test_helpers

package
v5.1.2-alpha Latest Latest
Warning

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

 Go to latest Published: Sep 30, 2023 License: AGPL-3.0 Imports: 26 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 = test_helpers.GenesisBlockForTesting(Testdb, TestBankAddress, TestBankFunds, big.NewInt(params.InitialBaseFee), params.MaxGasLimit)

	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 = createLegacyTransactionsAndReceipts()
	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{},
			ParentHash:  Genesis.Hash(),
		},
		{
			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{},
			ParentHash:  Genesis.Hash(),
		},
	}
	MockBlock       = createNewBlock(&MockHeader, MockTransactions, MockUncles, MockReceipts, trie.NewEmpty(nil))
	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, trie.NewEmpty(nil))
	Address         = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476592")
	AnotherAddress  = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476593")
	AnotherAddress1 = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476594")
	AnotherAddress2 = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476596")
	ContractAddress = crypto.CreateAddress(SenderAddr, MockTransactions[2].Nonce())

	MockLog1 = &types.Log{
		Address:     Address,
		Topics:      []common.Hash{mockTopic11, mockTopic12},
		Data:        []byte{},
		BlockNumber: BlockNumber.Uint64(),
		TxIndex:     0,
		Index:       0,
	}
	MockLog2 = &types.Log{
		Address:     AnotherAddress,
		Topics:      []common.Hash{mockTopic21, mockTopic22},
		Data:        []byte{},
		BlockNumber: BlockNumber.Uint64(),
		TxIndex:     1,
		Index:       1,
	}
	MockLog3 = &types.Log{
		Address:     AnotherAddress1,
		Topics:      []common.Hash{mockTopic31},
		Data:        []byte{},
		BlockNumber: BlockNumber.Uint64(),
		TxIndex:     2,
		Index:       2,
	}

	MockLog4 = &types.Log{
		Address:     AnotherAddress1,
		Topics:      []common.Hash{mockTopic41, mockTopic42, mockTopic43},
		Data:        []byte{},
		BlockNumber: BlockNumber.Uint64(),
		TxIndex:     2,
		Index:       3,
	}
	MockLog5 = &types.Log{
		Address:     AnotherAddress1,
		Topics:      []common.Hash{mockTopic51},
		Data:        []byte{},
		BlockNumber: BlockNumber.Uint64(),
		TxIndex:     2,
		Index:       4,
	}
	MockLog6 = &types.Log{
		Address:     AnotherAddress2,
		Topics:      []common.Hash{mockTopic61},
		Data:        []byte{},
		BlockNumber: BlockNumber.Uint64(),
		TxIndex:     3,
		Index:       5,
	}

	Rct1CID     = rctCIDs[0]
	Rct4CID     = rctCIDs[3]
	MockTrxMeta = []models.TxModel{
		{
			CID:    "",
			Src:    SenderAddr.Hex(),
			Dst:    Address.String(),
			Index:  0,
			TxHash: MockTransactions[0].Hash().String(),
		},
		{
			CID:    "",
			Src:    SenderAddr.Hex(),
			Dst:    AnotherAddress.String(),
			Index:  1,
			TxHash: MockTransactions[1].Hash().String(),
		},
		{
			CID:    "",
			Src:    SenderAddr.Hex(),
			Dst:    "",
			Index:  2,
			TxHash: MockTransactions[2].Hash().String(),
		},
		{
			CID:    "",
			Src:    SenderAddr.Hex(),
			Dst:    "",
			Index:  3,
			TxHash: MockTransactions[3].Hash().String(),
		},
	}
	MockRctMeta = []models.ReceiptModel{
		{
			CID:      "",
			Contract: "",
		},
		{
			CID:      "",
			Contract: "",
		},
		{
			CID:      "",
			Contract: ContractAddress.String(),
		},
		{
			CID:      "",
			Contract: "",
		},
	}

	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"

	ContractLeafKey = crypto.Keccak256(ContractAddress[:])
	ContractAccount = types.StateAccount{
		Nonce:    uint64(1),
		Balance:  big.NewInt(0),
		CodeHash: CodeHash.Bytes(),
		Root:     common.HexToHash(ContractRoot),
	}
	ContractAccountRLP, _ = rlp.EncodeToBytes(&ContractAccount)
	ContractPartialPath   = common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45")
	ContractLeafNode, _   = rlp.EncodeToBytes(&[]interface{}{
		ContractPartialPath,
		ContractAccountRLP,
	})

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

	MockStateNodes = []sdtypes.StateLeafNode{
		{
			AccountWrapper: sdtypes.AccountWrapper{
				Account: &ContractAccount,
				LeafKey: ContractLeafKey,
				CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(ContractLeafNode)).String(),
			},
			StorageDiff: []sdtypes.StorageLeafNode{
				{
					LeafKey: StorageLeafKey,
					Value:   StorageValue,
					CID:     ipld.Keccak256ToCid(ipld.MEthStorageTrie, crypto.Keccak256(StorageLeafNode)).String(),
				},
			},
		},
		{
			AccountWrapper: sdtypes.AccountWrapper{
				Account: &Account,
				LeafKey: AccountLeafKey,
				CID:     ipld.Keccak256ToCid(ipld.MEthStateTrie, crypto.Keccak256(AccountLeafNode)).String(),
			},
		},
	}
	MockStorageNodes = map[string][]sdtypes.StorageLeafNode{
						// contains filtered or unexported fields
	}

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

	LondonBlockNum   = new(big.Int).Add(BlockNumber, big.NewInt(2))
	MockLondonHeader = types.Header{
		Time:       0,
		Number:     LondonBlockNum,
		Root:       common.HexToHash("0x00"),
		Difficulty: big.NewInt(5000000),
		Extra:      []byte{},
		BaseFee:    big.NewInt(params.InitialBaseFee),
	}

	MockLondonTransactions, MockLondonReceipts, _ = createDynamicTransactionsAndReceipts(LondonBlockNum)
	MockLondonUncles                              = []*types.Header{
		{
			Time:        1,
			Number:      new(big.Int).Add(BlockNumber, big.NewInt(1)),
			ParentHash:  common.HexToHash("0x2"),
			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(1)),
			ParentHash:  common.HexToHash("0x1"),
			Root:        common.HexToHash("0x2"),
			TxHash:      common.HexToHash("0x2"),
			ReceiptHash: common.HexToHash("0x2"),
			Difficulty:  big.NewInt(500002),
			Extra:       []byte{},
		},
	}
	MockLondonBlock = createNewBlock(&MockLondonHeader, MockLondonTransactions, MockLondonUncles, MockLondonReceipts, trie.NewEmpty(nil))
)

Test variables

Functions

func IndexChain 

func IndexChain(params IndexChainParams) error

func MakeChain 

func MakeChain(n int, parent *types.Block, chainGen func(int, *core.BlockGen), config *params.ChainConfig) ([]*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

type IndexChainParams 

type IndexChainParams struct {
	Blocks      []*types.Block
	Receipts    []types.Receipts
	StateCache  state.Database
	ChainConfig *params.ChainConfig

	StateDiffParams statediff.Params
	TotalDifficulty *big.Int
	// Whether to skip indexing state nodes (state_cids, storage_cids)
	SkipStateNodes bool
	// Whether to skip indexing IPLD blocks
	SkipIPLDs bool
}

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.