interface all decorators except sigs

x/auth/ante/basic.go

@@ -6,7 +6,6 @@ import (
 	errs "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/cosmos/cosmos-sdk/x/auth/keeper"
-	"github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
 // ValidateBasicDecorator will call tx.ValidateBasic and return any non-nil error
@@ -25,8 +24,15 @@ func (vbd ValidateBasicDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulat
 	return next(ctx, tx, simulate)
 }
 
+// Tx must have GetMemo() method to use ValidateMemoDecorator
+type TxWithMemo interface {
+	sdk.Tx
+	GetMemo() string
+}
+
 // ValidateMemoDecorator will validate memo given the parameters passed in
 // If memo is too large decorator returns with error, otherwise call next AnteHandler
+// CONTRACT: Tx must implement TxWithMemo interface
 type ValidateMemoDecorator struct {
 	ak keeper.AccountKeeper
 }
@@ -38,14 +44,14 @@ func NewValidateMemoDecorator(ak keeper.AccountKeeper) ValidateMemoDecorator {
 }
 
 func (vmd ValidateMemoDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
-	stdTx, ok := tx.(types.StdTx)
+	memoTx, ok := tx.(TxWithMemo)
 	if !ok {
-		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must be a StdTx")
+		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must have a GetMemo method")
 	}
 
 	params := vmd.ak.GetParams(ctx)
 
-	memoLength := len(stdTx.GetMemo())
+	memoLength := len(memoTx.GetMemo())
 	if uint64(memoLength) > params.MaxMemoCharacters {
 		return ctx, err.Wrapf(err.ErrMemoTooLarge,
 			"maximum number of characters is %d but received %d characters",

x/auth/ante/fee.go

@@ -11,22 +11,32 @@ import (
 	errs "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
+// Tx must implement FeeTx interface to use the FeeDecorators
+type FeeTx interface {
+	sdk.Tx
+	Gas() uint64
+	FeeCoins() sdk.Coins
+	FeePayer() sdk.AccAddress
+}
+
 // MempoolFeeDecorator will check if the transaction's fee is at least as large the local validator's minimum gasFee (defined in validator config).
 // 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 MempoolFeeDecorator
 type MempoolFeeDecorator struct{}
 
 func NewMempoolFeeDecorator() MempoolFeeDecorator {
 	return MempoolFeeDecorator{}
 }
 
 func (mfd MempoolFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
-	stdTx, ok := tx.(types.StdTx)
+	feeTx, ok := tx.(FeeTx)
 	if !ok {
-		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must be a StdTx")
+		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must be a FeeTx")
 	}
-	stdFee := stdTx.Fee
+	feeCoins := feeTx.FeeCoins()
+	gas := feeTx.Gas()
 
 	// Ensure that the provided fees meet a minimum threshold for the validator,
 	// if this is a CheckTx. This is only for local mempool purposes, and thus
@@ -38,13 +48,15 @@ func (mfd MempoolFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate b
 
 			// Determine the required fees by multiplying each required minimum gas
 			// price by the gas limit, where fee = ceil(minGasPrice * gasLimit).
-			glDec := sdk.NewDec(int64(stdFee.Gas))
+			glDec := sdk.NewDec(int64(gas))
 			for i, gp := range minGasPrices {
 				fee := gp.Amount.Mul(glDec)
 				requiredFees[i] = sdk.NewCoin(gp.Denom, fee.Ceil().RoundInt())
 			}
 
-			return ctx, errs.Wrapf(errs.ErrInsufficientFee, "insufficient fees; got: %q required: %q", stdFee.Amount, requiredFees)
+			if !feeCoins.IsAnyGTE(requiredFees) {
+				return ctx, errs.Wrapf(errs.ErrInsufficientFee, "insufficient fees; got: %q required: %q", feeCoins, requiredFees)
+			}
 		}
 	}
 
@@ -54,6 +66,7 @@ func (mfd MempoolFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate b
 // 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           keeper.AccountKeeper
 	supplyKeeper types.SupplyKeeper
@@ -67,28 +80,21 @@ func NewDeductFeeDecorator(ak keeper.AccountKeeper, sk types.SupplyKeeper) Deduc
 }
 
 func (dfd DeductFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
-	stdTx, ok := tx.(types.StdTx)
+	feeTx, ok := tx.(FeeTx)
 	if !ok {
-		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must be a StdTx")
+		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must be a FeeTx")
 	}
 
 	if addr := dfd.supplyKeeper.GetModuleAddress(types.FeeCollectorName); addr == nil {
 		panic(fmt.Sprintf("%s module account has not been set", types.FeeCollectorName))
 	}
 
-	// stdSigs contains the sequence number, account number, and signatures.
-	// When simulating, this would just be a 0-length slice.
-	signerAddrs := stdTx.GetSigners()
-
-	// fetch first signer, who's going to pay the fees
-	feePayer, err := GetSignerAcc(ctx, dfd.ak, signerAddrs[0])
-	if err != nil {
-		return ctx, err
-	}
+	feePayer := feeTx.FeePayer()
+	feePayerAcc := dfd.ak.GetAccount(ctx, feePayer)
 
 	// deduct the fees
-	if !stdTx.Fee.Amount.IsZero() {
-		err = DeductFees(dfd.supplyKeeper, ctx, feePayer, stdTx.Fee.Amount)
+	if !feeTx.FeeCoins().IsZero() {
+		err = DeductFees(dfd.supplyKeeper, ctx, feePayerAcc, feeTx.FeeCoins())
 		if err != nil {
 			return ctx, err
 		}

x/auth/ante/setup.go

@@ -5,30 +5,35 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	errs "github.com/cosmos/cosmos-sdk/types/errors"
-	"github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
+// Tx with a Gas() method is needed to use SetupDecorator
+type GasTx interface {
+	Gas() uint64
+}
+
 // SetUpDecorator sets the GasMeter in the Context and wraps the next AnteHandler with a defer clause
 // to recover from any downstream OutOfGas panics in the AnteHandler chain to return an error with information
 // on gas provided and gas used.
-// Should be the first decorator in the chain
+// CONTRACT: Must be first decorator in the chain
+// CONTRACT: Tx must implement GasTx interface
 type SetUpDecorator struct{}
 
 func NewSetupDecorator() SetUpDecorator {
 	return SetUpDecorator{}
 }
 
 func (sud SetUpDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
-	// all transactions must be of type auth.StdTx
-	stdTx, ok := tx.(types.StdTx)
+	// all transactions must implement GasTx
+	gasTx, ok := tx.(GasTx)
 	if !ok {
 		// Set a gas meter with limit 0 as to prevent an infinite gas meter attack
 		// during runTx.
 		newCtx = SetGasMeter(simulate, ctx, 0)
-		return newCtx, errs.Wrap(errs.ErrTxDecode, "Tx must be auth.StdTx")
+		return newCtx, errs.Wrap(errs.ErrTxDecode, "Tx must be GasTx")
 	}
 
-	newCtx = SetGasMeter(simulate, ctx, stdTx.Fee.Gas)
+	newCtx = SetGasMeter(simulate, ctx, gasTx.Gas())
 
 	// Decorator will catch an OutOfGasPanic caused in the next antehandler
 	// AnteHandlers must have their own defer/recover in order for the BaseApp
@@ -41,7 +46,7 @@ func (sud SetUpDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool,
 			case sdk.ErrorOutOfGas:
 				log := fmt.Sprintf(
 					"out of gas in location: %v; gasWanted: %d, gasUsed: %d",
-					rType.Descriptor, stdTx.Fee.Gas, newCtx.GasMeter().GasConsumed())
+					rType.Descriptor, gasTx.Gas(), newCtx.GasMeter().GasConsumed())
 
 				err = errs.Wrap(errs.ErrOutOfGas, log)
 				// TODO: figure out how to return Context, error so that baseapp can recover gasWanted/gasUsed

x/auth/types/stdtx.go

@@ -107,6 +107,18 @@ func (tx StdTx) GetMemo() string { return tx.Memo }
 // .Empty().
 func (tx StdTx) GetSignatures() []StdSignature { return tx.Signatures }
 
+// Gas returns the Gas in StdFee
+func (tx StdTx) Gas() uint64 { return tx.Fee.Gas }
+
+// FeeCoins returns the FeeAmount in StdFee
+func (tx StdTx) FeeCoins() sdk.Coins { return tx.Fee.Amount }
+
+// FeePayer returns the address that is responsible for paying fee
+// StdTx returns the first signer as the fee payer
+func (tx StdTx) FeePayer() sdk.AccAddress {
+	return tx.GetMsgs()[0].GetSigners()[0]
+}
+
 //__________________________________________________________
 
 // StdFee includes the amount of coins paid in fees and the maximum