Auto-swap non-osmo tx fees to osmo

app/ante.go

@@ -31,6 +31,7 @@ func NewAnteHandler(
 ) sdk.AnteHandler {
 	mempoolFeeOptions := txfeestypes.NewMempoolFeeOptions(appOpts)
 	mempoolFeeDecorator := txfeeskeeper.NewMempoolFeeDecorator(*txFeesKeeper, mempoolFeeOptions)
+	deductFeeDecorator := txfeeskeeper.NewDeductFeeDecorator(*txFeesKeeper, ak, bankKeeper, nil)
 	return sdk.ChainAnteDecorators(
 		ante.NewSetUpContextDecorator(), // outermost AnteDecorator. SetUpContext must be called first
 		wasmkeeper.NewLimitSimulationGasDecorator(wasmConfig.SimulationGasLimit),
@@ -43,7 +44,8 @@ func NewAnteHandler(
 		ante.TxTimeoutHeightDecorator{},
 		ante.NewValidateMemoDecorator(ak),
 		ante.NewConsumeGasForTxSizeDecorator(ak),
-		ante.NewDeductFeeDecorator(ak, bankKeeper, nil),
+		// Replaced with version from our txfees module from auth (previously "ante.NewDeductFeeDecorator(ak, bankKeeper, nil)")"
+		deductFeeDecorator,
 		ante.NewSetPubKeyDecorator(ak), // SetPubKeyDecorator must be called before all signature verification decorators
 		ante.NewValidateSigCountDecorator(ak),
 		ante.NewSigGasConsumeDecorator(ak, sigGasConsumer),

app/keepers.go

@@ -345,6 +345,8 @@ func (app *OsmosisApp) InitNormalKeepers(
 	)
 	app.MintKeeper = &mintKeeper
 
+
+
 	poolIncentivesKeeper := poolincentiveskeeper.NewKeeper(
 		appCodec,
 		keys[poolincentivestypes.StoreKey],
@@ -358,10 +360,16 @@ func (app *OsmosisApp) InitNormalKeepers(
 	)
 	app.PoolIncentivesKeeper = &poolIncentivesKeeper
 
+	// Note: gammKeeper is expected to satisfy the SpotPriceCalculator interface parameter
 	txFeesKeeper := txfeeskeeper.NewKeeper(
 		appCodec,
+		app.AccountKeeper,
+		app.BankKeeper,
+		app.EpochsKeeper,
 		keys[txfeestypes.StoreKey],
-		app.GAMMKeeper,
+		gammKeeper,
+		txfeestypes.FeeCollectorName,
+		txfeestypes.FooCollectorName,
 	)
 	app.TxFeesKeeper = &txFeesKeeper
 
@@ -465,6 +473,8 @@ func (app *OsmosisApp) SetupHooks() {
 	app.EpochsKeeper.SetHooks(
 		epochstypes.NewMultiEpochHooks(
 			// insert epoch hooks receivers here
+			// TO DO: add TxFeesKeeper.Hooks() for auto fee swaps
+			app.TxFeesKeeper.Hooks(),
 			app.SuperfluidKeeper.Hooks(),
 			app.IncentivesKeeper.Hooks(),
 			app.MintKeeper.Hooks(),

app/modules.go

@@ -186,6 +186,7 @@ var moduleAaccountPermissions = map[string][]string{
 	poolincentivestypes.ModuleName:           nil,
 	superfluidtypes.ModuleName:               {authtypes.Minter, authtypes.Burner},
 	txfeestypes.ModuleName:                   nil,
+	txfeestypes.FooCollectorName:             nil,
 	wasm.ModuleName:                          {authtypes.Burner},
 }
 

x/txfees/keeper/feedecorator.go

@@ -1,11 +1,15 @@
 package keeper
 
 import (
+	"fmt"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/osmosis-labs/osmosis/v7/x/txfees/keeper/txfee_filters"
 	"github.com/osmosis-labs/osmosis/v7/x/txfees/types"
+
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
 // MempoolFeeDecorator will check if the transaction's fee is at least as large
@@ -119,3 +123,122 @@ func (mfd MempoolFeeDecorator) GetMinBaseGasPriceForTx(ctx sdk.Context, baseDeno
 	}
 	return cfgMinGasPrice
 }
+
+// DeductFeeDecorator deducts fees from the first signer of the tx
+// If the first signer does not have the funds to pay for the fees, return with InsufficientFunds error
+// Call next AnteHandler if fees successfully deducted
+// CONTRACT: Tx must implement FeeTx interface to use DeductFeeDecorator
+type DeductFeeDecorator struct {
+	ak             types.AccountKeeper
+	bankKeeper     types.BankKeeper
+	feegrantKeeper types.FeegrantKeeper
+	txFeesKeeper   Keeper
+}
+
+func NewDeductFeeDecorator(tk Keeper, ak types.AccountKeeper, bk types.BankKeeper, fk types.FeegrantKeeper) DeductFeeDecorator {
+	return DeductFeeDecorator{
+		ak:             ak,
+		bankKeeper:     bk,
+		feegrantKeeper: fk,
+		txFeesKeeper: tk,
+	}
+}
+
+func (dfd DeductFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
+
+	// checks to make sure feeTx is of the right type
+	feeTx, ok := tx.(sdk.FeeTx)
+	if !ok {
+		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx")
+	}
+
+	// checks to make sure the module account has been set to collect fees in OSMO
+	if addr := dfd.ak.GetModuleAddress(types.FeeCollectorName); addr == nil {
+		return ctx, fmt.Errorf("Fee collector module account (%s) has not been set", types.FeeCollectorName)
+	}
+
+	// checks to make sure a separate module account has been set to collect fees not in OSMO
+	if addrFoo := dfd.ak.GetModuleAddress(types.FooCollectorName); addrFoo == nil {
+		return ctx, fmt.Errorf("Foo collector module account (%s) has not been set", types.FooCollectorName)
+	}
+
+	// fee can be in any denom (checked for validity later)
+	fee := feeTx.GetFee()
+	feePayer := feeTx.FeePayer()
+	feeGranter := feeTx.FeeGranter()
+
+	// set the fee payer as the default address to deduct fees from
+	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)
+			}
+		}
+
+		// if no errors, change the account that is charged for fees to the fee granter
+		deductFeesFrom = feeGranter
+	}
+
+	// pulls account from address and makes sure it exists
+	deductFeesFromAcc := dfd.ak.GetAccount(ctx, deductFeesFrom)
+	if deductFeesFromAcc == nil {
+		return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "fee payer address: %s does not exist", deductFeesFrom)
+	}
+
+	// deducts the fees and transfer them to the module account
+	if !feeTx.GetFee().IsZero() {
+		err = DeductFees(dfd.txFeesKeeper, dfd.bankKeeper, ctx, deductFeesFromAcc, feeTx.GetFee())
+		if err != nil {
+			return ctx, err
+		}
+	} // no additional action/else statment needed if the fee is zero since zero-gas transactions are allowed
+
+	events := sdk.Events{sdk.NewEvent(sdk.EventTypeTx,
+		sdk.NewAttribute(sdk.AttributeKeyFee, feeTx.GetFee().String()),
+	)}
+	ctx.EventManager().EmitEvents(events)
+
+	return next(ctx, tx, simulate)
+}
+
+// DeductFees deducts fees from the given account and transfers them to the set module account
+func DeductFees(txFeesKeeper types.TxFeesKeeper, bankKeeper types.BankKeeper, ctx sdk.Context, acc authtypes.AccountI, fees sdk.Coins) error {
+
+	// Checks the validity of the fee tokens (sorted, have positive amount, valid and unique denomination)
+	if !fees.IsValid() {
+		return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "invalid fee amount: %s", fees)
+	}
+
+	// pulls base denom from TxFeesKeeper (should be uOSMO)
+	baseDenom, err := txFeesKeeper.GetBaseDenom(ctx)
+	if err != nil {
+		return err
+	}
+
+	// checks if input fee is uOSMO (assumes only one fee token exists in the fees array (as per the check in mempoolFeeDecorator))
+	if fees[0].Denom == baseDenom {
+
+		// sends to FeeCollectorName module account
+		err := bankKeeper.SendCoinsFromAccountToModule(ctx, acc.GetAddress(), types.FeeCollectorName, fees)
+		if err != nil {
+			return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds, err.Error())
+		}
+	} else {
+
+		// sends to FooCollectorName module account
+		err := bankKeeper.SendCoinsFromAccountToModule(ctx, acc.GetAddress(), types.FooCollectorName, fees)
+		if err != nil {
+			return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds, err.Error())
+		}
+	}
+
+	return nil
+}

