fix(eth-rpc): error propagation fixes and tests for the methods exposed by Nibiru's EVM JSON-RPC (#2289)

* test(rpcapi): prevent more regressions with runtime service inspection

* fix(backend): fix error propagation

* fix(eth): error propagation fixes and tests for the methods exposed by Nibiru's EVM JSON-RPC

Replace legacy error aliases throughout the eth module with sdkioerrors.Wrapf and sdkerrors.Err* to ensure consistent wrapping of Cosmos SDK errors. Simplify EVM backend error reporting by using fmt.Errorf with clear method prefixes (e.g. “BlockNumberError”, “RPCBlockFromTendermintBlock error”) and defaulting the base fee to evm.BASE_FEE_WEI. Suppress pruning‑related bloom errors by returning empty blooms when data is missing.

Unify RPC transaction conversion logic by renaming NewRPCTxFromMsg to NewRPCTxFromMsgEthTx, retiring the older NewRPCTxFromEthTx, and centralizing signer and signature‑value extraction. Refactor BackendSuite tests to use a SuccessfulTx map for structured receipt capture—eliminating global variables and improving setup clarity. Stub out unimplemented debugapi methods with context‑aware signatures and adjust filters, tracing, and utils to inline BlockBloom usage and align imports (e.g. eip1559, tracers) with modern patterns.

* chore: changelog PR number

Author: Unique-Divine

CHANGELOG.md

@@ -50,6 +50,7 @@ to geth v1.14 with tracing updates and new StateDB methods.
    setup. Namely, blobs (Cancun) and Verkle additions for zkEVM.
   - The jump to v1.14 was necessary to use an up-to-date "cockroach/pebble" DB
    dependency and leverage new generics features added in Go 1.23+.
