XATP module

ante/ante.go

@@ -17,6 +17,8 @@ import (
 	evmante "github.com/evmos/ethermint/app/ante"
 	evmtypes "github.com/evmos/ethermint/x/evm/types"
 	tmlog "github.com/tendermint/tendermint/libs/log"
+
+	xatpkeeper "github.com/xpladev/xpla/x/xatp/keeper"
 )
 
 // HandlerOptions extend the SDK's AnteHandler opts by requiring the IBC
@@ -35,6 +37,8 @@ type HandlerOptions struct {
 	BypassMinFeeMsgTypes []string
 	TxCounterStoreKey    sdk.StoreKey
 	WasmConfig           wasmTypes.WasmConfig
+	XATPKeeper           xatpkeeper.Keeper
+	MinGasPrices         string
 }
 
 // NewAnteHandler returns an 'AnteHandler' that will run actions before a tx is sent to a module's handler.
@@ -99,13 +103,15 @@ func newCosmosAnteHandler(opts HandlerOptions) sdk.AnteHandler {
 		wasmkeeper.NewLimitSimulationGasDecorator(opts.WasmConfig.SimulationGasLimit),
 		wasmkeeper.NewCountTXDecorator(opts.TxCounterStoreKey),
 		authante.NewRejectExtensionOptionsDecorator(),
-		NewMinGasPriceDecorator(opts.FeeMarketKeeper, opts.EvmKeeper, opts.BypassMinFeeMsgTypes),
+		NewMempoolFeeDecorator(opts.BypassMinFeeMsgTypes, opts.AccountKeeper, opts.XATPKeeper, opts.FeeMarketKeeper, opts.EvmKeeper),
 		authante.NewValidateBasicDecorator(),
 		authante.NewTxTimeoutHeightDecorator(),
 		authante.NewValidateMemoDecorator(opts.AccountKeeper),
 		authante.NewConsumeGasForTxSizeDecorator(opts.AccountKeeper),
-		authante.NewDeductFeeDecorator(opts.AccountKeeper, opts.BankKeeper, opts.FeegrantKeeper),
 		authante.NewSetPubKeyDecorator(opts.AccountKeeper), // SetPubKeyDecorator must be called before all signature verification decorators
+		NewDeductFeeDecorator(opts.AccountKeeper, opts.BankKeeper, opts.FeegrantKeeper, opts.XATPKeeper),
+		// SetPubKeyDecorator must be called before all signature verification decorators
+		authante.NewSetPubKeyDecorator(opts.AccountKeeper),
 		authante.NewValidateSigCountDecorator(opts.AccountKeeper),
 		authante.NewSigGasConsumeDecorator(opts.AccountKeeper, sigGasConsumer),
 		authante.NewSigVerificationDecorator(opts.AccountKeeper, opts.SignModeHandler),
@@ -117,8 +123,8 @@ func newCosmosAnteHandler(opts HandlerOptions) sdk.AnteHandler {
 
 func newEthAnteHandler(opts HandlerOptions) sdk.AnteHandler {
 	return sdk.ChainAnteDecorators(
-		evmante.NewEthSetUpContextDecorator(opts.EvmKeeper),                                      // outermost AnteDecorator. SetUpContext must be called first
-		NewMinGasPriceDecorator(opts.FeeMarketKeeper, opts.EvmKeeper, opts.BypassMinFeeMsgTypes), // Check eth effective gas price against the global MinGasPrice
+		evmante.NewEthSetUpContextDecorator(opts.EvmKeeper),                                                                          // outermost AnteDecorator. SetUpContext must be called first
+		NewMempoolFeeDecorator(opts.BypassMinFeeMsgTypes, opts.AccountKeeper, opts.XATPKeeper, opts.FeeMarketKeeper, opts.EvmKeeper), // Check eth effective gas price against the global MinGasPrice
 		evmante.NewEthValidateBasicDecorator(opts.EvmKeeper),
 		evmante.NewEthSigVerificationDecorator(opts.EvmKeeper),
 		evmante.NewEthAccountVerificationDecorator(opts.AccountKeeper, opts.EvmKeeper),

ante/fee.go

@@ -5,9 +5,14 @@ import (
 
 	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/cosmos/cosmos-sdk/x/auth/types"
 	tmstrings "github.com/tendermint/tendermint/libs/strings"
 
 	ethermintante "github.com/evmos/ethermint/app/ante"
+	xplatypes "github.com/xpladev/xpla/types"
+
+	xatpkeeper "github.com/xpladev/xpla/x/xatp/keeper"
 )
 
 const maxBypassMinFeeMsgGasUsage = uint64(200_000)
@@ -17,65 +22,100 @@ const maxBypassMinFeeMsgGasUsage = uint64(200_000)
 // is rejected. This applies for both CheckTx and DeliverTx
 // If fee is high enough, then call next AnteHandler
 // CONTRACT: Tx must implement FeeTx to use MinGasPriceDecorator
-type MinGasPriceDecorator struct {
+type MempoolFeeDecorator struct {
 	BypassMinFeeMsgTypes []string
 
-	feesKeeper ethermintante.FeeMarketKeeper
-	evmKeeper  ethermintante.EVMKeeper
+	accountKeeper authante.AccountKeeper
+	xatpKeeper    xatpkeeper.Keeper
+	feesKeeper    ethermintante.FeeMarketKeeper
+	evmKeeper     ethermintante.EVMKeeper
 }
 
-func NewMinGasPriceDecorator(fk ethermintante.FeeMarketKeeper, ek ethermintante.EVMKeeper, bypassMsgTypes []string) MinGasPriceDecorator {
-	return MinGasPriceDecorator{feesKeeper: fk, evmKeeper: ek, BypassMinFeeMsgTypes: bypassMsgTypes}
+func NewMempoolFeeDecorator(bypassMsgTypes []string, ak authante.AccountKeeper, ck xatpkeeper.Keeper, fk ethermintante.FeeMarketKeeper, ek ethermintante.EVMKeeper) MempoolFeeDecorator {
+	return MempoolFeeDecorator{
+		BypassMinFeeMsgTypes: bypassMsgTypes,
+		accountKeeper:        ak,
+		xatpKeeper:           ck,
+		feesKeeper:           fk,
+		evmKeeper:            ek,
+	}
 }
 
-func (mpd MinGasPriceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
+func (mfd MempoolFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
 	feeTx, ok := tx.(sdk.FeeTx)
 	if !ok {
 		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx")
 	}
 
-	minGasPrice := mpd.feesKeeper.GetParams(ctx).MinGasPrice
+	minGasPrice := mfd.feesKeeper.GetParams(ctx).MinGasPrice
 	gas := feeTx.GetGas()
 	msgs := feeTx.GetMsgs()
+	feeCoins := feeTx.GetFee()
 
-	// Short-circuit if min gas price is 0 or if simulating
-	if minGasPrice.IsZero() || simulate || (mpd.bypassMinFeeMsgs(msgs) && gas <= uint64(len(msgs))*maxBypassMinFeeMsgGasUsage) {
-		return next(ctx, tx, simulate)
-	}
-
-	evmDenom := mpd.evmKeeper.GetParams(ctx).EvmDenom
+	evmDenom := mfd.evmKeeper.GetParams(ctx).EvmDenom
 	minGasPrices := sdk.DecCoins{
 		{
 			Denom:  evmDenom,
 			Amount: minGasPrice,
 		},
 	}
-
-	feeCoins := feeTx.GetFee()
-
-	requiredFees := make(sdk.Coins, 0)
-
-	// Determine the required fees by multiplying each required minimum gas
-	// price by the gas limit, where fee = ceil(minGasPrice * gasLimit).
-	gasLimit := sdk.NewDecFromBigInt(new(big.Int).SetUint64(gas))
-
-	for _, gp := range minGasPrices {
-		fee := gp.Amount.Mul(gasLimit).Ceil().RoundInt()
-		if fee.IsPositive() {
-			requiredFees = requiredFees.Add(sdk.Coin{Denom: gp.Denom, Amount: fee})
+	// Only check for minimum fees 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() && !(mfd.bypassMinFeeMsgs(msgs) && gas <= uint64(len(msgs))*maxBypassMinFeeMsgGasUsage) {
+		mempoolCheckGas := ctx.GasMeter().GasConsumed()
+
+		if !minGasPrices.IsZero() {
+			var defaultGasPrice sdk.DecCoin
+			for _, minGasPrice := range minGasPrices {
+				if minGasPrice.Denom == xplatypes.DefaultDenom {
+					defaultGasPrice = minGasPrice
+					taxRate := mfd.xatpKeeper.GetTaxRate(ctx)
+					defaultGasPrice.Amount = defaultGasPrice.Amount.Mul(sdk.OneDec().Add(taxRate))
+					break
+				}
+			}
+
+			for _, fee := range feeCoins {
+				xatp, found := mfd.xatpKeeper.GetXatp(ctx, fee.Denom)
+				if found {
+					ratioDec, err := mfd.xatpKeeper.GetFeeInfoFromXATP(ctx, xatp.Denom)
+					if err != nil {
+						return ctx, err
+					}
+
+					decimalDiff := sdk.NewIntFromBigInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(sdk.Precision-int64(xatp.Decimals)), nil))
+					minGasPrices = minGasPrices.Add(sdk.NewDecCoinFromDec(xatp.Denom, defaultGasPrice.Amount.Mul(ratioDec).QuoInt(decimalDiff)))
+				}
+			}
+
+			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))
+			var fee sdk.Dec
+			for i, gp := range minGasPrices {
+				fee = gp.Amount.Mul(glDec)
+
+				requiredFees[i] = sdk.NewCoin(gp.Denom, fee.Ceil().RoundInt())
+			}
+
+			if !simulate && !feeCoins.IsAnyGTE(requiredFees) {
+				return ctx, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "insufficient fees; got: %s required: %s", feeCoins, requiredFees)
+			}
 		}
-	}
 
-	if !feeCoins.IsAnyGTE(requiredFees) {
-		return ctx, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "provided fee < minimum global fee (%s < %s). Please increase the gas price.", feeCoins, requiredFees)
+		ctx.GasMeter().RefundGas(ctx.GasMeter().GasConsumed()-mempoolCheckGas, "refund mempool check")
 	}
 
 	return next(ctx, tx, simulate)
 }
 
-func (mpd MinGasPriceDecorator) bypassMinFeeMsgs(msgs []sdk.Msg) bool {
+func (mfd MempoolFeeDecorator) bypassMinFeeMsgs(msgs []sdk.Msg) bool {
 	for _, msg := range msgs {
-		if tmstrings.StringInSlice(sdk.MsgTypeURL(msg), mpd.BypassMinFeeMsgTypes) {
+		if tmstrings.StringInSlice(sdk.MsgTypeURL(msg), mfd.BypassMinFeeMsgTypes) {
 			continue
 		}
 
@@ -84,3 +124,123 @@ func (mpd MinGasPriceDecorator) bypassMinFeeMsgs(msgs []sdk.Msg) bool {
 
 	return true
 }
+
+type DeductFeeDecorator struct {
+	accountKeeper  authante.AccountKeeper
+	bankKeeper     types.BankKeeper
+	feegrantKeeper authante.FeegrantKeeper
+
+	xatpKeeper xatpkeeper.Keeper
+}
+
+func NewDeductFeeDecorator(ak authante.AccountKeeper, bk types.BankKeeper, fk authante.FeegrantKeeper, xk xatpkeeper.Keeper) DeductFeeDecorator {
+	return DeductFeeDecorator{
+		accountKeeper:  ak,
+		bankKeeper:     bk,
+		feegrantKeeper: fk,
+
+		xatpKeeper: xk,
+	}
+}
+
+func (dfd DeductFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
+	feeTx, ok := tx.(sdk.FeeTx)
+	if !ok {
+		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx")
+	}
+
+	fee := feeTx.GetFee()
+	feePayer := feeTx.FeePayer()
+	feeGranter := feeTx.FeeGranter()
+
+	deductFeesFrom := feePayer
+
+	// if feegranter set deduct fee from feegranter account.
+	// this works with only when feegrant enabled.
+	if feeGranter != nil {
+		if dfd.feegrantKeeper == nil {
+			return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "fee grants are not enabled")
+		} else if !feeGranter.Equals(feePayer) {
+			err := dfd.feegrantKeeper.UseGrantedFees(ctx, feeGranter, feePayer, fee, tx.GetMsgs())
+
+			if err != nil {
+				return ctx, sdkerrors.Wrapf(err, "%s not allowed to pay fees from %s", feeGranter, feePayer)
+			}
+		}
+
+		deductFeesFrom = feeGranter
+	}
+
+	deductFeesFromAcc := dfd.accountKeeper.GetAccount(ctx, deductFeesFrom)
+	if deductFeesFromAcc == nil {
+		return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "fee payer address: %s does not exist", deductFeesFrom)
+	}
+
+	// deduct the fees
+	if feeTx.GetFee().Len() > 0 {
+		nativeFees := sdk.Coins{}
+		xatpFees := sdk.Coins{}
+
+		for _, fee := range feeTx.GetFee() {
+			xatp, found := dfd.xatpKeeper.GetXatp(ctx, fee.Denom)
+			if !found {
+				nativeFees = nativeFees.Add(fee)
+				continue
+			}
+
+			if simulate && feeTx.GetFee().IsZero() {
+				// for gas auto, add to minimum amount
+				fee.Amount = sdk.OneInt()
+			}
+
+			err := dfd.xatpKeeper.PayXATP(ctx, deductFeesFrom, xatp.Denom, fee.Amount.String())
+			if err != nil {
+				return ctx, err
+			}
+
+			ratioDec, err := dfd.xatpKeeper.GetFeeInfoFromXATP(ctx, xatp.Denom)
+			if err != nil {
+				return ctx, err
+			}
+
+			feeAmount := sdk.NewDecFromIntWithPrec(fee.Amount, int64(xatp.Decimals))
+			defaultFeeAmountDec := feeAmount.Quo(ratioDec)
+			xatpFees = xatpFees.Add(sdk.NewCoin(xplatypes.DefaultDenom, defaultFeeAmountDec.MulInt(sdk.DefaultPowerReduction).TruncateInt()))
+		}
+
+		if !nativeFees.Empty() {
+			err = DeductFees(dfd.bankKeeper, ctx, deductFeesFromAcc, nativeFees)
+			if err != nil {
+				return ctx, err
+			}
+		}
+
+		if !xatpFees.Empty() {
+			err = dfd.xatpKeeper.DeductAndDistiributeFees(ctx, xatpFees)
+			if err != nil {
+				return ctx, err
+			}
+		}
+	}
+
+	events := sdk.Events{sdk.NewEvent(sdk.EventTypeTx,
+		sdk.NewAttribute(sdk.AttributeKeyFee, feeTx.GetFee().String()),
+	)}
+
+	ctx.EventManager().EmitEvents(events)
+
+	return next(ctx, tx, simulate)
+}
+
+func DeductFees(bankKeeper types.BankKeeper, ctx sdk.Context, acc types.AccountI, fees sdk.Coins) error {
+	if !fees.IsValid() {
+		return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "invalid fee amount: %s", fees)
+	}
+
+	err := bankKeeper.SendCoinsFromAccountToModule(ctx, acc.GetAddress(), types.FeeCollectorName, fees)
+	if err != nil {
+		return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds, err.Error())
+	}
+
+	return nil
+}

ante/fee_test.go

@@ -6,26 +6,26 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	ibcclienttypes "github.com/cosmos/ibc-go/v3/modules/core/02-client/types"
 	ibcchanneltypes "github.com/cosmos/ibc-go/v3/modules/core/04-channel/types"
+	evmtypes "github.com/evmos/ethermint/x/evm/types"
 	feemarkettypes "github.com/evmos/ethermint/x/feemarket/types"
 
 	"github.com/xpladev/xpla/ante"
+	"github.com/xpladev/xpla/types"
 )
 
 func (s *IntegrationTestSuite) TestMinGasPriceDecorator() {
 	s.SetupTest()
 	s.txBuilder = s.clientCtx.TxConfig.NewTxBuilder()
 
 	s.app.FeeMarketKeeper.SetParams(s.ctx, feemarkettypes.NewParams(true, 8, 2, 0, 0, sdk.NewDec(200), sdk.MustNewDecFromStr("1.5")))
+	s.app.EvmKeeper.SetParams(s.ctx, evmtypes.NewParams(types.DefaultDenom, true, true, evmtypes.DefaultChainConfig()))
 
-	mpd := ante.NewMinGasPriceDecorator(
-		s.app.FeeMarketKeeper,
-		s.app.EvmKeeper,
-		[]string{
-			sdk.MsgTypeURL(&ibcchanneltypes.MsgRecvPacket{}),
-			sdk.MsgTypeURL(&ibcchanneltypes.MsgAcknowledgement{}),
-			sdk.MsgTypeURL(&ibcclienttypes.MsgUpdateClient{}),
-		})
-	antehandler := sdk.ChainAnteDecorators(mpd)
+	mfd := ante.NewMempoolFeeDecorator([]string{
+		sdk.MsgTypeURL(&ibcchanneltypes.MsgRecvPacket{}),
+		sdk.MsgTypeURL(&ibcchanneltypes.MsgAcknowledgement{}),
+		sdk.MsgTypeURL(&ibcclienttypes.MsgUpdateClient{}),
+	}, s.app.AccountKeeper, s.app.XATPKeeper, s.app.FeeMarketKeeper, s.app.EvmKeeper)
+	antehandler := sdk.ChainAnteDecorators(mfd)
 	priv1, _, addr1 := testdata.KeyTestPubAddr()
 
 	msg := testdata.NewTestMsg(addr1)
@@ -40,7 +40,7 @@ func (s *IntegrationTestSuite) TestMinGasPriceDecorator() {
 	s.Require().NoError(err)
 
 	// Set high gas price so standard test fee fails
-	feeAmt := sdk.NewDecCoinFromDec("uatom", sdk.NewDec(200).Quo(sdk.NewDec(100000)))
+	feeAmt := sdk.NewDecCoinFromDec(types.DefaultDenom, sdk.NewDec(200).Quo(sdk.NewDec(100000)))
 	minGasPrice := []sdk.DecCoin{feeAmt}
 	s.ctx = s.ctx.WithMinGasPrices(minGasPrice).WithIsCheckTx(true)