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

CHANGELOG.md

@@ -51,6 +51,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 @@
 	"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 @@
 // 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 @@
 	"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 @@
 	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 @@
 	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 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 @@
 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 @@
 
 	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 @@
 // 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 @@
 	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 @@
 	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 @@
 	"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 @@
 	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 @@
 	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 @@
 	// 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 @@
 // 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 @@
 		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 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 @@
 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 @@
 			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) 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) 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 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 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 @@
 	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 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 @@
 	"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 @@
 
 	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(),
+		)
 	}
 }