x/txfees/keeper/hooks.go

@@ -0,0 +1,78 @@
+package keeper
+
+import (
+	// "fmt"
+
+	// "github.com/cosmos/cosmos-sdk/telemetry"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	epochstypes "github.com/osmosis-labs/osmosis/v7/x/epochs/types"
+	txfeestypes "github.com/osmosis-labs/osmosis/v7/x/txfees/types"
+)
+
+func (k Keeper) BeforeEpochStart(ctx sdk.Context, epochIdentifier string, epochNumber int64) {
+}
+
+// at the end of each epoch, swap all non-OSMO fees into OSMO and transfer to fee module account
+func (k Keeper) AfterEpochEnd(ctx sdk.Context, epochIdentifier string, epochNumber int64) {
+
+	// get module address for FooCollectorName
+	addrFoo := k.accountKeeper.GetModuleAddress(txfeestypes.FooCollectorName)
+
+	// get balances for all denoms in the module account
+	fooAccountBalances := k.bankKeeper.GetAllBalances(ctx, addrFoo)
+
+	// pulls base denom from TxFeesKeeper (should be uOSMO)
+	baseDenom, _ := k.GetBaseDenom(ctx)
+
+	// iterate through the resulting array and swap each denom into OSMO using the GAMM module
+	for _, coin := range fooAccountBalances {
+
+		if coin.Denom == baseDenom {
+			continue
+		} else {
+
+			// TO DO: figure out how to cast this or get the pool ID for the main OSMO paired pool
+			feetoken := coin.(txfeestypes.FeeToken)
+
+			// calculate spot price to determine minimum out for swap
+			// question: is the order of input denom and output denom correct?
+			spotPrice, _ := k.spotPriceCalculator.CalculateSpotPrice(ctx, feetoken.GetPoolID(), coin.Denom, baseDenom)
+
+			// swap into OSMO
+			// question: is spotPrice really the minimum out for the swap?
+			k.spotPriceCalculator.SwapExactAmountIn(ctx, addrFoo, feetoken.GetPoolId(), coin.Denom, baseDenom, k.spotPriceCalculator)
+		}
+	}
+
+	// PLACEHOLDER – addrFee := k.accountKeeper.GetModuleAddress(txfeestypes.FeeCollectorName)
+
+	// Potential error to test for: do swaps to OSMO consolidate into a single denom in fooAccountBalances? Should be yes but keep an eye out
+
+	// send all OSMO to fee module account to be distributed in the next block
+	k.bankKeeper.SendCoinsFromModuleToModule(ctx, txfeestypes.FooCollectorName, txfeestypes.FeeCollectorName, fooAccountBalances)
+
+	// Should events be emitted at the end here?
+}
+
+// ___________________________________________________________________________________________________
+
+// Hooks wrapper struct for incentives keeper
+type Hooks struct {
+	k Keeper
+}
+
+var _ epochstypes.EpochHooks = Hooks{}
+
+// Return the wrapper struct
+func (k Keeper) Hooks() Hooks {
+	return Hooks{k}
+}
+
+// epochs hooks
+func (h Hooks) BeforeEpochStart(ctx sdk.Context, epochIdentifier string, epochNumber int64) {
+	h.k.BeforeEpochStart(ctx, epochIdentifier, epochNumber)
+}
+
+func (h Hooks) AfterEpochEnd(ctx sdk.Context, epochIdentifier string, epochNumber int64) {
+	h.k.AfterEpochEnd(ctx, epochIdentifier, epochNumber)
+}

