Lint fixes

app/ante/account_type.go

@@ -1,6 +1,8 @@
 package ante
 
 import (
+	errorsmod "cosmossdk.io/errors"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
@@ -34,7 +36,7 @@ func NewSetAccountTypeDecorator(ak AccountKeeper, ethAccountProto func(sdk.AccAd
 func (satd SetAccountTypeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
 	sigTx, ok := tx.(SignedTx)
 	if !ok {
-		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "invalid tx type")
+		return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid tx type")
 	}
 
 	signers := sigTx.GetSigners()
@@ -56,13 +58,13 @@ func (satd SetAccountTypeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simul
 
 			// Copy over the BaseAccount values
 			if err = replacement.SetAccountNumber(baseAccount.GetAccountNumber()); err != nil {
-				return ctx, sdkerrors.Wrap(err, "unable to set account number on replacement EthAccount")
+				return ctx, errorsmod.Wrap(err, "unable to set account number on replacement EthAccount")
 			}
 			if err = replacement.SetSequence(baseAccount.GetSequence()); err != nil {
-				return ctx, sdkerrors.Wrap(err, "unable to set sequence on replacement EthAccount")
+				return ctx, errorsmod.Wrap(err, "unable to set sequence on replacement EthAccount")
 			}
 			if err = replacement.SetPubKey(storedPubKey); err != nil {
-				return ctx, sdkerrors.Wrap(err, "unable to set pubkey on replacement EthAccount")
+				return ctx, errorsmod.Wrap(err, "unable to set pubkey on replacement EthAccount")
 			}
 
 			satd.ak.SetAccount(ctx, replacement)

app/ante/ante.go

@@ -1,6 +1,8 @@
 package ante
 
 import (
+	errorsmod "cosmossdk.io/errors"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	authante "github.com/cosmos/cosmos-sdk/x/auth/ante"
@@ -32,7 +34,7 @@ func NewAnteHandler(options HandlerOptions) sdk.AnteHandler {
 					// handle as normal Cosmos SDK tx, except signature is checked for EIP712 representation
 					anteHandler = newCosmosAnteHandlerEip712(options)
 				default:
-					return ctx, sdkerrors.Wrapf(
+					return ctx, errorsmod.Wrapf(
 						sdkerrors.ErrUnknownExtensionOptions,
 						"rejecting tx with unsupported extension option: %s", typeURL,
 					)
@@ -47,7 +49,7 @@ func NewAnteHandler(options HandlerOptions) sdk.AnteHandler {
 		case sdk.Tx:
 			anteHandler = newCosmosAnteHandler(options)
 		default:
-			return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type: %T", tx)
+			return ctx, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "invalid transaction type: %T", tx)
 		}
 
 		return anteHandler(ctx, tx, sim)

app/ante/charge_gasfree_fees.go

@@ -1,8 +1,9 @@
 package ante
 
 import (
+	errorsmod "cosmossdk.io/errors"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	gasfreekeeper "github.com/AltheaFoundation/althea-L1/x/gasfree/keeper"
 	microtxkeeper "github.com/AltheaFoundation/althea-L1/x/microtx/keeper"
@@ -32,7 +33,7 @@ func (satd ChargeGasfreeFeesDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, si
 	// Handle any microtxs individually
 	err := satd.DeductAnyMicrotxFees(ctx, tx)
 	if err != nil {
-		return ctx, sdkerrors.Wrap(err, "failed to deduct microtx fees")
+		return ctx, errorsmod.Wrap(err, "failed to deduct microtx fees")
 	}
 
 	return next(ctx, tx, simulate)
@@ -49,7 +50,7 @@ func (satd ChargeGasfreeFeesDecorator) DeductAnyMicrotxFees(ctx sdk.Context, tx
 		if isMicrotx {
 			feeCollected, err := satd.microtxKeeper.DeductMsgMicrotxFee(ctx, msgMicrotx)
 			if err != nil {
-				return sdkerrors.Wrap(err, "unable to collect microtx fee prior to msg execution")
+				return errorsmod.Wrap(err, "unable to collect microtx fee prior to msg execution")
 			}
 			ctx.EventManager().EmitEvent(microtxtypes.NewEventMicrotxFeeCollected(msgMicrotx.Sender, *feeCollected))
 		}

app/ante/charge_gasfree_fees_test.go

@@ -5,6 +5,8 @@ import (
 	"math/big"
 	"strings"
 
+	sdkmath "cosmossdk.io/math"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 	evmtypes "github.com/evmos/ethermint/x/evm/types"
@@ -91,7 +93,7 @@ func runGasfreeTest(suite *AnteTestSuite, expPass bool, ctx sdk.Context, tx sdk.
 	shouldChangeBalanceAfter := suite.app.BankKeeper.GetBalance(cached, addr, shouldChangeDenom)
 	shouldNotChangeBalanceAfter := suite.app.BankKeeper.GetBalance(cached, addr, shouldNotChangeDenom)
 
-	var shouldChangeDiff, shouldNotChangeDiff sdk.Int
+	var shouldChangeDiff, shouldNotChangeDiff sdkmath.Int
 	if shouldChangeBalance.Amount.GT(shouldChangeBalanceAfter.Amount) {
 		shouldChangeDiff = shouldChangeBalance.Amount.Sub(shouldChangeBalanceAfter.Amount)
 	} else {
@@ -128,7 +130,7 @@ func runNoChangeGasfreeTest(suite *AnteTestSuite, expPass bool, ctx sdk.Context,
 
 	shouldNotChangeBalanceAfter := suite.app.BankKeeper.GetBalance(cached, addr, shouldNotChangeDenom)
 
-	var shouldNotChangeDiff sdk.Int
+	var shouldNotChangeDiff sdkmath.Int
 
 	if shouldNotChangeBalance.Amount.GT(shouldNotChangeBalanceAfter.Amount) {
 		shouldNotChangeDiff = shouldNotChangeBalance.Amount.Sub(shouldNotChangeBalanceAfter.Amount)
@@ -149,6 +151,7 @@ func (suite *AnteTestSuite) TestChargeGasfreeFeesDecorator() {
 
 	testDenom := "test"
 	suite.Require().NoError(suite.app.BankKeeper.MintCoins(suite.ctx, evmtypes.ModuleName, sdk.NewCoins(sdk.NewCoin(testDenom, sdk.NewInt(10000000000)))))
+	//nolint: exhaustruct
 	metadata := banktypes.Metadata{
 		Base:        testDenom,
 		Display:     testDenom,

app/ante/comission.go

@@ -1,6 +1,8 @@
 package ante
 
 import (
+	errorsmod "cosmossdk.io/errors"
+
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@@ -53,7 +55,7 @@ func (vcd ValidatorCommissionDecorator) validateAuthz(ctx sdk.Context, execMsg *
 		var innerMsg sdk.Msg
 		err := vcd.cdc.UnpackAny(v, &innerMsg)
 		if err != nil {
-			return sdkerrors.Wrap(err, "cannot unmarshal authz exec msgs")
+			return errorsmod.Wrap(err, "cannot unmarshal authz exec msgs")
 		}
 
 		if err := vcd.validateMsg(ctx, innerMsg); err != nil {
@@ -69,13 +71,13 @@ func (vcd ValidatorCommissionDecorator) validateMsg(_ sdk.Context, msg sdk.Msg)
 	switch msg := msg.(type) {
 	case *stakingtypes.MsgCreateValidator:
 		if msg.Commission.Rate.LT(minCommission) {
-			return sdkerrors.Wrapf(
+			return errorsmod.Wrapf(
 				sdkerrors.ErrInvalidRequest,
 				"validator commission %s be lower than minimum of %s", msg.Commission.Rate, minCommission)
 		}
 	case *stakingtypes.MsgEditValidator:
 		if msg.CommissionRate != nil && msg.CommissionRate.LT(minCommission) {
-			return sdkerrors.Wrapf(
+			return errorsmod.Wrapf(
 				sdkerrors.ErrInvalidRequest,
 				"validator commission %s be lower than minimum of %s", msg.CommissionRate, minCommission)
 		}

app/ante/cosmos_handler_test.go

@@ -4,8 +4,9 @@ import (
 	"math/big"
 	"strings"
 
+	errorsmod "cosmossdk.io/errors"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
 
 	altheaconfig "github.com/AltheaFoundation/althea-L1/config"
@@ -24,65 +25,65 @@ func runBypassTest(suite *AnteTestSuite, expErrorStr string, gasfreeMicrotxCtx,
 	// Expect bypass for the Microtx tx
 	cached, _ := gasfreeMicrotxCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgMicrotxTx, false); err != nil {
-		return sdkerrors.Wrap(err, "microtx gasfree expected no error")
+		return errorsmod.Wrap(err, "microtx gasfree expected no error")
 	}
 	// Expect failure for the Send tx
 	cached, _ = gasfreeMicrotxCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgSendTx, false); !strings.Contains(err.Error(), expErrorStr) {
-		return sdkerrors.Wrap(err, "microtx gasfree sent send - expected error")
+		return errorsmod.Wrap(err, "microtx gasfree sent send - expected error")
 	}
 	// Expect failure for both msg tx
 	cached, _ = gasfreeMicrotxCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, bothTx, false); !strings.Contains(err.Error(), expErrorStr) {
-		return sdkerrors.Wrap(err, "microtx gasfree sent send and microtx - expected error")
+		return errorsmod.Wrap(err, "microtx gasfree sent send and microtx - expected error")
 	}
 
 	// --- Send is the only Gasfree Msg type ---
 	cached, _ = gasfreeSendCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgMicrotxTx, false); !strings.Contains(err.Error(), expErrorStr) {
-		return sdkerrors.Wrap(err, "send gasfree sent microtx - expected error")
+		return errorsmod.Wrap(err, "send gasfree sent microtx - expected error")
 	}
 	// Expect failure for the Send tx
 	cached, _ = gasfreeSendCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgSendTx, false); err != nil {
-		return sdkerrors.Wrap(err, "send gasfree expected no error")
+		return errorsmod.Wrap(err, "send gasfree expected no error")
 	}
 	// Expect failure for both msg tx
 	cached, _ = gasfreeSendCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, bothTx, false); !strings.Contains(err.Error(), expErrorStr) {
-		return sdkerrors.Wrap(err, "send gasfree sent send and microtx - expected error")
+		return errorsmod.Wrap(err, "send gasfree sent send and microtx - expected error")
 	}
 
 	// --- No Gasfree Msg types ---
 	// Expect failure for the Microtx tx
 	cached, _ = noGasfreeCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgMicrotxTx, false); !strings.Contains(err.Error(), expErrorStr) {
-		return sdkerrors.Wrap(err, "no gasfree msgs sent microtx - expected error")
+		return errorsmod.Wrap(err, "no gasfree msgs sent microtx - expected error")
 	}
 	// Expect failure for the Send tx
 	cached, _ = noGasfreeCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgSendTx, false); !strings.Contains(err.Error(), expErrorStr) {
-		return sdkerrors.Wrap(err, "no gasfree msgs sent send - expected error")
+		return errorsmod.Wrap(err, "no gasfree msgs sent send - expected error")
 	}
 	// Expect failure for both msg tx
 	cached, _ = noGasfreeCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, bothTx, false); !strings.Contains(err.Error(), expErrorStr) {
-		return sdkerrors.Wrap(err, "no gasfree msgs sent send and microtx - expected error")
+		return errorsmod.Wrap(err, "no gasfree msgs sent send and microtx - expected error")
 	}
 
 	// --- Send and Microtx are gasfree Msg types ---
 	// Expect success on all txs
 	cached, _ = bothGasfreeCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgMicrotxTx, false); err != nil {
-		return sdkerrors.Wrap(err, "send + microtx gasfree expected no error")
+		return errorsmod.Wrap(err, "send + microtx gasfree expected no error")
 	}
 	cached, _ = bothGasfreeCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, msgSendTx, false); err != nil {
-		return sdkerrors.Wrap(err, "send + microtx gasfree expected no error")
+		return errorsmod.Wrap(err, "send + microtx gasfree expected no error")
 	}
 	cached, _ = bothGasfreeCtx.CacheContext()
 	if _, err := suite.anteHandler(cached, bothTx, false); err != nil {
-		return sdkerrors.Wrap(err, "send + microtx gasfree expected no error")
+		return errorsmod.Wrap(err, "send + microtx gasfree expected no error")
 	}
 	return nil
 
@@ -126,7 +127,8 @@ func (suite *AnteTestSuite) TestCosmosAnteHandlerMinGasPricesBypass() {
 	suite.ctx = suite.ctx.WithIsCheckTx(false) // use checkTx false to avoid triggering mempool fee decorator
 	feemarketParams := suite.app.FeemarketKeeper.GetParams(suite.ctx)
 	feemarketParams.MinGasPrice = sdk.NewDec(100)
-	suite.app.FeemarketKeeper.SetParams(suite.ctx, feemarketParams) // Set the min gas price to trigger failure in the MinGasPricesDecorator
+	err := suite.app.FeemarketKeeper.SetParams(suite.ctx, feemarketParams) // Set the min gas price to trigger failure in the MinGasPricesDecorator
+	suite.Require().NoError(err)
 	privKey := suite.NewCosmosPrivkey()
 	addr := sdk.AccAddress(privKey.PubKey().Address().Bytes())
 	suite.FundAccount(suite.ctx, addr, big.NewInt(10000000000))
@@ -158,7 +160,8 @@ func (suite *AnteTestSuite) TestCosmosAnteHandlerDeductFeeBypass() {
 	suite.ctx = suite.ctx.WithIsCheckTx(false) // use checkTx false to avoid triggering mempool fee decorator
 	feemarketParams := suite.app.FeemarketKeeper.GetParams(suite.ctx)
 	feemarketParams.MinGasPrice = sdk.NewDec(0)
-	suite.app.FeemarketKeeper.SetParams(suite.ctx, feemarketParams) // Set the min gas price to avoid failure from MinGasPricesDecorator
+	err := suite.app.FeemarketKeeper.SetParams(suite.ctx, feemarketParams) // Set the min gas price to avoid failure from MinGasPricesDecorator
+	suite.Require().NoError(err)
 	privKey := suite.NewCosmosPrivkey()
 	addr := sdk.AccAddress(privKey.PubKey().Address().Bytes())
 	suite.FundAccount(suite.ctx, addr, big.NewInt(1))

app/ante/eth_account_verification.go

@@ -3,6 +3,8 @@ package ante
 import (
 	"github.com/ethereum/go-ethereum/common"
 
+	errorsmod "cosmossdk.io/errors"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
@@ -47,18 +49,18 @@ func (avd EthAccountVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx
 	for i, msg := range tx.GetMsgs() {
 		msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
 		if !ok {
-			return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid message type %T, expected %T", msg, (*evmtypes.MsgEthereumTx)(nil))
+			return ctx, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "invalid message type %T, expected %T", msg, (*evmtypes.MsgEthereumTx)(nil))
 		}
 
 		txData, err := evmtypes.UnpackTxData(msgEthTx.Data)
 		if err != nil {
-			return ctx, sdkerrors.Wrapf(err, "failed to unpack tx data any for tx %d", i)
+			return ctx, errorsmod.Wrapf(err, "failed to unpack tx data any for tx %d", i)
 		}
 
 		// sender address should be in the tx cache from the previous AnteHandle call
 		from := msgEthTx.GetFrom()
 		if from.Empty() {
-			return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "from address cannot be empty")
+			return ctx, errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "from address cannot be empty")
 		}
 
 		// check whether the sender address is EOA
@@ -69,17 +71,17 @@ func (avd EthAccountVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx
 			acc := ethtypes.ProtoAccount()
 			err := acc.SetAddress(from)
 			if err != nil {
-				return ctx, sdkerrors.Wrap(err, "failed to set address")
+				return ctx, errorsmod.Wrap(err, "failed to set address")
 			}
 			avd.ak.NewAccount(ctx, acc)
 			acct = statedb.NewEmptyAccount()
 		} else if acct.IsContract() {
-			return ctx, sdkerrors.Wrapf(sdkerrors.ErrInvalidType,
+			return ctx, errorsmod.Wrapf(sdkerrors.ErrInvalidType,
 				"the sender is not EOA: address %s, codeHash <%s>", fromAddr, acct.CodeHash)
 		}
 
 		if err := evmkeeper.CheckSenderBalance(sdk.NewIntFromBigInt(acct.Balance), txData); err != nil {
-			return ctx, sdkerrors.Wrap(err, "failed to check sender balance")
+			return ctx, errorsmod.Wrap(err, "failed to check sender balance")
 		}
 
 	}

app/ante/eth_set_pubkey.go

@@ -5,6 +5,8 @@ import (
 	"errors"
 	"math/big"
 
+	errorsmod "cosmossdk.io/errors"
+
 	"github.com/ethereum/go-ethereum/common"
 	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -51,24 +53,24 @@ func (espd EthSetPubkeyDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulat
 	for _, msg := range tx.GetMsgs() {
 		msgEthTx, ok := msg.(*evmtypes.MsgEthereumTx)
 		if !ok {
-			return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "invalid message type %T, expected %T", msg, (*evmtypes.MsgEthereumTx)(nil))
+			return ctx, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "invalid message type %T, expected %T", msg, (*evmtypes.MsgEthereumTx)(nil))
 		}
 
 		// sender address should be in the tx cache from the previous AnteHandle call
 		from := msgEthTx.GetFrom()
 		if from == nil || from.Empty() {
-			return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "from address cannot be empty")
+			return ctx, errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "from address cannot be empty")
 		}
 
 		fromAddr := common.BytesToAddress(from)
 		acct := espd.evmKeeper.GetAccount(ctx, fromAddr)
 		if acct.IsContract() {
-			return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "tx submitted by a contract account: %s", fromAddr.Hex())
+			return ctx, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "tx submitted by a contract account: %s", fromAddr.Hex())
 		}
 
 		fromCosmosAcc := espd.ak.GetAccount(ctx, from)
 		if fromCosmosAcc == nil {
-			return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", from)
+			return ctx, errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", from)
 		}
 
 		if fromCosmosAcc.GetPubKey() != nil {
@@ -81,7 +83,7 @@ func (espd EthSetPubkeyDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulat
 
 		pubkey, err := recoverPubKey(ethCfg, blockNum, ethTx)
 		if err != nil {
-			return ctx, sdkerrors.Wrapf(
+			return ctx, errorsmod.Wrapf(
 				sdkerrors.ErrorInvalidSigner,
 				"couldn't retrieve sender pubkey from the ethereum transaction: %s",
 				err.Error(),
@@ -90,7 +92,7 @@ func (espd EthSetPubkeyDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulat
 
 		// Set the pubkey on the account
 		if err := fromCosmosAcc.SetPubKey(pubkey); err != nil {
-			return ctx, sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "failed to set pubkey on account: %s", err.Error())
+			return ctx, errorsmod.Wrapf(sdkerrors.ErrInvalidPubKey, "failed to set pubkey on account: %s", err.Error())
 		}
 		espd.ak.SetAccount(ctx, fromCosmosAcc)
 	}

app/ante/handler_options.go

@@ -149,6 +149,8 @@ func newCosmosAnteHandlerEip712(options HandlerOptions) sdk.AnteHandler {
 		ante.NewValidateSigCountDecorator(options.AccountKeeper),
 		ante.NewSigGasConsumeDecorator(options.AccountKeeper, options.SigGasConsumer),
 		// Note: signature verification uses EIP instead of the cosmos signature validator
+		// Ethermint has deprecated this initial EIP-712 verifier, but we still want to use it for the time being, so we disable the linter for now
+		// nolint: staticcheck
 		ethante.NewLegacyEip712SigVerificationDecorator(options.AccountKeeper, options.SignModeHandler, ""), // Pass no chain id to have it parsed from the Cosmos chain id
 		ante.NewIncrementSequenceDecorator(options.AccountKeeper),
 		ibcante.NewRedundantRelayDecorator(options.IBCKeeper),