move tax payment to post handler

app/app.go

@@ -256,7 +256,11 @@ func NewTerraApp(
 
 	postHandler, err := custompost.NewPostHandler(
 		custompost.HandlerOptions{
-			DyncommKeeper: app.DyncommKeeper,
+			DyncommKeeper:  app.DyncommKeeper,
+			TaxKeeper:      app.TaxKeeper,
+			BankKeeper:     app.BankKeeper,
+			AccountKeeper:  app.AccountKeeper,
+			TreasuryKeeper: app.TreasuryKeeper,
 		},
 	)
 	if err != nil {

custom/auth/ante/fee.go

@@ -75,18 +75,19 @@ func (fd FeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, nex
 		taxes = sdk.Coins{}
 	}
 
-	if err := fd.checkDeductFee(ctx, feeTx, taxes, simulate); err != nil {
-		return ctx, err
+	newCtx, err := fd.checkDeductFee(ctx, feeTx, taxes, simulate)
+	if err != nil {
+		return newCtx, err
 	}
 
-	newCtx := ctx.WithPriority(priority).WithValue(taxtypes.ContextKeyTaxReverseCharge, reverseCharge)
+	newCtx = newCtx.WithPriority(priority).WithValue(taxtypes.ContextKeyTaxReverseCharge, reverseCharge)
 
 	return next(newCtx, tx, simulate)
 }
 
-func (fd FeeDecorator) checkDeductFee(ctx sdk.Context, feeTx sdk.FeeTx, taxes sdk.Coins, simulate bool) error {
+func (fd FeeDecorator) checkDeductFee(ctx sdk.Context, feeTx sdk.FeeTx, taxes sdk.Coins, simulate bool) (sdk.Context, error) {
 	if addr := fd.accountKeeper.GetModuleAddress(types.FeeCollectorName); addr == nil {
-		return fmt.Errorf("fee collector module account (%s) has not been set", types.FeeCollectorName)
+		return ctx, fmt.Errorf("fee collector module account (%s) has not been set", types.FeeCollectorName)
 	}
 
 	fee := feeTx.GetFee()
@@ -98,11 +99,11 @@ func (fd FeeDecorator) checkDeductFee(ctx sdk.Context, feeTx sdk.FeeTx, taxes sd
 	// this works with only when feegrant enabled.
 	if feeGranter != nil {
 		if fd.feegrantKeeper == nil {
-			return sdkerrors.ErrInvalidRequest.Wrap("fee grants are not enabled")
+			return ctx, sdkerrors.ErrInvalidRequest.Wrap("fee grants are not enabled")
 		} else if !feeGranter.Equals(feePayer) {
 			err := fd.feegrantKeeper.UseGrantedFees(ctx, feeGranter, feePayer, fee, feeTx.GetMsgs())
 			if err != nil {
-				return errorsmod.Wrapf(err, "%s does not not allow to pay fees for %s", feeGranter, feePayer)
+				return ctx, errorsmod.Wrapf(err, "%s does not not allow to pay fees for %s", feeGranter, feePayer)
 			}
 		}
 
@@ -111,7 +112,7 @@ func (fd FeeDecorator) checkDeductFee(ctx sdk.Context, feeTx sdk.FeeTx, taxes sd
 
 	deductFeesFromAcc := fd.accountKeeper.GetAccount(ctx, deductFeesFrom)
 	if deductFeesFromAcc == nil {
-		return sdkerrors.ErrUnknownAddress.Wrapf("fee payer address: %s does not exist", deductFeesFrom)
+		return ctx, sdkerrors.ErrUnknownAddress.Wrapf("fee payer address: %s does not exist", deductFeesFrom)
 	}
 
 	feesOrTax := fee
@@ -146,31 +147,31 @@ func (fd FeeDecorator) checkDeductFee(ctx sdk.Context, feeTx sdk.FeeTx, taxes sd
 			if !needMint.IsZero() {
 				err := fd.bankKeeper.MintCoins(ctx, minttypes.ModuleName, needMint)
 				if err != nil {
-					return err
+					return ctx, err
 				}
 
 				// we need to add the fees to the account balance to avoid deduction errors
 				err = fd.bankKeeper.SendCoinsFromModuleToAccount(ctx, minttypes.ModuleName, deductFeesFromAcc.GetAddress(), needMint)
 				if err != nil {
-					return err
+					return ctx, err
 				}
 			}
 		}
 	}
 
 	if !feesOrTax.IsZero() {
-		err := DeductFees(fd.bankKeeper, ctx, deductFeesFromAcc, feesOrTax)
-		if err != nil {
-			return err
-		}
+		// we will only deduct the fees from the account, not the tax
+		// the tax will be deducted in the message route for reverse charge
+		// or in the post handler for normal tax charge
+		deductFees := feesOrTax.Sub(taxes...) // feesOrTax can never be lower than taxes
 
-		if !taxes.IsZero() {
-			err := fd.taxKeeper.ProcessTaxSplits(ctx, taxes)
+		ctx = ctx.WithValue(taxtypes.ContextKeyTaxDue, taxes).WithValue(taxtypes.ContextKeyTaxPayer, deductFeesFrom.String())
+
+		if !deductFees.IsZero() {
+			err := DeductFees(fd.bankKeeper, ctx, deductFeesFromAcc, deductFees)
 			if err != nil {
-				return err
+				return ctx, err
 			}
-			// Record tax proceeds
-			fd.treasuryKeeper.RecordEpochTaxProceeds(ctx, taxes)
 		}
 	}
 
@@ -183,7 +184,7 @@ func (fd FeeDecorator) checkDeductFee(ctx sdk.Context, feeTx sdk.FeeTx, taxes sd
 	}
 	ctx.EventManager().EmitEvents(events)
 
-	return nil
+	return ctx, nil
 }
 
 // DeductFees deducts fees from the given account.

custom/auth/ante/fee_test.go

@@ -22,6 +22,7 @@ import (
 	core "github.com/classic-terra/core/v3/types"
 	markettypes "github.com/classic-terra/core/v3/x/market/types"
 	oracletypes "github.com/classic-terra/core/v3/x/oracle/types"
+	"github.com/classic-terra/core/v3/x/tax/post"
 	taxtypes "github.com/classic-terra/core/v3/x/tax/types"
 )
 
@@ -735,6 +736,8 @@ func (s *AnteTestSuite) TestTaxExemption() {
 
 		mfd := ante.NewFeeDecorator(s.app.AccountKeeper, s.app.BankKeeper, s.app.FeeGrantKeeper, s.app.TreasuryKeeper, s.app.DistrKeeper, s.app.TaxKeeper)
 		antehandler := sdk.ChainAnteDecorators(mfd)
+		pd := post.NewTaxDecorator(s.app.TaxKeeper, bk, ak, tk)
+		posthandler := sdk.ChainPostDecorators(pd)
 
 		for i := 0; i < 4; i++ {
 			coins := sdk.NewCoins(sdk.NewCoin(core.MicroSDRDenom, sdk.NewInt(10000000)))
@@ -754,6 +757,8 @@ func (s *AnteTestSuite) TestTaxExemption() {
 
 		newCtx, err := antehandler(s.ctx, tx, false)
 		require.NoError(err)
+		newCtx, err = posthandler(newCtx, tx, false, true)
+		require.NoError(err)
 
 		actualTaxRate := s.app.TaxKeeper.GetBurnTaxRate(s.ctx)
 		require.Equal(burnTaxRate, actualTaxRate)
@@ -812,7 +817,9 @@ func (s *AnteTestSuite) runBurnSplitTaxTest(burnSplitRate sdk.Dec, oracleSplitRa
 	dk := s.app.DistrKeeper
 	th := s.app.TaxKeeper
 	mfd := ante.NewFeeDecorator(ak, bk, s.app.FeeGrantKeeper, tk, dk, th)
+	pd := post.NewTaxDecorator(th, bk, ak, tk)
 	antehandler := sdk.ChainAnteDecorators(mfd)
+	postHandler := sdk.ChainPostDecorators(pd)
 
 	// Set burn split tax
 	tk.SetBurnSplitRate(s.ctx, burnSplitRate)
@@ -867,8 +874,9 @@ func (s *AnteTestSuite) runBurnSplitTaxTest(burnSplitRate sdk.Dec, oracleSplitRa
 	)*/
 
 	// send tx to BurnTaxFeeDecorator antehandler
-	_, err = antehandler(s.ctx, tx, false)
+	newCtx, err := antehandler(s.ctx, tx, false)
 	require.NoError(err)
+	_, err = postHandler(newCtx, tx, false, true)
 
 	// burn the burn account
 	tk.BurnCoinsFromBurnAccount(s.ctx)

custom/auth/post/post.go

@@ -3,18 +3,28 @@ package post
 import (
 	dyncommkeeper "github.com/classic-terra/core/v3/x/dyncomm/keeper"
 	dyncommpost "github.com/classic-terra/core/v3/x/dyncomm/post"
+	taxkeeper "github.com/classic-terra/core/v3/x/tax/keeper"
+	taxpost "github.com/classic-terra/core/v3/x/tax/post"
+	treasurykeeper "github.com/classic-terra/core/v3/x/treasury/keeper"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	accountkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
 )
 
 // HandlerOptions are the options required for constructing a default SDK AnteHandler.
 type HandlerOptions struct {
-	DyncommKeeper dyncommkeeper.Keeper
+	DyncommKeeper  dyncommkeeper.Keeper
+	TaxKeeper      taxkeeper.Keeper
+	BankKeeper     bankkeeper.Keeper
+	AccountKeeper  accountkeeper.AccountKeeper
+	TreasuryKeeper treasurykeeper.Keeper
 }
 
 // NewPostHandler returns an PostHandler that checks and set target
 // commission rate for msg create validator and msg edit validator
 func NewPostHandler(options HandlerOptions) (sdk.PostHandler, error) {
 	return sdk.ChainPostDecorators(
 		dyncommpost.NewDyncommPostDecorator(options.DyncommKeeper),
+		taxpost.NewTaxDecorator(options.TaxKeeper, options.BankKeeper, options.AccountKeeper, options.TreasuryKeeper),
 	), nil
 }

x/tax/handlers/wasm_msg_server.go

@@ -6,11 +6,8 @@ import (
 	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
 	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
 	taxkeeper "github.com/classic-terra/core/v3/x/tax/keeper"
-	taxtypes "github.com/classic-terra/core/v3/x/tax/types"
 	treasurykeeper "github.com/classic-terra/core/v3/x/treasury/keeper"
 	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
-
-	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
 // THIS FILE IS NOT USED CURRENTLY IN THE TAX MODULE
@@ -35,10 +32,10 @@ func NewWasmMsgServer(wasmKeeper wasmkeeper.Keeper, treasuryKeeper treasurykeepe
 	}
 }
 
-func (s *WasmMsgServer) WithContractValue(ctx sdk.Context, address sdk.AccAddress) sdk.Context {
+/*func (s *WasmMsgServer) WithContractValue(ctx sdk.Context, address sdk.AccAddress) sdk.Context {
 	balance := s.bankKeeper.GetAllBalances(ctx, address)
 	return ctx.WithValue(taxtypes.ContextKeyWasmFunds, balance)
-}
+}*/
 
 // ExecuteContract handles MsgExecuteContract with tax deduction
 func (s *WasmMsgServer) ExecuteContract(ctx context.Context, msg *wasmtypes.MsgExecuteContract) (*wasmtypes.MsgExecuteContractResponse, error) {

x/tax/types/keys.go

@@ -7,8 +7,8 @@ const (
 	RouterKey = ModuleName
 
 	ContextKeyTaxReverseCharge = "tax.reverse_charge"
-	ContextKeyWasmFunds        = "tax.wasm_funds"
-	ContextKeyWasmBalance      = "tax.wasm_balance"
+	ContextKeyTaxDue           = "tax.due"
+	ContextKeyTaxPayer         = "tax.payer"
 
 	EventTypeTax                  = "tax_payment"
 	AttributeKeyReverseCharge     = "reverse_charge"