fix(evmrpc): floor earliest state height at genesis InitialHeight (SEI-10383)

evmrpc/block_txcount_parity_test.go

@@ -36,6 +36,10 @@ func (*parityTxCountTMClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (*parityTxCountTMClient) GenesisInitialHeight() int64 {
+	return 1
+}
+
 func (*parityTxCountTMClient) EvmTxByHash(common.Hash) (tmtypes.Tx, bool) {
 	return nil, false
 }

evmrpc/genesis_latest_state_test.go

@@ -32,6 +32,10 @@ func (*freshChainClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (*freshChainClient) GenesisInitialHeight() int64 {
+	return 1
+}
+
 func (*freshChainClient) EvmTxByHash(common.Hash) (tmtypes.Tx, bool) {
 	return nil, false
 }

evmrpc/height_availability_test.go

@@ -34,6 +34,10 @@ func (*heightTestClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (*heightTestClient) GenesisInitialHeight() int64 {
+	return 1
+}
+
 func (*heightTestClient) EvmTxByHash(common.Hash) (tmtypes.Tx, bool) {
 	return nil, false
 }

evmrpc/setup_test.go

@@ -146,6 +146,10 @@ func (*MockClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (*MockClient) GenesisInitialHeight() int64 {
+	return 1
+}
+
 func (*MockClient) EvmTxByHash(hash common.Hash) (tmtypes.Tx, bool) {
 	tx, err := Encoder(UnconfirmedTx)
 	if err != nil {

evmrpc/simulate_test.go

@@ -1022,6 +1022,10 @@ func (c *fixedBlockClient) EvmNextPendingNonce(common.Address) uint64 {
 	return 0
 }
 
+func (c *fixedBlockClient) GenesisInitialHeight() int64 {
+	return 1
+}
+
 func (c *fixedBlockClient) EvmTxByHash(common.Hash) (tmtypes.Tx, bool) {
 	return nil, false
 }

evmrpc/tests/mock_client.go

@@ -42,6 +42,10 @@ func (c *MockClient) EvmNextPendingNonce(_ common.Address) uint64 {
 	return 0
 }
 
+func (c *MockClient) GenesisInitialHeight() int64 {
+	return 1
+}
+
 func (*MockClient) EvmTxByHash(common.Hash) (tmtypes.Tx, bool) {
 	return nil, false
 }

evmrpc/tx_test.go

@@ -301,6 +301,7 @@ type lowLatestTMClient struct {
 }
 
 func (c *lowLatestTMClient) EvmNextPendingNonce(common.Address) uint64 { return 0 }
+func (c *lowLatestTMClient) GenesisInitialHeight() int64               { return 1 }
 
 func (c *lowLatestTMClient) EvmTxByHash(common.Hash) (tmtypes.Tx, bool) { return nil, false }
 

evmrpc/watermark_manager.go

@@ -8,6 +8,7 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/sei-protocol/sei-chain/sei-cosmos/client"
 	sdk "github.com/sei-protocol/sei-chain/sei-cosmos/types"
+	genesistypes "github.com/sei-protocol/sei-chain/sei-cosmos/types/genesis"
 	"github.com/sei-protocol/sei-chain/sei-db/db_engine/types"
 	"github.com/sei-protocol/sei-chain/sei-db/ledger_db/receipt"
 	"github.com/sei-protocol/sei-chain/sei-tendermint/rpc/coretypes"
@@ -44,6 +45,16 @@ func NewWatermarkManager(
 	}
 }
 
+// genesisInitialHeight returns the chain's genesis InitialHeight, sourced from
+// the local client's in-memory genesis doc, falling back to
+// genesis.DefaultGenesisInitialHeight when the client cannot supply it.
+func (m *WatermarkManager) genesisInitialHeight() int64 {
+	if h := m.tmClient.GenesisInitialHeight(); h > 0 {
+		return h
+	}
+	return genesistypes.DefaultGenesisInitialHeight
+}
+
 // Watermarks returns the earliest block height, earliest state height, and
 // latest height that are safe to serve. Earliest heights are inclusive.
 // It is possible that block latest < block earliest, in case there are no blocks yet.
@@ -66,6 +77,19 @@ func (m *WatermarkManager) Watermarks(ctx context.Context) (int64, int64, int64,
 		latest = min(latest, m.stateStore.GetLatestVersion())
 		stateEarliest = m.stateStore.GetEarliestVersion()
 	}
+
+	// Floor the earliest state height at genesis. A never-pruned store reports
+	// its earliest version as 0 (the earliest-version key is only written by
+	// pruning or state-sync), which would otherwise resolve `earliest` to the
+	// tip via CreateQueryContext's height-0 coercion. Guarding on
+	// stateEarliest < latest leaves the pre-commit window (no blocks yet, where
+	// stateEarliest == latest) reading the genesis checkState, and the clamp to
+	// latest keeps the floor from ever exceeding the safe latest. Using the real
+	// InitialHeight (not a literal 1) keeps this correct for chains started
+	// above height 1, whose version 1 was never committed.
+	if stateEarliest < latest {
+		stateEarliest = max(stateEarliest, min(m.genesisInitialHeight(), latest))
+	}
 	return blockEarliest, stateEarliest, latest, nil
 }