complete bez suggestions

baseapp/baseapp_test.go

@@ -19,7 +19,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/store/rootmulti"
 	store "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	errs "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 var (
@@ -600,12 +600,12 @@ func anteHandlerTxTest(t *testing.T, capKey *sdk.KVStoreKey, storeKey []byte) sd
 		txTest := tx.(txTest)
 
 		if txTest.FailOnAnte {
-			return newCtx, errs.Wrap(errs.ErrUnauthorized, "ante handler failure")
+			return newCtx, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "ante handler failure")
 		}
 
 		res := incrementingCounter(t, store, storeKey, txTest.Counter)
 		if !res.IsOK() {
-			err = errs.ABCIError(string(res.Codespace), uint32(res.Code), res.Log)
+			err = sdkerrors.ABCIError(string(res.Codespace), uint32(res.Code), res.Log)
 		}
 		return
 	}
@@ -996,7 +996,7 @@ func TestTxGasLimits(t *testing.T) {
 					switch rType := r.(type) {
 					case sdk.ErrorOutOfGas:
 						log := fmt.Sprintf("out of gas in location: %v", rType.Descriptor)
-						err = errs.Wrap(errs.ErrOutOfGas, log)
+						err = sdkerrors.Wrap(sdkerrors.ErrOutOfGas, log)
 					default:
 						panic(r)
 					}
@@ -1076,7 +1076,7 @@ func TestMaxBlockGasLimits(t *testing.T) {
 				if r := recover(); r != nil {
 					switch rType := r.(type) {
 					case sdk.ErrorOutOfGas:
-						err = errs.Wrapf(errs.ErrOutOfGas, "out of gas in location: %v", rType.Descriptor)
+						err = sdkerrors.Wrapf(sdkerrors.ErrOutOfGas, "out of gas in location: %v", rType.Descriptor)
 					default:
 						panic(r)
 					}
@@ -1241,7 +1241,7 @@ func TestGasConsumptionBadTx(t *testing.T) {
 					switch rType := r.(type) {
 					case sdk.ErrorOutOfGas:
 						log := fmt.Sprintf("out of gas in location: %v", rType.Descriptor)
-						err = errs.Wrap(errs.ErrOutOfGas, log)
+						err = sdkerrors.Wrap(sdkerrors.ErrOutOfGas, log)
 					default:
 						panic(r)
 					}
@@ -1251,7 +1251,7 @@ func TestGasConsumptionBadTx(t *testing.T) {
 			txTest := tx.(txTest)
 			newCtx.GasMeter().ConsumeGas(uint64(txTest.Counter), "counter-ante")
 			if txTest.FailOnAnte {
-				return newCtx, errs.Wrap(errs.ErrUnauthorized, "ante handler failure")
+				return newCtx, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "ante handler failure")
 			}
 
 			return

docs/architecture/adr-010-modular-antehandler.md

@@ -191,16 +191,16 @@ type AnteDecorator interface {
 ```
 
 ```go
-// ChainDecorators will recursively link all of the AnteDecorators in the chain and return a final AnteHandler function
+// ChainAnteDecorators will recursively link all of the AnteDecorators in the chain and return a final AnteHandler function
 // This is done to preserve the ability to set a single AnteHandler function in the baseapp.
-func ChainDecorators(chain ...AnteDecorator) AnteHandler {
+func ChainAnteDecorators(chain ...AnteDecorator) AnteHandler {
     if len(chain) == 1 {
         return func(ctx Context, tx Tx, simulate bool) {
             chain[0].AnteHandle(ctx, tx, simulate, nil)
         }
     }
     return func(ctx Context, tx Tx, simulate bool) {
-        chain[0].AnteHandle(ctx, tx, simulate, ChainDecorators(chain[1:]))
+        chain[0].AnteHandle(ctx, tx, simulate, ChainAnteDecorators(chain[1:]))
     }
 }
 ```
@@ -251,7 +251,7 @@ Link AnteDecorators to create a final AnteHandler. Set this AnteHandler in basea
 
 ```go
 // Create final antehandler by chaining the decorators together
-antehandler := ChainDecorators(NewSetupDecorator(), NewSigVerifyDecorator(), NewUserDefinedDecorator())
+antehandler := ChainAnteDecorators(NewSetupDecorator(), NewSigVerifyDecorator(), NewUserDefinedDecorator())
 
 // Set chained Antehandler in the baseapp
 bapp.SetAnteHandler(antehandler)
@@ -264,7 +264,7 @@ Pros:
 
 Cons:
 
-1. Decorator pattern may have a deeply nested structure that is hard to understand, this is mitigated by having the decorator order explicitly listed in the `ChainDecorators` function.
+1. Decorator pattern may have a deeply nested structure that is hard to understand, this is mitigated by having the decorator order explicitly listed in the `ChainAnteDecorators` function.
 2. Does not make use of the ModuleManager design. Since this is already being used for BeginBlocker/EndBlocker, this proposal seems unaligned with that design pattern.
 
 ## Status

types/handler.go

@@ -16,23 +16,25 @@ type AnteDecorator interface {
 // wrapping over the decorators further along chain and returns a single AnteHandler
 //
 // First element is outermost decorator, last element is innermost decorator
-func ChainDecorators(chain ...AnteDecorator) AnteHandler {
-	chain = append(chain, Tail{})
+func ChainAnteDecorators(chain ...AnteDecorator) AnteHandler {
+	if (chain[len(chain)-1] != Terminator{}) {
+		chain = append(chain, Terminator{})
+	}
 	if len(chain) == 1 {
 		return func(ctx Context, tx Tx, simulate bool) (Context, error) {
 			return chain[0].AnteHandle(ctx, tx, simulate, nil)
 		}
 	}
 	return func(ctx Context, tx Tx, simulate bool) (Context, error) {
-		return chain[0].AnteHandle(ctx, tx, simulate, ChainDecorators(chain[1:]...))
+		return chain[0].AnteHandle(ctx, tx, simulate, ChainAnteDecorators(chain[1:]...))
 	}
 }
 
-// Tail AnteDecorator will get added to the chain to simplify decorator code
+// Terminator AnteDecorator will get added to the chain to simplify decorator code
 // Don't need to check if next == nil further up the chain
-type Tail struct{}
+type Terminator struct{}
 
 // Simply return provided Context and nil error
-func (t Tail) AnteHandle(ctx Context, tx Tx, simulate bool, next AnteHandler) (Context, error) {
+func (t Terminator) AnteHandle(ctx Context, tx Tx, simulate bool, next AnteHandler) (Context, error) {
 	return ctx, nil
 }

x/auth/ante/ante.go

@@ -10,15 +10,15 @@ import (
 // numbers, checks signatures & account numbers, and deducts fees from the first
 // signer.
 func NewAnteHandler(ak keeper.AccountKeeper, supplyKeeper types.SupplyKeeper, sigGasConsumer SignatureVerificationGasConsumer) sdk.AnteHandler {
-	return sdk.ChainDecorators(
+	return sdk.ChainAnteDecorators(
 		NewSetupDecorator(),
 		NewMempoolFeeDecorator(),
 		NewValidateBasicDecorator(),
 		NewValidateMemoDecorator(ak),
 		NewConsumeGasForTxSizeDecorator(ak),
+		NewDeductFeeDecorator(ak, supplyKeeper),
 		NewSetPubKeyDecorator(ak),
 		NewValidateSigCountDecorator(ak),
-		NewDeductFeeDecorator(ak, supplyKeeper),
 		NewSigGasConsumeDecorator(ak, sigGasConsumer),
 		NewSigVerificationDecorator(ak),
 	)

x/auth/ante/ante_test.go

@@ -13,7 +13,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/secp256k1"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	errs "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/cosmos/cosmos-sdk/x/auth/ante"
 	"github.com/cosmos/cosmos-sdk/x/auth/exported"
 	"github.com/cosmos/cosmos-sdk/x/auth/types"
@@ -736,7 +736,7 @@ func TestCustomSignatureVerificationGasConsumer(t *testing.T) {
 			meter.ConsumeGas(params.SigVerifyCostED25519, "ante verify: ed25519")
 			return nil
 		default:
-			return errs.Wrapf(errs.ErrInvalidPubKey, "unrecognized public key type: %T", pubkey)
+			return sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "unrecognized public key type: %T", pubkey)
 		}
 	})
 

x/auth/ante/basic.go

@@ -3,7 +3,7 @@ package ante
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	err "github.com/cosmos/cosmos-sdk/types/errors"
-	errs "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 
 	"github.com/cosmos/cosmos-sdk/x/auth/keeper"
 )
@@ -46,7 +46,7 @@ func NewValidateMemoDecorator(ak keeper.AccountKeeper) ValidateMemoDecorator {
 func (vmd ValidateMemoDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
 	memoTx, ok := tx.(TxWithMemo)
 	if !ok {
-		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must have a GetMemo method")
+		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must have a GetMemo method")
 	}
 
 	params := vmd.ak.GetParams(ctx)
@@ -62,19 +62,19 @@ func (vmd ValidateMemoDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 	return next(ctx, tx, simulate)
 }
 
-// ConsumeGasForTxSizeDecorator will take in parameters and consume gas proportional to the size of tx
+// ConsumeTxSizeGasDecorator will take in parameters and consume gas proportional to the size of tx
 // before calling next AnteHandler
-type ConsumeGasForTxSizeDecorator struct {
+type ConsumeTxSizeGasDecorator struct {
 	ak keeper.AccountKeeper
 }
 
-func NewConsumeGasForTxSizeDecorator(ak keeper.AccountKeeper) ConsumeGasForTxSizeDecorator {
-	return ConsumeGasForTxSizeDecorator{
+func NewConsumeGasForTxSizeDecorator(ak keeper.AccountKeeper) ConsumeTxSizeGasDecorator {
+	return ConsumeTxSizeGasDecorator{
 		ak: ak,
 	}
 }
 
-func (cgts ConsumeGasForTxSizeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
+func (cgts ConsumeTxSizeGasDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
 	params := cgts.ak.GetParams(ctx)
 	ctx.GasMeter().ConsumeGas(params.TxSizeCostPerByte*sdk.Gas(len(ctx.TxBytes())), "txSize")
 

x/auth/ante/basic_test.go

@@ -29,7 +29,7 @@ func TestValidateBasic(t *testing.T) {
 	invalidTx := types.NewTestTx(ctx, msgs, privs, accNums, seqs, fee)
 
 	vbd := ante.NewValidateBasicDecorator()
-	antehandler := sdk.ChainDecorators(vbd)
+	antehandler := sdk.ChainAnteDecorators(vbd)
 	_, err := antehandler(ctx, invalidTx, false)
 
 	require.NotNil(t, err, "Did not error on invalid tx")
@@ -58,7 +58,7 @@ func TestValidateMemo(t *testing.T) {
 	invalidTx := types.NewTestTxWithMemo(ctx, msgs, privs, accNums, seqs, fee, strings.Repeat("01234567890", 500))
 
 	vmd := ante.NewValidateMemoDecorator(app.AccountKeeper)
-	antehandler := sdk.ChainDecorators(vmd)
+	antehandler := sdk.ChainAnteDecorators(vmd)
 	_, err := antehandler(ctx, invalidTx, false)
 
 	require.NotNil(t, err, "Did not error on tx with high memo")
@@ -75,7 +75,7 @@ func TestConsumeGasForTxSize(t *testing.T) {
 	app, ctx := createTestApp(true)
 
 	cgtsd := ante.NewConsumeGasForTxSizeDecorator(app.AccountKeeper)
-	antehandler := sdk.ChainDecorators(cgtsd)
+	antehandler := sdk.ChainAnteDecorators(cgtsd)
 
 	params := app.AccountKeeper.GetParams(ctx)
 	txBytes := []byte(strings.Repeat("a", 10))
@@ -94,7 +94,7 @@ func TestConsumeGasForTxSize(t *testing.T) {
 	// No need to send tx here since this Decorator will do nothing with it
 	beforeGas = ctx.GasMeter().GasConsumed()
 	ctx, err := antehandler(ctx, nil, false)
-	require.Nil(t, err, "ConsumeGasForTxSizeDecorator returned error: %v", err)
+	require.Nil(t, err, "ConsumeTxSizeGasDecorator returned error: %v", err)
 
 	consumedGas := ctx.GasMeter().GasConsumed() - beforeGas
 	require.Equal(t, expectedGas, consumedGas, "Decorator did not consume the correct amount of gas")

x/auth/ante/fee.go

@@ -8,7 +8,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/auth/keeper"
 	"github.com/cosmos/cosmos-sdk/x/auth/types"
 
-	errs "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 // Tx must implement FeeTx interface to use the FeeDecorators
@@ -19,7 +19,8 @@ type FeeTx interface {
 	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).
+// MempoolFeeDecorator will check if the transaction's fee is at least as large
+// as 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
@@ -33,7 +34,7 @@ func NewMempoolFeeDecorator() MempoolFeeDecorator {
 func (mfd MempoolFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) {
 	feeTx, ok := tx.(FeeTx)
 	if !ok {
-		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must be a FeeTx")
+		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx")
 	}
 	feeCoins := feeTx.FeeCoins()
 	gas := feeTx.Gas()
@@ -55,7 +56,7 @@ func (mfd MempoolFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate b
 			}
 
 			if !feeCoins.IsAnyGTE(requiredFees) {
-				return ctx, errs.Wrapf(errs.ErrInsufficientFee, "insufficient fees; got: %q required: %q", feeCoins, requiredFees)
+				return ctx, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "insufficient fees; got: %q required: %q", feeCoins, requiredFees)
 			}
 		}
 	}
@@ -82,7 +83,7 @@ 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) {
 	feeTx, ok := tx.(FeeTx)
 	if !ok {
-		return ctx, errs.Wrap(errs.ErrTxDecode, "Tx must be a FeeTx")
+		return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx")
 	}
 
 	if addr := dfd.supplyKeeper.GetModuleAddress(types.FeeCollectorName); addr == nil {
@@ -112,21 +113,21 @@ func DeductFees(supplyKeeper types.SupplyKeeper, ctx sdk.Context, acc exported.A
 	coins := acc.GetCoins()
 
 	if !fees.IsValid() {
-		return errs.Wrapf(errs.ErrInsufficientFee, "invalid fee amount: %s", fees)
+		return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "invalid fee amount: %s", fees)
 	}
 
 	// verify the account has enough funds to pay for fees
 	_, hasNeg := coins.SafeSub(fees)
 	if hasNeg {
-		return errs.Wrapf(errs.ErrInsufficientFunds,
+		return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds,
 			"insufficient funds to pay for fees; %s < %s", coins, fees)
 	}
 
 	// Validate the account has enough "spendable" coins as this will cover cases
 	// such as vesting accounts.
 	spendableCoins := acc.SpendableCoins(blockTime)
 	if _, hasNeg := spendableCoins.SafeSub(fees); hasNeg {
-		return errs.Wrapf(errs.ErrInsufficientFunds,
+		return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds,
 			"insufficient funds to pay for fees; %s < %s", spendableCoins, fees)
 	}
 

x/auth/ante/fee_test.go

@@ -15,7 +15,7 @@ func TestEnsureMempoolFees(t *testing.T) {
 	_, ctx := createTestApp(true)
 
 	mfd := ante.NewMempoolFeeDecorator()
-	antehandler := sdk.ChainDecorators(mfd)
+	antehandler := sdk.ChainAnteDecorators(mfd)
 
 	// keys and addresses
 	priv1, _, addr1 := types.KeyTestPubAddr()
@@ -81,7 +81,7 @@ func TestDeductFees(t *testing.T) {
 	app.AccountKeeper.SetAccount(ctx, acc)
 
 	dfd := ante.NewDeductFeeDecorator(app.AccountKeeper, app.SupplyKeeper)
-	antehandler := sdk.ChainDecorators(dfd)
+	antehandler := sdk.ChainAnteDecorators(dfd)
 
 	_, err := antehandler(ctx, tx, false)
 

x/auth/ante/setup.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	errs "github.com/cosmos/cosmos-sdk/types/errors"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
 
 // Tx with a Gas() method is needed to use SetupDecorator
@@ -30,7 +30,7 @@ func (sud SetUpDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool,
 		// 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 GasTx")
+		return newCtx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be GasTx")
 	}
 
 	newCtx = SetGasMeter(simulate, ctx, gasTx.Gas())
@@ -48,8 +48,7 @@ func (sud SetUpDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool,
 					"out of gas in location: %v; gasWanted: %d, gasUsed: %d",
 					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
+				err = sdkerrors.Wrap(sdkerrors.ErrOutOfGas, log)
 			default:
 				panic(r)
 			}