예제 #1
0
파일: fBlock.go 프로젝트: jjdevbiz/factomd
func CreateTestFactoidBlockWithCoinbase(prev interfaces.IFBlock, address interfaces.IAddress, amount uint64) interfaces.IFBlock {
	block := factoidBlock.NewFBlockFromPreviousBlock(1, prev)
	tx := new(factoid.Transaction)
	tx.AddOutput(address, amount)
	err := block.AddCoinbase(tx)
	if err != nil {
		panic(err)
	}
	return block
}
예제 #2
0
파일: fBlock.go 프로젝트: jjdevbiz/factomd
func CreateTestFactoidBlock(prev interfaces.IFBlock) interfaces.IFBlock {
	fBlock := CreateTestFactoidBlockWithCoinbase(prev, NewFactoidAddress(0), DefaultCoinbaseAmount)

	ecTx := new(factoid.Transaction)
	ecTx.AddInput(NewFactoidAddress(0), fBlock.GetExchRate()*100)
	ecTx.AddECOutput(NewECAddress(0), fBlock.GetExchRate()*100)

	fee, err := ecTx.CalculateFee(1000)
	if err != nil {
		panic(err)
	}
	in, err := ecTx.GetInput(0)
	if err != nil {
		panic(err)
	}
	in.SetAmount(in.GetAmount() + fee)

	SignFactoidTransaction(0, ecTx)

	err = fBlock.AddTransaction(ecTx)
	if err != nil {
		panic(err)
	}

	return fBlock
}
예제 #3
0
func CreateTestFactoidBlockWithCoinbase(prev interfaces.IFBlock, address interfaces.IAddress, amount uint64) interfaces.IFBlock {
	block := factoid.NewFBlock(prev)
	tx := new(factoid.Transaction)
	tx.AddOutput(address, amount)
	tx.SetTimestamp(primitives.NewTimestampFromSeconds(60 * 10 * uint32(block.GetDBHeight())))
	err := block.AddCoinbase(tx)
	if err != nil {
		panic(err)
	}
	return block
}
예제 #4
0
func HandleV2FactoidACK(state interfaces.IState, params interface{}) (interface{}, *primitives.JSONError) {
	ackReq := new(AckRequest)
	err := MapToObject(params, ackReq)
	if err != nil {
		return nil, NewInvalidParamsError()
	}

	if ackReq.TxID == "" && ackReq.FullTransaction == "" {
		return nil, NewInvalidParamsError()
	}

	txid := ackReq.TxID

	if txid == "" {
		b, err := hex.DecodeString(ackReq.FullTransaction)
		if err != nil {
			return nil, NewUnableToDecodeTransactionError()
		}
		tx := new(factoid.Transaction)
		err = tx.UnmarshalBinary(b)
		if err != nil {
			return nil, NewUnableToDecodeTransactionError()
		}
		txid = tx.GetSigHash().String()
	}

	txhash, err := primitives.NewShaHashFromStr(txid)
	if err != nil {
		return nil, NewInvalidParamsError()
	}

	status, h, txTime, blockTime, err := state.GetACKStatus(txhash)
	if err != nil {
		return nil, NewInternalError()
	}

	answer := new(FactoidTxStatus)
	answer.TxID = h.String()

	if txTime != nil {
		answer.TransactionDate = txTime.GetTimeMilli()
		if txTime.GetTimeMilli() > 0 {
			answer.TransactionDateString = txTime.String()
		}
	}
	if blockTime != nil {
		answer.BlockDate = blockTime.GetTimeMilli()
		if blockTime.GetTimeMilli() > 0 {
			answer.BlockDateString = blockTime.String()
		}
	}

	switch status {
	case constants.AckStatusInvalid:
		answer.Status = AckStatusInvalid
		break
	case constants.AckStatusUnknown:
		answer.Status = AckStatusUnknown
		break
	case constants.AckStatusNotConfirmed:
		answer.Status = AckStatusNotConfirmed
		break
	case constants.AckStatusACK:
		answer.Status = AckStatusACK
		break
	case constants.AckStatus1Minute:
		answer.Status = AckStatus1Minute
		break
	case constants.AckStatusDBlockConfirmed:
		answer.Status = AckStatusDBlockConfirmed
		break
	default:
		return nil, NewInternalError()
		break
	}

	return answer, nil
}
예제 #5
0
func newFactoidTransaction() *FactoidTransaction {
	msg := new(FactoidTransaction)

	t := new(factoid.Transaction)

	for i := 0; i < 5; i++ {
		t.AddInput(nextAddress(), uint64(rand.Int63n(10000000000)))
	}

	for i := 0; i < 3; i++ {
		t.AddOutput(nextAddress(), uint64(rand.Int63n(10000000000)))
	}

	for i := 0; i < 3; i++ {
		t.AddECOutput(nextAddress(), uint64(rand.Int63n(10000000)))
	}

	for i := 0; i < 3; i++ {
		sig := factoid.NewRCD_1(nextSig())
		t.AddAuthorization(sig)
	}

	for i := 0; i < 2; i++ {
		t.AddAuthorization(nextAuth2())
	}

	msg.Transaction = t

	return msg
}
예제 #6
0
func TestBalances(t *testing.T) {
	s := new(State)
	s.Init("")
	state = s.GetFactoidState()
	state.SetFactoshisPerEC(1)
	add1, err := primitives.HexToHash("0000000000000000000000000000000000000000000000000000000000000001")
	if err != nil {
		t.Error(err)
	}
	add2, err := primitives.HexToHash("0000000000000000000000000000000000000000000000000000000000000002")
	if err != nil {
		t.Error(err)
	}
	add3, err := primitives.HexToHash("0000000000000000000000000000000000000000000000000000000000000003")
	if err != nil {
		t.Error(err)
	}

	tx := new(factoid.Transaction)
	tx.AddOutput(add1, 1000000)

	err = state.UpdateTransaction(tx)
	if err != nil {
		t.Error(err)
	}

	if state.GetFactoidBalance(add1.Fixed()) != 1000000 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add1.Fixed()))
	}
	if state.GetECBalance(add1.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add1.Fixed()))
	}
	if state.GetFactoidBalance(add2.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add2.Fixed()))
	}
	if state.GetECBalance(add2.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add2.Fixed()))
	}
	if state.GetFactoidBalance(add3.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add3.Fixed()))
	}
	if state.GetECBalance(add3.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add3.Fixed()))
	}

	tx = new(factoid.Transaction)
	tx.AddInput(add1, 1000)
	tx.AddOutput(add2, 1000)

	err = state.UpdateTransaction(tx)
	if err != nil {
		t.Error(err)
	}

	if state.GetFactoidBalance(add1.Fixed()) != 999000 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add1.Fixed()))
	}
	if state.GetECBalance(add1.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add1.Fixed()))
	}
	if state.GetFactoidBalance(add2.Fixed()) != 1000 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add2.Fixed()))
	}
	if state.GetECBalance(add2.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add2.Fixed()))
	}
	if state.GetFactoidBalance(add3.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add3.Fixed()))
	}
	if state.GetECBalance(add3.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add3.Fixed()))
	}

	tx = new(factoid.Transaction)
	tx.AddInput(add1, 1000)
	tx.AddECOutput(add3, 1000)

	err = state.UpdateTransaction(tx)
	if err != nil {
		t.Error(err)
	}

	if state.GetFactoidBalance(add1.Fixed()) != 998000 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add1.Fixed()))
	}
	if state.GetECBalance(add1.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add1.Fixed()))
	}
	if state.GetFactoidBalance(add2.Fixed()) != 1000 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add2.Fixed()))
	}
	if state.GetECBalance(add2.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add2.Fixed()))
	}
	if state.GetFactoidBalance(add3.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add3.Fixed()))
	}
	if state.GetECBalance(add3.Fixed()) != 1000 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add3.Fixed()))
	}

	state.ResetBalances()

	if state.GetFactoidBalance(add1.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add1.Fixed()))
	}
	if state.GetECBalance(add1.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add1.Fixed()))
	}
	if state.GetFactoidBalance(add2.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add2.Fixed()))
	}
	if state.GetECBalance(add2.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add2.Fixed()))
	}
	if state.GetFactoidBalance(add3.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetFactoidBalance(add3.Fixed()))
	}
	if state.GetECBalance(add3.Fixed()) != 0 {
		t.Errorf("Invalid address balance - %v", state.GetECBalance(add3.Fixed()))
	}
}