Implemented GetHeaderByNumber and GetHeaderByHash

e2e-polybft/e2e/bridge_test.go

@@ -74,12 +74,13 @@ func TestE2E_Bridge_RootchainTokensTransfers(t *testing.T) {
 		framework.WithBridge(),
 		framework.WithSecretsCallback(func(addrs []types.Address, tcc *framework.TestClusterConfig) {
 			for i := 0; i < len(addrs); i++ {
-				tcc.StakeAmounts = append(tcc.StakeAmounts, ethgo.Ether(10))
 				// premine receivers, so that they are able to do withdrawals
+				tcc.StakeAmounts = append(tcc.StakeAmounts, ethgo.Ether(10))
 			}
 
 			tcc.Premine = append(tcc.Premine, receivers...)
 		}))
+
 	defer cluster.Stop()
 
 	cluster.WaitForReady(t)
@@ -1337,6 +1338,7 @@ func TestE2E_Bridge_NonMintableERC20Token_WithPremine(t *testing.T) {
 		checkBalancesFn(types.Address(rewardWalletKey.Address()), bigZero, command.DefaultPremineBalance, true)
 
 		validatorsExpectedBalance := new(big.Int).Sub(command.DefaultPremineBalance, command.DefaultStake)
+
 		for _, server := range cluster.Servers {
 			validatorAccount, err := validatorHelper.GetAccountFromDir(server.DataDir())
 			require.NoError(t, err)

e2e-polybft/e2e/consensus_test.go

@@ -398,6 +398,7 @@ func TestE2E_Consensus_MintableERC20NativeToken(t *testing.T) {
 				config.Premine = append(config.Premine, fmt.Sprintf("%s:%d", addr, initValidatorsBalance))
 				config.StakeAmounts = append(config.StakeAmounts, new(big.Int).Set(initValidatorsBalance))
 				validatorsAddrs[i] = addr
+
 				initialTotalSupply.Add(initialTotalSupply, initValidatorsBalance)
 			}
 		}))
