Implement alt token fee

.gitignore

@@ -48,3 +48,4 @@ profile.cov
 
 **/yarn-error.log
 /build/db*/
+local-test

accounts/abi/bind/backends/simulated.go

@@ -918,6 +918,8 @@ func (m callMsg) IsL1MessageTx() bool          { return false }
 func (m callMsg) SetCodeAuthorizations() []types.SetCodeAuthorization {
 	return m.CallMsg.AuthorizationList
 }
+func (m callMsg) FeeTokenID() uint16 { return m.CallMsg.FeeTokenID }
+func (m callMsg) FeeLimit() *big.Int { return m.CallMsg.FeeLimit }
 
 // filterBackend implements filters.Backend to support filtering for logs without
 // taking bloom-bits acceleration structures into account.

accounts/abi/bind/base.go

@@ -57,6 +57,9 @@ type TransactOpts struct {
 	GasTipCap *big.Int // Gas priority fee cap to use for the 1559 transaction execution (nil = gas price oracle)
 	GasLimit  uint64   // Gas limit to set for the transaction execution (0 = estimate)
 
+	FeeTokenID uint16   // alt fee token id of transaction execution
+	FeeLimit   *big.Int // alt fee token limit of transaction execution
+
 	Context context.Context // Network context to support cancellation and timeouts (nil = no timeout)
 
 	NoSend bool // Do all transact steps but do not send the transaction
@@ -287,6 +290,64 @@ func (c *BoundContract) createDynamicTx(opts *TransactOpts, contract *common.Add
 	return types.NewTx(baseTx), nil
 }
 
+func (c *BoundContract) createAltFeeTx(opts *TransactOpts, contract *common.Address, input []byte, head *types.Header) (*types.Transaction, error) {
+	// Normalize value
+	value := opts.Value
+	if value == nil {
+		value = new(big.Int)
+	}
+	// Estimate TipCap
+	gasTipCap := opts.GasTipCap
+	if gasTipCap == nil {
+		tip, err := c.transactor.SuggestGasTipCap(ensureContext(opts.Context))
+		if err != nil {
+			return nil, err
+		}
+		gasTipCap = tip
+	}
+	// Estimate FeeCap
+	gasFeeCap := opts.GasFeeCap
+	if gasFeeCap == nil {
+		if head.BaseFee != nil {
+			gasFeeCap = new(big.Int).Add(
+				gasTipCap,
+				new(big.Int).Mul(head.BaseFee, big.NewInt(2)),
+			)
+		} else {
+			gasFeeCap = new(big.Int).Set(gasTipCap)
+		}
+	}
+	if gasFeeCap.Cmp(gasTipCap) < 0 {
+		return nil, fmt.Errorf("maxFeePerGas (%v) < maxPriorityFeePerGas (%v)", gasFeeCap, gasTipCap)
+	}
+	// Estimate GasLimit
+	gasLimit := opts.GasLimit
+	if opts.GasLimit == 0 {
+		var err error
+		gasLimit, err = c.estimateGasLimit(opts, contract, input, nil, gasTipCap, gasFeeCap, value)
+		if err != nil {
+			return nil, err
+		}
+	}
+	// create the transaction
+	nonce, err := c.getNonce(opts)
+	if err != nil {
+		return nil, err
+	}
+	baseTx := &types.AltFeeTx{
+		To:         contract,
+		Nonce:      nonce,
+		GasFeeCap:  gasFeeCap,
+		GasTipCap:  gasTipCap,
+		FeeTokenID: opts.FeeTokenID,
+		FeeLimit:   opts.FeeLimit,
+		Gas:        gasLimit,
+		Value:      value,
+		Data:       input,
+	}
+	return types.NewTx(baseTx), nil
+}
+
 func (c *BoundContract) createLegacyTx(opts *TransactOpts, contract *common.Address, input []byte) (*types.Transaction, error) {
 	if opts.GasFeeCap != nil || opts.GasTipCap != nil {
 		return nil, errors.New("maxFeePerGas or maxPriorityFeePerGas specified but curie is not active yet")
@@ -377,7 +438,11 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 		if head, errHead := c.transactor.HeaderByNumber(ensureContext(opts.Context), nil); errHead != nil {
 			return nil, errHead
 		} else if head.BaseFee != nil {
-			rawTx, err = c.createDynamicTx(opts, contract, input, head)
+			if opts.FeeTokenID != 0 {
+				rawTx, err = c.createAltFeeTx(opts, contract, input, head)
+			} else {
+				rawTx, err = c.createDynamicTx(opts, contract, input, head)
+			}
 		} else {
 			// Chain is not London ready -> use legacy transaction
 			rawTx, err = c.createLegacyTx(opts, contract, input)

accounts/external/backend.go

@@ -221,6 +221,12 @@ func (api *ExternalSigner) SignTx(account accounts.Account, tx *types.Transactio
 	case types.DynamicFeeTxType, types.SetCodeTxType:
 		args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
 		args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
+	case types.AltFeeTxType:
+		args.MaxFeePerGas = (*hexutil.Big)(tx.GasFeeCap())
+		args.MaxPriorityFeePerGas = (*hexutil.Big)(tx.GasTipCap())
+		feeTokenID := hexutil.Uint64(tx.FeeTokenID())
+		args.FeeTokenID = &feeTokenID
+		args.FeeLimit = (*hexutil.Big)(tx.FeeLimit())
 	default:
 		return nil, fmt.Errorf("unsupported tx type %d", tx.Type())
 	}

cmd/evm/internal/t8ntool/execution.go

@@ -207,6 +207,13 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 			receipt.TxHash = tx.Hash()
 			receipt.GasUsed = msgResult.UsedGas
 			receipt.L1Fee = msgResult.L1DataFee
+			if msg.FeeTokenID() != 0 {
+				tokenID := msg.FeeTokenID()
+				receipt.FeeTokenID = &tokenID
+				receipt.FeeLimit = msg.FeeLimit()
+				receipt.FeeRate = msgResult.FeeRate
+				receipt.TokenScale = msgResult.TokenScale
+			}
 
 			// If the transaction created a contract, store the creation address in the receipt.
 			if msg.To() == nil {

core/error.go

@@ -77,6 +77,11 @@ var (
 	// is higher than the balance of the user's account.
 	ErrInsufficientFunds = errors.New("insufficient funds for gas * price + value")
 
+	// ErrInsufficientValue is returned tx value
+	ErrInsufficientValue = errors.New("insufficient funds for value")
+
+	ErrInsufficientGasFee = errors.New("insufficient funds for gas * price + l1Fee")
+
 	// ErrGasUintOverflow is returned when calculating gas usage.
 	ErrGasUintOverflow = errors.New("gas uint64 overflow")
 

core/state_processor.go

@@ -192,6 +192,14 @@ func ApplyTransactionWithEVM(msg Message, config *params.ChainConfig, gp *GasPoo
 	receipt.BlockNumber = blockNumber
 	receipt.TransactionIndex = uint(statedb.TxIndex())
 	receipt.L1Fee = result.L1DataFee
+	if tx.IsAltFeeTx() {
+		tokenID := tx.FeeTokenID()
+		receipt.FeeTokenID = &tokenID
+		receipt.FeeLimit = tx.FeeLimit()
+		receipt.FeeRate = result.FeeRate
+		receipt.TokenScale = result.TokenScale
+	}
+
 	return receipt, err
 }
 

core/state_transition.go

@@ -17,8 +17,10 @@
 package core
 
 import (
+	"bytes"
+	"errors"
 	"fmt"
-	"math"
+	math "math"
 	"math/big"
 	"time"
 
@@ -31,6 +33,7 @@ import (
 	"github.com/morph-l2/go-ethereum/log"
 	"github.com/morph-l2/go-ethereum/metrics"
 	"github.com/morph-l2/go-ethereum/params"
+	"github.com/morph-l2/go-ethereum/rollup/fees"
 )
 
 var emptyKeccakCodeHash = codehash.EmptyKeccakCodeHash
@@ -73,6 +76,9 @@ type StateTransition struct {
 	evm        *vm.EVM
 
 	l1DataFee *big.Int
+
+	feeRate    *big.Int
+	tokenScale *big.Int
 }
 
 // Message represents a message sent to a contract.
@@ -92,12 +98,16 @@ type Message interface {
 	AccessList() types.AccessList
 	IsL1MessageTx() bool
 	SetCodeAuthorizations() []types.SetCodeAuthorization
+	FeeTokenID() uint16
+	FeeLimit() *big.Int
 }
 
 // ExecutionResult includes all output after executing given evm
 // message no matter the execution itself is successful or not.
 type ExecutionResult struct {
 	L1DataFee  *big.Int
+	FeeRate    *big.Int
+	TokenScale *big.Int
 	UsedGas    uint64 // Total used gas but include the refunded gas
 	Err        error  // Any error encountered during the execution(listed in core/vm/errors.go)
 	ReturnData []byte // Returned data from evm(function result or data supplied with revert opcode)
@@ -219,7 +229,6 @@ func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool, l1DataFee *big.Int) (*E
 	defer func(t time.Time) {
 		stateTransitionApplyMessageTimer.Update(time.Since(t))
 	}(time.Now())
-
 	return NewStateTransition(evm, msg, gp, l1DataFee).TransitionDb()
 }
 
@@ -275,6 +284,76 @@ func (st *StateTransition) buyGas() error {
 	return nil
 }
 
+// buyAltTokenGas handles gas payment using alternative tokens (ERC20, etc.)
+func (st *StateTransition) buyAltTokenGas() error {
+	// Calculate the total ETH fee needed
+	mgval := new(big.Int).SetUint64(st.msg.Gas())
+	mgval = mgval.Mul(mgval, st.gasPrice)
+
+	if !st.evm.ChainConfig().Morph.FeeVaultEnabled() {
+		return errors.New("tx need fee vault enable")
+	}
+
+	log.Debug("Adding L1DataFee for alt token gas payment", "l1DataFee", st.l1DataFee)
+	mgval = mgval.Add(mgval, st.l1DataFee)
+
+	// Check value
+	if have, want := st.state.GetBalance(st.msg.From()), st.value; have.Cmp(want) < 0 {
+		return fmt.Errorf("%w: address %v  have %v want %v", ErrInsufficientValue, st.msg.From().Hex(), have.String(), want.String())
+	}
+	// Check alt token balance
+	tokenInfo, tokenBalance, err := st.GetAltTokenBalanceHybrid(st.msg.FeeTokenID(), st.msg.From())
+	if err != nil {
+		return fmt.Errorf("failed to get alt token balance: %v", err)
+	}
+	log.Debug("Alt token gas payment calculation",
+		"tokenID", st.msg.FeeTokenID(),
+		"tokenAddress", tokenInfo.TokenAddress.Hex(),
+		"fee", mgval,
+	)
+
+	tokenFee := types.EthToAlt(mgval, st.feeRate, st.tokenScale)
+	feeLimit := tokenBalance
+	if st.msg.FeeLimit() != nil && st.msg.FeeLimit().Sign() > 0 {
+		feeLimit = cmath.BigMin(tokenBalance, st.msg.FeeLimit())
+	}
+	if feeLimit.Cmp(tokenFee) < 0 {
+		return fmt.Errorf("%w: address %v has insufficient token balance or fee limit, have %v need %v (token %s)",
+			ErrInsufficientGasFee, st.msg.From().Hex(), feeLimit, mgval, tokenInfo.TokenAddress.Hex())
+	}
+
+	// Check gas pool
+	if err := st.gp.SubGas(st.msg.Gas()); err != nil {
+		return err
+	}
+
+	// Transfer alt tokens from user to fee vault
+	feeVaultAddress := st.evm.ChainConfig().Morph.FeeVaultAddress
+	if feeVaultAddress == nil || bytes.Equal(feeVaultAddress.Bytes(), common.Address{}.Bytes()) {
+		return fmt.Errorf("fee vault address is not configured")
+	}
+	if err := st.TransferAltTokenHybrid(tokenInfo.TokenAddress, st.msg.From(), *feeVaultAddress, tokenFee, tokenInfo.BalanceSlot, tokenBalance); err != nil {
+		return fmt.Errorf("failed to transfer alt tokens for gas payment: %v", err)
+	}
+
+	if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil {
+		st.evm.Config.Tracer.OnGasChange(0, st.msg.Gas(), tracing.GasChangeTxInitialBalance)
+	}
+
+	st.gas += st.msg.Gas()
+	st.initialGas = st.msg.Gas()
+
+	log.Debug("Alt token gas payment successful",
+		"tokenID", st.msg.FeeTokenID(),
+		"tokenAddress", tokenInfo.TokenAddress.String(),
+		"from", st.msg.From().String(),
+		"amount", mgval,
+		"tokenAmount", tokenFee,
+		"feeVault", feeVaultAddress.String())
+
+	return nil
+}
+
 func (st *StateTransition) preCheck() error {
 	if st.msg.IsL1MessageTx() {
 		// No fee fields to check, no nonce to check, and no need to check if EOA (L1 already verified it for us)
@@ -343,6 +422,26 @@ func (st *StateTransition) preCheck() error {
 			return fmt.Errorf("%w (sender %v)", ErrEmptyAuthList, st.msg.From())
 		}
 	}
+
+	if st.msg.FeeTokenID() != 0 {
+		active, err := fees.IsTokenActive(st.state, st.msg.FeeTokenID())
+		if err != nil {
+			return fmt.Errorf("get token status failed %v", err)
+		}
+		if !active {
+			return fmt.Errorf("token %v not active", st.msg.FeeTokenID())
+		}
+		feeRate, tokenScale, err := fees.TokenRate(st.state, st.msg.FeeTokenID())
+		if err != nil {
+			return fmt.Errorf("get token rate failed %v", err)
+		}
+		if feeRate == nil || tokenScale == nil || feeRate.Sign() <= 0 || tokenScale.Sign() <= 0 {
+			return fmt.Errorf("token rate or scale is nil")
+		}
+		st.feeRate = feeRate
+		st.tokenScale = tokenScale
+		return st.buyAltTokenGas()
+	}
 	return st.buyGas()
 }
 
@@ -474,19 +573,26 @@ func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
 	// The L2 Fee is the same as the fee that is charged in the normal geth
 	// codepath. Add the L1DataFee to the L2 fee for the total fee that is sent
 	// to the sequencer.
-	l2Fee := new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), effectiveTip)
-	fee := l2Fee
-	if st.evm.ChainConfig().Morph.FeeVaultEnabled() {
-		fee = new(big.Int).Add(st.l1DataFee, l2Fee)
+	if st.msg.FeeTokenID() == 0 {
+		l2Fee := new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), effectiveTip)
+		fee := l2Fee
+		if st.evm.ChainConfig().Morph.FeeVaultEnabled() {
+			fee = new(big.Int).Add(st.l1DataFee, l2Fee)
+		}
+		st.state.AddBalance(st.evm.FeeRecipient(), fee, tracing.BalanceIncreaseRewardTransactionFee)
 	}
-	st.state.AddBalance(st.evm.FeeRecipient(), fee, tracing.BalanceIncreaseRewardTransactionFee)
 
-	return &ExecutionResult{
+	result := &ExecutionResult{
 		L1DataFee:  st.l1DataFee,
 		UsedGas:    st.gasUsed(),
 		Err:        vmerr,
 		ReturnData: ret,
-	}, nil
+	}
+	if st.msg.FeeTokenID() != 0 {
+		result.FeeRate = st.feeRate
+		result.TokenScale = st.tokenScale
+	}
+	return result, nil
 }
 
 // validateAuthorization validates an EIP-7702 authorization against the state.
@@ -559,17 +665,40 @@ func (st *StateTransition) refundGas(refundQuotient uint64) {
 	}
 	st.gas += refund
 
+	// Return remaining gas to the block gas counter at the end, regardless of refund success
+	defer func() {
+		if st.gas > 0 {
+			st.gp.AddGas(st.gas)
+		}
+	}()
+
 	// Return ETH for remaining gas, exchanged at the original rate.
 	remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice)
-	st.state.AddBalance(st.msg.From(), remaining, tracing.BalanceIncreaseGasReturn)
+	if st.msg.FeeTokenID() != 0 {
+		tokenInfo, err := fees.GetTokenInfo(st.state, st.msg.FeeTokenID())
+		if err != nil {
+			log.Error("Failed to get token info for gas refund", "tokenID", st.msg.FeeTokenID(), "error", err)
+			return
+		}
+		tokenAmount := types.EthToAlt(remaining, st.feeRate, st.tokenScale)
+		if err = st.TransferAltTokenHybrid(
+			tokenInfo.TokenAddress,
+			*st.evm.ChainConfig().Morph.FeeVaultAddress,
+			st.msg.From(),
+			tokenAmount,
+			tokenInfo.BalanceSlot,
+			nil,
+		); err != nil {
+			log.Error("Failed to refund alt token gas", "tokenID", st.msg.FeeTokenID(), "tokenAddress", tokenInfo.TokenAddress.Hex(), "amount", tokenAmount, "error", err)
+			// Continue execution even if refund fails - refund should not cause transaction to fail
+		}
+	} else {
+		st.state.AddBalance(st.msg.From(), remaining, tracing.BalanceIncreaseGasReturn)
+	}
 
 	if st.evm.Config.Tracer != nil && st.evm.Config.Tracer.OnGasChange != nil && st.gas > 0 {
 		st.evm.Config.Tracer.OnGasChange(st.gas, 0, tracing.GasChangeTxLeftOverReturned)
 	}
-
-	// Also return remaining gas to the block gas counter so it is
-	// available for the next transaction.
-	st.gp.AddGas(st.gas)
 }
 
 // gasUsed returns the amount of gas used up by the state transition.