test_helpers

package
v0.3.1-alpha Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 27, 2021 License: AGPL-3.0 Imports: 25 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	Testdb          = rawdb.NewMemoryDatabase()
	TestBankKey, _  = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
	TestBankAddress = crypto.PubkeyToAddress(TestBankKey.PublicKey) //0x71562b71999873DB5b286dF957af199Ec94617F7
	TestBankFunds   = big.NewInt(100000000)
	Genesis         = core.GenesisBlockForTesting(Testdb, TestBankAddress, TestBankFunds)

	Account1Key, _       = crypto.HexToECDSA("8a1f9a8f95be41cd7ccb6168179afb4504aefe388d1e14474d32c45c72ce7b7a")
	Account2Key, _       = crypto.HexToECDSA("49a7b37aa6f6645917e7b807e9d1c00d4fa71f18343b0d4122a4d2df64dd6fee")
	Account1Addr         = crypto.PubkeyToAddress(Account1Key.PublicKey) //0x703c4b2bD70c169f5717101CaeE543299Fc946C7
	Account2Addr         = crypto.PubkeyToAddress(Account2Key.PublicKey) //0x0D3ab14BBaD3D99F4203bd7a11aCB94882050E7e
	DeploymentTxData     = common.Hex2Bytes("608060405234801561001057600080fd5b50336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600180819055506101e2806100676000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c806343d726d61461004657806365f3c31a1461005057806373d4a13a1461007e575b600080fd5b61004e61009c565b005b61007c6004803603602081101561006657600080fd5b810190808035906020019092919050505061017b565b005b610086610185565b6040518082815260200191505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610141576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602281526020018061018c6022913960400191505060405180910390fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b8060018190555050565b6001548156fe4f6e6c79206f776e65722063616e2063616c6c20746869732066756e6374696f6e2ea265627a7a723158205ba91466129f45285f53176d805117208c231ec6343d7896790e6fc4165b802b64736f6c63430005110032")
	ContractCode         = common.Hex2Bytes("608060405234801561001057600080fd5b50600436106100415760003560e01c806343d726d61461004657806365f3c31a1461005057806373d4a13a1461007e575b600080fd5b61004e61009c565b005b61007c6004803603602081101561006657600080fd5b810190808035906020019092919050505061017b565b005b610086610185565b6040518082815260200191505060405180910390f35b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610141576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602281526020018061018c6022913960400191505060405180910390fd5b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16ff5b8060018190555050565b6001548156fe4f6e6c79206f776e65722063616e2063616c6c20746869732066756e6374696f6e2ea265627a7a723158205ba91466129f45285f53176d805117208c231ec6343d7896790e6fc4165b802b64736f6c63430005110032")
	CodeHash             = crypto.Keccak256Hash(ContractCode)
	ContractAddr         common.Address
	IndexZero            = "0000000000000000000000000000000000000000000000000000000000000000"
	IndexOne             = "0000000000000000000000000000000000000000000000000000000000000001"
	ContractSlotPosition = common.FromHex(IndexOne)
	ContractSlotKeyHash  = crypto.Keccak256Hash(ContractSlotPosition)
	MiningReward         = big.NewInt(2000000000000000000)
)

Test variables

