ipld-eth-server/pkg/eth/api_test/api_test.go

// VulcanizeDB
// Copyright © 2019 Vulcanize

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.

// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package eth_api_test

import (
	"context"
	"math/big"

	"github.com/cerc-io/plugeth-statediff/indexer/interfaces"
	"github.com/cerc-io/plugeth-statediff/indexer/ipld"
	sdtypes "github.com/cerc-io/plugeth-statediff/types"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/core/vm"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/eth/filters"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ethereum/go-ethereum/rpc"
	"github.com/jmoiron/sqlx"
	. "github.com/onsi/ginkgo/v2"
	. "github.com/onsi/gomega"

	"github.com/cerc-io/ipld-eth-server/v5/pkg/eth"
	"github.com/cerc-io/ipld-eth-server/v5/pkg/eth/test_helpers"
	"github.com/cerc-io/ipld-eth-server/v5/pkg/shared"
)

var (
	randomAddr     = common.HexToAddress("0x1C3ab14BBaD3D99F4203bd7a11aCB94882050E6f")
	randomHash     = crypto.Keccak256Hash(randomAddr.Bytes())
	number         = rpc.BlockNumber(test_helpers.BlockNumber1)
	blockTime      = test_helpers.BlockTime1
	londonBlockNum = rpc.BlockNumber(test_helpers.LondonBlockNum)
	wrongNumber    = number + 1
	blockHash      = test_helpers.MockBlock.Header().Hash()
	baseFee        = test_helpers.MockLondonBlock.BaseFee()
	ctx            = context.Background()
	chainConfig    = &*params.TestChainConfig

	expectedBlock = map[string]interface{}{
		"number":           (*hexutil.Big)(test_helpers.MockBlock.Number()),
		"hash":             test_helpers.MockBlock.Hash(),
		"parentHash":       test_helpers.MockBlock.ParentHash(),
		"nonce":            test_helpers.MockBlock.Header().Nonce,
		"mixHash":          test_helpers.MockBlock.MixDigest(),
		"sha3Uncles":       test_helpers.MockBlock.UncleHash(),
		"logsBloom":        test_helpers.MockBlock.Bloom(),
		"stateRoot":        test_helpers.MockBlock.Root(),
		"miner":            test_helpers.MockBlock.Coinbase(),
		"difficulty":       (*hexutil.Big)(test_helpers.MockBlock.Difficulty()),
		"extraData":        hexutil.Bytes(test_helpers.MockBlock.Header().Extra),
		"gasLimit":         hexutil.Uint64(test_helpers.MockBlock.GasLimit()),
		"gasUsed":          hexutil.Uint64(test_helpers.MockBlock.GasUsed()),
		"timestamp":        hexutil.Uint64(test_helpers.MockBlock.Time()),
		"transactionsRoot": test_helpers.MockBlock.TxHash(),
		"receiptsRoot":     test_helpers.MockBlock.ReceiptHash(),
		"totalDifficulty":  (*hexutil.Big)(test_helpers.MockBlock.Difficulty()),
		"size":             hexutil.Uint64(test_helpers.MockBlock.Size()),
	}
	expectedHeader = map[string]interface{}{
		"number":           (*hexutil.Big)(test_helpers.MockBlock.Header().Number),
		"hash":             blockHash,
		"parentHash":       test_helpers.MockBlock.Header().ParentHash,
		"nonce":            test_helpers.MockBlock.Header().Nonce,
		"mixHash":          test_helpers.MockBlock.Header().MixDigest,
		"sha3Uncles":       test_helpers.MockBlock.Header().UncleHash,
		"logsBloom":        test_helpers.MockBlock.Header().Bloom,
		"stateRoot":        test_helpers.MockBlock.Header().Root,
		"miner":            test_helpers.MockBlock.Header().Coinbase,
		"difficulty":       (*hexutil.Big)(test_helpers.MockBlock.Header().Difficulty),
		"extraData":        hexutil.Bytes(test_helpers.MockBlock.Header().Extra),
		"gasLimit":         hexutil.Uint64(test_helpers.MockBlock.Header().GasLimit),
		"gasUsed":          hexutil.Uint64(test_helpers.MockBlock.Header().GasUsed),
		"timestamp":        hexutil.Uint64(test_helpers.MockBlock.Header().Time),
		"transactionsRoot": test_helpers.MockBlock.Header().TxHash,
		"receiptsRoot":     test_helpers.MockBlock.Header().ReceiptHash,
		"totalDifficulty":  (*hexutil.Big)(test_helpers.MockBlock.Header().Difficulty),
	}
	expectedUncle1 = map[string]interface{}{
		"number":           (*hexutil.Big)(test_helpers.MockUncles[0].Number),
		"hash":             test_helpers.MockUncles[0].Hash(),
		"parentHash":       test_helpers.MockUncles[0].ParentHash,
		"nonce":            test_helpers.MockUncles[0].Nonce,
		"mixHash":          test_helpers.MockUncles[0].MixDigest,
		"sha3Uncles":       test_helpers.MockUncles[0].UncleHash,
		"logsBloom":        test_helpers.MockUncles[0].Bloom,
		"stateRoot":        test_helpers.MockUncles[0].Root,
		"miner":            test_helpers.MockUncles[0].Coinbase,
		"difficulty":       (*hexutil.Big)(test_helpers.MockUncles[0].Difficulty),
		"extraData":        hexutil.Bytes(test_helpers.MockUncles[0].Extra),
		"size":             hexutil.Uint64(types.NewBlockWithHeader(test_helpers.MockUncles[0]).Size()),
		"gasLimit":         hexutil.Uint64(test_helpers.MockUncles[0].GasLimit),
		"gasUsed":          hexutil.Uint64(test_helpers.MockUncles[0].GasUsed),
		"timestamp":        hexutil.Uint64(test_helpers.MockUncles[0].Time),
		"transactionsRoot": test_helpers.MockUncles[0].TxHash,
		"receiptsRoot":     test_helpers.MockUncles[0].ReceiptHash,
		"uncles":           []common.Hash{},
	}
	expectedUncle2 = map[string]interface{}{
		"number":           (*hexutil.Big)(test_helpers.MockUncles[1].Number),
		"hash":             test_helpers.MockUncles[1].Hash(),
		"parentHash":       test_helpers.MockUncles[1].ParentHash,
		"nonce":            test_helpers.MockUncles[1].Nonce,
		"mixHash":          test_helpers.MockUncles[1].MixDigest,
		"sha3Uncles":       test_helpers.MockUncles[1].UncleHash,
		"logsBloom":        test_helpers.MockUncles[1].Bloom,
		"stateRoot":        test_helpers.MockUncles[1].Root,
		"miner":            test_helpers.MockUncles[1].Coinbase,
		"difficulty":       (*hexutil.Big)(test_helpers.MockUncles[1].Difficulty),
		"extraData":        hexutil.Bytes(test_helpers.MockUncles[1].Extra),
		"size":             hexutil.Uint64(types.NewBlockWithHeader(test_helpers.MockUncles[1]).Size()),
		"gasLimit":         hexutil.Uint64(test_helpers.MockUncles[1].GasLimit),
		"gasUsed":          hexutil.Uint64(test_helpers.MockUncles[1].GasUsed),
		"timestamp":        hexutil.Uint64(test_helpers.MockUncles[1].Time),
		"transactionsRoot": test_helpers.MockUncles[1].TxHash,
		"receiptsRoot":     test_helpers.MockUncles[1].ReceiptHash,
		"uncles":           []common.Hash{},
	}
	expectedTransaction       = eth.NewRPCTransaction(test_helpers.MockTransactions[0], test_helpers.MockBlock.Hash(), test_helpers.MockBlock.NumberU64(), blockTime, 0, test_helpers.MockBlock.BaseFee(), chainConfig)
	expectedTransaction2      = eth.NewRPCTransaction(test_helpers.MockTransactions[1], test_helpers.MockBlock.Hash(), test_helpers.MockBlock.NumberU64(), blockTime, 1, test_helpers.MockBlock.BaseFee(), chainConfig)
	expectedTransaction3      = eth.NewRPCTransaction(test_helpers.MockTransactions[2], test_helpers.MockBlock.Hash(), test_helpers.MockBlock.NumberU64(), blockTime, 2, test_helpers.MockBlock.BaseFee(), chainConfig)
	expectedLondonTransaction = eth.NewRPCTransaction(
		test_helpers.MockLondonTransactions[0],
		test_helpers.MockLondonBlock.Hash(),
		test_helpers.MockLondonBlock.NumberU64(),
		test_helpers.MockLondonBlock.Time(),
		0,
		test_helpers.MockLondonBlock.BaseFee(),
		chainConfig,
	)
	expectRawTx, _  = test_helpers.MockTransactions[0].MarshalBinary()
	expectRawTx2, _ = test_helpers.MockTransactions[1].MarshalBinary()
	expectRawTx3, _ = test_helpers.MockTransactions[2].MarshalBinary()
	expectedReceipt = map[string]interface{}{
		"blockHash":         blockHash,
		"blockNumber":       hexutil.Uint64(uint64(number.Int64())),
		"transactionHash":   expectedTransaction.Hash,
		"transactionIndex":  hexutil.Uint64(0),
		"from":              expectedTransaction.From,
		"to":                expectedTransaction.To,
		"gasUsed":           hexutil.Uint64(test_helpers.MockReceipts[0].GasUsed),
		"cumulativeGasUsed": hexutil.Uint64(test_helpers.MockReceipts[0].CumulativeGasUsed),
		"contractAddress":   nil,
		"logs":              test_helpers.MockReceipts[0].Logs,
		"logsBloom":         test_helpers.MockReceipts[0].Bloom,
		"status":            hexutil.Uint(test_helpers.MockReceipts[0].Status),
		"effectiveGasPrice": (*hexutil.Big)(big.NewInt(100)),
		"type":              hexutil.Uint64(types.LegacyTxType),
	}
	expectedReceipt2 = map[string]interface{}{
		"blockHash":         blockHash,
		"blockNumber":       hexutil.Uint64(uint64(number.Int64())),
		"transactionHash":   expectedTransaction2.Hash,
		"transactionIndex":  hexutil.Uint64(1),
		"from":              expectedTransaction2.From,
		"to":                expectedTransaction2.To,
		"gasUsed":           hexutil.Uint64(test_helpers.MockReceipts[1].GasUsed),
		"cumulativeGasUsed": hexutil.Uint64(test_helpers.MockReceipts[1].CumulativeGasUsed),
		"contractAddress":   nil,
		"logs":              test_helpers.MockReceipts[1].Logs,
		"logsBloom":         test_helpers.MockReceipts[1].Bloom,
		"root":              hexutil.Bytes(test_helpers.MockReceipts[1].PostState),
		"effectiveGasPrice": (*hexutil.Big)(big.NewInt(200)),
		"type":              hexutil.Uint64(types.LegacyTxType),
	}
	expectedReceipt3 = map[string]interface{}{
		"blockHash":         blockHash,
		"blockNumber":       hexutil.Uint64(uint64(number.Int64())),
		"transactionHash":   expectedTransaction3.Hash,
		"transactionIndex":  hexutil.Uint64(2),
		"from":              expectedTransaction3.From,
		"to":                expectedTransaction3.To,
		"gasUsed":           hexutil.Uint64(test_helpers.MockReceipts[2].GasUsed),
		"cumulativeGasUsed": hexutil.Uint64(test_helpers.MockReceipts[2].CumulativeGasUsed),
		"contractAddress":   test_helpers.ContractAddress,
		"logs":              test_helpers.MockReceipts[2].Logs,
		"logsBloom":         test_helpers.MockReceipts[2].Bloom,
		"root":              hexutil.Bytes(test_helpers.MockReceipts[2].PostState),
		"effectiveGasPrice": (*hexutil.Big)(big.NewInt(150)),
		"type":              hexutil.Uint64(types.LegacyTxType),
	}
)

var (
	db  *sqlx.DB
	api *eth.PublicEthAPI
)

var _ = BeforeSuite(func() {
	var (
		err error
		tx  interfaces.Batch
	)

	db = shared.SetupDB()
	indexAndPublisher := shared.SetupTestStateDiffIndexer(ctx, chainConfig, test_helpers.Genesis.Hash())

	backend, err := eth.NewEthBackend(db, &eth.Config{
		ChainConfig: chainConfig,
		VMConfig:    vm.Config{},
		RPCGasCap:   big.NewInt(10000000000), // Max gas capacity for a rpc call.
		GroupCacheConfig: &shared.GroupCacheConfig{
			StateDB: shared.GroupConfig{
				Name:                   "api_test",
				CacheSizeInMB:          8,
				CacheExpiryInMins:      60,
				LogStatsIntervalInSecs: 0,
			},
		},
	})
	Expect(err).ToNot(HaveOccurred())
	api, _ = eth.NewPublicEthAPI(backend, nil, eth.APIConfig{StateDiffTimeout: shared.DefaultStateDiffTimeout})
	tx, err = indexAndPublisher.PushBlock(test_helpers.MockBlock, test_helpers.MockReceipts, test_helpers.MockBlock.Difficulty())
	Expect(err).ToNot(HaveOccurred())
	defer tx.RollbackOnFailure(err)

	ipld := sdtypes.IPLD{
		CID:     ipld.Keccak256ToCid(ipld.RawBinary, test_helpers.CodeHash.Bytes()).String(),
		Content: test_helpers.ContractCode,
	}
	err = indexAndPublisher.PushIPLD(tx, ipld)
	Expect(err).ToNot(HaveOccurred())

	for _, node := range test_helpers.MockStateNodes {
		err = indexAndPublisher.PushStateNode(tx, node, test_helpers.MockBlock.Hash().String())
		Expect(err).ToNot(HaveOccurred())
	}

	err = tx.Submit()
	Expect(err).ToNot(HaveOccurred())

	uncles := test_helpers.MockBlock.Uncles()
	uncleHashes := make([]common.Hash, len(uncles))
	for i, uncle := range uncles {
		uncleHashes[i] = uncle.Hash()
	}
	expectedBlock["uncles"] = uncleHashes

	// setting chain config to for london block
	chainConfig.LondonBlock = big.NewInt(2)
	indexAndPublisher = shared.SetupTestStateDiffIndexer(ctx, chainConfig, test_helpers.Genesis.Hash())

	tx, err = indexAndPublisher.PushBlock(test_helpers.MockLondonBlock, test_helpers.MockLondonReceipts, test_helpers.MockLondonBlock.Difficulty())
	Expect(err).ToNot(HaveOccurred())
	defer tx.RollbackOnFailure(err)

	err = tx.Submit()
	Expect(err).ToNot(HaveOccurred())
})

var _ = AfterSuite(func() { shared.TearDownDB(db) })

var _ = Describe("API", func() {
	/*

	   Headers and blocks

	*/
	Describe("eth_getHeaderByNumber", func() {
		It("Retrieves a header by number", func() {
			header, err := api.GetHeaderByNumber(ctx, number)
			Expect(err).ToNot(HaveOccurred())
			Expect(header).To(Equal(expectedHeader))
		})

		It("Throws an error if a header cannot be found", func() {
			header, err := api.GetHeaderByNumber(ctx, wrongNumber)
			Expect(err).To(HaveOccurred())
			Expect(err.Error()).To(ContainSubstring("sql: no rows in result set"))
			Expect(header).To(BeNil())
		})
	})

	Describe("eth_getHeaderByHash", func() {
		It("Retrieves a header by hash", func() {
			header := api.GetHeaderByHash(ctx, blockHash)
			Expect(header).To(Equal(expectedHeader))
		})

		It("Throws an error if a header cannot be found", func() {
			header := api.GetHeaderByHash(ctx, randomHash)
			Expect(header).To(BeNil())
		})
	})

	Describe("eth_blockNumber", func() {
		It("Retrieves the head block number", func() {
			bn := api.BlockNumber()
			Expect(bn).To(Equal(hexutil.Uint64(test_helpers.LondonBlockNum)))
		})
	})

	Describe("eth_getBlockByNumber", func() {
		It("Retrieves a block by number, without full txs", func() {
			block, err := api.GetBlockByNumber(ctx, number, false)
			Expect(err).ToNot(HaveOccurred())
			transactionHashes := make([]interface{}, len(test_helpers.MockBlock.Transactions()))
			for i, trx := range test_helpers.MockBlock.Transactions() {
				transactionHashes[i] = trx.Hash()
			}
			expectedBlock["transactions"] = transactionHashes
			for key, val := range expectedBlock {
				Expect(val).To(Equal(block[key]))
			}
		})
		It("Retrieves a block by number, with full txs", func() {
			block, err := api.GetBlockByNumber(ctx, number, true)
			Expect(err).ToNot(HaveOccurred())
			transactions := make([]interface{}, len(test_helpers.MockBlock.Transactions()))
			for i, trx := range test_helpers.MockBlock.Transactions() {
				transactions[i] = eth.NewRPCTransactionFromBlockHash(test_helpers.MockBlock, trx.Hash(), chainConfig)
			}
			expectedBlock["transactions"] = transactions
			for key, val := range expectedBlock {
				Expect(val).To(Equal(block[key]))
			}
		})
		It("Returns `nil` if a block cannot be found", func() {
			block, err := api.GetBlockByNumber(ctx, wrongNumber, false)
			Expect(err).ToNot(HaveOccurred())
			Expect(block).To(BeNil())
		})
		It("Fetch BaseFee from london block by block number, returns `nil` for legacy block", func() {
			block, err := api.GetBlockByNumber(ctx, number, false)
			Expect(err).ToNot(HaveOccurred())
			_, ok := block["baseFeePerGas"]
			Expect(ok).To(Equal(false))

			block, err = api.GetBlockByNumber(ctx, londonBlockNum, false)
			Expect(err).ToNot(HaveOccurred())
			Expect(block["baseFeePerGas"]).To(Equal((*hexutil.Big)(baseFee)))
		})
		It("Retrieves a block by number with uncles in correct order", func() {
			block, err := api.GetBlockByNumber(ctx, londonBlockNum, false)
			Expect(err).ToNot(HaveOccurred())

			expectedUncles := []common.Hash{
				test_helpers.MockLondonUncles[0].Hash(),
				test_helpers.MockLondonUncles[1].Hash(),
			}
			Expect(block["uncles"]).To(Equal(expectedUncles))
			Expect(block["sha3Uncles"]).To(Equal(test_helpers.MockLondonBlock.UncleHash()))
			Expect(block["hash"]).To(Equal(test_helpers.MockLondonBlock.Hash()))
		})
	})

	Describe("eth_getBlockByHash", func() {
		It("Retrieves a block by hash, without full txs", func() {
			block, err := api.GetBlockByHash(ctx, test_helpers.MockBlock.Hash(), false)
			Expect(err).ToNot(HaveOccurred())
			transactionHashes := make([]interface{}, len(test_helpers.MockBlock.Transactions()))
			for i, trx := range test_helpers.MockBlock.Transactions() {
				transactionHashes[i] = trx.Hash()
			}
			expectedBlock["transactions"] = transactionHashes
			for key, val := range expectedBlock {
				Expect(val).To(Equal(block[key]))
			}
		})
		It("Retrieves a block by hash, with full txs", func() {
			block, err := api.GetBlockByHash(ctx, test_helpers.MockBlock.Hash(), true)
			Expect(err).ToNot(HaveOccurred())
			transactions := make([]interface{}, len(test_helpers.MockBlock.Transactions()))
			for i, trx := range test_helpers.MockBlock.Transactions() {
				transactions[i] = eth.NewRPCTransactionFromBlockHash(test_helpers.MockBlock, trx.Hash(), chainConfig)
			}
			expectedBlock["transactions"] = transactions
			for key, val := range expectedBlock {
				Expect(val).To(Equal(block[key]))
			}
		})
		It("Returns `nil` if a block cannot be found", func() {
			block, err := api.GetBlockByHash(ctx, randomHash, false)
			Expect(err).ToNot(HaveOccurred())
			Expect(block).To(BeZero())
		})
		It("Fetch BaseFee from london block by block hash, returns `nil` for legacy block", func() {
			block, err := api.GetBlockByHash(ctx, test_helpers.MockBlock.Hash(), true)
			Expect(err).ToNot(HaveOccurred())
			_, ok := block["baseFeePerGas"]
			Expect(ok).To(Equal(false))
			block, err = api.GetBlockByHash(ctx, test_helpers.MockLondonBlock.Hash(), false)
			Expect(err).ToNot(HaveOccurred())
			Expect(block["baseFeePerGas"]).To(Equal((*hexutil.Big)(baseFee)))
		})
		It("Retrieves a block by hash with uncles in correct order", func() {
			block, err := api.GetBlockByHash(ctx, test_helpers.MockLondonBlock.Hash(), false)
			Expect(err).ToNot(HaveOccurred())

			expectedUncles := []common.Hash{
				test_helpers.MockLondonUncles[0].Hash(),
				test_helpers.MockLondonUncles[1].Hash(),
			}
			Expect(block["uncles"]).To(Equal(expectedUncles))
			Expect(block["sha3Uncles"]).To(Equal(test_helpers.MockLondonBlock.UncleHash()))
			Expect(block["hash"]).To(Equal(test_helpers.MockLondonBlock.Hash()))
		})
	})

	/*

	   Uncles

	*/

	Describe("eth_getUncleByBlockNumberAndIndex", func() {
		It("Retrieves the uncle at the provided index in the canoncial block with the provided hash", func() {
			uncle1, err := api.GetUncleByBlockNumberAndIndex(ctx, number, 0)
			Expect(err).ToNot(HaveOccurred())
			Expect(uncle1).To(Equal(expectedUncle1))
			uncle2, err := api.GetUncleByBlockNumberAndIndex(ctx, number, 1)
			Expect(err).ToNot(HaveOccurred())
			Expect(uncle2).To(Equal(expectedUncle2))
		})
		It("Returns `nil` if an block for block number cannot be found", func() {
			block, err := api.GetUncleByBlockNumberAndIndex(ctx, wrongNumber, 0)
			Expect(err).ToNot(HaveOccurred())
			Expect(block).To(BeNil())
		})
		It("Returns `nil` if an uncle at the provided index does not exist for the block found for the provided block number", func() {
			uncle, err := api.GetUncleByBlockNumberAndIndex(ctx, number, 2)
			Expect(err).ToNot(HaveOccurred())
			Expect(uncle).To(BeNil())
		})
	})

	Describe("eth_getUncleByBlockHashAndIndex", func() {
		It("Retrieves the uncle at the provided index in the block with the provided hash", func() {
			uncle1, err := api.GetUncleByBlockHashAndIndex(ctx, blockHash, 0)
			Expect(err).ToNot(HaveOccurred())
			Expect(uncle1).To(Equal(expectedUncle1))
			uncle2, err := api.GetUncleByBlockHashAndIndex(ctx, blockHash, 1)
			Expect(err).ToNot(HaveOccurred())
			Expect(uncle2).To(Equal(expectedUncle2))
		})
		It("Returns `nil` if a block for blockhash cannot be found", func() {
			block, err := api.GetUncleByBlockHashAndIndex(ctx, randomHash, 0)
			Expect(err).ToNot(HaveOccurred())
			Expect(block).To(BeNil())
		})
		It("Returns `nil` if an uncle at the provided index does not exist for the block with the provided hash", func() {
			uncle, err := api.GetUncleByBlockHashAndIndex(ctx, blockHash, 2)
			Expect(err).ToNot(HaveOccurred())
			Expect(uncle).To(BeNil())
		})
	})

	Describe("eth_getUncleCountByBlockNumber", func() {
		It("Retrieves the number of uncles for the canonical block with the provided number", func() {
			count := api.GetUncleCountByBlockNumber(ctx, number)
			Expect(*count).NotTo(Equal(nil))
			Expect(uint64(*count)).To(Equal(uint64(2)))
		})
	})

	Describe("eth_getUncleCountByBlockHash", func() {
		It("Retrieves the number of uncles for the block with the provided hash", func() {
			count := api.GetUncleCountByBlockHash(ctx, blockHash)
			Expect(*count).NotTo(Equal(nil))
			Expect(uint64(*count)).To(Equal(uint64(2)))
		})
	})

	/*

	   Transactions

	*/

	Describe("eth_getTransactionCount", func() {
		It("Retrieves the number of transactions the given address has sent for the given block number", func() {
			count, err := api.GetTransactionCount(ctx, test_helpers.ContractAddress, rpc.BlockNumberOrHashWithNumber(number))
			Expect(err).ToNot(HaveOccurred())
			Expect(*count).To(Equal(hexutil.Uint64(1)))

			count, err = api.GetTransactionCount(ctx, test_helpers.AccountAddresss, rpc.BlockNumberOrHashWithNumber(number))
			Expect(err).ToNot(HaveOccurred())
			Expect(*count).To(Equal(hexutil.Uint64(0)))
		})
		It("Retrieves the number of transactions the given address has sent for the given block hash", func() {
			count, err := api.GetTransactionCount(ctx, test_helpers.ContractAddress, rpc.BlockNumberOrHashWithHash(blockHash, true))
			Expect(err).ToNot(HaveOccurred())
			Expect(*count).To(Equal(hexutil.Uint64(1)))

			count, err = api.GetTransactionCount(ctx, test_helpers.AccountAddresss, rpc.BlockNumberOrHashWithHash(blockHash, true))
			Expect(err).ToNot(HaveOccurred())
			Expect(*count).To(Equal(hexutil.Uint64(0)))
		})
	})

	Describe("eth_getBlockTransactionCountByNumber", func() {
		It("Retrieves the number of transactions in the canonical block with the provided number", func() {
			count := api.GetBlockTransactionCountByNumber(ctx, number)
			Expect(uint64(*count)).To(Equal(uint64(4)))
		})
	})

	Describe("eth_getBlockTransactionCountByHash", func() {
		It("Retrieves the number of transactions in the block with the provided hash ", func() {
			count := api.GetBlockTransactionCountByHash(ctx, blockHash)
			Expect(uint64(*count)).To(Equal(uint64(4)))
		})
	})

	Describe("eth_getTransactionByBlockNumberAndIndex", func() {
		It("Retrieves the tx with the provided index in the canonical block with the provided block number", func() {
			tx := api.GetTransactionByBlockNumberAndIndex(ctx, number, 0)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(expectedTransaction))

			tx = api.GetTransactionByBlockNumberAndIndex(ctx, number, 1)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(expectedTransaction2))

			tx = api.GetTransactionByBlockNumberAndIndex(ctx, number, 2)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(expectedTransaction3))
		})
		It("Retrieves the GasFeeCap and GasTipCap for dynamic transaction from the london block hash", func() {
			tx := api.GetTransactionByBlockNumberAndIndex(ctx, londonBlockNum, 0)
			Expect(tx).ToNot(BeNil())
			Expect(tx.GasFeeCap).To(Equal((*hexutil.Big)(test_helpers.MockLondonTransactions[0].GasFeeCap())))
			Expect(tx.GasTipCap).To(Equal((*hexutil.Big)(test_helpers.MockLondonTransactions[0].GasTipCap())))
			Expect(tx).To(Equal(expectedLondonTransaction))
		})
	})

	Describe("eth_getTransactionByBlockHashAndIndex", func() {
		It("Retrieves the tx with the provided index in the block with the provided hash", func() {
			tx := api.GetTransactionByBlockHashAndIndex(ctx, blockHash, 0)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(expectedTransaction))

			tx = api.GetTransactionByBlockHashAndIndex(ctx, blockHash, 1)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(expectedTransaction2))

			tx = api.GetTransactionByBlockHashAndIndex(ctx, blockHash, 2)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(expectedTransaction3))
		})

		It("Retrieves the GasFeeCap and GasTipCap for dynamic transaction from the london block hash", func() {
			tx := api.GetTransactionByBlockHashAndIndex(ctx, test_helpers.MockLondonBlock.Hash(), 0)
			Expect(tx).ToNot(BeNil())
			Expect(tx.GasFeeCap).To(Equal((*hexutil.Big)(test_helpers.MockLondonTransactions[0].GasFeeCap())))
			Expect(tx.GasTipCap).To(Equal((*hexutil.Big)(test_helpers.MockLondonTransactions[0].GasTipCap())))
			Expect(tx).To(Equal(expectedLondonTransaction))
		})
	})

	Describe("eth_getRawTransactionByBlockNumberAndIndex", func() {
		It("Retrieves the raw tx with the provided index in the canonical block with the provided block number", func() {
			tx := api.GetRawTransactionByBlockNumberAndIndex(ctx, number, 0)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx)))

			tx = api.GetRawTransactionByBlockNumberAndIndex(ctx, number, 1)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx2)))

			tx = api.GetRawTransactionByBlockNumberAndIndex(ctx, number, 2)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx3)))
		})
	})

	Describe("eth_getRawTransactionByBlockHashAndIndex", func() {
		It("Retrieves the raw tx with the provided index in the block with the provided hash", func() {
			tx := api.GetRawTransactionByBlockHashAndIndex(ctx, blockHash, 0)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx)))

			tx = api.GetRawTransactionByBlockHashAndIndex(ctx, blockHash, 1)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx2)))

			tx = api.GetRawTransactionByBlockHashAndIndex(ctx, blockHash, 2)
			Expect(tx).ToNot(BeNil())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx3)))
		})
	})

	Describe("eth_getTransactionByHash", func() {
		It("Retrieves a transaction by hash", func() {
			hash := test_helpers.MockTransactions[0].Hash()
			tx, err := api.GetTransactionByHash(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(tx).To(Equal(expectedTransaction))

			hash = test_helpers.MockTransactions[1].Hash()
			tx, err = api.GetTransactionByHash(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(tx).To(Equal(expectedTransaction2))

			hash = test_helpers.MockTransactions[2].Hash()
			tx, err = api.GetTransactionByHash(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(tx).To(Equal(expectedTransaction3))
		})
		It("Throws an error if it cannot find a tx for the provided tx hash", func() {
			_, err := api.GetTransactionByHash(ctx, randomHash)
			Expect(err).To(HaveOccurred())
		})
	})

	Describe("eth_getRawTransactionByHash", func() {
		It("Retrieves a raw transaction by hash", func() {
			hash := test_helpers.MockTransactions[0].Hash()
			tx, err := api.GetRawTransactionByHash(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx)))

			hash = test_helpers.MockTransactions[1].Hash()
			tx, err = api.GetRawTransactionByHash(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx2)))

			hash = test_helpers.MockTransactions[2].Hash()
			tx, err = api.GetRawTransactionByHash(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(tx).To(Equal(hexutil.Bytes(expectRawTx3)))
		})
		It("Throws an error if it cannot find a tx for the provided tx hash", func() {
			_, err := api.GetRawTransactionByHash(ctx, randomHash)
			Expect(err).To(HaveOccurred())
		})
	})

	/*

	   Receipts and logs

	*/

	Describe("eth_getTransactionReceipt", func() {
		It("Retrieves a receipt by tx hash", func() {
			hash := test_helpers.MockTransactions[0].Hash()
			rct, err := api.GetTransactionReceipt(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(rct).To(Equal(expectedReceipt))

			hash = test_helpers.MockTransactions[1].Hash()
			rct, err = api.GetTransactionReceipt(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(rct).To(Equal(expectedReceipt2))

			hash = test_helpers.MockTransactions[2].Hash()
			rct, err = api.GetTransactionReceipt(ctx, hash)
			Expect(err).ToNot(HaveOccurred())
			Expect(rct).To(Equal(expectedReceipt3))
		})
		It("Throws an error if it cannot find a receipt for the provided tx hash", func() {
			_, err := api.GetTransactionReceipt(ctx, randomHash)
			Expect(err).To(HaveOccurred())
		})
	})

	Describe("eth_getLogs", func() {
		It("Retrieves receipt logs that match the provided topics within the provided range", func() {
			crit := filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x0c"),
					},
					{
						common.HexToHash("0x0a"),
					},
					{
						common.HexToHash("0x0b"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err := api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(0))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x08"),
					},
					{
						common.HexToHash("0x0a"),
					},
					{
						common.HexToHash("0x0c"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(0))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x09"),
					},
					{
						common.HexToHash("0x0a"),
					},
					{
						common.HexToHash("0x0b"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog4}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x05"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(2))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x06"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
					},
					{
						common.HexToHash("0x07"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(0))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
					},
					{
						common.HexToHash("0x06"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x07"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x06"),
						common.HexToHash("0x07"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x06"),
						common.HexToHash("0x07"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(2))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{},
					{
						common.HexToHash("0x07"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				Topics: [][]common.Hash{
					{},
					{
						common.HexToHash("0x06"),
					},
				},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1}))

			crit = filters.FilterCriteria{
				Topics:    [][]common.Hash{},
				FromBlock: test_helpers.MockBlock.Number(),
				ToBlock:   test_helpers.MockBlock.Number(),
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(6))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2, test_helpers.MockLog3, test_helpers.MockLog4, test_helpers.MockLog5, test_helpers.MockLog6}))
		})

		It("Uses the provided blockhash if one is provided", func() {
			hash := test_helpers.MockBlock.Hash()
			crit := filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{},
					{
						common.HexToHash("0x06"),
					},
				},
			}
			logs, err := api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1}))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
					},
					{
						common.HexToHash("0x06"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1}))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{},
					{
						common.HexToHash("0x07"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x07"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
					},
					{
						common.HexToHash("0x07"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(0))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x07"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x05"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(2))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x06"),
						common.HexToHash("0x07"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(2))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2}))

			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Topics:    [][]common.Hash{},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(6))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2, test_helpers.MockLog3, test_helpers.MockLog4, test_helpers.MockLog5, test_helpers.MockLog6}))
		})

		It("Filters on contract address if any are provided", func() {
			hash := test_helpers.MockBlock.Hash()
			crit := filters.FilterCriteria{
				BlockHash: &hash,
				Addresses: []common.Address{
					test_helpers.Address,
				},
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x06"),
						common.HexToHash("0x07"),
					},
				},
			}
			logs, err := api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(1))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1}))

			hash = test_helpers.MockBlock.Hash()
			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Addresses: []common.Address{
					test_helpers.Address,
					test_helpers.AnotherAddress,
				},
				Topics: [][]common.Hash{
					{
						common.HexToHash("0x04"),
						common.HexToHash("0x05"),
					},
					{
						common.HexToHash("0x06"),
						common.HexToHash("0x07"),
					},
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(2))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2}))

			hash = test_helpers.MockBlock.Hash()
			crit = filters.FilterCriteria{
				BlockHash: &hash,
				Addresses: []common.Address{
					test_helpers.Address,
					test_helpers.AnotherAddress,
				},
			}
			logs, err = api.GetLogs(ctx, crit)
			Expect(err).ToNot(HaveOccurred())
			Expect(len(logs)).To(Equal(2))
			Expect(logs).To(Equal([]*types.Log{test_helpers.MockLog1, test_helpers.MockLog2}))
		})
	})

	/*

	   State and storage

	*/

	Describe("eth_getBalance", func() {
		It("Retrieves the eth balance for the provided account address at the block with the provided number", func() {
			bal, err := api.GetBalance(ctx, test_helpers.AccountAddresss, rpc.BlockNumberOrHashWithNumber(number))
			Expect(err).ToNot(HaveOccurred())
			Expect(bal).To(Equal((*hexutil.Big)(test_helpers.AccountBalance.ToBig())))

			bal, err = api.GetBalance(ctx, test_helpers.ContractAddress, rpc.BlockNumberOrHashWithNumber(number))
			Expect(err).ToNot(HaveOccurred())
			Expect(bal.ToInt().Cmp(common.Big0)).To(Equal(0))
		})
		It("Retrieves the eth balance for the provided account address at the block with the provided hash", func() {
			bal, err := api.GetBalance(ctx, test_helpers.AccountAddresss, rpc.BlockNumberOrHashWithHash(blockHash, true))
			Expect(err).ToNot(HaveOccurred())
			Expect(bal).To(Equal((*hexutil.Big)(test_helpers.AccountBalance.ToBig())))

			bal, err = api.GetBalance(ctx, test_helpers.ContractAddress, rpc.BlockNumberOrHashWithHash(blockHash, true))
			Expect(err).ToNot(HaveOccurred())
			Expect(bal.ToInt().Cmp(common.Big0)).To(Equal(0))
		})
		It("Retrieves the eth balance for the non-existing account address at the block with the provided hash", func() {
			bal, err := api.GetBalance(ctx, randomAddr, rpc.BlockNumberOrHashWithHash(blockHash, true))
			Expect(err).ToNot(HaveOccurred())
			Expect(bal).To(Equal((*hexutil.Big)(common.Big0)))
		})
		It("Throws an error for an account of a non-existing block hash", func() {
			_, err := api.GetBalance(ctx, test_helpers.AccountAddresss, rpc.BlockNumberOrHashWithHash(randomHash, true))
			Expect(err).To(HaveOccurred())
		})
		It("Throws an error for an account of a non-existing block number", func() {
			_, err := api.GetBalance(ctx, test_helpers.AccountAddresss, rpc.BlockNumberOrHashWithNumber(wrongNumber))
			Expect(err).To(HaveOccurred())
		})
	})

	Describe("eth_getCode", func() {
		It("Retrieves the code for the provided contract address at the block with the provided number", func() {
			code, err := api.GetCode(ctx, test_helpers.ContractAddress, rpc.BlockNumberOrHashWithNumber(number))
			Expect(err).ToNot(HaveOccurred())
			Expect(code).To(Equal((hexutil.Bytes)(test_helpers.ContractCode)))
		})
		It("Retrieves the code for the provided contract address at the block with the provided hash", func() {
			code, err := api.GetCode(ctx, test_helpers.ContractAddress, rpc.BlockNumberOrHashWithHash(blockHash, true))
			Expect(err).ToNot(HaveOccurred())
			Expect(code).To(Equal((hexutil.Bytes)(test_helpers.ContractCode)))
		})
		It("Returns `nil` for an account it cannot find the code for", func() {
			code, err := api.GetCode(ctx, randomAddr, rpc.BlockNumberOrHashWithHash(blockHash, true))
			Expect(err).ToNot(HaveOccurred())
			Expect(code).To(BeEmpty())
		})
	})
})