@@ -536,7 +537,7 @@ func TestE2E_Consensus_EIP1559Check(t *testing.T) {
 
 	client := cluster.Servers[0].JSONRPC().Eth()
 
-	waitUntilBalancesChanged := func(_ ethgo.Address, initialBalance *big.Int) error {
+	waitUntilBalancesChanged := func(initialBalance *big.Int) error {
 		err := cluster.WaitUntil(30*time.Second, 1*time.Second, func() bool {
 			balance, err := client.GetBalance(recipient, ethgo.Latest)
 			if err != nil {
@@ -587,7 +588,7 @@ func TestE2E_Consensus_EIP1559Check(t *testing.T) {
 		require.Equal(t, uint64(types.ReceiptSuccess), receipt.Status)
 
 		// wait for recipient's balance to increase
-		err = waitUntilBalancesChanged(recipient, receiverInitialBalance)
+		err = waitUntilBalancesChanged(receiverInitialBalance)
 		require.NoError(t, err)
 
 		block, _ := client.GetBlockByHash(receipt.BlockHash, true)

e2e-polybft/e2e/jsonrpc_test.go

@@ -191,11 +191,13 @@ func TestE2E_JsonRPC(t *testing.T) {
 			Value: newBalance,
 		})
 		require.NoError(t, err)
+
 		txPrice := gasPrice * estimatedGas
 		// subtract gasPrice * estimatedGas from the balance and transfer the rest to the other account
 		// in order to leave no funds on the account
 		amountToSend := new(big.Int).Sub(newBalance, big.NewInt(int64(txPrice)))
 		targetAddr := acct.Address()
+
 		txn = cluster.SendTxn(t, key1, &ethgo.Transaction{
 			To:    &targetAddr,
 			Value: amountToSend,

e2e-polybft/e2e/txpool_test.go

@@ -83,7 +83,9 @@ func TestE2E_TxPool_Transfer(t *testing.T) {
 			if err != nil {
 				return true
 			}
+
 			t.Logf("Balance %s %s", receiver, balance)
+
 			if balance.Uint64() != uint64(sendAmount) {
 				return false
 			}
@@ -274,6 +276,7 @@ func TestE2E_TxPool_BroadcastTransactions(t *testing.T) {
 		for _, srv := range cluster.Servers {
 			balance, err := srv.WaitForNonZeroBalance(recipient, time.Second*10)
 			assert.NoError(t, err)
+
 			if balance != nil && balance.BitLen() > 0 {
 				assert.Equal(t, sentAmount, balance)
 			} else {

e2e-polybft/property/property_test.go

@@ -109,8 +109,11 @@ func TestProperty_DropValidators(t *testing.T) {
 		// check that block production is stoped
 		currentBlock, err = activeValidator.JSONRPC().Eth().BlockNumber()
 		require.NoError(t, err)
+
 		oldBlockNumber := currentBlock
+
 		time.Sleep(2 * blockTime)
+
 		currentBlock, err = activeValidator.JSONRPC().Eth().BlockNumber()
 		require.NoError(t, err)
 		require.Equal(t, oldBlockNumber, currentBlock)

jsonrpc/codec_test.go

@@ -105,9 +105,11 @@ func TestBlockNumberOrHash_UnmarshalJSON(t *testing.T) {
 				assert.Error(t, err)
 			} else {
 				assert.NoError(t, err)
+
 				if tt.expectedBnh.BlockNumber != nil {
 					assert.Equal(t, *bnh.BlockNumber, *tt.expectedBnh.BlockNumber)
 				}
+
 				if tt.expectedBnh.BlockHash != nil {
 					assert.Equal(t, bnh.BlockHash.String(), tt.expectedBnh.BlockHash.String())
 				}

jsonrpc/dispatcher.go

@@ -212,6 +212,7 @@ func (d *Dispatcher) handleSubscribe(req Request, conn wsConn) (string, Error) {
 		if err != nil {
 			return "", NewInternalError(err.Error())
 		}
+
 		filterID = d.filterManager.NewLogFilter(logQuery, conn)
 	} else if subscribeMethod == "newPendingTransactions" {
 		filterID = d.filterManager.NewPendingTxFilter(conn)

jsonrpc/dispatcher_test.go

@@ -467,20 +467,24 @@ func TestDispatcherBatchRequest(t *testing.T) {
 			assert.Equal(t, c.err, resp.Error)
 		} else {
 			var batchResp []SuccessResponse
+
 			assert.NoError(t, expectBatchJSONResult(res, &batchResp))
 
 			if c.name == "leading-whitespace" {
 				assert.Len(t, batchResp, 4)
+
 				for index, resp := range batchResp {
 					assert.Equal(t, c.batchResponse[index].Error, resp.Error)
 				}
 			} else if c.name == "valid-batch-req" {
 				assert.Len(t, batchResp, 6)
+
 				for index, resp := range batchResp {
 					assert.Equal(t, c.batchResponse[index].Error, resp.Error)
 				}
 			} else if c.name == "no-limits" {
 				assert.Len(t, batchResp, 12)
+
 				for index, resp := range batchResp {
 					assert.Equal(t, c.batchResponse[index].Error, resp.Error)
 				}

jsonrpc/eth_blockchain_test.go

@@ -3,6 +3,7 @@ package jsonrpc
 import (
 	"errors"
 	"math/big"
+	"strconv"
 	"testing"
 
 	"github.com/0xPolygon/polygon-edge/blockchain"
@@ -68,6 +69,59 @@ func TestEth_Block_GetBlockByHash(t *testing.T) {
 	assert.Nil(t, res)
 }
 
+func TestEth_Block_GetHeaderByNumber(t *testing.T) {
+	store := &mockBlockStore{}
+	for i := 0; i < 10; i++ {
+		store.add(newTestBlock(uint64(i), hash1))
+	}
+
+	eth := newTestEthEndpoint(store)
+
+	cases := []struct {
+		description string
+		blockNum    BlockNumber
+		isNotNil    bool
+		err         bool
+	}{
+		{"should be able to get the latest block number", LatestBlockNumber, true, false},
+		{"should be able to get the earliest block number", EarliestBlockNumber, true, false},
+		{"should not be able to get block with negative number", BlockNumber(-50), false, true},
+		{"should be able to get block with number 0", BlockNumber(0), true, false},
+		{"should be able to get block with number 2", BlockNumber(2), true, false},
+		{"should be able to get block with number greater than latest block", BlockNumber(50), false, false},
+	}
+	for _, c := range cases {
+		res, err := eth.GetHeaderByNumber(c.blockNum)
+
+		if c.isNotNil {
+			assert.NotNil(t, res, "expected to return block, but got nil")
+		} else {
+			assert.Nil(t, res, "expected to return nil, but got data")
+		}
+
+		if c.err {
+			assert.Error(t, err)
+		} else {
+			assert.NoError(t, err)
+		}
+	}
+}
+
+func TestEth_Block_GetHeaderByHash(t *testing.T) {
+	store := &mockBlockStore{}
+	store.add(newTestBlock(1, hash1))
+
+	eth := newTestEthEndpoint(store)
+
+	res, err := eth.GetHeaderByHash(hash1)
+	assert.NoError(t, err)
+	assert.NotNil(t, res)
+
+	res, err = eth.GetHeaderByHash(hash2)
+	assert.NoError(t, err)
+	assert.Nil(t, res)
+}
+
 func TestEth_Block_BlockNumber(t *testing.T) {
 	store := &mockBlockStore{}
 	store.add(&types.Block{
@@ -261,8 +315,10 @@ func TestEth_GetTransactionReceipt(t *testing.T) {
 		eth := newTestEthEndpoint(store)
 		block := newTestBlock(1, hash4)
 		store.add(block)
+
 		txn0 := newTestTransaction(uint64(0), addr0)
 		txn1 := newTestTransaction(uint64(1), addr1)
+
 		block.Transactions = []*types.Transaction{txn0, txn1}
 		receipt1 := &types.Receipt{
 			Logs: []*types.Log{
@@ -287,6 +343,7 @@ func TestEth_GetTransactionReceipt(t *testing.T) {
 			},
 		}
 		receipt1.SetStatus(types.ReceiptSuccess)
+
 		receipt2 := &types.Receipt{
 			Logs: []*types.Log{
 				{
@@ -315,6 +372,68 @@ func TestEth_GetTransactionReceipt(t *testing.T) {
 	})
 }
 
+func TestEth_GetBlockReceipts(t *testing.T) {
+	store := newMockBlockStore()
+	eth := newTestEthEndpoint(store)
+	block := newTestBlock(1, hash4)
+	store.add(block)
+
+	txn0 := newTestTransaction(uint64(0), addr0)
+	txn1 := newTestTransaction(uint64(1), addr1)
+
+	block.Transactions = []*types.Transaction{txn0, txn1}
+	receipt1 := &types.Receipt{
+		Logs: []*types.Log{
+			{
+				// log 0
+				Topics: []types.Hash{
+					hash1,
+				},
+			},
+			{
+				// log 1
+				Topics: []types.Hash{
+					hash2,
+				},
+			},
+			{
+				// log 2
+				Topics: []types.Hash{
+					hash3,
+				},
+			},
+		},
+	}
+	receipt1.SetStatus(types.ReceiptSuccess)
+
+	receipt2 := &types.Receipt{
+		Logs: []*types.Log{
+			{
+				// log 3
+				Topics: []types.Hash{
+					hash4,
+				},
+			},
+		},
+	}
+	receipt2.SetStatus(types.ReceiptSuccess)
+	store.receipts[hash4] = []*types.Receipt{receipt1, receipt2}
+
+	res, err := eth.GetBlockReceipts(1)
+
+	assert.NoError(t, err)
+	assert.NotNil(t, res)
+
+	response := res.([]*receipt)
+	assert.Equal(t, txn1.Hash(), response[1].TxHash)
+	assert.Equal(t, 2, len(response))
+	assert.Equal(t, block.Hash(), response[1].BlockHash)
+	assert.NotNil(t, response[1].Logs)
+	assert.Len(t, response[1].Logs, 1)
+	assert.Equal(t, uint64(3), uint64(response[1].Logs[0].LogIndex))
+	assert.Equal(t, uint64(1), uint64(response[1].Logs[0].TxIndex))
+}
+
 func TestEth_Syncing(t *testing.T) {
 	store := newMockBlockStore()
 	eth := newTestEthEndpoint(store)
@@ -508,6 +627,79 @@ func TestEth_Call(t *testing.T) {
 	})
 }
 
+func TestEth_CreateAccessList(t *testing.T) {
+	store := newMockBlockStore()
+	hashs := make([]types.Hash, 10)
+	latest := LatestBlockNumber
+	blockNum1 := BlockNumber(1)
+	blockNum2 := BlockNumber(2)
+
+	for i := 0; i < 10; i++ {
+		hashs[i] = types.StringToHash(strconv.Itoa(i))
+		block := newTestBlock(uint64(i), hashs[i])
+		block.Header.GasUsed = uint64(i * 10)
+		store.add(block)
+	}
+
+	eth := newTestEthEndpoint(store)
+
+	txn := &txnArgs{
+		From:     &addr0,
+		To:       &addr1,
+		Gas:      argUintPtr(100000),
+		GasPrice: argBytesPtr([]byte{0x64}),
+		Value:    argBytesPtr([]byte{0x64}),
+		Data:     nil,
+		Nonce:    argUintPtr(0),
+	}
+
+	cases := []struct {
+		filter BlockNumberOrHash
+		err    bool
+	}{
+		{
+			// both fields are empty
+			BlockNumberOrHash{},
+			true,
+		},
+		{
+			// return the latest block number
+			BlockNumberOrHash{BlockNumber: &latest},
+			true,
+		},
+		{
+			// specific real block number
+			BlockNumberOrHash{BlockNumber: &blockNum1},
+			true,
+		},
+		{
+			// specific block number (not found)
+			BlockNumberOrHash{BlockNumber: &blockNum2},
+			true,
+		},
+		{
+			// specific block by hash (found). By default all blocks in the mock have hash zero
+			BlockNumberOrHash{BlockHash: &types.ZeroHash},
+			false,
+		},
+		{
+			// specific block by hash (not found)
+			BlockNumberOrHash{BlockHash: &hashs[8]},
+			true,
+		},
+	}
+
+	for _, c := range cases {
+		res, err := eth.CreateAccessList(txn, c.filter)
+		if c.err {
+			assert.NoError(t, err)
+			assert.NotNil(t, res)
+		} else {
+			assert.Nil(t, err)
+		}
+	}
+}
+
 type testStore interface {
 	ethStore
 }
@@ -558,6 +750,15 @@ func (m *mockBlockStore) appendBlocksToStore(blocks []*types.Block) {
 	}
 }
 
+func (m *mockBlockStore) GetHeaderByNumber(num uint64) (*types.Header, bool) {
+	block, ok := m.GetBlockByNumber(num, true)
+	if !ok {
+		return nil, false
+	}
+
+	return block.Header, block.Header != nil
+}
+
 func (m *mockBlockStore) setupLogs() {
 	m.receipts = make(map[types.Hash][]*types.Receipt)