x/txfees/keeper/keeper.go

@@ -9,6 +9,8 @@ import (
 	"github.com/cosmos/cosmos-sdk/store/prefix"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+
 	"github.com/osmosis-labs/osmosis/v7/x/txfees/types"
 )
 
@@ -17,19 +19,36 @@ type (
 		cdc      codec.Codec
 		storeKey sdk.StoreKey
 
+		accountKeeper    types.AccountKeeper
+		bankKeeper       *bankkeeper.BaseKeeper
+		epochKeeper      types.EpochKeeper
+
 		spotPriceCalculator types.SpotPriceCalculator
+
+		feeCollectorName string
+		fooCollectorName string
 	}
 )
 
 func NewKeeper(
 	cdc codec.Codec,
+	accountKeeper types.AccountKeeper,
+	bankKeeper *bankkeeper.BaseKeeper,
+	epochKeeper types.EpochKeeper,
 	storeKey sdk.StoreKey,
 	spotPriceCalculator types.SpotPriceCalculator,
+	feeCollectorName string,
+	fooCollectorName string,
 ) Keeper {
 	return Keeper{
 		cdc:                 cdc,
+		accountKeeper: accountKeeper,
+		bankKeeper: bankKeeper,
+		epochKeeper: epochKeeper,
 		storeKey:            storeKey,
 		spotPriceCalculator: spotPriceCalculator,
+		feeCollectorName: feeCollectorName,
+		fooCollectorName: fooCollectorName,
 	}
 }
 

