feat: global fee module

Makefile

@@ -228,7 +228,7 @@ start-localnet-ci:
 	./build/gaiad keys add val --home ~/.gaiad-liveness
 	./build/gaiad add-genesis-account val 10000000000000000000000000stake --home ~/.gaiad-liveness --keyring-backend test
 	./build/gaiad gentx val 1000000000stake --home ~/.gaiad-liveness --chain-id liveness
-	./build/gaiad collect-gentxs --home ~/.gaiad-liveness 
+	./build/gaiad collect-gentxs --home ~/.gaiad-liveness
 	sed -i'' 's/minimum-gas-prices = ""/minimum-gas-prices = "0uatom"/' ~/.gaiad-liveness/config/app.toml
 	./build/gaiad start --home ~/.gaiad-liveness --x-crisis-skip-assert-invariants
 

ante/ante.go

@@ -4,6 +4,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/x/auth/ante"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	ibcante "github.com/cosmos/ibc-go/v5/modules/core/ante"
 	ibckeeper "github.com/cosmos/ibc-go/v5/modules/core/keeper"
 )
@@ -14,6 +15,7 @@ type HandlerOptions struct {
 	ante.HandlerOptions
 	IBCkeeper            *ibckeeper.Keeper
 	BypassMinFeeMsgTypes []string
+	GlobalFeeSubspace    paramtypes.Subspace
 }
 
 func NewAnteHandler(opts HandlerOptions) (sdk.AnteHandler, error) {
@@ -26,10 +28,12 @@ func NewAnteHandler(opts HandlerOptions) (sdk.AnteHandler, error) {
 	if opts.SignModeHandler == nil {
 		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder")
 	}
-
 	if opts.IBCkeeper == nil {
 		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "IBC keeper is required for middlewares")
 	}
+	if opts.GlobalFeeSubspace.Name() == "" {
+		return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "param store is required for ante builder")
+	}
 
 	sigGasConsumer := opts.SigGasConsumer
 	if sigGasConsumer == nil {
@@ -43,15 +47,15 @@ func NewAnteHandler(opts HandlerOptions) (sdk.AnteHandler, error) {
 		ante.NewTxTimeoutHeightDecorator(),
 		ante.NewValidateMemoDecorator(opts.AccountKeeper),
 		ante.NewConsumeGasForTxSizeDecorator(opts.AccountKeeper),
-		NewBypassMinFeeDecorator(opts.BypassMinFeeMsgTypes),
+		NewBypassMinFeeDecorator(opts.BypassMinFeeMsgTypes, opts.GlobalFeeSubspace),
 		// if opts.TxFeeCheck is nil,  it is the default fee check
 		ante.NewDeductFeeDecorator(opts.AccountKeeper, opts.BankKeeper, opts.FeegrantKeeper, opts.TxFeeChecker),
-		// SetPubKeyDecorator must be called before all signature verification decorators
-		ante.NewSetPubKeyDecorator(opts.AccountKeeper),
+		ante.NewSetPubKeyDecorator(opts.AccountKeeper), // SetPubKeyDecorator must be called before all signature verification decorators
 		ante.NewValidateSigCountDecorator(opts.AccountKeeper),
 		ante.NewSigGasConsumeDecorator(opts.AccountKeeper, sigGasConsumer),
 		ante.NewSigVerificationDecorator(opts.AccountKeeper, opts.SignModeHandler),
 		ante.NewIncrementSequenceDecorator(opts.AccountKeeper),
+		// todo check
 		ibcante.NewRedundantRelayDecorator(opts.IBCkeeper),
 	}
 

ante/ante_test.go

@@ -7,17 +7,19 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/tx"
 	cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
-	"github.com/cosmos/cosmos-sdk/simapp"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/tx/signing"
 	xauthsigning "github.com/cosmos/cosmos-sdk/x/auth/signing"
+	"github.com/cosmos/cosmos-sdk/x/params/types"
 	"github.com/stretchr/testify/suite"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 
 	gaiaapp "github.com/cosmos/gaia/v8/app"
 	gaiahelpers "github.com/cosmos/gaia/v8/app/helpers"
+	"github.com/cosmos/gaia/v8/x/globalfee"
+	globfeetypes "github.com/cosmos/gaia/v8/x/globalfee/types"
 )
 
 type IntegrationTestSuite struct {
@@ -41,7 +43,7 @@ func (s *IntegrationTestSuite) SetupTest() {
 		Height:  1,
 	})
 