View Source 
var (
	// block data
	BlockNumber = big.NewInt(1)
	MockHeader  = types.Header{
		Time:        0,
		Number:      new(big.Int).Set(BlockNumber),
		Root:        common.HexToHash("0x0"),
		TxHash:      common.HexToHash("0x0"),
		ReceiptHash: common.HexToHash("0x0"),
		Difficulty:  big.NewInt(5000000),
		Extra:       []byte{},
	}
	MockTransactions, MockReceipts, SenderAddr = createTransactionsAndReceipts()
	MockUncles                                 = []*types.Header{
		{
			Time:        1,
			Number:      new(big.Int).Add(BlockNumber, big.NewInt(1)),
			Root:        common.HexToHash("0x1"),
			TxHash:      common.HexToHash("0x1"),
			ReceiptHash: common.HexToHash("0x1"),
			Difficulty:  big.NewInt(500001),
			Extra:       []byte{},
		},
		{
			Time:        2,
			Number:      new(big.Int).Add(BlockNumber, big.NewInt(2)),
			Root:        common.HexToHash("0x2"),
			TxHash:      common.HexToHash("0x2"),
			ReceiptHash: common.HexToHash("0x2"),
			Difficulty:  big.NewInt(500002),
			Extra:       []byte{},
		},
	}
	ReceiptsRlp, _   = rlp.EncodeToBytes(MockReceipts)
	MockBlock        = types.NewBlock(&MockHeader, MockTransactions, MockUncles, MockReceipts, new(trie.Trie))
	MockHeaderRlp, _ = rlp.EncodeToBytes(MockBlock.Header())
	MockChildHeader  = types.Header{
		Time:        0,
		Number:      new(big.Int).Add(BlockNumber, common.Big1),
		Root:        common.HexToHash("0x0"),
		TxHash:      common.HexToHash("0x0"),
		ReceiptHash: common.HexToHash("0x0"),
		Difficulty:  big.NewInt(5000001),
		Extra:       []byte{},
		ParentHash:  MockBlock.Header().Hash(),
	}
	MockChild            = types.NewBlock(&MockChildHeader, MockTransactions, MockUncles, MockReceipts, new(trie.Trie))
	MockChildRlp, _      = rlp.EncodeToBytes(MockChild.Header())
	Address              = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476592")
	AnotherAddress       = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476593")
	ContractAddress      = crypto.CreateAddress(SenderAddr, MockTransactions[2].Nonce())
	ContractHash         = crypto.Keccak256Hash(ContractAddress.Bytes()).String()
	MockContractByteCode = []byte{0, 1, 2, 3, 4, 5}

	MockLog1 = &types.Log{
		Address: Address,
		Topics:  []common.Hash{mockTopic11, mockTopic12},
		Data:    []byte{},
	}
	MockLog2 = &types.Log{
		Address: AnotherAddress,
		Topics:  []common.Hash{mockTopic21, mockTopic22},
		Data:    []byte{},
	}
	HeaderCID, _  = ipld.RawdataToCid(ipld.MEthHeader, MockHeaderRlp, multihash.KECCAK_256)
	HeaderMhKey   = shared.MultihashKeyFromCID(HeaderCID)
	Trx1CID, _    = ipld.RawdataToCid(ipld.MEthTx, MockTransactions.GetRlp(0), multihash.KECCAK_256)
	Trx1MhKey     = shared.MultihashKeyFromCID(Trx1CID)
	Trx2CID, _    = ipld.RawdataToCid(ipld.MEthTx, MockTransactions.GetRlp(1), multihash.KECCAK_256)
	Trx2MhKey     = shared.MultihashKeyFromCID(Trx2CID)
	Trx3CID, _    = ipld.RawdataToCid(ipld.MEthTx, MockTransactions.GetRlp(2), multihash.KECCAK_256)
	Trx3MhKey     = shared.MultihashKeyFromCID(Trx3CID)
	Rct1CID, _    = ipld.RawdataToCid(ipld.MEthTxReceipt, MockReceipts.GetRlp(0), multihash.KECCAK_256)
	Rct1MhKey     = shared.MultihashKeyFromCID(Rct1CID)
	Rct2CID, _    = ipld.RawdataToCid(ipld.MEthTxReceipt, MockReceipts.GetRlp(1), multihash.KECCAK_256)
	Rct2MhKey     = shared.MultihashKeyFromCID(Rct2CID)
	Rct3CID, _    = ipld.RawdataToCid(ipld.MEthTxReceipt, MockReceipts.GetRlp(2), multihash.KECCAK_256)
	Rct3MhKey     = shared.MultihashKeyFromCID(Rct3CID)
	State1CID, _  = ipld.RawdataToCid(ipld.MEthStateTrie, ContractLeafNode, multihash.KECCAK_256)
	State1MhKey   = shared.MultihashKeyFromCID(State1CID)
	State2CID, _  = ipld.RawdataToCid(ipld.MEthStateTrie, AccountLeafNode, multihash.KECCAK_256)
	State2MhKey   = shared.MultihashKeyFromCID(State2CID)
	StorageCID, _ = ipld.RawdataToCid(ipld.MEthStorageTrie, StorageLeafNode, multihash.KECCAK_256)
	StorageMhKey  = shared.MultihashKeyFromCID(StorageCID)
	MockTrxMeta   = []eth.TxModel{
		{
			CID:    "",
			MhKey:  "",
			Src:    SenderAddr.Hex(),
			Dst:    Address.String(),
			Index:  0,
			TxHash: MockTransactions[0].Hash().String(),
			Data:   []byte{},
		},
		{
			CID:    "",
			MhKey:  "",
			Src:    SenderAddr.Hex(),
			Dst:    AnotherAddress.String(),
			Index:  1,
			TxHash: MockTransactions[1].Hash().String(),
			Data:   []byte{},
		},
		{
			CID:    "",
			MhKey:  "",
			Src:    SenderAddr.Hex(),
			Dst:    "",
			Index:  2,
			TxHash: MockTransactions[2].Hash().String(),
			Data:   MockContractByteCode,
		},
	}
	MockTrxMetaPostPublsh = []eth.TxModel{
		{
			CID:    Trx1CID.String(),
			MhKey:  Trx1MhKey,
			Src:    SenderAddr.Hex(),
			Dst:    Address.String(),
			Index:  0,
			TxHash: MockTransactions[0].Hash().String(),
			Data:   []byte{},
		},
		{
			CID:    Trx2CID.String(),
			MhKey:  Trx2MhKey,
			Src:    SenderAddr.Hex(),
			Dst:    AnotherAddress.String(),
			Index:  1,
			TxHash: MockTransactions[1].Hash().String(),
			Data:   []byte{},
		},
		{
			CID:    Trx3CID.String(),
			MhKey:  Trx3MhKey,
			Src:    SenderAddr.Hex(),
			Dst:    "",
			Index:  2,
			TxHash: MockTransactions[2].Hash().String(),
			Data:   MockContractByteCode,
		},
	}
	MockRctMeta = []eth.ReceiptModel{
		{
			CID:   "",
			MhKey: "",
			Topic0s: []string{
				mockTopic11.String(),
			},
			Topic1s: []string{
				mockTopic12.String(),
			},
			Contract:     "",
			ContractHash: "",
			LogContracts: []string{
				Address.String(),
			},
		},
		{
			CID:   "",
			MhKey: "",
			Topic0s: []string{
				mockTopic21.String(),
			},
			Topic1s: []string{
				mockTopic22.String(),
			},
			Contract:     "",
			ContractHash: "",
			LogContracts: []string{
				AnotherAddress.String(),
			},
		},
		{
			CID:          "",
			MhKey:        "",
			Contract:     ContractAddress.String(),
			ContractHash: ContractHash,
			LogContracts: []string{},
		},
	}
	MockRctMetaPostPublish = []eth.ReceiptModel{
		{
			CID:   Rct1CID.String(),
			MhKey: Rct1MhKey,
			Topic0s: []string{
				mockTopic11.String(),
			},
			Topic1s: []string{
				mockTopic12.String(),
			},
			Contract:     "",
			ContractHash: "",
			LogContracts: []string{
				Address.String(),
			},
		},
		{
			CID:   Rct2CID.String(),
			MhKey: Rct2MhKey,
			Topic0s: []string{
				mockTopic21.String(),
			},
			Topic1s: []string{
				mockTopic22.String(),
			},
			Contract:     "",
			ContractHash: "",
			LogContracts: []string{
				AnotherAddress.String(),
			},
		},
		{
			CID:          Rct3CID.String(),
			MhKey:        Rct3MhKey,
			Contract:     ContractAddress.String(),
			ContractHash: ContractHash,
			LogContracts: []string{},
		},
	}

	StorageLeafKey     = crypto.Keccak256Hash(storageLocation[:]).Bytes()
	StorageValue       = crypto.Keccak256([]byte{1, 2, 3, 4, 5})
	StoragePartialPath = common.Hex2Bytes("20290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563")
	StorageLeafNode, _ = rlp.EncodeToBytes([]interface{}{
		StoragePartialPath,
		StorageValue,
	})

	ContractRoot     = "0x821e2556a290c86405f8160a2d662042a431ba456b9db265c79bb837c04be5f0"
	ContractCodeHash = crypto.Keccak256Hash(MockContractByteCode)

	ContractLeafKey    = testhelpers.AddressToLeafKey(ContractAddress)
	ContractAccount, _ = rlp.EncodeToBytes(state.Account{
		Nonce:    nonce1,
		Balance:  big.NewInt(0),
		CodeHash: ContractCodeHash.Bytes(),
		Root:     common.HexToHash(ContractRoot),
	})
	ContractPartialPath = common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45")
	ContractLeafNode, _ = rlp.EncodeToBytes([]interface{}{
		ContractPartialPath,
		ContractAccount,
	})

	AccountBalance  = big.NewInt(1000)
	AccountRoot     = "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"
	AccountCodeHash = common.HexToHash("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")
	AccountAddresss = common.HexToAddress("0x0D3ab14BBaD3D99F4203bd7a11aCB94882050E7e")
	AccountLeafKey  = testhelpers.Account2LeafKey
	Account, _      = rlp.EncodeToBytes(state.Account{
		Nonce:    nonce0,
		Balance:  AccountBalance,
		CodeHash: AccountCodeHash.Bytes(),
		Root:     common.HexToHash(AccountRoot),
	})
	AccountPartialPath = common.Hex2Bytes("3957f3e2f04a0764c3a0491b175f69926da61efbcc8f61fa1455fd2d2b4cdd45")
	AccountLeafNode, _ = rlp.EncodeToBytes([]interface{}{
		AccountPartialPath,
		Account,
	})

	MockStateNodes = []eth.TrieNode{
		{
			LeafKey: common.BytesToHash(ContractLeafKey),
			Path:    []byte{'\x06'},
			Value:   ContractLeafNode,
			Type:    sdtypes.Leaf,
		},
		{
			LeafKey: common.BytesToHash(AccountLeafKey),
			Path:    []byte{'\x0c'},
			Value:   AccountLeafNode,
			Type:    sdtypes.Leaf,
		},
	}
	MockStateMetaPostPublish = []eth.StateNodeModel{
		{
			CID:      State1CID.String(),
			MhKey:    State1MhKey,
			Path:     []byte{'\x06'},
			NodeType: 2,
			StateKey: common.BytesToHash(ContractLeafKey).Hex(),
		},
		{
			CID:      State2CID.String(),
			MhKey:    State2MhKey,
			Path:     []byte{'\x0c'},
			NodeType: 2,
			StateKey: common.BytesToHash(AccountLeafKey).Hex(),
		},
	}
	MockStorageNodes = map[string][]eth.TrieNode{
						// contains filtered or unexported fields
	}

	MockConvertedPayload = eth.ConvertedPayload{
		TotalDifficulty: MockBlock.Difficulty(),
		Block:           MockBlock,
		Receipts:        MockReceipts,
		TxMetaData:      MockTrxMeta,
		ReceiptMetaData: MockRctMeta,
		StorageNodes:    MockStorageNodes,
		StateNodes:      MockStateNodes,
	}
	MockConvertedPayloadForChild = eth.ConvertedPayload{
		TotalDifficulty: MockChild.Difficulty(),
		Block:           MockChild,
		Receipts:        MockReceipts,
		TxMetaData:      MockTrxMeta,
		ReceiptMetaData: MockRctMeta,
		StorageNodes:    MockStorageNodes,
		StateNodes:      MockStateNodes,
	}

	MockCIDWrapper = &eth2.CIDWrapper{
		BlockNumber: new(big.Int).Set(BlockNumber),
		Header: eth.HeaderModel{
			BlockNumber:     "1",
			BlockHash:       MockBlock.Hash().String(),
			ParentHash:      "0x0000000000000000000000000000000000000000000000000000000000000000",
			CID:             HeaderCID.String(),
			MhKey:           HeaderMhKey,
			TotalDifficulty: MockBlock.Difficulty().String(),
			Reward:          "5312500000000000000",
			StateRoot:       MockBlock.Root().String(),
			RctRoot:         MockBlock.ReceiptHash().String(),
			TxRoot:          MockBlock.TxHash().String(),
			UncleRoot:       MockBlock.UncleHash().String(),
			Bloom:           MockBlock.Bloom().Bytes(),
			Timestamp:       MockBlock.Time(),
			TimesValidated:  1,
		},
		Transactions: MockTrxMetaPostPublsh,
		Receipts:     MockRctMetaPostPublish,
		Uncles:       []eth.UncleModel{},
		StateNodes:   MockStateMetaPostPublish,
		StorageNodes: []eth.StorageNodeWithStateKeyModel{
			{
				Path:       []byte{},
				CID:        StorageCID.String(),
				MhKey:      StorageMhKey,
				NodeType:   2,
				StateKey:   common.BytesToHash(ContractLeafKey).Hex(),
				StorageKey: common.BytesToHash(StorageLeafKey).Hex(),
			},
		},
	}

	HeaderIPLD, _  = blocks.NewBlockWithCid(MockHeaderRlp, HeaderCID)
	Trx1IPLD, _    = blocks.NewBlockWithCid(MockTransactions.GetRlp(0), Trx1CID)
	Trx2IPLD, _    = blocks.NewBlockWithCid(MockTransactions.GetRlp(1), Trx2CID)
	Trx3IPLD, _    = blocks.NewBlockWithCid(MockTransactions.GetRlp(2), Trx3CID)
	Rct1IPLD, _    = blocks.NewBlockWithCid(MockReceipts.GetRlp(0), Rct1CID)
	Rct2IPLD, _    = blocks.NewBlockWithCid(MockReceipts.GetRlp(1), Rct2CID)
	Rct3IPLD, _    = blocks.NewBlockWithCid(MockReceipts.GetRlp(2), Rct3CID)
	State1IPLD, _  = blocks.NewBlockWithCid(ContractLeafNode, State1CID)
	State2IPLD, _  = blocks.NewBlockWithCid(AccountLeafNode, State2CID)
	StorageIPLD, _ = blocks.NewBlockWithCid(StorageLeafNode, StorageCID)

	MockIPLDs = eth2.IPLDs{
		BlockNumber: new(big.Int).Set(BlockNumber),
		Header: ipfs.BlockModel{
			Data: HeaderIPLD.RawData(),
			CID:  HeaderIPLD.Cid().String(),
		},
		Transactions: []ipfs.BlockModel{
			{
				Data: Trx1IPLD.RawData(),
				CID:  Trx1IPLD.Cid().String(),
			},
			{
				Data: Trx2IPLD.RawData(),
				CID:  Trx2IPLD.Cid().String(),
			},
			{
				Data: Trx3IPLD.RawData(),
				CID:  Trx3IPLD.Cid().String(),
			},
		},
		Receipts: []ipfs.BlockModel{
			{
				Data: Rct1IPLD.RawData(),
				CID:  Rct1IPLD.Cid().String(),
			},
			{
				Data: Rct2IPLD.RawData(),
				CID:  Rct2IPLD.Cid().String(),
			},
			{
				Data: Rct3IPLD.RawData(),
				CID:  Rct3IPLD.Cid().String(),
			},
		},
		StateNodes: []eth2.StateNode{
			{
				StateLeafKey: common.BytesToHash(ContractLeafKey),
				Type:         sdtypes.Leaf,
				IPLD: ipfs.BlockModel{
					Data: State1IPLD.RawData(),
					CID:  State1IPLD.Cid().String(),
				},
				Path: []byte{'\x06'},
			},
			{
				StateLeafKey: common.BytesToHash(AccountLeafKey),
				Type:         sdtypes.Leaf,
				IPLD: ipfs.BlockModel{
					Data: State2IPLD.RawData(),
					CID:  State2IPLD.Cid().String(),
				},
				Path: []byte{'\x0c'},
			},
		},
		StorageNodes: []eth2.StorageNode{
			{
				StateLeafKey:   common.BytesToHash(ContractLeafKey),
				StorageLeafKey: common.BytesToHash(StorageLeafKey),
				Type:           sdtypes.Leaf,
				IPLD: ipfs.BlockModel{
					Data: StorageIPLD.RawData(),
					CID:  StorageIPLD.Cid().String(),
				},
				Path: []byte{},
			},
		},
	}
)

Test variables

Functions

func MakeChain 

func MakeChain(n int, parent *types.Block, chainGen func(int, *core.BlockGen)) ([]*types.Block, []types.Receipts, *core.BlockChain)

MakeChain creates a chain of n blocks starting at and including parent. the returned hash chain is ordered head->parent.

func TestChainGen 

func TestChainGen(i int, block *core.BlockGen)

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.