From 052134aff6e3aa7e8f342915495485d3eeb5a170 Mon Sep 17 00:00:00 2001 From: Tomas Guerra <54514587+GAtom22@users.noreply.github.com> Date: Mon, 14 Nov 2022 16:40:14 -0300 Subject: [PATCH] refactor(all): refactor errors import to use cosmossdk.io (#1456) * refactor (errors) refactor errors import to use cosmossdk.io instead of cosmos-sdk/types/errors * refactor (errors) refactor errors import in ethsecp256k1 file * refactor (errors) add changes to changelog --- CHANGELOG.md | 1 + crypto/ethsecp256k1/ethsecp256k1.go | 5 +-- ethereum/eip712/eip712.go | 17 ++++----- go.mod | 2 +- indexer/kv_indexer.go | 20 +++++------ rpc/backend/call_tx.go | 4 +-- rpc/backend/client_test.go | 10 +++--- rpc/backend/evm_query_client_test.go | 10 +++--- rpc/backend/node_info.go | 4 +-- rpc/backend/sign_tx.go | 4 +-- rpc/backend/tx_info.go | 6 ++-- rpc/types/block_test.go | 2 +- rpc/types/utils.go | 5 +-- server/config/config.go | 10 +++--- server/start.go | 4 +-- types/chain_id.go | 8 ++--- types/errors.go | 10 +++--- types/int.go | 6 ++-- types/validation.go | 11 +++--- x/evm/handler.go | 5 +-- x/evm/keeper/hooks.go | 4 +-- x/evm/keeper/keeper.go | 4 +-- x/evm/keeper/msg_server.go | 6 ++-- x/evm/keeper/state_transition.go | 39 ++++++++++---------- x/evm/keeper/statedb.go | 4 +-- x/evm/keeper/utils.go | 23 ++++++------ x/evm/migrations/v2/types/chain_config.go | 36 +++++++++---------- x/evm/migrations/v3/types/chain_config.go | 36 +++++++++---------- x/evm/statedb/statedb.go | 6 ++-- x/evm/types/access_list_tx.go | 21 +++++------ x/evm/types/chain_config.go | 38 ++++++++++---------- x/evm/types/codec.go | 11 +++--- x/evm/types/dynamic_fee_tx.go | 29 +++++++-------- x/evm/types/errors.go | 44 +++++++++++------------ x/evm/types/legacy_tx.go | 16 ++++----- x/evm/types/msg.go | 13 +++---- x/evm/types/storage.go | 6 ++-- x/evm/types/utils.go | 4 +-- 38 files changed, 248 insertions(+), 236 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e4c29217a..c87967620c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -69,6 +69,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ * (ante) [#1397](https://github.com/evmos/ethermint/pull/1397) Refactor EIP-712 signature verification to support EIP-712 multi-signing. * (deps) [#1416](https://github.com/evmos/ethermint/pull/1416) Bump Go version to `1.19` * (cmd) [\#1417](https://github.com/evmos/ethermint/pull/1417) Apply Google CLI Syntax for required and optional args. +* (deps) [#1456](https://github.com/evmos/ethermint/pull/1456) Migrate errors-related functionality from "github.com/cosmos/cosmos-sdk/types/errors" (deprecated) to "cosmossdk.io/errors" ### Bug Fixes diff --git a/crypto/ethsecp256k1/ethsecp256k1.go b/crypto/ethsecp256k1/ethsecp256k1.go index 787e6d8e50..2dad73dc0b 100644 --- a/crypto/ethsecp256k1/ethsecp256k1.go +++ b/crypto/ethsecp256k1/ethsecp256k1.go @@ -6,9 +6,10 @@ import ( "crypto/subtle" "fmt" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/codec" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/crypto" "github.com/evmos/ethermint/ethereum/eip712" tmcrypto "github.com/tendermint/tendermint/crypto" @@ -182,7 +183,7 @@ func (pubKey PubKey) MarshalAmino() ([]byte, error) { // UnmarshalAmino overrides Amino binary marshaling. func (pubKey *PubKey) UnmarshalAmino(bz []byte) error { if len(bz) != PubKeySize { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz)) + return errorsmod.Wrapf(errortypes.ErrInvalidPubKey, "invalid pubkey size, expected %d, got %d", PubKeySize, len(bz)) } pubKey.Key = bz diff --git a/ethereum/eip712/eip712.go b/ethereum/eip712/eip712.go index 50860093d3..c621aaa98c 100644 --- a/ethereum/eip712/eip712.go +++ b/ethereum/eip712/eip712.go @@ -14,9 +14,10 @@ import ( "golang.org/x/text/cases" "golang.org/x/text/language" + errorsmod "cosmossdk.io/errors" codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -28,13 +29,13 @@ import ( func ComputeTypedDataHash(typedData apitypes.TypedData) ([]byte, error) { domainSeparator, err := typedData.HashStruct("EIP712Domain", typedData.Domain.Map()) if err != nil { - err = sdkerrors.Wrap(err, "failed to pack and hash typedData EIP712Domain") + err = errorsmod.Wrap(err, "failed to pack and hash typedData EIP712Domain") return nil, err } typedDataHash, err := typedData.HashStruct(typedData.PrimaryType, typedData.Message) if err != nil { - err = sdkerrors.Wrap(err, "failed to pack and hash typedData primary type") + err = errorsmod.Wrap(err, "failed to pack and hash typedData primary type") return nil, err } @@ -54,7 +55,7 @@ func WrapTxToTypedData( txData := make(map[string]interface{}) if err := json.Unmarshal(data, &txData); err != nil { - return apitypes.TypedData{}, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, "failed to JSON unmarshal data") + return apitypes.TypedData{}, errorsmod.Wrap(errortypes.ErrJSONUnmarshal, "failed to JSON unmarshal data") } domain := apitypes.TypedDataDomain{ @@ -73,7 +74,7 @@ func WrapTxToTypedData( if feeDelegation != nil { feeInfo, ok := txData["fee"].(map[string]interface{}) if !ok { - return apitypes.TypedData{}, sdkerrors.Wrap(sdkerrors.ErrInvalidType, "cannot parse fee from tx data") + return apitypes.TypedData{}, errorsmod.Wrap(errortypes.ErrInvalidType, "cannot parse fee from tx data") } feeInfo["feePayer"] = feeDelegation.FeePayer.String() @@ -217,7 +218,7 @@ func traverseFields( if fieldType == cosmosAnyType { any, ok := field.Interface().(*codectypes.Any) if !ok { - return sdkerrors.Wrapf(sdkerrors.ErrPackAny, "%T", field.Interface()) + return errorsmod.Wrapf(errortypes.ErrPackAny, "%T", field.Interface()) } anyWrapper := &cosmosAnyWrapper{ @@ -225,7 +226,7 @@ func traverseFields( } if err := cdc.UnpackAny(any, &anyWrapper.Value); err != nil { - return sdkerrors.Wrap(err, "failed to unpack Any in msg struct") + return errorsmod.Wrap(err, "failed to unpack Any in msg struct") } fieldType = reflect.TypeOf(anyWrapper) @@ -465,7 +466,7 @@ func typToEth(typ reflect.Type) string { func doRecover(err *error) { if r := recover(); r != nil { if e, ok := r.(error); ok { - e = sdkerrors.Wrap(e, "panicked with error") + e = errorsmod.Wrap(e, "panicked with error") *err = e return } diff --git a/go.mod b/go.mod index 6cff024356..42586db55f 100644 --- a/go.mod +++ b/go.mod @@ -3,6 +3,7 @@ module github.com/evmos/ethermint go 1.19 require ( + cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/math v1.0.0-beta.3 github.com/armon/go-metrics v0.4.1 github.com/btcsuite/btcd v0.22.1 @@ -48,7 +49,6 @@ require ( cloud.google.com/go/compute/metadata v0.2.1 // indirect cloud.google.com/go/iam v0.4.0 // indirect cloud.google.com/go/storage v1.23.0 // indirect - cosmossdk.io/errors v1.0.0-beta.7 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/keyring v1.2.1 // indirect github.com/ChainSafe/go-schnorrkel v0.0.0-20200405005733-88cbf1b4c40d // indirect diff --git a/indexer/kv_indexer.go b/indexer/kv_indexer.go index bc8afce4fa..e5b7d0408f 100644 --- a/indexer/kv_indexer.go +++ b/indexer/kv_indexer.go @@ -3,10 +3,10 @@ package indexer import ( "fmt" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" authante "github.com/cosmos/cosmos-sdk/x/auth/ante" "github.com/ethereum/go-ethereum/common" rpctypes "github.com/evmos/ethermint/rpc/types" @@ -110,12 +110,12 @@ func (kv *KVIndexer) IndexBlock(block *tmtypes.Block, txResults []*abci.Response ethTxIndex++ if err := saveTxResult(kv.clientCtx.Codec, batch, txHash, &txResult); err != nil { - return sdkerrors.Wrapf(err, "IndexBlock %d", height) + return errorsmod.Wrapf(err, "IndexBlock %d", height) } } } if err := batch.Write(); err != nil { - return sdkerrors.Wrapf(err, "IndexBlock %d, write batch", block.Height) + return errorsmod.Wrapf(err, "IndexBlock %d, write batch", block.Height) } return nil } @@ -134,14 +134,14 @@ func (kv *KVIndexer) FirstIndexedBlock() (int64, error) { func (kv *KVIndexer) GetByTxHash(hash common.Hash) (*ethermint.TxResult, error) { bz, err := kv.db.Get(TxHashKey(hash)) if err != nil { - return nil, sdkerrors.Wrapf(err, "GetByTxHash %s", hash.Hex()) + return nil, errorsmod.Wrapf(err, "GetByTxHash %s", hash.Hex()) } if len(bz) == 0 { return nil, fmt.Errorf("tx not found, hash: %s", hash.Hex()) } var txKey ethermint.TxResult if err := kv.clientCtx.Codec.Unmarshal(bz, &txKey); err != nil { - return nil, sdkerrors.Wrapf(err, "GetByTxHash %s", hash.Hex()) + return nil, errorsmod.Wrapf(err, "GetByTxHash %s", hash.Hex()) } return &txKey, nil } @@ -150,7 +150,7 @@ func (kv *KVIndexer) GetByTxHash(hash common.Hash) (*ethermint.TxResult, error) func (kv *KVIndexer) GetByBlockAndIndex(blockNumber int64, txIndex int32) (*ethermint.TxResult, error) { bz, err := kv.db.Get(TxIndexKey(blockNumber, txIndex)) if err != nil { - return nil, sdkerrors.Wrapf(err, "GetByBlockAndIndex %d %d", blockNumber, txIndex) + return nil, errorsmod.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) @@ -174,7 +174,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, sdkerrors.Wrap(err, "LoadLastBlock") + return 0, errorsmod.Wrap(err, "LoadLastBlock") } defer it.Close() if !it.Valid() { @@ -187,7 +187,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, sdkerrors.Wrap(err, "LoadFirstBlock") + return 0, errorsmod.Wrap(err, "LoadFirstBlock") } defer it.Close() if !it.Valid() { @@ -213,10 +213,10 @@ func isEthTx(tx sdk.Tx) bool { func saveTxResult(codec codec.Codec, batch dbm.Batch, txHash common.Hash, txResult *ethermint.TxResult) error { bz := codec.MustMarshal(txResult) if err := batch.Set(TxHashKey(txHash), bz); err != nil { - return sdkerrors.Wrap(err, "set tx-hash key") + return errorsmod.Wrap(err, "set tx-hash key") } if err := batch.Set(TxIndexKey(txResult.Height, txResult.EthTxIndex), txHash.Bytes()); err != nil { - return sdkerrors.Wrap(err, "set tx-index key") + return errorsmod.Wrap(err, "set tx-index key") } return nil } diff --git a/rpc/backend/call_tx.go b/rpc/backend/call_tx.go index 8cbbff961c..86a2ae51e1 100644 --- a/rpc/backend/call_tx.go +++ b/rpc/backend/call_tx.go @@ -7,9 +7,9 @@ import ( "fmt" "math/big" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/client/flags" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" ethtypes "github.com/ethereum/go-ethereum/core/types" @@ -151,7 +151,7 @@ func (b *Backend) SendRawTransaction(data hexutil.Bytes) (common.Hash, error) { syncCtx := b.clientCtx.WithBroadcastMode(flags.BroadcastSync) rsp, err := syncCtx.BroadcastTx(txBytes) if rsp != nil && rsp.Code != 0 { - err = sdkerrors.ABCIError(rsp.Codespace, rsp.Code, rsp.RawLog) + err = errorsmod.ABCIError(rsp.Codespace, rsp.Code, rsp.RawLog) } if err != nil { b.logger.Error("failed to broadcast tx", "error", err.Error()) diff --git a/rpc/backend/client_test.go b/rpc/backend/client_test.go index 6dc8949e70..4716e312fc 100644 --- a/rpc/backend/client_test.go +++ b/rpc/backend/client_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/evmos/ethermint/rpc/backend/mocks" rpc "github.com/evmos/ethermint/rpc/types" @@ -50,7 +50,7 @@ func RegisterBlock( // Block returns error func RegisterBlockError(client *mocks.Client, height int64) { client.On("Block", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } // Block not found @@ -86,7 +86,7 @@ func RegisterConsensusParams(client *mocks.Client, height int64) { func RegisterConsensusParamsError(client *mocks.Client, height int64) { client.On("ConsensusParams", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } func TestRegisterConsensusParams(t *testing.T) { @@ -117,7 +117,7 @@ func RegisterBlockResults( func RegisterBlockResultsError(client *mocks.Client, height int64) { client.On("BlockResults", rpc.ContextWithHeight(height), mock.AnythingOfType("*int64")). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } func TestRegisterBlockResults(t *testing.T) { @@ -150,7 +150,7 @@ func RegisterBlockByHash( func RegisterBlockByHashError(client *mocks.Client, hash common.Hash, tx []byte) { client.On("BlockByHash", rpc.ContextWithHeight(1), []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } func RegisterBlockByHashNotFound(client *mocks.Client, hash common.Hash, tx []byte) { diff --git a/rpc/backend/evm_query_client_test.go b/rpc/backend/evm_query_client_test.go index 5aef0d057c..45585c8449 100644 --- a/rpc/backend/evm_query_client_test.go +++ b/rpc/backend/evm_query_client_test.go @@ -6,7 +6,7 @@ import ( "testing" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" grpctypes "github.com/cosmos/cosmos-sdk/types/grpc" "github.com/ethereum/go-ethereum/common" "github.com/evmos/ethermint/rpc/backend/mocks" @@ -67,7 +67,7 @@ func RegisterParamsInvalidHeight(queryClient *mocks.EVMQueryClient, header *meta // Params returns error func RegisterParamsError(queryClient *mocks.EVMQueryClient, header *metadata.MD, height int64) { queryClient.On("Params", rpc.ContextWithHeight(height), &evmtypes.QueryParamsRequest{}, grpc.Header(header)). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } func TestRegisterParams(t *testing.T) { @@ -168,7 +168,7 @@ func RegisterCode(queryClient *mocks.EVMQueryClient, addr common.Address, code [ func RegisterCodeError(queryClient *mocks.EVMQueryClient, addr common.Address) { queryClient.On("Code", rpc.ContextWithHeight(1), &evmtypes.QueryCodeRequest{Address: addr.String()}). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } // Storage @@ -179,7 +179,7 @@ func RegisterStorageAt(queryClient *mocks.EVMQueryClient, addr common.Address, k func RegisterStorageAtError(queryClient *mocks.EVMQueryClient, addr common.Address, key string) { queryClient.On("Storage", rpc.ContextWithHeight(1), &evmtypes.QueryStorageRequest{Address: addr.String(), Key: key}). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } func RegisterAccount(queryClient *mocks.EVMQueryClient, addr common.Address, height int64) { @@ -211,5 +211,5 @@ func RegisterBalanceNegative(queryClient *mocks.EVMQueryClient, addr common.Addr func RegisterBalanceError(queryClient *mocks.EVMQueryClient, addr common.Address, height int64) { queryClient.On("Balance", rpc.ContextWithHeight(height), &evmtypes.QueryBalanceRequest{Address: addr.String()}). - Return(nil, sdkerrors.ErrInvalidRequest) + Return(nil, errortypes.ErrInvalidRequest) } diff --git a/rpc/backend/node_info.go b/rpc/backend/node_info.go index d858f011b3..cd7434ae8a 100644 --- a/rpc/backend/node_info.go +++ b/rpc/backend/node_info.go @@ -5,6 +5,7 @@ import ( "math/big" "time" + errorsmod "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/client/tx" @@ -12,7 +13,6 @@ import ( "github.com/cosmos/cosmos-sdk/crypto/keyring" sdkconfig "github.com/cosmos/cosmos-sdk/server/config" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" authtx "github.com/cosmos/cosmos-sdk/x/auth/tx" distributiontypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/ethereum/go-ethereum/common" @@ -165,7 +165,7 @@ func (b *Backend) SetEtherbase(etherbase common.Address) bool { syncCtx := b.clientCtx.WithBroadcastMode(flags.BroadcastSync) rsp, err := syncCtx.BroadcastTx(txBytes) if rsp != nil && rsp.Code != 0 { - err = sdkerrors.ABCIError(rsp.Codespace, rsp.Code, rsp.RawLog) + err = errorsmod.ABCIError(rsp.Codespace, rsp.Code, rsp.RawLog) } if err != nil { b.logger.Debug("failed to broadcast tx", "error", err.Error()) diff --git a/rpc/backend/sign_tx.go b/rpc/backend/sign_tx.go index 09c9775b94..b8052e1282 100644 --- a/rpc/backend/sign_tx.go +++ b/rpc/backend/sign_tx.go @@ -4,9 +4,9 @@ import ( "fmt" "math/big" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/client/flags" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/accounts/keystore" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" @@ -89,7 +89,7 @@ func (b *Backend) SendTransaction(args evmtypes.TransactionArgs) (common.Hash, e syncCtx := b.clientCtx.WithBroadcastMode(flags.BroadcastSync) rsp, err := syncCtx.BroadcastTx(txBytes) if rsp != nil && rsp.Code != 0 { - err = sdkerrors.ABCIError(rsp.Codespace, rsp.Code, rsp.RawLog) + err = errorsmod.ABCIError(rsp.Codespace, rsp.Code, rsp.RawLog) } if err != nil { b.logger.Error("failed to broadcast tx", "error", err.Error()) diff --git a/rpc/backend/tx_info.go b/rpc/backend/tx_info.go index 08f3af7b5b..7a49231da6 100644 --- a/rpc/backend/tx_info.go +++ b/rpc/backend/tx_info.go @@ -3,8 +3,8 @@ package backend import ( "fmt" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" ethtypes "github.com/ethereum/go-ethereum/core/types" @@ -288,7 +288,7 @@ func (b *Backend) GetTxByEthHash(hash common.Hash) (*ethermint.TxResult, error) return txs.GetTxByHash(hash) }) if err != nil { - return nil, sdkerrors.Wrapf(err, "GetTxByEthHash %s", hash.Hex()) + return nil, errorsmod.Wrapf(err, "GetTxByEthHash %s", hash.Hex()) } return txResult, nil } @@ -308,7 +308,7 @@ func (b *Backend) GetTxByTxIndex(height int64, index uint) (*ethermint.TxResult, return txs.GetTxByTxIndex(int(index)) }) if err != nil { - return nil, sdkerrors.Wrapf(err, "GetTxByTxIndex %d %d", height, index) + return nil, errorsmod.Wrapf(err, "GetTxByTxIndex %d %d", height, index) } return txResult, nil } diff --git a/rpc/types/block_test.go b/rpc/types/block_test.go index c7b6c5bca2..1cbb11f61e 100644 --- a/rpc/types/block_test.go +++ b/rpc/types/block_test.go @@ -88,7 +88,7 @@ func TestUnmarshalBlockNumberOrHash(t *testing.T) { } for _, tc := range testCases { - fmt.Sprintf("Case %s", tc.msg) + fmt.Printf("Case %s", tc.msg) // reset input bnh = new(BlockNumberOrHash) err := bnh.UnmarshalJSON(tc.input) diff --git a/rpc/types/utils.go b/rpc/types/utils.go index 5843ed24ef..9d12851d99 100644 --- a/rpc/types/utils.go +++ b/rpc/types/utils.go @@ -10,8 +10,9 @@ import ( abci "github.com/tendermint/tendermint/abci/types" tmtypes "github.com/tendermint/tendermint/types" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/client" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" evmtypes "github.com/evmos/ethermint/x/evm/types" feemarkettypes "github.com/evmos/ethermint/x/feemarket/types" @@ -31,7 +32,7 @@ const ExceedBlockGasLimitError = "out of gas in location: block gas meter; gasWa func RawTxToEthTx(clientCtx client.Context, txBz tmtypes.Tx) ([]*evmtypes.MsgEthereumTx, error) { tx, err := clientCtx.TxConfig.TxDecoder()(txBz) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error()) + return nil, errorsmod.Wrap(errortypes.ErrJSONUnmarshal, err.Error()) } ethTxs := make([]*evmtypes.MsgEthereumTx, len(tx.GetMsgs())) diff --git a/server/config/config.go b/server/config/config.go index 00f17c2f65..cfa8db4d63 100644 --- a/server/config/config.go +++ b/server/config/config.go @@ -10,9 +10,9 @@ import ( "github.com/tendermint/tendermint/libs/strings" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/server/config" - - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" ) const ( @@ -346,15 +346,15 @@ func ParseConfig(v *viper.Viper) (*Config, error) { // ValidateBasic returns an error any of the application configuration fields are invalid func (c Config) ValidateBasic() error { if err := c.EVM.Validate(); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrAppConfig, "invalid evm config value: %s", err.Error()) + return errorsmod.Wrapf(errortypes.ErrAppConfig, "invalid evm config value: %s", err.Error()) } if err := c.JSONRPC.Validate(); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrAppConfig, "invalid json-rpc config value: %s", err.Error()) + return errorsmod.Wrapf(errortypes.ErrAppConfig, "invalid json-rpc config value: %s", err.Error()) } if err := c.TLS.Validate(); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrAppConfig, "invalid tls config value: %s", err.Error()) + return errorsmod.Wrapf(errortypes.ErrAppConfig, "invalid tls config value: %s", err.Error()) } return c.Config.ValidateBasic() diff --git a/server/start.go b/server/start.go index a476f5ffb3..ab515a09ea 100644 --- a/server/start.go +++ b/server/start.go @@ -35,6 +35,7 @@ import ( ethmetricsexp "github.com/ethereum/go-ethereum/metrics/exp" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" pruningtypes "github.com/cosmos/cosmos-sdk/pruning/types" @@ -43,7 +44,6 @@ import ( serverconfig "github.com/cosmos/cosmos-sdk/server/config" servergrpc "github.com/cosmos/cosmos-sdk/server/grpc" "github.com/cosmos/cosmos-sdk/server/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/evmos/ethermint/indexer" ethdebug "github.com/evmos/ethermint/rpc/namespaces/ethereum/debug" @@ -404,7 +404,7 @@ func startInProcess(ctx *server.Context, clientCtx client.Context, appCreator ty if config.GRPC.Enable { _, port, err := net.SplitHostPort(config.GRPC.Address) if err != nil { - return sdkerrors.Wrapf(err, "invalid grpc address %s", config.GRPC.Address) + return errorsmod.Wrapf(err, "invalid grpc address %s", config.GRPC.Address) } maxSendMsgSize := config.GRPC.MaxSendMsgSize diff --git a/types/chain_id.go b/types/chain_id.go index 0688423c9f..fd69d39de5 100644 --- a/types/chain_id.go +++ b/types/chain_id.go @@ -6,7 +6,7 @@ import ( "regexp" "strings" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" ) var ( @@ -37,18 +37,18 @@ func IsValidChainID(chainID string) bool { func ParseChainID(chainID string) (*big.Int, error) { chainID = strings.TrimSpace(chainID) if len(chainID) > 48 { - return nil, sdkerrors.Wrapf(ErrInvalidChainID, "chain-id '%s' cannot exceed 48 chars", chainID) + return nil, errorsmod.Wrapf(ErrInvalidChainID, "chain-id '%s' cannot exceed 48 chars", chainID) } matches := ethermintChainID.FindStringSubmatch(chainID) if matches == nil || len(matches) != 4 || matches[1] == "" { - return nil, sdkerrors.Wrapf(ErrInvalidChainID, "%s: %v", chainID, matches) + return nil, errorsmod.Wrapf(ErrInvalidChainID, "%s: %v", chainID, matches) } // verify that the chain-id entered is a base 10 integer chainIDInt, ok := new(big.Int).SetString(matches[2], 10) if !ok { - return nil, sdkerrors.Wrapf(ErrInvalidChainID, "epoch %s must be base-10 integer format", matches[2]) + return nil, errorsmod.Wrapf(ErrInvalidChainID, "epoch %s must be base-10 integer format", matches[2]) } return chainIDInt, nil diff --git a/types/errors.go b/types/errors.go index a80e02e72d..1fe4673aea 100644 --- a/types/errors.go +++ b/types/errors.go @@ -1,7 +1,7 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" ) const ( @@ -13,14 +13,14 @@ const ( var ( // ErrInvalidValue returns an error resulting from an invalid value. - ErrInvalidValue = sdkerrors.Register(RootCodespace, 2, "invalid value") + ErrInvalidValue = errorsmod.Register(RootCodespace, 2, "invalid value") // ErrInvalidChainID returns an error resulting from an invalid chain ID. - ErrInvalidChainID = sdkerrors.Register(RootCodespace, 3, "invalid chain ID") + ErrInvalidChainID = errorsmod.Register(RootCodespace, 3, "invalid chain ID") // ErrMarshalBigInt returns an error resulting from marshaling a big.Int to a string. - ErrMarshalBigInt = sdkerrors.Register(RootCodespace, 5, "cannot marshal big.Int to string") + ErrMarshalBigInt = errorsmod.Register(RootCodespace, 5, "cannot marshal big.Int to string") // ErrUnmarshalBigInt returns an error resulting from unmarshaling a big.Int from a string. - ErrUnmarshalBigInt = sdkerrors.Register(RootCodespace, 6, "cannot unmarshal big.Int from string") + ErrUnmarshalBigInt = errorsmod.Register(RootCodespace, 6, "cannot unmarshal big.Int from string") ) diff --git a/types/int.go b/types/int.go index 7f66b519dc..16cb5d6103 100644 --- a/types/int.go +++ b/types/int.go @@ -5,9 +5,9 @@ import ( math "math" "math/big" + errorsmod "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" - - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" ) const maxBitLen = 256 @@ -15,7 +15,7 @@ const maxBitLen = 256 // SafeInt64 checks for overflows while casting a uint64 to int64 value. func SafeInt64(value uint64) (int64, error) { if value > uint64(math.MaxInt64) { - return 0, sdkerrors.Wrapf(sdkerrors.ErrInvalidHeight, "uint64 value %v cannot exceed %v", value, int64(math.MaxInt64)) + return 0, errorsmod.Wrapf(errortypes.ErrInvalidHeight, "uint64 value %v cannot exceed %v", value, int64(math.MaxInt64)) } return int64(value), nil diff --git a/types/validation.go b/types/validation.go index e49ac308a0..348598e589 100644 --- a/types/validation.go +++ b/types/validation.go @@ -3,7 +3,8 @@ package types import ( "bytes" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" ) @@ -20,8 +21,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 sdkerrors.Wrapf( - sdkerrors.ErrInvalidAddress, "address '%s' is not a valid ethereum hex address", + return errorsmod.Wrapf( + errortypes.ErrInvalidAddress, "address '%s' is not a valid ethereum hex address", address, ) } @@ -32,8 +33,8 @@ func ValidateAddress(address string) error { // formatted string address or is equal to zero func ValidateNonZeroAddress(address string) error { if IsZeroAddress(address) { - return sdkerrors.Wrapf( - sdkerrors.ErrInvalidAddress, "address '%s' must not be zero", + return errorsmod.Wrapf( + errortypes.ErrInvalidAddress, "address '%s' must not be zero", address, ) } diff --git a/x/evm/handler.go b/x/evm/handler.go index 609a93c8e6..b3909135c6 100644 --- a/x/evm/handler.go +++ b/x/evm/handler.go @@ -1,8 +1,9 @@ package evm import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/evmos/ethermint/x/evm/types" ) @@ -19,7 +20,7 @@ func NewHandler(server types.MsgServer) sdk.Handler { return sdk.WrapServiceResult(ctx, res, err) default: - err := sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized %s message type: %T", types.ModuleName, msg) + err := errorsmod.Wrapf(errortypes.ErrUnknownRequest, "unrecognized %s message type: %T", types.ModuleName, msg) return nil, err } } diff --git a/x/evm/keeper/hooks.go b/x/evm/keeper/hooks.go index fc1c740516..d10abffc08 100644 --- a/x/evm/keeper/hooks.go +++ b/x/evm/keeper/hooks.go @@ -1,8 +1,8 @@ package keeper import ( + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/core" ethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/evmos/ethermint/x/evm/types" @@ -22,7 +22,7 @@ func NewMultiEvmHooks(hooks ...types.EvmHooks) MultiEvmHooks { func (mh MultiEvmHooks) PostTxProcessing(ctx sdk.Context, msg core.Message, receipt *ethtypes.Receipt) error { for i := range mh { if err := mh[i].PostTxProcessing(ctx, msg, receipt); err != nil { - return sdkerrors.Wrapf(err, "EVM hook %T failed", mh[i]) + return errorsmod.Wrapf(err, "EVM hook %T failed", mh[i]) } } return nil diff --git a/x/evm/keeper/keeper.go b/x/evm/keeper/keeper.go index 331082831d..f93b22a5ab 100644 --- a/x/evm/keeper/keeper.go +++ b/x/evm/keeper/keeper.go @@ -3,11 +3,11 @@ package keeper import ( "math/big" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/store/prefix" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" @@ -364,7 +364,7 @@ func (k Keeper) SetTransientGasUsed(ctx sdk.Context, gasUsed uint64) { func (k Keeper) AddTransientGasUsed(ctx sdk.Context, gasUsed uint64) (uint64, error) { result := k.GetTransientGasUsed(ctx) + gasUsed if result < gasUsed { - return 0, sdkerrors.Wrap(types.ErrGasOverflow, "transient gas used") + return 0, errorsmod.Wrap(types.ErrGasOverflow, "transient gas used") } k.SetTransientGasUsed(ctx, result) return result, nil diff --git a/x/evm/keeper/msg_server.go b/x/evm/keeper/msg_server.go index 8329f040cb..1b17a4af28 100644 --- a/x/evm/keeper/msg_server.go +++ b/x/evm/keeper/msg_server.go @@ -9,10 +9,10 @@ import ( tmbytes "github.com/tendermint/tendermint/libs/bytes" tmtypes "github.com/tendermint/tendermint/types" + errorsmod "cosmossdk.io/errors" "github.com/armon/go-metrics" "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/evmos/ethermint/x/evm/types" ) @@ -45,7 +45,7 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t response, err := k.ApplyTransaction(ctx, tx) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to apply transaction") + return nil, errorsmod.Wrap(err, "failed to apply transaction") } defer func() { @@ -104,7 +104,7 @@ func (k *Keeper) EthereumTx(goCtx context.Context, msg *types.MsgEthereumTx) (*t for i, log := range response.Logs { value, err := json.Marshal(log) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to encode log") + return nil, errorsmod.Wrap(err, "failed to encode log") } txLogAttrs[i] = sdk.NewAttribute(types.AttributeKeyTxLog, string(value)) } diff --git a/x/evm/keeper/state_transition.go b/x/evm/keeper/state_transition.go index c3b225774f..8629376cce 100644 --- a/x/evm/keeper/state_transition.go +++ b/x/evm/keeper/state_transition.go @@ -8,8 +8,9 @@ import ( tmtypes "github.com/tendermint/tendermint/types" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -46,7 +47,7 @@ func (k *Keeper) EVMConfig(ctx sdk.Context, proposerAddress sdk.ConsAddress) (*t // get the coinbase address from the block proposer coinbase, err := k.GetCoinbaseAddress(ctx, proposerAddress) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to obtain coinbase address") + return nil, errorsmod.Wrap(err, "failed to obtain coinbase address") } baseFee := k.GetBaseFee(ctx, ethCfg) @@ -201,7 +202,7 @@ func (k *Keeper) ApplyTransaction(ctx sdk.Context, tx *ethtypes.Transaction) (*t cfg, err := k.EVMConfig(ctx, sdk.ConsAddress(ctx.BlockHeader().ProposerAddress)) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to load evm config") + return nil, errorsmod.Wrap(err, "failed to load evm config") } txConfig := k.TxConfig(ctx, tx.Hash()) @@ -209,7 +210,7 @@ func (k *Keeper) ApplyTransaction(ctx sdk.Context, tx *ethtypes.Transaction) (*t signer := ethtypes.MakeSigner(cfg.ChainConfig, big.NewInt(ctx.BlockHeight())) msg, err := tx.AsMessage(signer, cfg.BaseFee) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to return ethereum transaction as core message") + return nil, errorsmod.Wrap(err, "failed to return ethereum transaction as core message") } // snapshot to contain the tx processing and post processing in same scope @@ -226,7 +227,7 @@ func (k *Keeper) ApplyTransaction(ctx sdk.Context, tx *ethtypes.Transaction) (*t // pass true to commit the StateDB res, err := k.ApplyMessageWithConfig(tmpCtx, msg, nil, true, cfg, txConfig) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to apply ethereum core message") + return nil, errorsmod.Wrap(err, "failed to apply ethereum core message") } logs := types.LogsToEthereum(res.Logs) @@ -285,7 +286,7 @@ func (k *Keeper) ApplyTransaction(ctx sdk.Context, tx *ethtypes.Transaction) (*t // refund gas in order to match the Ethereum gas consumption instead of the default SDK one. if err = k.RefundGas(ctx, msg, msg.Gas()-res.GasUsed, cfg.Params.EvmDenom); err != nil { - return nil, sdkerrors.Wrapf(err, "failed to refund gas leftover gas to sender %s", msg.From()) + return nil, errorsmod.Wrapf(err, "failed to refund gas leftover gas to sender %s", msg.From()) } if len(receipt.Logs) > 0 { @@ -298,7 +299,7 @@ func (k *Keeper) ApplyTransaction(ctx sdk.Context, tx *ethtypes.Transaction) (*t totalGasUsed, err := k.AddTransientGasUsed(ctx, res.GasUsed) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to add transient gas used") + return nil, errorsmod.Wrap(err, "failed to add transient gas used") } // reset the gas meter for current cosmos transaction @@ -358,9 +359,9 @@ func (k *Keeper) ApplyMessageWithConfig(ctx sdk.Context, // return error if contract creation or call are disabled through governance if !cfg.Params.EnableCreate && msg.To() == nil { - return nil, sdkerrors.Wrap(types.ErrCreateDisabled, "failed to create new contract") + return nil, errorsmod.Wrap(types.ErrCreateDisabled, "failed to create new contract") } else if !cfg.Params.EnableCall && msg.To() != nil { - return nil, sdkerrors.Wrap(types.ErrCallDisabled, "failed to call contract") + return nil, errorsmod.Wrap(types.ErrCallDisabled, "failed to call contract") } stateDB := statedb.New(ctx, k, txConfig) @@ -384,13 +385,13 @@ func (k *Keeper) ApplyMessageWithConfig(ctx sdk.Context, intrinsicGas, err := k.GetEthIntrinsicGas(ctx, msg, cfg.ChainConfig, contractCreation) if err != nil { // should have already been checked on Ante Handler - return nil, sdkerrors.Wrap(err, "intrinsic gas failed") + return nil, errorsmod.Wrap(err, "intrinsic gas failed") } // Should check again even if it is checked on Ante Handler, because eth_call don't go through Ante Handler. if leftoverGas < intrinsicGas { // eth_estimateGas will check for this exact error - return nil, sdkerrors.Wrap(core.ErrIntrinsicGas, "apply message") + return nil, errorsmod.Wrap(core.ErrIntrinsicGas, "apply message") } leftoverGas -= intrinsicGas @@ -420,7 +421,7 @@ func (k *Keeper) ApplyMessageWithConfig(ctx sdk.Context, // calculate gas refund if msg.Gas() < leftoverGas { - return nil, sdkerrors.Wrap(types.ErrGasOverflow, "apply message") + return nil, errorsmod.Wrap(types.ErrGasOverflow, "apply message") } // refund gas leftoverGas += GasToRefund(stateDB.GetRefund(), msg.Gas()-leftoverGas, refundQuotient) @@ -434,7 +435,7 @@ func (k *Keeper) ApplyMessageWithConfig(ctx sdk.Context, // The dirty states in `StateDB` is either committed or discarded after return if commit { if err := stateDB.Commit(); err != nil { - return nil, sdkerrors.Wrap(err, "failed to commit stateDB") + return nil, errorsmod.Wrap(err, "failed to commit stateDB") } } @@ -446,7 +447,7 @@ func (k *Keeper) ApplyMessageWithConfig(ctx sdk.Context, minimumGasUsed := gasLimit.Mul(minGasMultiplier) if msg.Gas() < leftoverGas { - return nil, sdkerrors.Wrapf(types.ErrGasOverflow, "message gas limit < leftover gas (%d < %d)", msg.Gas(), leftoverGas) + return nil, errorsmod.Wrapf(types.ErrGasOverflow, "message gas limit < leftover gas (%d < %d)", msg.Gas(), leftoverGas) } temporaryGasUsed := msg.Gas() - leftoverGas gasUsed := sdk.MaxDec(minimumGasUsed, sdk.NewDec(int64(temporaryGasUsed))).TruncateInt().Uint64() @@ -466,7 +467,7 @@ func (k *Keeper) ApplyMessageWithConfig(ctx sdk.Context, func (k *Keeper) ApplyMessage(ctx sdk.Context, msg core.Message, tracer vm.EVMLogger, commit bool) (*types.MsgEthereumTxResponse, error) { cfg, err := k.EVMConfig(ctx, sdk.ConsAddress(ctx.BlockHeader().ProposerAddress)) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to load evm config") + return nil, errorsmod.Wrap(err, "failed to load evm config") } txConfig := statedb.NewEmptyTxConfig(common.BytesToHash(ctx.HeaderHash())) return k.ApplyMessageWithConfig(ctx, msg, tracer, commit, cfg, txConfig) @@ -492,7 +493,7 @@ func (k *Keeper) RefundGas(ctx sdk.Context, msg core.Message, leftoverGas uint64 switch remaining.Sign() { case -1: // negative refund errors - return sdkerrors.Wrapf(types.ErrInvalidRefund, "refunded amount value cannot be negative %d", remaining.Int64()) + return errorsmod.Wrapf(types.ErrInvalidRefund, "refunded amount value cannot be negative %d", remaining.Int64()) case 1: // positive amount refund refundedCoins := sdk.Coins{sdk.NewCoin(denom, sdkmath.NewIntFromBigInt(remaining))} @@ -501,8 +502,8 @@ func (k *Keeper) RefundGas(ctx sdk.Context, msg core.Message, leftoverGas uint64 err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, authtypes.FeeCollectorName, msg.From().Bytes(), refundedCoins) if err != nil { - err = sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds, "fee collector account failed to refund fees: %s", err.Error()) - return sdkerrors.Wrapf(err, "failed to refund %d leftover gas (%s)", leftoverGas, refundedCoins.String()) + err = errorsmod.Wrapf(errortypes.ErrInsufficientFunds, "fee collector account failed to refund fees: %s", err.Error()) + return errorsmod.Wrapf(err, "failed to refund %d leftover gas (%s)", leftoverGas, refundedCoins.String()) } default: // no refund, consume gas and update the tx gas meter @@ -531,7 +532,7 @@ func GetProposerAddress(ctx sdk.Context, proposerAddress sdk.ConsAddress) sdk.Co func (k Keeper) GetCoinbaseAddress(ctx sdk.Context, proposerAddress sdk.ConsAddress) (common.Address, error) { validator, found := k.stakingKeeper.GetValidatorByConsAddr(ctx, GetProposerAddress(ctx, proposerAddress)) if !found { - return common.Address{}, sdkerrors.Wrapf( + return common.Address{}, errorsmod.Wrapf( stakingtypes.ErrNoValidatorFound, "failed to retrieve validator from block proposer address %s", proposerAddress.String(), diff --git a/x/evm/keeper/statedb.go b/x/evm/keeper/statedb.go index 92ee7e4fa0..45cf4d907d 100644 --- a/x/evm/keeper/statedb.go +++ b/x/evm/keeper/statedb.go @@ -6,9 +6,9 @@ import ( sdkmath "cosmossdk.io/math" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/store/prefix" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" ethermint "github.com/evmos/ethermint/types" "github.com/evmos/ethermint/x/evm/statedb" @@ -189,7 +189,7 @@ func (k *Keeper) DeleteAccount(ctx sdk.Context, addr common.Address) error { // NOTE: only Ethereum accounts (contracts) can be selfdestructed _, ok := acct.(ethermint.EthAccountI) if !ok { - return sdkerrors.Wrapf(types.ErrInvalidAccount, "type %T, address %s", acct, addr) + return errorsmod.Wrapf(types.ErrInvalidAccount, "type %T, address %s", acct, addr) } // clear balance diff --git a/x/evm/keeper/utils.go b/x/evm/keeper/utils.go index 6d0d37d99a..f72632c88c 100644 --- a/x/evm/keeper/utils.go +++ b/x/evm/keeper/utils.go @@ -4,9 +4,10 @@ import ( "math" "math/big" + errorsmod "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" authante "github.com/cosmos/cosmos-sdk/x/auth/ante" evmtypes "github.com/evmos/ethermint/x/evm/types" @@ -29,7 +30,7 @@ func (k Keeper) DeductTxCostsFromUserBalance( // fetch sender account from signature signerAcc, err := authante.GetSignerAcc(ctx, k.accountKeeper, msgEthTx.GetFrom()) if err != nil { - return nil, 0, sdkerrors.Wrapf(err, "account not found for sender %s", msgEthTx.From) + return nil, 0, errorsmod.Wrapf(err, "account not found for sender %s", msgEthTx.From) } gasLimit := txData.GetGas() @@ -41,7 +42,7 @@ func (k Keeper) DeductTxCostsFromUserBalance( intrinsicGas, err := core.IntrinsicGas(txData.GetData(), accessList, isContractCreation, homestead, istanbul) if err != nil { - return nil, 0, sdkerrors.Wrapf( + return nil, 0, errorsmod.Wrapf( err, "failed to retrieve intrinsic gas, contract creation = %t; homestead = %t, istanbul = %t", isContractCreation, homestead, istanbul, @@ -50,8 +51,8 @@ func (k Keeper) DeductTxCostsFromUserBalance( // intrinsic gas verification during CheckTx if ctx.IsCheckTx() && gasLimit < intrinsicGas { - return nil, 0, sdkerrors.Wrapf( - sdkerrors.ErrOutOfGas, + return nil, 0, errorsmod.Wrapf( + errortypes.ErrOutOfGas, "gas limit too low: %d (gas limit) < %d (intrinsic gas)", gasLimit, intrinsicGas, ) } @@ -60,7 +61,7 @@ func (k Keeper) DeductTxCostsFromUserBalance( baseFee := k.getBaseFee(ctx, london) if baseFee != nil && txData.GetGasFeeCap().Cmp(baseFee) < 0 { - return nil, 0, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, + return nil, 0, errorsmod.Wrapf(errortypes.ErrInsufficientFee, "the tx gasfeecap is lower than the tx baseFee: %s (gasfeecap), %s (basefee) ", txData.GetGasFeeCap(), baseFee) @@ -76,7 +77,7 @@ func (k Keeper) DeductTxCostsFromUserBalance( // deduct the full gas cost from the user balance if err := authante.DeductFees(k.bankKeeper, ctx, signerAcc, fees); err != nil { - return nil, 0, sdkerrors.Wrapf( + return nil, 0, errorsmod.Wrapf( err, "failed to deduct full gas cost %s from the user %s balance", fees, msgEthTx.From, @@ -108,15 +109,15 @@ func CheckSenderBalance( cost := txData.Cost() if cost.Sign() < 0 { - return sdkerrors.Wrapf( - sdkerrors.ErrInvalidCoins, + return errorsmod.Wrapf( + errortypes.ErrInvalidCoins, "tx cost (%s) is negative and invalid", cost, ) } if balance.IsNegative() || balance.BigInt().Cmp(cost) < 0 { - return sdkerrors.Wrapf( - sdkerrors.ErrInsufficientFunds, + return errorsmod.Wrapf( + errortypes.ErrInsufficientFunds, "sender balance < tx cost (%s < %s)", balance, txData.Cost(), ) } diff --git a/x/evm/migrations/v2/types/chain_config.go b/x/evm/migrations/v2/types/chain_config.go index 15aa6087ea..2bbbb6a7ba 100644 --- a/x/evm/migrations/v2/types/chain_config.go +++ b/x/evm/migrations/v2/types/chain_config.go @@ -6,8 +6,8 @@ import ( sdkmath "cosmossdk.io/math" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/params" @@ -91,61 +91,61 @@ func getBlockValue(block *sdkmath.Int) *big.Int { // if any of the block values is uninitialized (i.e nil) or if the EIP150Hash is an invalid hash. func (cc ChainConfig) Validate() error { if err := validateBlock(cc.HomesteadBlock); err != nil { - return sdkerrors.Wrap(err, "homesteadBlock") + return errorsmod.Wrap(err, "homesteadBlock") } if err := validateBlock(cc.DAOForkBlock); err != nil { - return sdkerrors.Wrap(err, "daoForkBlock") + return errorsmod.Wrap(err, "daoForkBlock") } if err := validateBlock(cc.EIP150Block); err != nil { - return sdkerrors.Wrap(err, "eip150Block") + return errorsmod.Wrap(err, "eip150Block") } if err := validateHash(cc.EIP150Hash); err != nil { return err } if err := validateBlock(cc.EIP155Block); err != nil { - return sdkerrors.Wrap(err, "eip155Block") + return errorsmod.Wrap(err, "eip155Block") } if err := validateBlock(cc.EIP158Block); err != nil { - return sdkerrors.Wrap(err, "eip158Block") + return errorsmod.Wrap(err, "eip158Block") } if err := validateBlock(cc.ByzantiumBlock); err != nil { - return sdkerrors.Wrap(err, "byzantiumBlock") + return errorsmod.Wrap(err, "byzantiumBlock") } if err := validateBlock(cc.ConstantinopleBlock); err != nil { - return sdkerrors.Wrap(err, "constantinopleBlock") + return errorsmod.Wrap(err, "constantinopleBlock") } if err := validateBlock(cc.PetersburgBlock); err != nil { - return sdkerrors.Wrap(err, "petersburgBlock") + return errorsmod.Wrap(err, "petersburgBlock") } if err := validateBlock(cc.IstanbulBlock); err != nil { - return sdkerrors.Wrap(err, "istanbulBlock") + return errorsmod.Wrap(err, "istanbulBlock") } if err := validateBlock(cc.MuirGlacierBlock); err != nil { - return sdkerrors.Wrap(err, "muirGlacierBlock") + return errorsmod.Wrap(err, "muirGlacierBlock") } if err := validateBlock(cc.BerlinBlock); err != nil { - return sdkerrors.Wrap(err, "berlinBlock") + return errorsmod.Wrap(err, "berlinBlock") } if err := validateBlock(cc.LondonBlock); err != nil { - return sdkerrors.Wrap(err, "londonBlock") + return errorsmod.Wrap(err, "londonBlock") } if err := validateBlock(cc.ArrowGlacierBlock); err != nil { - return sdkerrors.Wrap(err, "arrowGlacierBlock") + return errorsmod.Wrap(err, "arrowGlacierBlock") } if err := validateBlock(cc.MergeForkBlock); err != nil { - return sdkerrors.Wrap(err, "mergeForkBlock") + return errorsmod.Wrap(err, "mergeForkBlock") } // NOTE: chain ID is not needed to check config order if err := cc.EthereumConfig(nil).CheckConfigForkOrder(); err != nil { - return sdkerrors.Wrap(err, "invalid config fork order") + return errorsmod.Wrap(err, "invalid config fork order") } return nil } func validateHash(hex string) error { if hex != "" && strings.TrimSpace(hex) == "" { - return sdkerrors.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank") + return errorsmod.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank") } return nil @@ -158,7 +158,7 @@ func validateBlock(block *sdkmath.Int) error { } if block.IsNegative() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrInvalidChainConfig, "block value cannot be negative: %s", block, ) } diff --git a/x/evm/migrations/v3/types/chain_config.go b/x/evm/migrations/v3/types/chain_config.go index 5b25084b35..ac8cecfb7b 100644 --- a/x/evm/migrations/v3/types/chain_config.go +++ b/x/evm/migrations/v3/types/chain_config.go @@ -8,8 +8,8 @@ import ( "github.com/evmos/ethermint/x/evm/types" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/params" @@ -90,61 +90,61 @@ func getBlockValue(block *sdkmath.Int) *big.Int { // if any of the block values is uninitialized (i.e nil) or if the EIP150Hash is an invalid hash. func (cc ChainConfig) Validate() error { if err := validateBlock(cc.HomesteadBlock); err != nil { - return sdkerrors.Wrap(err, "homesteadBlock") + return errorsmod.Wrap(err, "homesteadBlock") } if err := validateBlock(cc.DAOForkBlock); err != nil { - return sdkerrors.Wrap(err, "daoForkBlock") + return errorsmod.Wrap(err, "daoForkBlock") } if err := validateBlock(cc.EIP150Block); err != nil { - return sdkerrors.Wrap(err, "eip150Block") + return errorsmod.Wrap(err, "eip150Block") } if err := validateHash(cc.EIP150Hash); err != nil { return err } if err := validateBlock(cc.EIP155Block); err != nil { - return sdkerrors.Wrap(err, "eip155Block") + return errorsmod.Wrap(err, "eip155Block") } if err := validateBlock(cc.EIP158Block); err != nil { - return sdkerrors.Wrap(err, "eip158Block") + return errorsmod.Wrap(err, "eip158Block") } if err := validateBlock(cc.ByzantiumBlock); err != nil { - return sdkerrors.Wrap(err, "byzantiumBlock") + return errorsmod.Wrap(err, "byzantiumBlock") } if err := validateBlock(cc.ConstantinopleBlock); err != nil { - return sdkerrors.Wrap(err, "constantinopleBlock") + return errorsmod.Wrap(err, "constantinopleBlock") } if err := validateBlock(cc.PetersburgBlock); err != nil { - return sdkerrors.Wrap(err, "petersburgBlock") + return errorsmod.Wrap(err, "petersburgBlock") } if err := validateBlock(cc.IstanbulBlock); err != nil { - return sdkerrors.Wrap(err, "istanbulBlock") + return errorsmod.Wrap(err, "istanbulBlock") } if err := validateBlock(cc.MuirGlacierBlock); err != nil { - return sdkerrors.Wrap(err, "muirGlacierBlock") + return errorsmod.Wrap(err, "muirGlacierBlock") } if err := validateBlock(cc.BerlinBlock); err != nil { - return sdkerrors.Wrap(err, "berlinBlock") + return errorsmod.Wrap(err, "berlinBlock") } if err := validateBlock(cc.LondonBlock); err != nil { - return sdkerrors.Wrap(err, "londonBlock") + return errorsmod.Wrap(err, "londonBlock") } if err := validateBlock(cc.ArrowGlacierBlock); err != nil { - return sdkerrors.Wrap(err, "arrowGlacierBlock") + return errorsmod.Wrap(err, "arrowGlacierBlock") } if err := validateBlock(cc.MergeForkBlock); err != nil { - return sdkerrors.Wrap(err, "mergeForkBlock") + return errorsmod.Wrap(err, "mergeForkBlock") } // NOTE: chain ID is not needed to check config order if err := cc.EthereumConfig(nil).CheckConfigForkOrder(); err != nil { - return sdkerrors.Wrap(err, "invalid config fork order") + return errorsmod.Wrap(err, "invalid config fork order") } return nil } func validateHash(hex string) error { if hex != "" && strings.TrimSpace(hex) == "" { - return sdkerrors.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank") + return errorsmod.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank") } return nil @@ -157,7 +157,7 @@ func validateBlock(block *sdkmath.Int) error { } if block.IsNegative() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrInvalidChainConfig, "block value cannot be negative: %s", block, ) } diff --git a/x/evm/statedb/statedb.go b/x/evm/statedb/statedb.go index ee8cd05816..56578e9034 100644 --- a/x/evm/statedb/statedb.go +++ b/x/evm/statedb/statedb.go @@ -5,8 +5,8 @@ import ( "math/big" "sort" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" ethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" @@ -440,14 +440,14 @@ func (s *StateDB) Commit() error { obj := s.stateObjects[addr] if obj.suicided { if err := s.keeper.DeleteAccount(s.ctx, obj.Address()); err != nil { - return sdkerrors.Wrap(err, "failed to delete account") + return errorsmod.Wrap(err, "failed to delete account") } } else { if obj.code != nil && obj.dirtyCode { s.keeper.SetCode(s.ctx, obj.CodeHash(), obj.code) } if err := s.keeper.SetAccount(s.ctx, obj.Address(), obj.account); err != nil { - return sdkerrors.Wrap(err, "failed to set account") + return errorsmod.Wrap(err, "failed to set account") } for _, key := range obj.dirtyStorage.SortedKeys() { value := obj.dirtyStorage[key] diff --git a/x/evm/types/access_list_tx.go b/x/evm/types/access_list_tx.go index d684f8722c..0d531a7c52 100644 --- a/x/evm/types/access_list_tx.go +++ b/x/evm/types/access_list_tx.go @@ -3,8 +3,9 @@ package types import ( "math/big" + errorsmod "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" ethtypes "github.com/ethereum/go-ethereum/core/types" @@ -183,38 +184,38 @@ func (tx *AccessListTx) SetSignatureValues(chainID, v, r, s *big.Int) { func (tx AccessListTx) Validate() error { gasPrice := tx.GetGasPrice() if gasPrice == nil { - return sdkerrors.Wrap(ErrInvalidGasPrice, "cannot be nil") + return errorsmod.Wrap(ErrInvalidGasPrice, "cannot be nil") } if !types.IsValidInt256(gasPrice) { - return sdkerrors.Wrap(ErrInvalidGasPrice, "out of bound") + return errorsmod.Wrap(ErrInvalidGasPrice, "out of bound") } if gasPrice.Sign() == -1 { - return sdkerrors.Wrapf(ErrInvalidGasPrice, "gas price cannot be negative %s", gasPrice) + return errorsmod.Wrapf(ErrInvalidGasPrice, "gas price cannot be negative %s", gasPrice) } amount := tx.GetValue() // Amount can be 0 if amount != nil && amount.Sign() == -1 { - return sdkerrors.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) + return errorsmod.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) } if !types.IsValidInt256(amount) { - return sdkerrors.Wrap(ErrInvalidAmount, "out of bound") + return errorsmod.Wrap(ErrInvalidAmount, "out of bound") } if !types.IsValidInt256(tx.Fee()) { - return sdkerrors.Wrap(ErrInvalidGasFee, "out of bound") + return errorsmod.Wrap(ErrInvalidGasFee, "out of bound") } if tx.To != "" { if err := types.ValidateAddress(tx.To); err != nil { - return sdkerrors.Wrap(err, "invalid to address") + return errorsmod.Wrap(err, "invalid to address") } } if tx.GetChainID() == nil { - return sdkerrors.Wrap( - sdkerrors.ErrInvalidChainID, + return errorsmod.Wrap( + errortypes.ErrInvalidChainID, "chain ID must be present on AccessList txs", ) } diff --git a/x/evm/types/chain_config.go b/x/evm/types/chain_config.go index 35a0bac26e..e10d3897c4 100644 --- a/x/evm/types/chain_config.go +++ b/x/evm/types/chain_config.go @@ -6,8 +6,8 @@ import ( sdkmath "cosmossdk.io/math" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/params" @@ -92,64 +92,64 @@ func getBlockValue(block *sdkmath.Int) *big.Int { // if any of the block values is uninitialized (i.e nil) or if the EIP150Hash is an invalid hash. func (cc ChainConfig) Validate() error { if err := validateBlock(cc.HomesteadBlock); err != nil { - return sdkerrors.Wrap(err, "homesteadBlock") + return errorsmod.Wrap(err, "homesteadBlock") } if err := validateBlock(cc.DAOForkBlock); err != nil { - return sdkerrors.Wrap(err, "daoForkBlock") + return errorsmod.Wrap(err, "daoForkBlock") } if err := validateBlock(cc.EIP150Block); err != nil { - return sdkerrors.Wrap(err, "eip150Block") + return errorsmod.Wrap(err, "eip150Block") } if err := validateHash(cc.EIP150Hash); err != nil { return err } if err := validateBlock(cc.EIP155Block); err != nil { - return sdkerrors.Wrap(err, "eip155Block") + return errorsmod.Wrap(err, "eip155Block") } if err := validateBlock(cc.EIP158Block); err != nil { - return sdkerrors.Wrap(err, "eip158Block") + return errorsmod.Wrap(err, "eip158Block") } if err := validateBlock(cc.ByzantiumBlock); err != nil { - return sdkerrors.Wrap(err, "byzantiumBlock") + return errorsmod.Wrap(err, "byzantiumBlock") } if err := validateBlock(cc.ConstantinopleBlock); err != nil { - return sdkerrors.Wrap(err, "constantinopleBlock") + return errorsmod.Wrap(err, "constantinopleBlock") } if err := validateBlock(cc.PetersburgBlock); err != nil { - return sdkerrors.Wrap(err, "petersburgBlock") + return errorsmod.Wrap(err, "petersburgBlock") } if err := validateBlock(cc.IstanbulBlock); err != nil { - return sdkerrors.Wrap(err, "istanbulBlock") + return errorsmod.Wrap(err, "istanbulBlock") } if err := validateBlock(cc.MuirGlacierBlock); err != nil { - return sdkerrors.Wrap(err, "muirGlacierBlock") + return errorsmod.Wrap(err, "muirGlacierBlock") } if err := validateBlock(cc.BerlinBlock); err != nil { - return sdkerrors.Wrap(err, "berlinBlock") + return errorsmod.Wrap(err, "berlinBlock") } if err := validateBlock(cc.LondonBlock); err != nil { - return sdkerrors.Wrap(err, "londonBlock") + return errorsmod.Wrap(err, "londonBlock") } if err := validateBlock(cc.ArrowGlacierBlock); err != nil { - return sdkerrors.Wrap(err, "arrowGlacierBlock") + return errorsmod.Wrap(err, "arrowGlacierBlock") } if err := validateBlock(cc.GrayGlacierBlock); err != nil { - return sdkerrors.Wrap(err, "GrayGlacierBlock") + return errorsmod.Wrap(err, "GrayGlacierBlock") } if err := validateBlock(cc.MergeNetsplitBlock); err != nil { - return sdkerrors.Wrap(err, "MergeNetsplitBlock") + return errorsmod.Wrap(err, "MergeNetsplitBlock") } // NOTE: chain ID is not needed to check config order if err := cc.EthereumConfig(nil).CheckConfigForkOrder(); err != nil { - return sdkerrors.Wrap(err, "invalid config fork order") + return errorsmod.Wrap(err, "invalid config fork order") } return nil } func validateHash(hex string) error { if hex != "" && strings.TrimSpace(hex) == "" { - return sdkerrors.Wrap(ErrInvalidChainConfig, "hash cannot be blank") + return errorsmod.Wrap(ErrInvalidChainConfig, "hash cannot be blank") } return nil @@ -162,7 +162,7 @@ func validateBlock(block *sdkmath.Int) error { } if block.IsNegative() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( ErrInvalidChainConfig, "block value cannot be negative: %s", block, ) } diff --git a/x/evm/types/codec.go b/x/evm/types/codec.go index 645b82ea20..f29c9c3d89 100644 --- a/x/evm/types/codec.go +++ b/x/evm/types/codec.go @@ -1,10 +1,11 @@ package types import ( + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/msgservice" "github.com/cosmos/cosmos-sdk/types/tx" proto "github.com/gogo/protobuf/proto" @@ -39,12 +40,12 @@ func RegisterInterfaces(registry codectypes.InterfaceRegistry) { func PackTxData(txData TxData) (*codectypes.Any, error) { msg, ok := txData.(proto.Message) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", txData) + return nil, errorsmod.Wrapf(errortypes.ErrPackAny, "cannot proto marshal %T", txData) } anyTxData, err := codectypes.NewAnyWithValue(msg) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrPackAny, err.Error()) + return nil, errorsmod.Wrap(errortypes.ErrPackAny, err.Error()) } return anyTxData, nil @@ -54,12 +55,12 @@ func PackTxData(txData TxData) (*codectypes.Any, error) { // client state can't be unpacked into a TxData. func UnpackTxData(any *codectypes.Any) (TxData, error) { if any == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrUnpackAny, "protobuf Any message cannot be nil") + return nil, errorsmod.Wrap(errortypes.ErrUnpackAny, "protobuf Any message cannot be nil") } txData, ok := any.GetCachedValue().(TxData) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnpackAny, "cannot unpack Any into TxData %T", any) + return nil, errorsmod.Wrapf(errortypes.ErrUnpackAny, "cannot unpack Any into TxData %T", any) } return txData, nil diff --git a/x/evm/types/dynamic_fee_tx.go b/x/evm/types/dynamic_fee_tx.go index a2b04bf1cb..9be5b7d2c7 100644 --- a/x/evm/types/dynamic_fee_tx.go +++ b/x/evm/types/dynamic_fee_tx.go @@ -3,8 +3,9 @@ package types import ( "math/big" + errorsmod "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" ethtypes "github.com/ethereum/go-ethereum/core/types" @@ -195,58 +196,58 @@ func (tx *DynamicFeeTx) SetSignatureValues(chainID, v, r, s *big.Int) { // Validate performs a stateless validation of the tx fields. func (tx DynamicFeeTx) Validate() error { if tx.GasTipCap == nil { - return sdkerrors.Wrap(ErrInvalidGasCap, "gas tip cap cannot nil") + return errorsmod.Wrap(ErrInvalidGasCap, "gas tip cap cannot nil") } if tx.GasFeeCap == nil { - return sdkerrors.Wrap(ErrInvalidGasCap, "gas fee cap cannot nil") + return errorsmod.Wrap(ErrInvalidGasCap, "gas fee cap cannot nil") } if tx.GasTipCap.IsNegative() { - return sdkerrors.Wrapf(ErrInvalidGasCap, "gas tip cap cannot be negative %s", tx.GasTipCap) + return errorsmod.Wrapf(ErrInvalidGasCap, "gas tip cap cannot be negative %s", tx.GasTipCap) } if tx.GasFeeCap.IsNegative() { - return sdkerrors.Wrapf(ErrInvalidGasCap, "gas fee cap cannot be negative %s", tx.GasFeeCap) + return errorsmod.Wrapf(ErrInvalidGasCap, "gas fee cap cannot be negative %s", tx.GasFeeCap) } if !types.IsValidInt256(tx.GetGasTipCap()) { - return sdkerrors.Wrap(ErrInvalidGasCap, "out of bound") + return errorsmod.Wrap(ErrInvalidGasCap, "out of bound") } if !types.IsValidInt256(tx.GetGasFeeCap()) { - return sdkerrors.Wrap(ErrInvalidGasCap, "out of bound") + return errorsmod.Wrap(ErrInvalidGasCap, "out of bound") } if tx.GasFeeCap.LT(*tx.GasTipCap) { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( ErrInvalidGasCap, "max priority fee per gas higher than max fee per gas (%s > %s)", tx.GasTipCap, tx.GasFeeCap, ) } if !types.IsValidInt256(tx.Fee()) { - return sdkerrors.Wrap(ErrInvalidGasFee, "out of bound") + return errorsmod.Wrap(ErrInvalidGasFee, "out of bound") } amount := tx.GetValue() // Amount can be 0 if amount != nil && amount.Sign() == -1 { - return sdkerrors.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) + return errorsmod.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) } if !types.IsValidInt256(amount) { - return sdkerrors.Wrap(ErrInvalidAmount, "out of bound") + return errorsmod.Wrap(ErrInvalidAmount, "out of bound") } if tx.To != "" { if err := types.ValidateAddress(tx.To); err != nil { - return sdkerrors.Wrap(err, "invalid to address") + return errorsmod.Wrap(err, "invalid to address") } } if tx.GetChainID() == nil { - return sdkerrors.Wrap( - sdkerrors.ErrInvalidChainID, + return errorsmod.Wrap( + errortypes.ErrInvalidChainID, "chain ID must be present on AccessList txs", ) } diff --git a/x/evm/types/errors.go b/x/evm/types/errors.go index 06bd126604..c5c41d8456 100644 --- a/x/evm/types/errors.go +++ b/x/evm/types/errors.go @@ -4,7 +4,7 @@ import ( "errors" "fmt" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/accounts/abi" @@ -40,67 +40,67 @@ var ErrPostTxProcessing = errors.New("failed to execute post processing") var ( // ErrInvalidState returns an error resulting from an invalid Storage State. - ErrInvalidState = sdkerrors.Register(ModuleName, codeErrInvalidState, "invalid storage state") + ErrInvalidState = errorsmod.Register(ModuleName, codeErrInvalidState, "invalid storage state") // ErrExecutionReverted returns an error resulting from an error in EVM execution. - ErrExecutionReverted = sdkerrors.Register(ModuleName, codeErrExecutionReverted, vm.ErrExecutionReverted.Error()) + ErrExecutionReverted = errorsmod.Register(ModuleName, codeErrExecutionReverted, vm.ErrExecutionReverted.Error()) // ErrChainConfigNotFound returns an error if the chain config cannot be found on the store. - ErrChainConfigNotFound = sdkerrors.Register(ModuleName, codeErrChainConfigNotFound, "chain configuration not found") + ErrChainConfigNotFound = errorsmod.Register(ModuleName, codeErrChainConfigNotFound, "chain configuration not found") // ErrInvalidChainConfig returns an error resulting from an invalid ChainConfig. - ErrInvalidChainConfig = sdkerrors.Register(ModuleName, codeErrInvalidChainConfig, "invalid chain configuration") + ErrInvalidChainConfig = errorsmod.Register(ModuleName, codeErrInvalidChainConfig, "invalid chain configuration") // ErrZeroAddress returns an error resulting from an zero (empty) ethereum Address. - ErrZeroAddress = sdkerrors.Register(ModuleName, codeErrZeroAddress, "invalid zero address") + ErrZeroAddress = errorsmod.Register(ModuleName, codeErrZeroAddress, "invalid zero address") // ErrEmptyHash returns an error resulting from an empty ethereum Hash. - ErrEmptyHash = sdkerrors.Register(ModuleName, codeErrEmptyHash, "empty hash") + ErrEmptyHash = errorsmod.Register(ModuleName, codeErrEmptyHash, "empty hash") // ErrBloomNotFound returns an error if the block bloom cannot be found on the store. - ErrBloomNotFound = sdkerrors.Register(ModuleName, codeErrBloomNotFound, "block bloom not found") + ErrBloomNotFound = errorsmod.Register(ModuleName, codeErrBloomNotFound, "block bloom not found") // ErrTxReceiptNotFound returns an error if the transaction receipt could not be found - ErrTxReceiptNotFound = sdkerrors.Register(ModuleName, codeErrTxReceiptNotFound, "transaction receipt not found") + ErrTxReceiptNotFound = errorsmod.Register(ModuleName, codeErrTxReceiptNotFound, "transaction receipt not found") // ErrCreateDisabled returns an error if the EnableCreate parameter is false. - ErrCreateDisabled = sdkerrors.Register(ModuleName, codeErrCreateDisabled, "EVM Create operation is disabled") + ErrCreateDisabled = errorsmod.Register(ModuleName, codeErrCreateDisabled, "EVM Create operation is disabled") // ErrCallDisabled returns an error if the EnableCall parameter is false. - ErrCallDisabled = sdkerrors.Register(ModuleName, codeErrCallDisabled, "EVM Call operation is disabled") + ErrCallDisabled = errorsmod.Register(ModuleName, codeErrCallDisabled, "EVM Call operation is disabled") // ErrInvalidAmount returns an error if a tx contains an invalid amount. - ErrInvalidAmount = sdkerrors.Register(ModuleName, codeErrInvalidAmount, "invalid transaction amount") + ErrInvalidAmount = errorsmod.Register(ModuleName, codeErrInvalidAmount, "invalid transaction amount") // ErrInvalidGasPrice returns an error if an invalid gas price is provided to the tx. - ErrInvalidGasPrice = sdkerrors.Register(ModuleName, codeErrInvalidGasPrice, "invalid gas price") + ErrInvalidGasPrice = errorsmod.Register(ModuleName, codeErrInvalidGasPrice, "invalid gas price") // ErrInvalidGasFee returns an error if the tx gas fee is out of bound. - ErrInvalidGasFee = sdkerrors.Register(ModuleName, codeErrInvalidGasFee, "invalid gas fee") + ErrInvalidGasFee = errorsmod.Register(ModuleName, codeErrInvalidGasFee, "invalid gas fee") // ErrVMExecution returns an error resulting from an error in EVM execution. - ErrVMExecution = sdkerrors.Register(ModuleName, codeErrVMExecution, "evm transaction execution failed") + ErrVMExecution = errorsmod.Register(ModuleName, codeErrVMExecution, "evm transaction execution failed") // ErrInvalidRefund returns an error if a the gas refund value is invalid. - ErrInvalidRefund = sdkerrors.Register(ModuleName, codeErrInvalidRefund, "invalid gas refund amount") + ErrInvalidRefund = errorsmod.Register(ModuleName, codeErrInvalidRefund, "invalid gas refund amount") // ErrInconsistentGas returns an error if a the gas differs from the expected one. - ErrInconsistentGas = sdkerrors.Register(ModuleName, codeErrInconsistentGas, "inconsistent gas") + ErrInconsistentGas = errorsmod.Register(ModuleName, codeErrInconsistentGas, "inconsistent gas") // ErrInvalidGasCap returns an error if a the gas cap value is negative or invalid - ErrInvalidGasCap = sdkerrors.Register(ModuleName, codeErrInvalidGasCap, "invalid gas cap") + ErrInvalidGasCap = errorsmod.Register(ModuleName, codeErrInvalidGasCap, "invalid gas cap") // ErrInvalidBaseFee returns an error if a the base fee cap value is invalid - ErrInvalidBaseFee = sdkerrors.Register(ModuleName, codeErrInvalidBaseFee, "invalid base fee") + ErrInvalidBaseFee = errorsmod.Register(ModuleName, codeErrInvalidBaseFee, "invalid base fee") // ErrGasOverflow returns an error if gas computation overlow/underflow - ErrGasOverflow = sdkerrors.Register(ModuleName, codeErrGasOverflow, "gas computation overflow/underflow") + ErrGasOverflow = errorsmod.Register(ModuleName, codeErrGasOverflow, "gas computation overflow/underflow") // ErrInvalidAccount returns an error if the account is not an EVM compatible account - ErrInvalidAccount = sdkerrors.Register(ModuleName, codeErrInvalidAccount, "account type is not a valid ethereum account") + ErrInvalidAccount = errorsmod.Register(ModuleName, codeErrInvalidAccount, "account type is not a valid ethereum account") // ErrInvalidGasLimit returns an error if gas limit value is invalid - ErrInvalidGasLimit = sdkerrors.Register(ModuleName, codeErrInvalidGasLimit, "invalid gas limit") + ErrInvalidGasLimit = errorsmod.Register(ModuleName, codeErrInvalidGasLimit, "invalid gas limit") ) // NewExecErrorWithReason unpacks the revert return bytes and returns a wrapped error diff --git a/x/evm/types/legacy_tx.go b/x/evm/types/legacy_tx.go index e6ddc0848e..105090b351 100644 --- a/x/evm/types/legacy_tx.go +++ b/x/evm/types/legacy_tx.go @@ -3,7 +3,7 @@ package types import ( "math/big" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" "github.com/ethereum/go-ethereum/common" ethtypes "github.com/ethereum/go-ethereum/core/types" "github.com/evmos/ethermint/types" @@ -160,31 +160,31 @@ func (tx *LegacyTx) SetSignatureValues(_, v, r, s *big.Int) { func (tx LegacyTx) Validate() error { gasPrice := tx.GetGasPrice() if gasPrice == nil { - return sdkerrors.Wrap(ErrInvalidGasPrice, "gas price cannot be nil") + return errorsmod.Wrap(ErrInvalidGasPrice, "gas price cannot be nil") } if gasPrice.Sign() == -1 { - return sdkerrors.Wrapf(ErrInvalidGasPrice, "gas price cannot be negative %s", gasPrice) + return errorsmod.Wrapf(ErrInvalidGasPrice, "gas price cannot be negative %s", gasPrice) } if !types.IsValidInt256(gasPrice) { - return sdkerrors.Wrap(ErrInvalidGasPrice, "out of bound") + return errorsmod.Wrap(ErrInvalidGasPrice, "out of bound") } if !types.IsValidInt256(tx.Fee()) { - return sdkerrors.Wrap(ErrInvalidGasFee, "out of bound") + return errorsmod.Wrap(ErrInvalidGasFee, "out of bound") } amount := tx.GetValue() // Amount can be 0 if amount != nil && amount.Sign() == -1 { - return sdkerrors.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) + return errorsmod.Wrapf(ErrInvalidAmount, "amount cannot be negative %s", amount) } if !types.IsValidInt256(amount) { - return sdkerrors.Wrap(ErrInvalidAmount, "out of bound") + return errorsmod.Wrap(ErrInvalidAmount, "out of bound") } if tx.To != "" { if err := types.ValidateAddress(tx.To); err != nil { - return sdkerrors.Wrap(err, "invalid to address") + return errorsmod.Wrap(err, "invalid to address") } } diff --git a/x/evm/types/msg.go b/x/evm/types/msg.go index 513a7cb871..64070abef5 100644 --- a/x/evm/types/msg.go +++ b/x/evm/types/msg.go @@ -7,11 +7,12 @@ import ( sdkmath "cosmossdk.io/math" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/cosmos-sdk/client" codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/crypto/keyring" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errortypes "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/ante" "github.com/cosmos/cosmos-sdk/x/auth/signing" authtx "github.com/cosmos/cosmos-sdk/x/auth/tx" @@ -165,23 +166,23 @@ func (msg MsgEthereumTx) Type() string { return TypeMsgEthereumTx } func (msg MsgEthereumTx) ValidateBasic() error { if msg.From != "" { if err := types.ValidateAddress(msg.From); err != nil { - return sdkerrors.Wrap(err, "invalid from address") + return errorsmod.Wrap(err, "invalid from address") } } // Validate Size_ field, should be kept empty if msg.Size_ != 0 { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "tx size is deprecated") + return errorsmod.Wrapf(errortypes.ErrInvalidRequest, "tx size is deprecated") } txData, err := UnpackTxData(msg.Data) if err != nil { - return sdkerrors.Wrap(err, "failed to unpack tx data") + return errorsmod.Wrap(err, "failed to unpack tx data") } // prevent txs with 0 gas to fill up the mempool if txData.GetGas() == 0 { - return sdkerrors.Wrap(ErrInvalidGasLimit, "gas limit must not be zero") + return errorsmod.Wrap(ErrInvalidGasLimit, "gas limit must not be zero") } if err := txData.Validate(); err != nil { @@ -191,7 +192,7 @@ func (msg MsgEthereumTx) ValidateBasic() error { // Validate Hash field after validated txData to avoid panic txHash := msg.AsTransaction().Hash().Hex() if msg.Hash != txHash { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid tx hash %s, expected: %s", msg.Hash, txHash) + return errorsmod.Wrapf(errortypes.ErrInvalidRequest, "invalid tx hash %s, expected: %s", msg.Hash, txHash) } return nil diff --git a/x/evm/types/storage.go b/x/evm/types/storage.go index 40c5bcc066..7e51f4203b 100644 --- a/x/evm/types/storage.go +++ b/x/evm/types/storage.go @@ -4,7 +4,7 @@ import ( "fmt" "strings" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" "github.com/ethereum/go-ethereum/common" ) @@ -17,7 +17,7 @@ func (s Storage) Validate() error { seenStorage := make(map[string]bool) for i, state := range s { if seenStorage[state.Key] { - return sdkerrors.Wrapf(ErrInvalidState, "duplicate state key %d: %s", i, state.Key) + return errorsmod.Wrapf(ErrInvalidState, "duplicate state key %d: %s", i, state.Key) } if err := state.Validate(); err != nil { @@ -51,7 +51,7 @@ func (s Storage) Copy() Storage { // NOTE: state value can be empty func (s State) Validate() error { if strings.TrimSpace(s.Key) == "" { - return sdkerrors.Wrap(ErrInvalidState, "state key hash cannot be blank") + return errorsmod.Wrap(ErrInvalidState, "state key hash cannot be blank") } return nil diff --git a/x/evm/types/utils.go b/x/evm/types/utils.go index b8ffd782d3..2b6aa793a8 100644 --- a/x/evm/types/utils.go +++ b/x/evm/types/utils.go @@ -6,8 +6,8 @@ import ( "github.com/gogo/protobuf/proto" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" @@ -34,7 +34,7 @@ func DecodeTxResponse(in []byte) (*MsgEthereumTxResponse, error) { var res MsgEthereumTxResponse if err := proto.Unmarshal(txMsgData.MsgResponses[0].Value, &res); err != nil { - return nil, sdkerrors.Wrap(err, "failed to unmarshal tx response message data") + return nil, errorsmod.Wrap(err, "failed to unmarshal tx response message data") } return &res, nil