feat: migration to Cosmos SDK v0.46

.github/workflows/tests.yml

@@ -124,13 +124,16 @@ jobs:
       - name: Install Starport
         if: env.GIT_DIFF
         run: |
-          curl https://get.ignite.com/cli! | bash
+          cd ../
+          git clone https://github.com/umee-network/cli --depth=1
+          cd cli && make install
+          cd ../umee
       - name: Start Local Network via Starport
         if: env.GIT_DIFF
         run: |
-          /usr/local/bin/ignite chain serve --reset-once -v -c ./starport.ci.yml  &
+          ~/go/bin/ignite chain serve --reset-once -v -c ./starport.ci.yml  &
       - name: Test Local Network Liveness
         if: env.GIT_DIFF
         run: |
           sleep 1m
-          ./contrib/scripts/test_localnet_liveness.sh 40 5 50 localhost
+          ./contrib/scripts/test_localnet_liveness.sh 50 5 50 localhost

CHANGELOG.md

@@ -80,6 +80,9 @@ Ref: https://keepachangelog.com/en/1.0.0/
 - [1188](https://github.com/umee-network/umee/pull/1188) Add `liquidity`, `maximum_borrow`, `maximum_collateral`, `minimum_liquidity`, `available_withdraw`, `available_collateralize`, and `utoken_supply` fields to market summary.
 - [1203](https://github.com/umee-network/umee/pull/1203) Add Swagger docs.
 - [1212](https://github.com/umee-network/umee/pull/1212) Add `util/checkers` utility package providing common check / validation functions.
+- [1217](https://github.com/umee-network/umee/pull/1217) Integrated Cosmos SDK v0.46
+  - Adding Cosmos SDK x/group module.
+  - Increased Gov `MaxMetadataLen` from 255 to 800 characters.
 - [1220](https://github.com/umee-network/umee/pull/1220) Submit oracle prevotes / vote txs via the CLI.
 - [1222](https://github.com/umee-network/umee/pull/1222) Liquidation reward_denom can now be either token or uToken.
 - [1238](https://github.com/umee-network/umee/pull/1238) Added bad debts query.

ante/ante.go

@@ -22,40 +22,31 @@ type HandlerOptions struct {
 // signer.
 func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
 	if options.AccountKeeper == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "account keeper is required for ante builder")
+		return nil, sdkerrors.ErrLogic.Wrap("account keeper is required for ante builder")
 	}
-
 	if options.BankKeeper == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for ante builder")
+		return nil, sdkerrors.ErrLogic.Wrap("bank keeper is required for ante builder")
 	}
-
 	if options.OracleKeeper == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "oracle keeper is required for ante builder")
+		return nil, sdkerrors.ErrLogic.Wrap("oracle keeper is required for ante builder")
 	}
-
 	if options.SignModeHandler == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder")
-	}
-
-	sigGasConsumer := options.SigGasConsumer
-	if sigGasConsumer == nil {
-		sigGasConsumer = cosmosante.DefaultSigVerificationGasConsumer
+		return nil, sdkerrors.ErrLogic.Wrap("sign mode handler is required for ante builder")
 	}
 
 	return sdk.ChainAnteDecorators(
-		cosmosante.NewSetUpContextDecorator(), // outermost AnteDecorator. SetUpContext must be called first
-		cosmosante.NewRejectExtensionOptionsDecorator(),
-		NewMempoolFeeDecorator(),                         // mempool fee validation
+		cosmosante.NewSetUpContextDecorator(),            // outermost AnteDecorator. SetUpContext must be called first
+		cosmosante.NewExtensionOptionsDecorator(nil),     // nil=reject extensions
 		NewSpamPreventionDecorator(options.OracleKeeper), // spam prevention
 		cosmosante.NewValidateBasicDecorator(),
 		cosmosante.NewTxTimeoutHeightDecorator(),
 		cosmosante.NewValidateMemoDecorator(options.AccountKeeper),
 		cosmosante.NewConsumeGasForTxSizeDecorator(options.AccountKeeper),
-		cosmosante.NewDeductFeeDecorator(options.AccountKeeper, options.BankKeeper, options.FeegrantKeeper),
+		cosmosante.NewDeductFeeDecorator(options.AccountKeeper, options.BankKeeper, options.FeegrantKeeper, FeeAndPriority),
 		// SetPubKeyDecorator must be called before all signature verification decorators
 		cosmosante.NewSetPubKeyDecorator(options.AccountKeeper),
 		cosmosante.NewValidateSigCountDecorator(options.AccountKeeper),
-		cosmosante.NewSigGasConsumeDecorator(options.AccountKeeper, sigGasConsumer),
+		cosmosante.NewSigGasConsumeDecorator(options.AccountKeeper, options.SigGasConsumer),
 		cosmosante.NewSigVerificationDecorator(options.AccountKeeper, options.SignModeHandler),
 		cosmosante.NewIncrementSequenceDecorator(options.AccountKeeper),
 	), nil

ante/fee.go

@@ -1,48 +1,36 @@
 package ante
 
 import (
+	"math"
+
+	gbtypes "github.com/Gravity-Bridge/Gravity-Bridge/module/x/gravity/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	oracletypes "github.com/umee-network/umee/v2/x/oracle/types"
 )
 
-// MaxOracleMsgGasUsage defines the maximum gas allowed for an oracle transaction.
-const MaxOracleMsgGasUsage = uint64(100000)
-
-// MempoolFeeDecorator defines a custom Umee AnteHandler decorator that is
-// responsible for allowing oracle transactions from oracle feeders to bypass
-// the minimum fee CheckTx check. However, if an oracle transaction's gas limit
-// is beyond the accepted threshold, the minimum fee check is still applied.
-//
-// For non-oracle transactions, the minimum fee check is applied.
-type MempoolFeeDecorator struct{}
-
-func NewMempoolFeeDecorator() MempoolFeeDecorator {
-	return MempoolFeeDecorator{}
-}
+// MaxMsgGasUsage defines the maximum gas allowed for an oracle transaction.
+const MaxMsgGasUsage = uint64(100000)
 
-func (mfd MempoolFeeDecorator) AnteHandle(
-	ctx sdk.Context,
-	tx sdk.Tx,
-	simulate bool,
-	next sdk.AnteHandler,
-) (newCtx sdk.Context, err error) {
+// FeeAndPriority ensures tx has enough fee coins to pay for the gas at the CheckTx time
+// to early remove transactions from the mempool without enough attached fee.
+// The validator min fee check is ignored if the tx contains only oracle messages and
+// tx gas limit is <= MaxOracleMsgGasUsage. Essentially, validators can provide price
+// transactison for free as long as the gas per message is in the MaxOracleMsgGasUsage limit.
+func FeeAndPriority(ctx sdk.Context, tx sdk.Tx) (sdk.Coins, int64, error) {
 	feeTx, ok := tx.(sdk.FeeTx)
 	if !ok {
-		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx")
+		return nil, 0, sdkerrors.ErrTxDecode.Wrap("Tx must be a FeeTx")
 	}
 
 	feeCoins := feeTx.GetFee()
 	gas := feeTx.GetGas()
 	msgs := feeTx.GetMsgs()
+	isOracleOrGravity := IsOracleOrGravityTx(msgs)
+	chargeFees := !isOracleOrGravity || gas > uint64(len(msgs))*MaxMsgGasUsage
 
-	// Only check for minimum fees if the execution mode is CheckTx and the tx does
-	// not contain oracle messages. If the tx does contain oracle messages, it's
-	// total gas must be less than or equal to a constant, otherwise minimum fees
-	// are checked.
-	if ctx.IsCheckTx() && !simulate &&
-		!(isOracleTx(msgs) && gas <= uint64(len(msgs))*MaxOracleMsgGasUsage) {
+	if ctx.IsCheckTx() && chargeFees {
 		minGasPrices := ctx.MinGasPrices()
 		if !minGasPrices.IsZero() {
 			requiredFees := make(sdk.Coins, len(minGasPrices))
@@ -56,26 +44,38 @@ func (mfd MempoolFeeDecorator) AnteHandle(
 			}
 
 			if !feeCoins.IsAnyGTE(requiredFees) {
-				return ctx, sdkerrors.Wrapf(
-					sdkerrors.ErrInsufficientFee,
-					"insufficient fees; got: %s required: %s",
-					feeCoins,
-					requiredFees,
-				)
+				return nil, 0, sdkerrors.ErrInsufficientFee.Wrapf(
+					"insufficient fees; got: %s required: %s", feeCoins, requiredFees)
 			}
 		}
 	}
 
-	return next(ctx, tx, simulate)
+	priority := getTxPriority(feeCoins, isOracleOrGravity)
+	if !chargeFees {
+		return sdk.Coins{}, priority, nil
+	}
+	return feeCoins, priority, nil
 }
 
-func isOracleTx(msgs []sdk.Msg) bool {
+// IsOracleOrGravityTx checks if all messages are oracle messages
+func IsOracleOrGravityTx(msgs []sdk.Msg) bool {
 	for _, msg := range msgs {
 		switch msg.(type) {
-		case *oracletypes.MsgAggregateExchangeRatePrevote:
+		case *oracletypes.MsgAggregateExchangeRatePrevote,
+			*oracletypes.MsgAggregateExchangeRateVote:
 			continue
 
-		case *oracletypes.MsgAggregateExchangeRateVote:
+		case *gbtypes.MsgValsetConfirm,
+			*gbtypes.MsgRequestBatch,
+			*gbtypes.MsgConfirmBatch,
+			*gbtypes.MsgERC20DeployedClaim,
+			*gbtypes.MsgConfirmLogicCall,
+			*gbtypes.MsgLogicCallExecutedClaim,
+			*gbtypes.MsgSendToCosmosClaim,
+			*gbtypes.MsgExecuteIbcAutoForwards,
+			*gbtypes.MsgBatchSendToEthClaim,
+			*gbtypes.MsgValsetUpdatedClaim,
+			*gbtypes.MsgSubmitBadSignatureEvidence:
 			continue
 
 		default:
@@ -85,3 +85,26 @@ func isOracleTx(msgs []sdk.Msg) bool {
 
 	return true
 }
+
+// getTxPriority returns naive tx priority based on the lowest fee amount (regardless of the
+// denom) and oracle tx check.
+func getTxPriority(fee sdk.Coins, isOracleOrGravity bool) int64 {
+	var priority int64
+	for _, c := range fee {
+		// TODO: we should better compare amounts
+		// https://github.com/umee-network/umee/issues/510
+		p := int64(math.MaxInt64)
+		if c.Amount.IsInt64() {
+			p = c.Amount.Int64()
+		}
+		if priority == 0 || p < priority {
+			priority = p
+		}
+	}
+	if isOracleOrGravity {
+		// TODO: this is a naive version.
+		// Proper solution will be implemented in https://github.com/umee-network/umee/issues/510
+		priority += 100000
+	}
+	return priority
+}

ante/fee_test.go

@@ -4,61 +4,71 @@ import (
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+
 	"github.com/umee-network/umee/v2/ante"
 	oracletypes "github.com/umee-network/umee/v2/x/oracle/types"
 )
 
-func (suite *IntegrationTestSuite) TestMempoolFee() {
-	suite.SetupTest()
+func (suite *IntegrationTestSuite) TestFeeAndPriority() {
+	require := suite.Require()
 	suite.txBuilder = suite.clientCtx.TxConfig.NewTxBuilder()
-
-	mfd := ante.NewMempoolFeeDecorator()
-	antehandler := sdk.ChainAnteDecorators(mfd)
 	priv1, _, addr1 := testdata.KeyTestPubAddr()
+	privs, accNums, accSeqs := []cryptotypes.PrivKey{priv1}, []uint64{0}, []uint64{0}
 
-	msg := testdata.NewTestMsg(addr1)
-	feeAmount := testdata.NewTestFeeAmount()
-	gasLimit := testdata.NewTestGasLimit()
-	suite.Require().NoError(suite.txBuilder.SetMsgs(msg))
-	suite.txBuilder.SetFeeAmount(feeAmount)
-	suite.txBuilder.SetGasLimit(gasLimit)
+	msgs := testdata.NewTestMsg(addr1)
+	require.NoError(suite.txBuilder.SetMsgs(msgs))
+	fee := sdk.NewCoins(sdk.NewInt64Coin("atom", 150))
+	gasLimit := 200000
+	suite.txBuilder.SetFeeAmount(fee)
+	suite.txBuilder.SetGasLimit(uint64(gasLimit))
 
-	privs, accNums, accSeqs := []cryptotypes.PrivKey{priv1}, []uint64{0}, []uint64{0}
+	// Test1: validator min gas price check
+	// Ante should fail when validator min gas price is above the transaction gas limit
+	minGasPrice := sdk.NewDecCoinFromDec("atom", sdk.NewDecFromInt(fee[0].Amount).QuoInt64(int64(gasLimit/2)))
+	ctx := suite.ctx.
+		WithMinGasPrices([]sdk.DecCoin{minGasPrice}).
+		WithIsCheckTx(true)
 	tx, err := suite.CreateTestTx(privs, accNums, accSeqs, suite.ctx.ChainID())
-	suite.Require().NoError(err)
+	require.NoError(err)
+	_, _, err = ante.FeeAndPriority(ctx, tx)
+	require.ErrorIs(sdkerrors.ErrInsufficientFee, err)
 
-	// Set high gas price so standard test fee fails
-	atomPrice := sdk.NewDecCoinFromDec("atom", sdk.NewDec(200).Quo(sdk.NewDec(100000)))
-	highGasPrice := []sdk.DecCoin{atomPrice}
-	suite.ctx = suite.ctx.WithMinGasPrices(highGasPrice)
+	// Test2: min gas price not checked in DeliverTx
+	ctx = suite.ctx.WithIsCheckTx(false)
+	suite.checkFeeAnte(tx, fee, ctx)
 
-	suite.ctx = suite.ctx.WithIsCheckTx(true)
+	// Test3: should not error when min gas price is same or lower than the fee
+	ctx = ctx.WithMinGasPrices(sdk.NewDecCoinsFromCoins(fee...))
+	suite.checkFeeAnte(tx, fee, ctx)
 
-	// antehandler errors with insufficient fees
-	_, err = antehandler(suite.ctx, tx, false)
-	suite.Require().Error(err, "Decorator should have errored on too low fee for local gasPrice")
+	ctx = ctx.WithMinGasPrices([]sdk.DecCoin{sdk.NewDecCoin(fee[0].Denom, fee[0].Amount.QuoRaw(2))})
+	suite.checkFeeAnte(tx, fee, ctx)
 
-	// ensure no fees for oracle msgs
-	suite.Require().NoError(suite.txBuilder.SetMsgs(
+	// Test4: ensure no fees for oracle msgs
+	require.NoError(suite.txBuilder.SetMsgs(
 		oracletypes.NewMsgAggregateExchangeRatePrevote(oracletypes.AggregateVoteHash{}, addr1, sdk.ValAddress(addr1)),
 		oracletypes.NewMsgAggregateExchangeRateVote("", "", addr1, sdk.ValAddress(addr1)),
 	))
+	suite.txBuilder.SetFeeAmount(sdk.Coins{})
+	suite.txBuilder.SetGasLimit(0)
 	oracleTx, err := suite.CreateTestTx(privs, accNums, accSeqs, suite.ctx.ChainID())
-	_, err = antehandler(suite.ctx, oracleTx, false)
-	suite.Require().NoError(err, "Decorator should not require high price for oracle tx")
+	require.NoError(err)
+	require.True(oracleTx.GetFee().IsZero(), "got: %s", oracleTx.GetFee())
+	require.Equal(uint64(0), oracleTx.GetGas())
+	require.True(ante.IsOracleTx(oracleTx.GetMsgs()))
 
-	suite.ctx = suite.ctx.WithIsCheckTx(false)
-
-	// antehandler should not error since we do not check minGasPrice in DeliverTx
-	_, err = antehandler(suite.ctx, tx, false)
-	suite.Require().NoError(err, "MempoolFeeDecorator returned error in DeliverTx")
-
-	suite.ctx = suite.ctx.WithIsCheckTx(true)
-
-	atomPrice = sdk.NewDecCoinFromDec("atom", sdk.NewDec(0).Quo(sdk.NewDec(100000)))
-	lowGasPrice := []sdk.DecCoin{atomPrice}
-	suite.ctx = suite.ctx.WithMinGasPrices(lowGasPrice)
+	suite.checkFeeAnte(oracleTx, sdk.Coins{}, suite.ctx.WithIsCheckTx(true))
+	suite.checkFeeAnte(oracleTx, sdk.Coins{}, suite.ctx.WithIsCheckTx(false))
+}
 
-	_, err = antehandler(suite.ctx, tx, false)
-	suite.Require().NoError(err, "Decorator should not have errored on fee higher than local gasPrice")
+func (suite *IntegrationTestSuite) checkFeeAnte(tx sdk.Tx, feeExpected sdk.Coins, ctx sdk.Context) {
+	require := suite.Require()
+	fee, _, err := ante.FeeAndPriority(ctx, tx)
+	require.NoError(err)
+	if len(feeExpected) == 0 {
+		require.True(fee.IsZero(), "fee should be zero, got: %s", fee)
+	} else {
+		require.True(fee.IsEqual(feeExpected), "Fee expected %s, got: %s", feeExpected, fee)
+	}
 }

ante/spam_prevention.go

@@ -74,9 +74,14 @@ func (spd *SpamPreventionDecorator) CheckOracleSpam(ctx sdk.Context, msgs []sdk.
 	return nil
 }
 
-func (spd *SpamPreventionDecorator) validate(ctx sdk.Context, feeder, validator string,
-	cache map[string]int64, curHeight int64, txType string) error {
-
+func (spd *SpamPreventionDecorator) validate(
+	ctx sdk.Context,
+	feeder,
+	validator string,
+	cache map[string]int64,
+	curHeight int64,
+	txType string,
+) error {
 	feederAddr, err := sdk.AccAddressFromBech32(feeder)
 	if err != nil {
 		return err

ante/spam_prevention_test.go

@@ -11,7 +11,6 @@ import (
 )
 
 func (suite *IntegrationTestSuite) TestOracleSpam() {
-	suite.SetupTest()
 	suite.txBuilder = suite.clientCtx.TxConfig.NewTxBuilder()
 
 	priv1, _, addr1 := testdata.KeyTestPubAddr()