test_helpers

package

v5.3.0-alpha Latest Latest Go to latest Published: Aug 5, 2024 License: AGPL-3.0 Imports: 22 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/cerc-io/ipld-eth-server

Documentation ¶

Index ¶

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

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
	BlockNumber1 = int64(1)
	BlockTime1   = uint64(0)
	MockHeader   = types.Header{
		Time:        0,
		Number:      big.NewInt(BlockNumber1),
		Root:        common.HexToHash("0x0"),
		TxHash:      common.HexToHash("0x0"),
		ReceiptHash: common.HexToHash("0x0"),
		Difficulty:  big.NewInt(5000000),
		Extra:       []byte{},
	}
	MockTransactions, MockReceipts, SenderAddr = createLegacyTransactionsAndReceipts()
	MockWithdrawals                            = types.Withdrawals{
		{Index: 0, Validator: 1, Address: Address, Amount: 1000000000},
		{Index: 1, Validator: 5, Address: AnotherAddress, Amount: 2000000000},
	}
	MockUncles = []*types.Header{
		{
			Time:        1,
			Number:      big.NewInt(BlockNumber1 + 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:      big.NewInt(BlockNumber1 + 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, nil, trie.NewEmpty(nil))
	MockChildHeader = types.Header{
		Time:        0,
		Number:      big.NewInt(BlockNumber1 + 1),
		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: uint64(BlockNumber1),
		TxIndex:     0,
		Index:       0,
	}
	MockLog2 = &types.Log{
		Address:     AnotherAddress,
		Topics:      []common.Hash{mockTopic21, mockTopic22},
		Data:        []byte{},
		BlockNumber: uint64(BlockNumber1),
		TxIndex:     1,
		Index:       1,
	}
	MockLog3 = &types.Log{
		Address:     AnotherAddress1,
		Topics:      []common.Hash{mockTopic31},
		Data:        []byte{},
		BlockNumber: uint64(BlockNumber1),
		TxIndex:     2,
		Index:       2,
	}

	MockLog4 = &types.Log{
		Address:     AnotherAddress1,
		Topics:      []common.Hash{mockTopic41, mockTopic42, mockTopic43},
		Data:        []byte{},
		BlockNumber: uint64(BlockNumber1),
		TxIndex:     2,
		Index:       3,
	}
	MockLog5 = &types.Log{
		Address:     AnotherAddress1,
		Topics:      []common.Hash{mockTopic51},
		Data:        []byte{},
		BlockNumber: uint64(BlockNumber1),
		TxIndex:     2,
		Index:       4,
	}
	MockLog6 = &types.Log{
		Address:     AnotherAddress2,
		Topics:      []common.Hash{mockTopic61},
		Data:        []byte{},
		BlockNumber: uint64(BlockNumber1),
		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:  uint256.NewInt(0),
		CodeHash: CodeHash.Bytes(),
		Root:     common.HexToHash(ContractRoot),
	}
	ContractAccountRLP, _ = rlp.EncodeToBytes(&ContractAccount)
	ContractPartialPath   = common.Hex2Bytes("3114658a74d9cc9f7acf2c5cd696c3494d7c344d78bfec3add0d91ec4e8d1c45")
	ContractLeafNode, _   = rlp.EncodeToBytes(&[]interface{}{
		ContractPartialPath,
		ContractAccountRLP,
	})

	AccountBalance  = uint256.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   = (BlockNumber1 + 2)
	LondonBlockTime  = BlockTime1 + 1
	MockLondonHeader = types.Header{
		Time:       LondonBlockTime,
		Number:     big.NewInt(LondonBlockNum),
		Root:       common.HexToHash("0x00"),
		Difficulty: big.NewInt(5000000),
		Extra:      []byte{},
		BaseFee:    big.NewInt(params.InitialBaseFee),
	}

	MockLondonTransactions, MockLondonReceipts, _ = createDynamicTransactionsAndReceipts(big.NewInt(LondonBlockNum), LondonBlockTime)
	MockLondonUncles                              = []*types.Header{
		{
			Time:        1,
			Number:      big.NewInt(BlockNumber1 + 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:      big.NewInt(BlockNumber1 + 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, MockWithdrawals, trie.NewEmpty(nil))
)

Test variables

Functions ¶

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 ¶

This section is empty.

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL