Add a config value for InitCadenceHeight to fix emulator startup issu…

…e and rework the E2E tests

bootstrap/bootstrap.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/onflow/flow-evm-gateway/api"
 	"github.com/onflow/flow-evm-gateway/config"
@@ -34,7 +35,7 @@ func Start(ctx context.Context, cfg *config.Config) error {
 
 	// if database is not initialized require init height
 	if _, err := blocks.LatestCadenceHeight(); errors.Is(err, storageErrs.ErrNotInitialized) {
-		if err := blocks.InitHeights(); err != nil {
+		if err := blocks.InitHeights(cfg.InitCadenceHeight); err != nil {
 			return fmt.Errorf("failed to init the database: %w", err)
 		}
 		logger.Info().Msg("database initialized with 0 evm and cadence heights")
@@ -152,7 +153,14 @@ func startServer(
 		return fmt.Errorf("failed to create a COA signer: %w", err)
 	}
 
-	evm, err := requester.NewEVM(client, cfg.COAAddress, signer, cfg.FlowNetworkID, true, logger)
+	evm, err := requester.NewEVM(
+		client,
+		cfg.COAAddress,
+		signer,
+		cfg.FlowNetworkID,
+		cfg.CreateCOAResource,
+		logger,
+	)
 	if err != nil {
 		return fmt.Errorf("failed to create EVM requester: %w", err)
 	}

config/config.go

@@ -14,6 +14,13 @@ import (
 	"github.com/onflow/flow-go/utils/io"
 )
 
+// Default InitCadenceHeight for initializing the database on a local emulator.
+const EmulatorInitCadenceHeight = uint64(0)
+
+// Default InitCadenceHeight for initializing the database on a live network.
+// We don't use 0 as it has a special meaning to represent latest block in the AN API context.
+const LiveNetworkInitCadenceHeght = uint64(1)
+
 type Config struct {
 	// DatabaseDir is where the database should be stored.
 	DatabaseDir string
@@ -41,6 +48,8 @@ type Config struct {
 	CreateCOAResource bool
 	// GasPrice is a fixed gas price that will be used when submitting transactions.
 	GasPrice *big.Int
+	// InitCadenceHeight is used for initializing the database on a local emulator or a live network.
+	InitCadenceHeight uint64
 }
 
 func FromFlags() (*Config, error) {
@@ -115,8 +124,10 @@ func FromFlags() (*Config, error) {
 	switch flowNetwork {
 	case "flow-previewnet":
 		cfg.FlowNetworkID = flowGo.Previewnet
+		cfg.InitCadenceHeight = EmulatorInitCadenceHeight
 	case "flow-emulator":
 		cfg.FlowNetworkID = flowGo.Emulator
+		cfg.InitCadenceHeight = EmulatorInitCadenceHeight
 	default:
 		return nil, fmt.Errorf("flow network ID not supported, only possible to specify 'flow-previewnet' or 'flow-emulator'")
 	}

integration/e2e_test.go

@@ -288,7 +288,7 @@ func TestIntegration_DeployCallContract(t *testing.T) {
 		heights = append(heights, blk.Height)
 
 		sumHash := blk.TransactionHashes[0]
-		tx, err = txs.Get(sumHash)
+		_, err = txs.Get(sumHash)
 		require.NoError(t, err)
 
 		rcp, err = receipts.GetByTransactionID(sumHash)
@@ -410,23 +410,23 @@ func TestIntegration_DeployCallContract(t *testing.T) {
 func TestE2E_API_DeployEvents(t *testing.T) {
 	srv, err := startEmulator()
 	require.NoError(t, err)
-	emu := srv.Emulator()
-	dbDir := t.TempDir()
 
 	ctx, cancel := context.WithCancel(context.Background())
 	defer func() {
 		cancel()
 		srv.Stop()
 	}()
 
+	emu := srv.Emulator()
+	dbDir := t.TempDir()
 	gwAcc := emu.ServiceKey()
 	gwKey := gwAcc.PrivateKey
 	gwAddress := gwAcc.Address
 
 	cfg := &config.Config{
 		DatabaseDir:        dbDir,
 		AccessNodeGRPCHost: "localhost:3569", // emulator
-		RPCPort:            3001,
+		RPCPort:            8545,
 		RPCHost:            "127.0.0.1",
 		FlowNetworkID:      "flow-emulator",
 		EVMNetworkID:       emulator.FlowEVMTestnetChainID,
@@ -449,26 +449,19 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 	time.Sleep(500 * time.Millisecond) // some time to startup
 
 	flowAmount, _ := cadence.NewUFix64("5.0")
-	gasLimit := uint64(4700000) // arbitrarily big
-
-	storeContract, err := newContract(testContractBinary, testContractABI)
-	require.NoError(t, err)
 
 	// Steps 1, 2 and 3. - create COA and fund it - setup phase
 	res, err := fundEOA(emu, flowAmount, fundEOAAddress)
 	require.NoError(t, err)
 	require.NoError(t, res.Error)
 	assert.Len(t, res.Events, 9)
 
-	eoaKey, err := crypto.HexToECDSA(fundEOARawKey)
-	require.NoError(t, err)
-
 	deployData, err := hex.DecodeString(testContractBinary)
 	require.NoError(t, err)
 
 	time.Sleep(1 * time.Second)
 
-	// estimate gas
+	// estimate gas for contract deployment
 	gasUsed, err := rpcTester.estimateGas(fundEOAAddress, deployData, 200_000)
 	require.Error(t, err)
 	assert.ErrorContains(t, err, "contract creation code storage out of gas")
@@ -478,14 +471,18 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, hexutil.Uint64(215_324), gasUsed)
 
-	// check balance
+	// check EOA balance
 	balance, err := rpcTester.getBalance(fundEOAAddress)
 	require.NoError(t, err)
 	c, _ := cadence.NewUFix64("4.0")
 	assert.Zero(t, balance.ToInt().Cmp(types.NewBalanceFromUFix64(c)))
 
 	// Step 4. - deploy contract
 	nonce := uint64(0)
+	gasLimit := uint64(4700000) // arbitrarily big
+	eoaKey, err := crypto.HexToECDSA(fundEOARawKey)
+	require.NoError(t, err)
+
 	signed, _, err := evmSign(nil, gasLimit, eoaKey, nonce, nil, deployData)
 	nonce++
 	hash, err := rpcTester.sendRawTx(signed)
@@ -494,18 +491,19 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 
 	time.Sleep(1 * time.Second) // todo change
 
-	// todo improve tests to use get latest block request instead of manually tracking block heights
-	// block 6 comes from contract deployment, all blocks before are from creating COA funded account
-	blkRpc, err := rpcTester.getBlock(6)
+	latestBlockNumber, err := rpcTester.blockNumber()
+	require.NoError(t, err)
+
+	blkRpc, err := rpcTester.getBlock(latestBlockNumber)
 	require.NoError(t, err)
 
-	assert.Len(t, blkRpc.Transactions, 1)
+	require.Len(t, blkRpc.Transactions, 1)
 	assert.Equal(t, uintHex(6), blkRpc.Number)
 
 	// check the deployment transaction and receipt
 	deployHash := blkRpc.Transactions[0]
+	require.Equal(t, hash.String(), deployHash)
 
-	// todo require.Equal(t, hash.String(), deployHash)
 	txRpc, err := rpcTester.getTx(deployHash)
 	require.NoError(t, err)
 
@@ -531,6 +529,9 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 	// contract deployment tx.
 	assert.Contains(t, hex.EncodeToString(deployData), hex.EncodeToString(code))
 
+	storeContract, err := newContract(testContractBinary, testContractABI)
+	require.NoError(t, err)
+
 	callRetrieve, err := storeContract.call("retrieve")
 	require.NoError(t, err)
 
@@ -551,8 +552,11 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, nonce, eoaNonce)
 
-	// block 5 comes from contract interaction
-	blkRpc, err = rpcTester.getBlock(7)
+	// block 7 comes from contract interaction
+	latestBlockNumber, err = rpcTester.blockNumber()
+	require.NoError(t, err)
+
+	blkRpc, err = rpcTester.getBlock(latestBlockNumber)
 	require.NoError(t, err)
 	assert.Equal(t, uintHex(7), blkRpc.Number)
 	require.Len(t, blkRpc.Transactions, 1)
@@ -602,8 +606,11 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, nonce, eoaNonce)
 
-	// block comes from contract store interaction
-	blkRpc, err = rpcTester.getBlock(8)
+	// block 8 comes from contract store interaction
+	latestBlockNumber, err = rpcTester.blockNumber()
+	require.NoError(t, err)
+
+	blkRpc, err = rpcTester.getBlock(latestBlockNumber)
 	require.NoError(t, err)
 	assert.Equal(t, uintHex(8), blkRpc.Number)
 	require.Len(t, blkRpc.Transactions, 1)
@@ -624,9 +631,6 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 	assert.Equal(t, uint64(8), rcp.BlockNumber.Uint64())
 	assert.Len(t, rcp.Logs, 0)
 
-	callStore, err = storeContract.call("store", big.NewInt(1337))
-	require.NoError(t, err)
-
 	// step 6 - call sdkEvent emitting function with different values
 	for i := 0; i < 4; i++ {
 		sumA := big.NewInt(5)
@@ -646,14 +650,14 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 		time.Sleep(1 * time.Second)
 
 		// block is produced by above call to the sum that emits sdkEvent
-		blkRpc, err = rpcTester.getBlock(uint64(9 + i))
+		blkRpc, err = rpcTester.getBlock(latestBlockNumber + 1 + uint64(i))
 		require.NoError(t, err)
 		require.Len(t, blkRpc.Transactions, 1)
 
 		sumHash := blkRpc.Transactions[0]
 		assert.Equal(t, signedHash.String(), sumHash)
 
-		txRpc, err = rpcTester.getTx(sumHash)
+		_, err = rpcTester.getTx(sumHash)
 		require.NoError(t, err)
 
 		rcp, err = rpcTester.getReceipt(sumHash)
@@ -679,7 +683,7 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 
 	// successfully filter by block id with found single match for each block
 	for i := 0; i < 4; i++ {
-		blkRpc, err = rpcTester.getBlock(uint64(9 + i))
+		blkRpc, err = rpcTester.getBlock(latestBlockNumber + 1 + uint64(i))
 		require.NoError(t, err)
 
 		blkID := common.HexToHash(blkRpc.Hash)
@@ -704,7 +708,7 @@ func TestE2E_API_DeployEvents(t *testing.T) {
 	}
 
 	// invalid filter by block id with wrong topic value
-	blkRpc, err = rpcTester.getBlock(9)
+	blkRpc, err = rpcTester.getBlock(latestBlockNumber + 1)
 	require.NoError(t, err)
 	blkID := common.HexToHash(blkRpc.Hash)
 	require.NoError(t, err)
@@ -799,7 +803,7 @@ func TestE2E_ConcurrentTransactionSubmission(t *testing.T) {
 	cfg := &config.Config{
 		DatabaseDir:        dbDir,
 		AccessNodeGRPCHost: host,
-		RPCPort:            3001,
+		RPCPort:            8545,
 		RPCHost:            "127.0.0.1",
 		EVMNetworkID:       emulator.FlowEVMTestnetChainID,
 		FlowNetworkID:      "flow-emulator",

integration/helpers.go

@@ -23,6 +23,7 @@ import (
 	"github.com/onflow/flow-emulator/emulator"
 	"github.com/onflow/flow-emulator/server"
 	"github.com/onflow/flow-evm-gateway/api"
+	"github.com/onflow/flow-evm-gateway/config"
 	"github.com/onflow/flow-evm-gateway/services/ingestion"
 	"github.com/onflow/flow-evm-gateway/services/logs"
 	"github.com/onflow/flow-evm-gateway/storage"
@@ -106,7 +107,7 @@ func startEventIngestionEngine(ctx context.Context, dbDir string) (
 	accounts := pebble.NewAccounts(db)
 	txs := pebble.NewTransactions(db)
 
-	err = blocks.InitHeights()
+	err = blocks.InitHeights(config.EmulatorInitCadenceHeight)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@@ -457,6 +458,21 @@ func (r *rpcTest) getBlock(height uint64) (*rpcBlock, error) {
 	return &blkRpc, nil
 }
 
+func (r *rpcTest) blockNumber() (uint64, error) {
+	rpcRes, err := r.request("eth_blockNumber", "[]")
+	if err != nil {
+		return 0, err
+	}
+
+	var blockNumber hexutil.Uint64
+	err = json.Unmarshal(rpcRes, &blockNumber)
+	if err != nil {
+		return 0, err
+	}
+
+	return uint64(blockNumber), nil
+}
+
 func (r *rpcTest) getTx(hash string) (*api.RPCTransaction, error) {
 	rpcRes, err := r.request("eth_getTransactionByHash", fmt.Sprintf(`["%s"]`, hash))
 	if err != nil {
@@ -615,15 +631,3 @@ type rpcBlock struct {
 	ParentHash   string
 	Transactions []string
 }
-
-type rpcTx struct {
-	BlockHash   string
-	BlockNumber string
-	Gas         string
-	GasPrice    string
-	From        string
-	Hash        string
-	Input       hexutil.Bytes
-	Nonce       string
-	Type        string
-}

storage/pebble/blocks.go

@@ -12,10 +12,6 @@ import (
 	"github.com/onflow/flow-go/fvm/evm/types"
 )
 
-// default initCadenceHeight for initializing the database, we don't use 0 as it has
-// a special meaning to represent latest block in the AN API context.
-const initCadenceHeight = uint64(1)
-
 var _ storage.BlockIndexer = &Blocks{}
 
 type Blocks struct {
@@ -147,14 +143,14 @@ func (b *Blocks) SetLatestCadenceHeight(height uint64) error {
 }
 
 // InitHeights sets the Cadence height to zero as well as EVM heights. Used for empty database init.
-func (b *Blocks) InitHeights() error {
+func (b *Blocks) InitHeights(cadenceHeight uint64) error {
 	// sanity check, make sure we don't have any heights stored, disable overwriting the database
 	_, err := b.LatestEVMHeight()
 	if !errors.Is(err, errs.ErrNotInitialized) {
 		return fmt.Errorf("can not init the database that already has data stored")
 	}
 
-	if err := b.store.set(latestCadenceHeightKey, nil, uint64Bytes(initCadenceHeight)); err != nil {
+	if err := b.store.set(latestCadenceHeightKey, nil, uint64Bytes(cadenceHeight)); err != nil {
 		return fmt.Errorf("failed to set init Cadence height: %w", err)
 	}