+- [#2289](https://github.com/NibiruChain/nibiru/pull/2289) - fix(eth-rpc): error propagation fixes and tests for the methods exposed by Nibiru's EVM JSON-RPC
 - [#2288](https://github.com/NibiruChain/nibiru/pull/2288) - chore(ci): add workflow to check for missing upgrade handler
 - [#2278](https://github.com/NibiruChain/nibiru/pull/2278) - chore: migrate to cosmossdk.io/mathLegacyDec and cosmossdk.io/math.Int
 

eth/assert.go

@@ -4,8 +4,8 @@ package eth
 import (
 	"bytes"
 
-	errorsmod "cosmossdk.io/errors"
-	errortypes "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkioerrors "cosmossdk.io/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/ethereum/go-ethereum/common"
 )
 
@@ -22,8 +22,8 @@ func IsZeroAddress(address string) bool {
 // ValidateAddress returns an error if the provided string is either not a hex formatted string address
 func ValidateAddress(address string) error {
 	if !common.IsHexAddress(address) {
-		return errorsmod.Wrapf(
-			errortypes.ErrInvalidAddress, "address '%s' is not a valid ethereum hex address",
+		return sdkioerrors.Wrapf(
+			sdkerrors.ErrInvalidAddress, "address '%s' is not a valid ethereum hex address",
 			address,
 		)
 	}
@@ -34,8 +34,8 @@ func ValidateAddress(address string) error {
 // formatted string address or is equal to zero
 func ValidateNonZeroAddress(address string) error {
 	if IsZeroAddress(address) {
-		return errorsmod.Wrapf(
-			errortypes.ErrInvalidAddress, "address '%s' must not be zero",
+		return sdkioerrors.Wrapf(
+			sdkerrors.ErrInvalidAddress, "address '%s' must not be zero",
 			address,
 		)
 	}

eth/crypto/ethsecp256k1/ethsecp256k1.go

@@ -8,11 +8,11 @@ import (
 	"crypto/subtle"
 	"fmt"
 
-	errorsmod "cosmossdk.io/errors"
+	sdkioerrors "cosmossdk.io/errors"
 	tmcrypto "github.com/cometbft/cometbft/crypto"
 	"github.com/cosmos/cosmos-sdk/codec"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
-	errortypes "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/ethereum/go-ethereum/crypto"
 
 	"github.com/NibiruChain/nibiru/v2/eth/eip712"
@@ -186,7 +186,7 @@ func (pubKey PubKey) MarshalAmino() ([]byte, error) {
 // UnmarshalAmino overrides Amino binary marshaling.
 func (pubKey *PubKey) UnmarshalAmino(bz []byte) error {
 	if len(bz) != PubKeySize {
-		return errorsmod.Wrapf(errortypes.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz))
+		return sdkioerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz))
 	}
 	pubKey.Key = bz
 

eth/eip712/eip712_legacy.go

@@ -9,12 +9,12 @@ import (
 	"strings"
 	"time"
 
-	errorsmod "cosmossdk.io/errors"
+	sdkioerrors "cosmossdk.io/errors"
 	sdkmath "cosmossdk.io/math"
 	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/crypto/keys/ed25519"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	errortypes "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/ethereum/go-ethereum/common"
 	gethmath "github.com/ethereum/go-ethereum/common/math"
@@ -41,7 +41,7 @@ func LegacyWrapTxToTypedData(
 	txData := make(map[string]any)
 
 	if err := json.Unmarshal(data, &txData); err != nil {
-		return apitypes.TypedData{}, errorsmod.Wrap(errortypes.ErrJSONUnmarshal, "failed to JSON unmarshal data")
+		return apitypes.TypedData{}, sdkioerrors.Wrap(sdkerrors.ErrJSONUnmarshal, "failed to JSON unmarshal data")
 	}
 
 	domain := apitypes.TypedDataDomain{
@@ -60,7 +60,7 @@ func LegacyWrapTxToTypedData(
 	if feeDelegation != nil {
 		feeInfo, ok := txData["fee"].(map[string]any)
 		if !ok {
-			return apitypes.TypedData{}, errorsmod.Wrap(errortypes.ErrInvalidType, "cannot parse fee from tx data")
+			return apitypes.TypedData{}, sdkioerrors.Wrap(sdkerrors.ErrInvalidType, "cannot parse fee from tx data")
 		}
 
 		feeInfo["feePayer"] = feeDelegation.FeePayer.String()
@@ -369,15 +369,15 @@ func jsonNameFromTag(tag reflect.StructTag) string {
 func UnpackAny(cdc codectypes.AnyUnpacker, field reflect.Value) (reflect.Type, reflect.Value, error) {
 	anyData, ok := field.Interface().(*codectypes.Any)
 	if !ok {
-		return nil, reflect.Value{}, errorsmod.Wrapf(errortypes.ErrPackAny, "%T", field.Interface())
+		return nil, reflect.Value{}, sdkioerrors.Wrapf(sdkerrors.ErrPackAny, "%T", field.Interface())
 	}
 
 	anyWrapper := &CosmosAnyWrapper{
 		Type: anyData.TypeUrl,
 	}
 
 	if err := cdc.UnpackAny(anyData, &anyWrapper.Value); err != nil {
-		return nil, reflect.Value{}, errorsmod.Wrap(err, "failed to unpack Any in msg struct")
+		return nil, reflect.Value{}, sdkioerrors.Wrap(err, "failed to unpack Any in msg struct")
 	}
 
 	fieldType := reflect.TypeOf(anyWrapper)

eth/eip712/message.go

@@ -4,8 +4,8 @@ package eip712
 import (
 	"fmt"
 
-	errorsmod "cosmossdk.io/errors"
-	errortypes "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkioerrors "cosmossdk.io/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/tidwall/gjson"
 	"github.com/tidwall/sjson"
@@ -31,12 +31,12 @@ func createEIP712MessagePayload(data []byte) (eip712MessagePayload, error) {
 
 	payload, numPayloadMsgs, err := FlattenPayloadMessages(basicPayload)
 	if err != nil {
-		return eip712MessagePayload{}, errorsmod.Wrap(err, "failed to flatten payload JSON messages")
+		return eip712MessagePayload{}, sdkioerrors.Wrap(err, "failed to flatten payload JSON messages")
 	}
 
 	message, ok := payload.Value().(map[string]any)
 	if !ok {
-		return eip712MessagePayload{}, errorsmod.Wrap(errortypes.ErrInvalidType, "failed to parse JSON as map")
+		return eip712MessagePayload{}, sdkioerrors.Wrap(sdkerrors.ErrInvalidType, "failed to parse JSON as map")
 	}
 
 	messagePayload := eip712MessagePayload{
@@ -52,13 +52,13 @@ func createEIP712MessagePayload(data []byte) (eip712MessagePayload, error) {
 // a JSON object, then makes sure the JSON is an object.
 func unmarshalBytesToJSONObject(data []byte) (gjson.Result, error) {
 	if !gjson.ValidBytes(data) {
-		return gjson.Result{}, errorsmod.Wrap(errortypes.ErrJSONUnmarshal, "invalid JSON received")
+		return gjson.Result{}, sdkioerrors.Wrap(sdkerrors.ErrJSONUnmarshal, "invalid JSON received")
 	}
 
 	payload := gjson.ParseBytes(data)
 
 	if !payload.IsObject() {
-		return gjson.Result{}, errorsmod.Wrap(errortypes.ErrJSONUnmarshal, "failed to JSON unmarshal data as object")
+		return gjson.Result{}, sdkioerrors.Wrap(sdkerrors.ErrJSONUnmarshal, "failed to JSON unmarshal data as object")
 	}
 
 	return payload, nil
@@ -96,11 +96,11 @@ func getPayloadMessages(payload gjson.Result) ([]gjson.Result, error) {
 	rawMsgs := payload.Get(payloadMsgsField)
 
 	if !rawMsgs.Exists() {
-		return nil, errorsmod.Wrap(errortypes.ErrInvalidRequest, "no messages found in payload, unable to parse")
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrInvalidRequest, "no messages found in payload, unable to parse")
 	}
 
 	if !rawMsgs.IsArray() {
-		return nil, errorsmod.Wrap(errortypes.ErrInvalidRequest, "expected type array of messages, cannot parse")
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrInvalidRequest, "expected type array of messages, cannot parse")
 	}
 
 	return rawMsgs.Array(), nil
@@ -112,14 +112,14 @@ func payloadWithNewMessage(payload gjson.Result, msg gjson.Result, index int) (g
 	field := msgFieldForIndex(index)
 
 	if payload.Get(field).Exists() {
-		return gjson.Result{}, errorsmod.Wrapf(
-			errortypes.ErrInvalidRequest,
+		return gjson.Result{}, sdkioerrors.Wrapf(
+			sdkerrors.ErrInvalidRequest,
 			"malformed payload received, did not expect to find key at field %v", field,
 		)
 	}
 
 	if !msg.IsObject() {
-		return gjson.Result{}, errorsmod.Wrapf(errortypes.ErrInvalidRequest, "msg at index %d is not valid JSON: %v", index, msg)
+		return gjson.Result{}, sdkioerrors.Wrapf(sdkerrors.ErrInvalidRequest, "msg at index %d is not valid JSON: %v", index, msg)
 	}
 
 	newRaw, err := sjson.SetRaw(payload.Raw, field, msg.Raw)

eth/eip712/types.go

@@ -10,8 +10,8 @@ import (
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 
-	errorsmod "cosmossdk.io/errors"
-	errortypes "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkioerrors "cosmossdk.io/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/ethereum/go-ethereum/signer/core/apitypes"
 	"github.com/tidwall/gjson"
@@ -93,7 +93,7 @@ func addMsgTypesToRoot(eip712Types apitypes.Types, msgField string, msg gjson.Re
 	defer doRecover(&err)
 
 	if !msg.IsObject() {
-		return errorsmod.Wrapf(errortypes.ErrInvalidRequest, "message is not valid JSON, cannot parse types")
+		return sdkioerrors.Wrapf(sdkerrors.ErrInvalidRequest, "message is not valid JSON, cannot parse types")
 	}
 
 	msgRootType, err := msgRootType(msg)
@@ -117,7 +117,7 @@ func msgRootType(msg gjson.Result) (string, error) {
 	msgType := msg.Get(msgTypeField).Str
 	if msgType == "" {
 		// .Str is empty for arrays and objects
-		return "", errorsmod.Wrap(errortypes.ErrInvalidType, "malformed message type value, expected type string")
+		return "", sdkioerrors.Wrap(sdkerrors.ErrInvalidType, "malformed message type value, expected type string")
 	}
 
 	// Convert e.g. cosmos-sdk/MsgSend to TypeMsgSend
@@ -152,7 +152,7 @@ func recursivelyAddTypesToRoot(
 	// Must sort the JSON keys for deterministic type generation.
 	sortedFieldNames, err := sortedJSONKeys(payload)
 	if err != nil {
-		return "", errorsmod.Wrap(err, "unable to sort object keys")
+		return "", sdkioerrors.Wrap(err, "unable to sort object keys")
 	}
 
 	typeDef := typeDefForPrefix(prefix, rootType)
@@ -224,7 +224,7 @@ func recursivelyAddTypesToRoot(
 // to be used for deterministic iteration.
 func sortedJSONKeys(json gjson.Result) ([]string, error) {
 	if !json.IsObject() {
-		return nil, errorsmod.Wrap(errortypes.ErrInvalidType, "expected JSON map to parse")
+		return nil, sdkioerrors.Wrap(sdkerrors.ErrInvalidType, "expected JSON map to parse")
 	}
 
 	jsonMap := json.Map()
@@ -299,7 +299,7 @@ func addTypesToRoot(typeMap apitypes.Types, typeDef string, types []apitypes.Typ
 		indexAsDuplicate++
 
 		if indexAsDuplicate == maxDuplicateTypeDefs {
-			return "", errorsmod.Wrap(errortypes.ErrInvalidRequest, "exceeded maximum number of duplicates for a single type definition")
+			return "", sdkioerrors.Wrap(sdkerrors.ErrInvalidRequest, "exceeded maximum number of duplicates for a single type definition")
 		}
 	}
 
@@ -380,7 +380,7 @@ func getEthTypeForJSON(json gjson.Result) string {
 func doRecover(err *error) {
 	if r := recover(); r != nil {
 		if e, ok := r.(error); ok {
-			e = errorsmod.Wrap(e, "panicked with error")
+			e = sdkioerrors.Wrap(e, "panicked with error")
 			*err = e
 			return
 		}

eth/errors.go

@@ -1,14 +1,14 @@
 package eth
 
 import (
-	sdkerrors "cosmossdk.io/errors"
+	sdkioerrors "cosmossdk.io/errors"
 )
 
 var moduleErrorCodeIdx uint32 = 1
 
-func registerError(msg string) *sdkerrors.Error {
+func registerError(msg string) *sdkioerrors.Error {
 	moduleErrorCodeIdx += 1
-	return sdkerrors.Register("eth", moduleErrorCodeIdx, msg)
+	return sdkioerrors.Register("eth", moduleErrorCodeIdx, msg)
 }
 
 // Module "sentinel" errors

eth/indexer/evm_tx_indexer.go

@@ -4,7 +4,7 @@ package indexer
 import (
 	"fmt"
 
-	errorsmod "cosmossdk.io/errors"
+	sdkioerrors "cosmossdk.io/errors"
 	dbm "github.com/cometbft/cometbft-db"
 	abci "github.com/cometbft/cometbft/abci/types"
 	"github.com/cometbft/cometbft/libs/log"
@@ -122,12 +122,12 @@ func (indexer *EVMTxIndexer) IndexBlock(block *tmtypes.Block, txResults []*abci.
 			ethTxIndex++
 
 			if err := saveTxResult(indexer.clientCtx.Codec, batch, txHash, &txResult); err != nil {
-				return errorsmod.Wrapf(err, "IndexBlock %d", height)
+				return sdkioerrors.Wrapf(err, "IndexBlock %d", height)
 			}
 		}
 	}
 	if err := batch.Write(); err != nil {
-		return errorsmod.Wrapf(err, "IndexBlock %d, write batch", block.Height)
+		return sdkioerrors.Wrapf(err, "IndexBlock %d, write batch", block.Height)
 	}
 	return nil
 }
@@ -146,14 +146,14 @@ func (indexer *EVMTxIndexer) FirstIndexedBlock() (int64, error) {
 func (indexer *EVMTxIndexer) GetByTxHash(hash common.Hash) (*eth.TxResult, error) {
 	bz, err := indexer.db.Get(TxHashKey(hash))
 	if err != nil {
-		return nil, errorsmod.Wrapf(err, "GetByTxHash %s", hash.Hex())
+		return nil, sdkioerrors.Wrapf(err, "GetByTxHash %s", hash.Hex())
 	}
 	if len(bz) == 0 {
 		return nil, fmt.Errorf("tx not found, hash: %s", hash.Hex())
 	}
 	var txKey eth.TxResult
 	if err := indexer.clientCtx.Codec.Unmarshal(bz, &txKey); err != nil {
-		return nil, errorsmod.Wrapf(err, "GetByTxHash %s", hash.Hex())
+		return nil, sdkioerrors.Wrapf(err, "GetByTxHash %s", hash.Hex())
 	}
 	return &txKey, nil
 }
@@ -162,7 +162,7 @@ func (indexer *EVMTxIndexer) GetByTxHash(hash common.Hash) (*eth.TxResult, error
 func (indexer *EVMTxIndexer) GetByBlockAndIndex(blockNumber int64, txIndex int32) (*eth.TxResult, error) {
 	bz, err := indexer.db.Get(TxIndexKey(blockNumber, txIndex))
 	if err != nil {
-		return nil, errorsmod.Wrapf(err, "GetByBlockAndIndex %d %d", blockNumber, txIndex)
+		return nil, sdkioerrors.Wrapf(err, "GetByBlockAndIndex %d %d", blockNumber, txIndex)
 	}
 	if len(bz) == 0 {
 		return nil, fmt.Errorf("tx not found, block: %d, eth-index: %d", blockNumber, txIndex)
@@ -186,7 +186,7 @@ func TxIndexKey(blockNumber int64, txIndex int32) []byte {
 func LoadLastBlock(db dbm.DB) (int64, error) {
 	it, err := db.ReverseIterator([]byte{KeyPrefixTxIndex}, []byte{KeyPrefixTxIndex + 1})
 	if err != nil {
-		return 0, errorsmod.Wrap(err, "LoadLastBlock")
+		return 0, sdkioerrors.Wrap(err, "LoadLastBlock")
 	}
 	defer it.Close()
 	if !it.Valid() {
@@ -199,7 +199,7 @@ func LoadLastBlock(db dbm.DB) (int64, error) {
 func LoadFirstBlock(db dbm.DB) (int64, error) {
 	it, err := db.Iterator([]byte{KeyPrefixTxIndex}, []byte{KeyPrefixTxIndex + 1})
 	if err != nil {
-		return 0, errorsmod.Wrap(err, "LoadFirstBlock")
+		return 0, sdkioerrors.Wrap(err, "LoadFirstBlock")
 	}
 	defer it.Close()
 	if !it.Valid() {
@@ -213,7 +213,7 @@ func (indexer *EVMTxIndexer) CloseDBAndExit() error {
 	indexer.logger.Info("Closing EVMTxIndexer DB")
 	err := indexer.db.Close()
 	if err != nil {
-		return errorsmod.Wrap(err, "CloseDBAndExit")
+		return sdkioerrors.Wrap(err, "CloseDBAndExit")
 	}
 	return nil
 }
@@ -235,10 +235,10 @@ func isEthTx(tx sdk.Tx) bool {
 func saveTxResult(codec codec.Codec, batch dbm.Batch, txHash common.Hash, txResult *eth.TxResult) error {
 	bz := codec.MustMarshal(txResult)
 	if err := batch.Set(TxHashKey(txHash), bz); err != nil {
-		return errorsmod.Wrap(err, "set tx-hash key")
+		return sdkioerrors.Wrap(err, "set tx-hash key")
 	}
 	if err := batch.Set(TxIndexKey(txResult.Height, txResult.EthTxIndex), txHash.Bytes()); err != nil {
-		return errorsmod.Wrap(err, "set tx-index key")
+		return sdkioerrors.Wrap(err, "set tx-index key")
 	}
 	return nil
 }

eth/rpc/backend/account_info.go

@@ -6,8 +6,7 @@ import (
 	"math"
 	"math/big"
 
-	errorsmod "cosmossdk.io/errors"
-
+	sdkioerrors "cosmossdk.io/errors"
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@@ -204,7 +203,7 @@ func (b *Backend) GetTransactionCount(address gethcommon.Address, blockNum rpc.B
 
 	currentHeight := int64(bn) //#nosec G701 -- checked for int overflow already
 	if height > currentHeight {
-		return &n, errorsmod.Wrapf(
+		return &n, sdkioerrors.Wrapf(
 			sdkerrors.ErrInvalidHeight,
 			"cannot query with height in the future (current: %d, queried: %d); please provide a valid height",
 			currentHeight, height,

eth/rpc/backend/backend_suite_test.go

@@ -132,7 +132,10 @@ func (s *BackendSuite) SetupSuite() {
 	}
 
 	for _, tx := range s.SuccessfulTxs {
-		s.T().Logf("SuccessfulTx{ BlockNumber: %s, BlockHash: %s, TxHash: %s }", tx.BlockNumber, tx.BlockHash.Hex(), tx.Receipt.TxHash.Hex())
+		s.T().Logf(
+			"SuccessfulTx{ BlockNumber: %s, BlockHash: %s, TxHash: %s }",
+			tx.BlockNumber, tx.BlockHash.Hex(), tx.Receipt.TxHash.Hex(),
+		)
 	}
 }