feat: added fee deduction in CEA -> smart contract route

Author: 0xNilesh

test/integration/uexecutor/inbound_cea_smart_contract_test.go

@@ -260,7 +260,13 @@ func TestInboundCEASmartContractRecipient(t *testing.T) {
 	})
 
 	t.Run("executeUniversalTx PCTx is recorded for smart contract recipient", func(t *testing.T) {
-		chainApp, ctx, vals, inbound, coreVals, _ := setupInboundCEASmartContractTest(t, 4)
+		chainApp, ctx, vals, inbound, coreVals, contractAddr := setupInboundCEASmartContractTest(t, 4)
+
+		// Fund the smart contract with upc so gas fee deduction succeeds
+		contractAccAddr := sdk.AccAddress(contractAddr.Bytes())
+		fundCoins := sdk.NewCoins(sdk.NewInt64Coin("upc", 1_000_000_000))
+		require.NoError(t, chainApp.BankKeeper.MintCoins(ctx, "mint", fundCoins))
+		require.NoError(t, chainApp.BankKeeper.SendCoinsFromModuleToAccount(ctx, "mint", contractAccAddr, fundCoins))
 
 		for i := 0; i < 3; i++ {
 			valAddr, err := sdk.ValAddressFromBech32(coreVals[i].OperatorAddress)
@@ -283,13 +289,51 @@ func TestInboundCEASmartContractRecipient(t *testing.T) {
 		require.Empty(t, callPcTx.ErrorMsg)
 	})
 
-	t.Run("EOA recipient receives deposit and executeUniversalTx call", func(t *testing.T) {
+	t.Run("gas fees deducted from smart contract recipient after executeUniversalTx", func(t *testing.T) {
+		chainApp, ctx, vals, inbound, coreVals, contractAddr := setupInboundCEASmartContractTest(t, 4)
+
+		// Fund the smart contract with upc so fee deduction can succeed
+		contractAccAddr := sdk.AccAddress(contractAddr.Bytes())
+		fundCoins := sdk.NewCoins(sdk.NewInt64Coin("upc", 1_000_000_000))
+		require.NoError(t, chainApp.BankKeeper.MintCoins(ctx, "mint", fundCoins))
+		require.NoError(t, chainApp.BankKeeper.SendCoinsFromModuleToAccount(ctx, "mint", contractAccAddr, fundCoins))
+
+		balanceBefore := chainApp.BankKeeper.GetBalance(ctx, contractAccAddr, "upc")
+
+		// Reach quorum
+		for i := 0; i < 3; i++ {
+			valAddr, err := sdk.ValAddressFromBech32(coreVals[i].OperatorAddress)
+			require.NoError(t, err)
+			coreValAcc := sdk.AccAddress(valAddr).String()
+
+			err = utils.ExecVoteInbound(t, ctx, chainApp, vals[i], coreValAcc, inbound)
+			require.NoError(t, err)
+		}
+
+		// Verify executeUniversalTx PCTx has gas_used > 0
+		utxKey := uexecutortypes.GetInboundUniversalTxKey(*inbound)
+		utx, found, err := chainApp.UexecutorKeeper.GetUniversalTx(ctx, utxKey)
+		require.NoError(t, err)
+		require.True(t, found)
+		require.GreaterOrEqual(t, len(utx.PcTx), 2, "should have deposit + executeUniversalTx PCTxs")
+
+		callPcTx := utx.PcTx[1]
+		require.Equal(t, "SUCCESS", callPcTx.Status)
+		require.Greater(t, callPcTx.GasUsed, uint64(0), "executeUniversalTx should report gas used")
+
+		// Verify upc balance decreased (gas was deducted)
+		balanceAfter := chainApp.BankKeeper.GetBalance(ctx, contractAccAddr, "upc")
+		require.True(t, balanceAfter.Amount.LT(balanceBefore.Amount),
+			"smart contract upc balance should decrease after gas fee deduction (before=%s, after=%s)",
+			balanceBefore.Amount, balanceAfter.Amount)
+	})
+
+	t.Run("EOA recipient receives deposit only, no executeUniversalTx", func(t *testing.T) {
 		chainApp, ctx, vals, _, coreVals, _ := setupInboundCEASmartContractTest(t, 4)
 		usdcAddress := utils.GetDefaultAddresses().ExternalUSDCAddr
 		testAddress := utils.GetDefaultAddresses().DefaultTestAddr
 
-		// TargetAddr2 is a plain EOA — deposit lands there and executeUniversalTx is called
-		// (calling to an EOA in EVM succeeds with empty output)
+		// TargetAddr2 is a plain EOA (no contract code deployed)
 		eoaRecipient := utils.GetDefaultAddresses().TargetAddr2
 
 		validUP := &uexecutortypes.UniversalPayload{
@@ -335,8 +379,15 @@ func TestInboundCEASmartContractRecipient(t *testing.T) {
 		require.NoError(t, err)
 		require.True(t, found)
 
-		// Expect 2 PCTxs: deposit + executeUniversalTx
-		require.GreaterOrEqual(t, len(utx.PcTx), 2, "should have deposit and executeUniversalTx PCTxs")
+		// EOA recipient: deposit PCTx only, no executeUniversalTx PCTx
+		// (code size check skips executeUniversalTx for EOAs, but payload execution via UEA may still run)
+		require.GreaterOrEqual(t, len(utx.PcTx), 1, "should have at least deposit PCTx for EOA recipient")
+
+		// Verify no executeUniversalTx-specific PCTx (the smart contract call path is skipped)
+		// The deposit PCTx should succeed
+		require.Equal(t, "SUCCESS", utx.PcTx[0].Status, "deposit should succeed for EOA recipient")
+
+		// No outbound should be created from executeUniversalTx (which was skipped)
 		require.Equal(t, "SUCCESS", utx.PcTx[0].Status, "deposit should succeed for EOA recipient")
 
 		// isCEA path never creates a revert outbound

x/uexecutor/keeper/execute_inbound_funds_and_payload.go

@@ -85,8 +85,13 @@ func (k Keeper) ExecuteInboundFundsAndPayload(ctx context.Context, utx types.Uni
 					}
 				}
 			} else {
-				// Non-UEA path (smart contract or EOA): deposit PRC20 and call executeUniversalTx
-				isSmartContract = true
+				// Non-UEA: check if recipient has code (smart contract) vs EOA
+				codeHash := k.evmKeeper.GetCodeHash(sdkCtx, ueaAddr)
+				if codeHash != types.EmptyCodeHash && codeHash != (common.Hash{}) {
+					// Smart contract: will call executeUniversalTx after deposit
+					isSmartContract = true
+				}
+				// EOA: just deposit, skip executeUniversalTx (no contract to call)
 				if inboundAmount.Sign() > 0 {
 					receipt, execErr = k.depositPRC20(
 						sdkCtx,
@@ -262,12 +267,20 @@ func (k Keeper) ExecuteInboundFundsAndPayload(ctx context.Context, utx types.Uni
 			BlockHeight: uint64(sdkCtx.BlockHeight()),
 			Status:      "FAILED",
 		}
+		if contractReceipt != nil {
+			callPcTx.TxHash = contractReceipt.Hash
+			callPcTx.GasUsed = contractReceipt.GasUsed
+		}
 		if contractErr != nil {
 			callPcTx.ErrorMsg = contractErr.Error()
 		} else {
-			callPcTx.TxHash = contractReceipt.Hash
-			callPcTx.GasUsed = contractReceipt.GasUsed
-			callPcTx.Status = "SUCCESS"
+			// Deduct gas fees from the recipient contract address
+			if feeErr := k.DeductGasFeesFromReceipt(ctx, sdkCtx, ueaAddr, contractReceipt, utx.InboundTx.UniversalPayload); feeErr != nil {
+				callPcTx.Status = "FAILED"
+				callPcTx.ErrorMsg = fmt.Sprintf("gas fee deduction failed: %s", feeErr.Error())
+			} else {
+				callPcTx.Status = "SUCCESS"
+			}
 		}
 		if updateErr := k.UpdateUniversalTx(ctx, universalTxKey, func(utx *types.UniversalTx) error {
 			utx.PcTx = append(utx.PcTx, &callPcTx)

x/uexecutor/keeper/execute_inbound_gas_and_payload.go

@@ -87,8 +87,12 @@ func (k Keeper) ExecuteInboundGasAndPayload(ctx context.Context, utx types.Unive
 							}
 						}
 					} else {
-						// Non-UEA path (smart contract or EOA): deposit + autoswap and call executeUniversalTx
-						isSmartContract = true
+						// Non-UEA: check if recipient has code (smart contract) vs EOA
+						codeHash := k.evmKeeper.GetCodeHash(sdkCtx, ueaAddr)
+						if codeHash != types.EmptyCodeHash && codeHash != (common.Hash{}) {
+							isSmartContract = true
+						}
+						// EOA: just deposit, skip executeUniversalTx
 						if amount.Sign() > 0 {
 							prc20AddrHex := common.HexToAddress(tokenConfig.NativeRepresentation.ContractAddress)
 							receipt, execErr = k.gasAndPayloadDepositAutoSwap(sdkCtx, prc20AddrHex, ueaAddr, amount)
@@ -261,12 +265,20 @@ func (k Keeper) ExecuteInboundGasAndPayload(ctx context.Context, utx types.Unive
 			BlockHeight: uint64(sdkCtx.BlockHeight()),
 			Status:      "FAILED",
 		}
+		if contractReceipt != nil {
+			callPcTx.TxHash = contractReceipt.Hash
+			callPcTx.GasUsed = contractReceipt.GasUsed
+		}
 		if contractErr != nil {
 			callPcTx.ErrorMsg = contractErr.Error()
 		} else if contractReceipt != nil {
-			callPcTx.TxHash = contractReceipt.Hash
-			callPcTx.GasUsed = contractReceipt.GasUsed
-			callPcTx.Status = "SUCCESS"
+			// Deduct gas fees from the recipient contract address
+			if feeErr := k.DeductGasFeesFromReceipt(ctx, sdkCtx, ueaAddr, contractReceipt, utx.InboundTx.UniversalPayload); feeErr != nil {
+				callPcTx.Status = "FAILED"
+				callPcTx.ErrorMsg = fmt.Sprintf("gas fee deduction failed: %s", feeErr.Error())
+			} else {
+				callPcTx.Status = "SUCCESS"
+			}
 		}
 		if updateErr := k.UpdateUniversalTx(ctx, universalTxKey, func(utx *types.UniversalTx) error {
 			utx.PcTx = append(utx.PcTx, &callPcTx)

x/uexecutor/keeper/execute_payload.go

@@ -2,11 +2,10 @@ package keeper
 
 import (
 	"context"
-	"math/big"
+	"fmt"
 
 	"cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkErrors "github.com/cosmos/cosmos-sdk/types/errors"
 	vmtypes "github.com/cosmos/evm/x/vm/types"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pushchain/push-chain-node/utils"
@@ -23,9 +22,8 @@ func (k Keeper) ExecutePayloadV2(ctx context.Context, evmFrom common.Address, ue
 		"from", evmFrom.Hex(),
 	)
 
-	// Step 1: Parse and validate payload and verificationData
-	payload, err := types.NewAbiUniversalPayload(universalPayload)
-	if err != nil {
+	// Step 1: Validate payload and verificationData early (fast-fail before EVM work)
+	if _, err := types.NewAbiUniversalPayload(universalPayload); err != nil {
 		return nil, errors.Wrapf(err, "invalid universal payload")
 	}
 
@@ -35,46 +33,23 @@ func (k Keeper) ExecutePayloadV2(ctx context.Context, evmFrom common.Address, ue
 	}
 
 	// Step 2: Execute payload through UEA
-	receipt, err := k.CallUEAExecutePayload(sdkCtx, evmFrom, ueaAddr, universalPayload, verificationDataVal)
-	if err != nil {
-		// Return receipt even on EVM revert so callers can capture the tx hash for debugging.
-		// DerivedEVMCall returns (receipt, error) on revert -- receipt.Hash is valid.
-		return receipt, err
-	}
-
-	gasUnitsUsed := receipt.GasUsed
-	gasUnitsUsedBig := new(big.Int).SetUint64(gasUnitsUsed)
-
-	k.Logger().Debug("payload executed via UEA",
-		"uea", ueaAddr.Hex(),
-		"tx_hash", receipt.Hash,
-		"gas_used", gasUnitsUsed,
-	)
+	receipt, execErr := k.CallUEAExecutePayload(sdkCtx, evmFrom, ueaAddr, universalPayload, verificationDataVal)
 
-	// Step 3: Handle fee calculation and deduction
-	ueaAccAddr := sdk.AccAddress(ueaAddr.Bytes())
-
-	baseFee := k.feemarketKeeper.GetBaseFee(sdkCtx)
-	if baseFee.IsNil() {
-		return nil, errors.Wrapf(sdkErrors.ErrLogic, "base fee not found")
-	}
-
-	gasCost, err := k.CalculateGasCost(baseFee, payload.MaxFeePerGas, payload.MaxPriorityFeePerGas, gasUnitsUsed)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to calculate gas cost")
+	// Step 3: Deduct gas fees regardless of success/failure.
+	// If deduction fails, return error so the caller records a FAILED PCTx.
+	// The receipt is still returned so callers can capture the tx hash.
+	if feeErr := k.DeductGasFeesFromReceipt(ctx, sdkCtx, ueaAddr, receipt, universalPayload); feeErr != nil {
+		return receipt, fmt.Errorf("gas fee deduction failed: %w", feeErr)
 	}
 
-	if gasUnitsUsedBig.Cmp(payload.GasLimit) > 0 {
-		return nil, errors.Wrapf(sdkErrors.ErrOutOfGas, "gas cost (%d) exceeds limit (%d)", gasCost, payload.GasLimit)
+	if execErr != nil {
+		return receipt, execErr
 	}
 
-	if err = k.DeductAndBurnFees(ctx, ueaAccAddr, gasCost); err != nil {
-		return nil, errors.Wrapf(err, "failed to deduct fees from %s", ueaAccAddr)
-	}
-
-	k.Logger().Debug("fees deducted for payload execution",
+	k.Logger().Debug("payload executed via UEA",
 		"uea", ueaAddr.Hex(),
-		"gas_cost", gasCost.String(),
+		"tx_hash", receipt.Hash,
+		"gas_used", receipt.GasUsed,
 	)
 
 	return receipt, nil

x/uexecutor/keeper/fees.go

@@ -7,6 +7,8 @@ import (
 
 	sdkmath "cosmossdk.io/math"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	evmtypes "github.com/cosmos/evm/x/vm/types"
+	"github.com/ethereum/go-ethereum/common"
 	pchaintypes "github.com/pushchain/push-chain-node/types"
 	"github.com/pushchain/push-chain-node/x/uexecutor/types"
 )
@@ -87,3 +89,60 @@ func (k Keeper) CalculateGasCost(
 
 	return gasCost, nil
 }
+
+// DeductGasFeesFromReceipt calculates and deducts gas fees from a recipient address
+// based on the EVM receipt and universal payload parameters.
+// Returns nil if receipt is nil (Go-level error, no EVM tx was created).
+// Returns error with gas details if deduction fails (insufficient balance, etc).
+func (k Keeper) DeductGasFeesFromReceipt(
+	ctx context.Context,
+	sdkCtx sdk.Context,
+	recipient common.Address,
+	receipt *evmtypes.MsgEthereumTxResponse,
+	universalPayload *types.UniversalPayload,
+) error {
+	if receipt == nil || receipt.GasUsed == 0 {
+		return nil
+	}
+	if universalPayload == nil {
+		return nil
+	}
+
+	abiPayload, err := types.NewAbiUniversalPayload(universalPayload)
+	if err != nil {
+		return fmt.Errorf("failed to parse payload for gas deduction: %w", err)
+	}
+
+	baseFee := k.feemarketKeeper.GetBaseFee(sdkCtx)
+	if baseFee.IsNil() {
+		return fmt.Errorf("base fee not found")
+	}
+
+	gasCost, err := k.CalculateGasCost(baseFee, abiPayload.MaxFeePerGas, abiPayload.MaxPriorityFeePerGas, receipt.GasUsed)
+	if err != nil {
+		return fmt.Errorf("failed to calculate gas cost: %w", err)
+	}
+	if gasCost.Sign() <= 0 {
+		return nil
+	}
+
+	gasUsedBig := new(big.Int).SetUint64(receipt.GasUsed)
+	if gasUsedBig.Cmp(abiPayload.GasLimit) > 0 {
+		return fmt.Errorf("gas used (%d) exceeds gas limit (%s)", receipt.GasUsed, abiPayload.GasLimit.String())
+	}
+
+	recipientAccAddr := sdk.AccAddress(recipient.Bytes())
+	balance := k.bankKeeper.GetBalance(sdkCtx, recipientAccAddr, pchaintypes.BaseDenom)
+
+	if err := k.DeductAndBurnFees(ctx, recipientAccAddr, gasCost); err != nil {
+		return fmt.Errorf("insufficient gas: required %s upc, available %s upc, gas_used %d, from %s: %w",
+			gasCost.String(), balance.Amount.String(), receipt.GasUsed, recipient.Hex(), err)
+	}
+
+	k.Logger().Debug("gas fees deducted",
+		"recipient", recipient.Hex(),
+		"gas_used", receipt.GasUsed,
+		"gas_cost", gasCost.String(),
+	)
+	return nil
+}