cherry-pick return meaningful error instead of malformed data if block is pruned (#2473)

## Describe your changes and provide context

## Testing performed to validate your change

---------

Co-authored-by: Tony Chen <[email protected]>

Author: stevenlanders

app/app.go

@@ -1833,9 +1833,12 @@ func (app *App) RegisterTendermintService(clientCtx client.Context) {
 		}
 		return app.legacyEncodingConfig.TxConfig
 	}
+	earliestVersionFetcher := func() int64 {
+		return app.CommitMultiStore().GetEarliestVersion()
+	}
 
 	if app.evmRPCConfig.HTTPEnabled {
-		evmHTTPServer, err := evmrpc.NewEVMHTTPServer(app.Logger(), app.evmRPCConfig, clientCtx.Client, &app.EvmKeeper, app.BaseApp, app.TracerAnteHandler, app.RPCContextProvider, txConfigProvider, DefaultNodeHome, nil)
+		evmHTTPServer, err := evmrpc.NewEVMHTTPServer(app.Logger(), app.evmRPCConfig, clientCtx.Client, &app.EvmKeeper, app.BaseApp, app.TracerAnteHandler, app.RPCContextProvider, txConfigProvider, earliestVersionFetcher, DefaultNodeHome, nil)
 		if err != nil {
 			panic(err)
 		}
@@ -1848,7 +1851,7 @@ func (app *App) RegisterTendermintService(clientCtx client.Context) {
 	}
 
 	if app.evmRPCConfig.WSEnabled {
-		evmWSServer, err := evmrpc.NewEVMWebSocketServer(app.Logger(), app.evmRPCConfig, clientCtx.Client, &app.EvmKeeper, app.BaseApp, app.TracerAnteHandler, app.RPCContextProvider, txConfigProvider, DefaultNodeHome)
+		evmWSServer, err := evmrpc.NewEVMWebSocketServer(app.Logger(), app.evmRPCConfig, clientCtx.Client, &app.EvmKeeper, app.BaseApp, app.TracerAnteHandler, app.RPCContextProvider, txConfigProvider, earliestVersionFetcher, DefaultNodeHome)
 		if err != nil {
 			panic(err)
 		}

evmrpc/block.go

@@ -39,6 +39,7 @@ type BlockAPI struct {
 	keeper               *keeper.Keeper
 	ctxProvider          func(int64) sdk.Context
 	txConfigProvider     func(int64) client.TxConfig
+	earliestVersion      func() int64
 	connectionType       ConnectionType
 	namespace            string
 	includeShellReceipts bool
@@ -52,12 +53,22 @@ type SeiBlockAPI struct {
 	isPanicTx func(ctx context.Context, hash common.Hash) (bool, error)
 }
 
-func NewBlockAPI(tmClient rpcclient.Client, k *keeper.Keeper, ctxProvider func(int64) sdk.Context, txConfigProvider func(int64) client.TxConfig, connectionType ConnectionType, globalBlockCache BlockCache, cacheCreationMutex *sync.Mutex) *BlockAPI {
+func NewBlockAPI(
+	tmClient rpcclient.Client,
+	k *keeper.Keeper,
+	ctxProvider func(int64) sdk.Context,
+	txConfigProvider func(int64) client.TxConfig,
+	earliestVersion func() int64,
+	connectionType ConnectionType,
+	globalBlockCache BlockCache,
+	cacheCreationMutex *sync.Mutex,
+) *BlockAPI {
 	return &BlockAPI{
 		tmClient:             tmClient,
 		keeper:               k,
 		ctxProvider:          ctxProvider,
 		txConfigProvider:     txConfigProvider,
+		earliestVersion:      earliestVersion,
 		connectionType:       connectionType,
 		includeShellReceipts: false,
 		includeBankTransfers: false,
@@ -72,6 +83,7 @@ func NewSeiBlockAPI(
 	k *keeper.Keeper,
 	ctxProvider func(int64) sdk.Context,
 	txConfigProvider func(int64) client.TxConfig,
+	earliestVersion func() int64,
 	connectionType ConnectionType,
 	isPanicTx func(ctx context.Context, hash common.Hash) (bool, error),
 	globalBlockCache BlockCache,
@@ -82,6 +94,7 @@ func NewSeiBlockAPI(
 		keeper:               k,
 		ctxProvider:          ctxProvider,
 		txConfigProvider:     txConfigProvider,
+		earliestVersion:      earliestVersion,
 		connectionType:       connectionType,
 		includeShellReceipts: true,
 		includeBankTransfers: false,
@@ -100,12 +113,13 @@ func NewSei2BlockAPI(
 	k *keeper.Keeper,
 	ctxProvider func(int64) sdk.Context,
 	txConfigProvider func(int64) client.TxConfig,
+	earliestVersion func() int64,
 	connectionType ConnectionType,
 	isPanicTx func(ctx context.Context, hash common.Hash) (bool, error),
 	globalBlockCache BlockCache,
 	cacheCreationMutex *sync.Mutex,
 ) *SeiBlockAPI {
-	blockAPI := NewSeiBlockAPI(tmClient, k, ctxProvider, txConfigProvider, connectionType, isPanicTx, globalBlockCache, cacheCreationMutex)
+	blockAPI := NewSeiBlockAPI(tmClient, k, ctxProvider, txConfigProvider, earliestVersion, connectionType, isPanicTx, globalBlockCache, cacheCreationMutex)
 	blockAPI.namespace = Sei2Namespace
 	blockAPI.includeBankTransfers = true
 	return blockAPI
@@ -161,7 +175,24 @@ func (a *BlockAPI) getBlockByHash(ctx context.Context, blockHash common.Hash, fu
 	if err != nil {
 		return nil, err
 	}
-	return EncodeTmBlock(a.ctxProvider, a.txConfigProvider, block, blockRes, a.keeper, fullTx, a.includeBankTransfers, includeSyntheticTxs, isPanicTx, a.globalBlockCache, a.cacheCreationMutex)
+	encodedBlock, err := EncodeTmBlock(
+		a.ctxProvider,
+		a.txConfigProvider,
+		a.earliestVersion,
+		block,
+		blockRes,
+		a.keeper,
+		fullTx,
+		a.includeBankTransfers,
+		includeSyntheticTxs,
+		isPanicTx,
+		a.globalBlockCache,
+		a.cacheCreationMutex,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return encodedBlock, nil
 }
 
 func (a *BlockAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (result map[string]interface{}, returnErr error) {
@@ -216,7 +247,24 @@ func (a *BlockAPI) getBlockByNumber(
 	if err != nil {
 		return nil, err
 	}
-	return EncodeTmBlock(a.ctxProvider, a.txConfigProvider, block, blockRes, a.keeper, fullTx, a.includeBankTransfers, includeSyntheticTxs, isPanicTx, a.globalBlockCache, a.cacheCreationMutex)
+	encodedBlock, err := EncodeTmBlock(
+		a.ctxProvider,
+		a.txConfigProvider,
+		a.earliestVersion,
+		block,
+		blockRes,
+		a.keeper,
+		fullTx,
+		a.includeBankTransfers,
+		includeSyntheticTxs,
+		isPanicTx,
+		a.globalBlockCache,
+		a.cacheCreationMutex,
+	)
+	if err != nil {
+		return nil, err
+	}
+	return encodedBlock, nil
 }
 
 func (a *BlockAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (result []map[string]interface{}, returnErr error) {
@@ -235,9 +283,19 @@ func (a *BlockAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.Block
 
 	// Get all tx hashes for the block
 	height := block.Block.Height
-
-	txHashes := getTxHashesFromBlock(a.ctxProvider, a.txConfigProvider, a.keeper, block, shouldIncludeSynthetic(a.namespace), a.cacheCreationMutex, a.globalBlockCache)
-
+	txHashes, err := getTxHashesFromBlock(
+		a.ctxProvider,
+		a.txConfigProvider,
+		a.earliestVersion,
+		a.keeper,
+		block,
+		shouldIncludeSynthetic(a.namespace),
+		a.cacheCreationMutex,
+		a.globalBlockCache,
+	)
+	if err != nil {
+		return nil, err
+	}
 	// Get tx receipts for all hashes in parallel
 	wg := sync.WaitGroup{}
 	mtx := sync.Mutex{}
@@ -256,7 +314,17 @@ func (a *BlockAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.Block
 					mtx.Unlock()
 				}
 			} else {
-				encodedReceipt, err := encodeReceipt(a.ctxProvider, a.txConfigProvider, receipt, a.keeper, block, a.includeShellReceipts, a.globalBlockCache, a.cacheCreationMutex)
+				encodedReceipt, err := encodeReceipt(
+					a.ctxProvider,
+					a.txConfigProvider,
+					a.earliestVersion,
+					receipt,
+					a.keeper,
+					block,
+					a.includeShellReceipts,
+					a.globalBlockCache,
+					a.cacheCreationMutex,
+				)
 				if err != nil {
 					mtx.Lock()
 					returnErr = err
@@ -285,6 +353,7 @@ func (a *BlockAPI) GetBlockReceipts(ctx context.Context, blockNrOrHash rpc.Block
 func EncodeTmBlock(
 	ctxProvider func(int64) sdk.Context,
 	txConfigProvider func(int64) client.TxConfig,
+	earliestVersion func() int64,
 	block *coretypes.ResultBlock,
 	blockRes *coretypes.ResultBlockResults,
 	k *keeper.Keeper,
@@ -315,7 +384,10 @@ func EncodeTmBlock(
 	transactions := []interface{}{}
 	latestCtx := ctxProvider(LatestCtxHeight)
 
-	msgs := filterTransactions(k, ctxProvider, txConfigProvider, block, includeSyntheticTxs, includeBankTransfers, cacheCreationMutex, globalBlockCache)
+	msgs, err := filterTransactions(k, ctxProvider, txConfigProvider, earliestVersion, block, includeSyntheticTxs, includeBankTransfers, cacheCreationMutex, globalBlockCache)
+	if err != nil {
+		return nil, err
+	}
 
 	blockBloom := make([]byte, ethtypes.BloomByteLength)
 	for _, msg := range msgs {

evmrpc/block_test.go

@@ -50,7 +50,7 @@ func TestEncodeTmBlock_EmptyTransactions(t *testing.T) {
 	}
 
 	// Call EncodeTmBlock with empty transactions
-	result, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, block, blockRes, k, true, false, false, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
+	result, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, noopEarliestVersionFetcher, block, blockRes, k, true, false, false, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
 	require.Nil(t, err)
 
 	// Assert txHash is equal to ethtypes.EmptyTxsHash
@@ -96,7 +96,7 @@ func TestEncodeBankMsg(t *testing.T) {
 			},
 		},
 	}
-	res, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, &resBlock, &resBlockRes, k, true, false, false, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
+	res, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, noopEarliestVersionFetcher, &resBlock, &resBlockRes, k, true, false, false, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
 	require.Nil(t, err)
 	txs := res["transactions"].([]interface{})
 	require.Equal(t, 0, len(txs))
@@ -144,7 +144,7 @@ func TestEncodeWasmExecuteMsg(t *testing.T) {
 			},
 		},
 	}
-	res, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, &resBlock, &resBlockRes, k, true, false, true, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
+	res, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, noopEarliestVersionFetcher, &resBlock, &resBlockRes, k, true, false, true, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
 	require.Nil(t, err)
 	txs := res["transactions"].([]interface{})
 	require.Equal(t, 1, len(txs))
@@ -205,7 +205,7 @@ func TestEncodeBankTransferMsg(t *testing.T) {
 			},
 		},
 	}
-	res, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, &resBlock, &resBlockRes, k, true, true, false, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
+	res, err := evmrpc.EncodeTmBlock(func(i int64) sdk.Context { return ctx }, func(i int64) client.TxConfig { return TxConfig }, noopEarliestVersionFetcher, &resBlock, &resBlockRes, k, true, true, false, nil, evmrpc.NewBlockCache(3000), &sync.Mutex{})
 	require.Nil(t, err)
 	txs := res["transactions"].([]interface{})
 	require.Equal(t, 1, len(txs))

evmrpc/filter.go

@@ -270,6 +270,7 @@ func NewFilterAPI(
 	k *keeper.Keeper,
 	ctxProvider func(int64) sdk.Context,
 	txConfigProvider func(int64) client.TxConfig,
+	earliestVersion func() int64,
 	filterConfig *FilterConfig,
 	connectionType ConnectionType,
 	namespace string,
@@ -291,6 +292,7 @@ func NewFilterAPI(
 		k:                        k,
 		ctxProvider:              ctxProvider,
 		txConfigProvider:         txConfigProvider,
+		earliestVersion:          earliestVersion,
 		filterConfig:             filterConfig,
 		includeSyntheticReceipts: shouldIncludeSynthetic(namespace),
 		dbReadSemaphore:          dbReadSemaphore,
@@ -653,6 +655,7 @@ type LogFetcher struct {
 	k                        *keeper.Keeper
 	txConfigProvider         func(int64) client.TxConfig
 	ctxProvider              func(int64) sdk.Context
+	earliestVersion          func() int64
 	filterConfig             *FilterConfig
 	includeSyntheticReceipts bool
 	dbReadSemaphore          chan struct{}
@@ -661,7 +664,7 @@ type LogFetcher struct {
 	globalLogSlicePool       *LogSlicePool
 }
 
-func (f *LogFetcher) GetLogsByFilters(ctx context.Context, crit filters.FilterCriteria, lastToHeight int64) (res []*ethtypes.Log, end int64, err error) {
+func (f *LogFetcher) GetLogsByFilters(ctx context.Context, crit filters.FilterCriteria, lastToHeight int64) (res []*ethtypes.Log, end int64, rerr error) {
 	latest := f.ctxProvider(LatestCtxHeight).BlockHeight()
 	begin, end := latest, latest
 	if crit.FromBlock != nil {
@@ -723,6 +726,12 @@ func (f *LogFetcher) GetLogsByFilters(ctx context.Context, crit filters.FilterCr
 		resultsMutex.Unlock()
 	}
 
+	defer func() {
+		if r := recover(); r != nil {
+			rerr = fmt.Errorf("encountered error when fetching logs: %v", r)
+		}
+	}()
+
 	// Batch process with fail-fast
 	blockBatch := make([]*coretypes.ResultBlock, 0, WorkerBatchSize)
 	for block := range blocks {
@@ -843,8 +852,20 @@ func (f *LogFetcher) collectLogs(block *coretypes.ResultBlock, crit filters.Filt
 	ctx := f.ctxProvider(block.Block.Height)
 	totalLogs := uint(0)
 	evmTxIndex := 0
-
-	for _, hash := range getTxHashesFromBlock(f.ctxProvider, f.txConfigProvider, f.k, block, f.includeSyntheticReceipts, f.cacheCreationMutex, f.globalBlockCache) {
+	txHashes, err := getTxHashesFromBlock(
+		f.ctxProvider,
+		f.txConfigProvider,
+		f.earliestVersion,
+		f.k,
+		block,
+		f.includeSyntheticReceipts,
+		f.cacheCreationMutex,
+		f.globalBlockCache,
+	)
+	if err != nil {
+		panic(err)
+	}
+	for _, hash := range txHashes {
 		receipt, found := getOrSetCachedReceipt(f.cacheCreationMutex, f.globalBlockCache, ctx, f.k, block, hash.hash)
 		if !found {
 			ctx.Logger().Error(fmt.Sprintf("collectLogs: unable to find receipt for hash %s", hash.hash.Hex()))

evmrpc/send.go

@@ -42,6 +42,7 @@ type SendConfig struct {
 func NewSendAPI(
 	tmClient rpcclient.Client,
 	txConfigProvider func(int64) client.TxConfig,
+	earliestVersion func() int64,
 	sendConfig *SendConfig,
 	k *keeper.Keeper,
 	ctxProvider func(int64) sdk.Context,
@@ -60,7 +61,7 @@ func NewSendAPI(
 		keeper:           k,
 		ctxProvider:      ctxProvider,
 		homeDir:          homeDir,
-		backend:          NewBackend(ctxProvider, k, txConfigProvider, tmClient, simulateConfig, app, antehandler, globalBlockCache, cacheCreationMutex),
+		backend:          NewBackend(ctxProvider, k, txConfigProvider, earliestVersion, tmClient, simulateConfig, app, antehandler, globalBlockCache, cacheCreationMutex),
 		connectionType:   connectionType,
 	}
 }