x/txfees/types/expected_keepers.go

@@ -2,10 +2,51 @@ package types
 
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+	epochstypes "github.com/osmosis-labs/osmosis/v7/x/epochs/types"
 )
 
 // SpotPriceCalculator defines the contract that must be fulfilled by a spot price calculator
 // The x/gamm keeper is expected to satisfy this interface
 type SpotPriceCalculator interface {
 	CalculateSpotPrice(ctx sdk.Context, poolId uint64, tokenInDenom, tokenOutDenom string) (sdk.Dec, error)
+	SwapExactAmountIn(
+		ctx sdk.Context,
+		sender sdk.AccAddress,
+		poolId uint64,
+		tokenIn sdk.Coin,
+		tokenOutDenom string,
+		tokenOutMinAmount sdk.Int,
+	) (tokenOutAmount sdk.Int, spotPriceAfter sdk.Dec, err error)
 }
+
+// AccountKeeper defines the contract needed for AccountKeeper related APIs.
+// Interface provides support to use non-sdk AccountKeeper for AnteHandler's decorators.
+type AccountKeeper interface {
+	GetParams(ctx sdk.Context) (params authtypes.Params)
+	GetAccount(ctx sdk.Context, addr sdk.AccAddress) authtypes.AccountI
+	SetAccount(ctx sdk.Context, acc authtypes.AccountI)
+	GetModuleAddress(moduleName string) sdk.AccAddress
+}
+
+// FeegrantKeeper defines the expected feegrant keeper.
+type FeegrantKeeper interface {
+	UseGrantedFees(ctx sdk.Context, granter, grantee sdk.AccAddress, fee sdk.Coins, msgs []sdk.Msg) error
+}
+
+// BankKeeper defines the contract needed for supply related APIs (noalias)
+type BankKeeper interface {
+	SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
+}
+
+// TxFeesKeeper defines the expected transaction fee keeper
+type TxFeesKeeper interface {
+	ConvertToBaseToken(ctx sdk.Context, inputFee sdk.Coin) (sdk.Coin, error)
+	GetBaseDenom(ctx sdk.Context) (denom string, err error)
+	GetFeeToken(ctx sdk.Context, denom string) (FeeToken, error)
+}
+
+// EpochKeeper defines the contract needed to be fulfilled for epochs keeper
+type EpochKeeper interface {
+	GetEpochInfo(ctx sdk.Context, identifier string) epochstypes.EpochInfo
+}