-	encodingConfig := simapp.MakeTestEncodingConfig()
+	encodingConfig := gaiaapp.MakeTestEncodingConfig()
 	encodingConfig.Amino.RegisterConcrete(&testdata.TestMsg{}, "testdata.TestMsg", nil)
 	testdata.RegisterInterfaces(encodingConfig.InterfaceRegistry)
 
@@ -50,7 +52,15 @@ func (s *IntegrationTestSuite) SetupTest() {
 	s.clientCtx = client.Context{}.WithTxConfig(encodingConfig.TxConfig)
 }
 
-func (s *IntegrationTestSuite) CreateTestTx(privs []cryptotypes.PrivKey, accNums, accSeqs []uint64, chainID string) (xauthsigning.Tx, error) {
+func (s *IntegrationTestSuite) setupTestGlobalFeeStoreAndMinGasPrice(minGasPrice []sdk.DecCoin, globalFeeParams *globfeetypes.Params) types.Subspace {
+	subspace := s.app.GetSubspace(globalfee.ModuleName)
+	subspace.SetParamSet(s.ctx, globalFeeParams)
+	s.ctx = s.ctx.WithMinGasPrices(minGasPrice).WithIsCheckTx(true)
+
+	return subspace
+}
+
+func (s *IntegrationTestSuite) CreateTestTx(privs []cryptotypes.PrivKey, accNums []uint64, accSeqs []uint64, chainID string) (xauthsigning.Tx, error) {
 	var sigsV2 []signing.SignatureV2
 	for i, priv := range privs {
 		sigV2 := signing.SignatureV2{

ante/fee.go

@@ -1,95 +1,99 @@
 package ante
 
 import (
-	"math"
-
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
-	tmstrings "github.com/tendermint/tendermint/libs/strings"
+	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+
+	"github.com/cosmos/gaia/v8/x/globalfee"
 )
 
 const maxBypassMinFeeMsgGasUsage = uint64(200_000)
 
 // FeeWithBypassDecorator will check if the transaction's fee is at least as large
-// as the local validator's minimum gasFee (defined in validator config).
+// as the local validator's minimum gasFee (defined in validator config) and global fee, and the fee denom should be in the global fees' denoms.
 //
 // If fee is too low, decorator returns error and tx is rejected from mempool.
 // Note this only applies when ctx.CheckTx = true. If fee is high enough or not
 // CheckTx, then call next AnteHandler.
 //
-// CONTRACT: Tx must implement FeeTx to use FeeWithBypassDecorator
+// CONTRACT: Tx must implement FeeTx to use BypassMinFeeDecorator
+// If the tx msg type is one of the bypass msg types, the tx is valid even if the min fee is lower than normally required.
+// If the bypass tx still carries fees, the fee denom should be the same as global fee required.
+
+var _ sdk.AnteDecorator = BypassMinFeeDecorator{}
+
 type BypassMinFeeDecorator struct {
 	BypassMinFeeMsgTypes []string
+	GlobalMinFee         globalfee.ParamSource
 }
 
-func NewBypassMinFeeDecorator(bypassMsgTypes []string) BypassMinFeeDecorator {
+const defaultZeroGlobalFeeDenom = "uatom"
+
+func DefaultZeroGlobalFee() []sdk.DecCoin {
+	return []sdk.DecCoin{sdk.NewDecCoinFromDec(defaultZeroGlobalFeeDenom, sdk.NewDec(0))}
+}
+
+func NewBypassMinFeeDecorator(bypassMsgTypes []string, paramSpace paramtypes.Subspace) BypassMinFeeDecorator {
+	if !paramSpace.HasKeyTable() {
+		panic("global fee paramspace was not set up via module")
+	}
+
 	return BypassMinFeeDecorator{
 		BypassMinFeeMsgTypes: bypassMsgTypes,
+		GlobalMinFee:         paramSpace,
 	}
 }
 
 func (mfd BypassMinFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
+	// please note: after parsing feeflag, the zero fees are removed already
 	feeTx, ok := tx.(sdk.FeeTx)
 	if !ok {
 		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx")
 	}
-
-	feeCoins := feeTx.GetFee()
+	feeCoins := feeTx.GetFee().Sort()
 	gas := feeTx.GetGas()
 	msgs := feeTx.GetMsgs()
 
-	// Only check for minimum fees if the execution mode is CheckTx and the tx does
+	// Only check for minimum fees and global fee if the execution mode is CheckTx and the tx does
 	// not contain operator configured bypass messages. If the tx does contain
 	// operator configured bypass messages only, it's total gas must be less than
-	// or equal to a constant, otherwise minimum fees are checked to prevent spam.
-	if ctx.IsCheckTx() && !simulate && !(mfd.bypassMinFeeMsgs(msgs) && gas <= uint64(len(msgs))*maxBypassMinFeeMsgGasUsage) {
-		minGasPrices := ctx.MinGasPrices()
-		if !minGasPrices.IsZero() {
-			requiredFees := make(sdk.Coins, len(minGasPrices))
-
-			// Determine the required fees by multiplying each required minimum gas
-			// price by the gas limit, where fee = ceil(minGasPrice * gasLimit).
-			glDec := sdk.NewDec(int64(gas))
-			for i, gp := range minGasPrices {
-				fee := gp.Amount.Mul(glDec)
-				requiredFees[i] = sdk.NewCoin(gp.Denom, fee.Ceil().RoundInt())
-			}
-
-			if !feeCoins.IsAnyGTE(requiredFees) {
-				return ctx, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "insufficient fees; got: %s required: %s", feeCoins, requiredFees)
-			}
-		}
-	}
+	// or equal to a constant, otherwise minimum fees and global fees are checked to prevent spam.
+	containsOnlyBypassMinFeeMsgs := mfd.bypassMinFeeMsgs(msgs)
+	doesNotExceedMaxGasUsage := gas <= uint64(len(msgs))*maxBypassMinFeeMsgGasUsage
+	allowedToBypassMinFee := containsOnlyBypassMinFeeMsgs && doesNotExceedMaxGasUsage
 
-	return next(ctx, tx, simulate)
-}
+	var allFees sdk.Coins
+	requiredFees := getMinGasPrice(ctx, feeTx)
 
-func (mfd BypassMinFeeDecorator) bypassMinFeeMsgs(msgs []sdk.Msg) bool {
-	for _, msg := range msgs {
-		if tmstrings.StringInSlice(sdk.MsgTypeURL(msg), mfd.BypassMinFeeMsgTypes) {
-			continue
-		}
+	if ctx.IsCheckTx() && !simulate && !allowedToBypassMinFee {
 
-		return false
-	}
+		requiredGlobalFees := mfd.getGlobalFee(ctx, feeTx)
+		allFees = CombinedFeeRequirement(requiredGlobalFees, requiredFees)
 
-	return true
-}
+		// this is to ban 1stake passing if the globalfee is 1photon or 0photon
+		// if feeCoins=[] and requiredGlobalFees has 0denom coins then it should pass.
+		if !DenomsSubsetOfIncludingZero(feeCoins, allFees) {
+			return ctx, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "fees %s is not a subset of required fees %s", feeCoins, allFees)
+		}
+		// At least one feeCoin amount must be GTE to one of the requiredGlobalFees
+		if !IsAnyGTEIncludingZero(feeCoins, allFees) {
+			return ctx, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "insufficient fees for global fee; got: %s required: %s", feeCoins, allFees)
+		}
+	}
 
-// utils function: GetTxPriority
-// getTxPriority returns a naive tx priority based on the amount of the smallest denomination of the fee
-// provided in a transaction.
-func GetTxPriority(fee sdk.Coins) int64 {
-	var priority int64
-	for _, c := range fee {
-		p := int64(math.MaxInt64)
-		if c.Amount.IsInt64() {
-			p = c.Amount.Int64()
+	// when the tx is bypass msg type, still need to check the denom is not some unknown denom
+	if ctx.IsCheckTx() && !simulate && allowedToBypassMinFee {
+		requiredGlobalFees := mfd.getGlobalFee(ctx, feeTx)
+		// bypass tx without pay fee
+		if len(feeCoins) == 0 {
+			return next(ctx, tx, simulate)
 		}
-		if priority == 0 || p < priority {
-			priority = p
+		// bypass with fee, fee denom must in requiredGlobalFees
+		if !DenomsSubsetOfIncludingZero(feeCoins, requiredGlobalFees) {
+			return ctx, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "fees denom is wrong; got: %s required: %s", feeCoins, requiredGlobalFees)
 		}
 	}
 
-	return priority
+	return next(ctx, tx, simulate)
 }