[protocol] split gas fee and burn base fee

action/actctx.go

@@ -75,6 +75,24 @@ func (act *AbstractAction) GasFeeCap() *big.Int {
 	return new(big.Int).Set(act.gasFeeCap)
 }
 
+// EffectiveGas returns the effective gas
+func (act *AbstractAction) EffectiveGas(baseFee *big.Int) (*big.Int, error) {
+	tip := act.GasTipCap()
+	if baseFee == nil {
+		return tip, nil
+	}
+	effectiveGas := act.GasFeeCap()
+	effectiveGas.Sub(effectiveGas, baseFee)
+	if effectiveGas.Sign() < 0 {
+		return effectiveGas, ErrGasFeeCapTooLow
+	}
+	// effective gas = min(tip, feeCap - baseFee)
+	if effectiveGas.Cmp(tip) <= 0 {
+		return effectiveGas, nil
+	}
+	return tip, nil
+}
+
 // BasicActionSize returns the basic size of action
 func (act *AbstractAction) BasicActionSize() uint32 {
 	// VersionSizeInBytes + NonceSizeInBytes + GasSizeInBytes

action/const.go

@@ -26,6 +26,7 @@ var (
 	ErrNonceTooLow        = errors.New("nonce too low")
 	ErrUnderpriced        = errors.New("transaction underpriced")
 	ErrNegativeValue      = errors.New("negative value")
+	ErrGasFeeCapTooLow    = errors.New("fee cap less than base fee")
 	ErrIntrinsicGas       = errors.New("intrinsic gas too low")
 	ErrInsufficientFunds  = errors.New("insufficient funds for gas * price + value")
 	ErrNonceTooHigh       = errors.New("nonce too high")

action/protocol/account/protocol.go

@@ -28,14 +28,14 @@ const protocolID = "account"
 // Protocol defines the protocol of handling account
 type Protocol struct {
 	addr       address.Address
-	depositGas DepositGas
+	depositGas DepositGasAndBurn
 }
 
 // DepositGas deposits gas to some pool
-type DepositGas func(ctx context.Context, sm protocol.StateManager, amount *big.Int) (*action.TransactionLog, error)
+type DepositGasAndBurn func(ctx context.Context, sm protocol.StateManager, priorityFee, baseFee *big.Int) ([]*action.TransactionLog, error)
 
 // NewProtocol instantiates the protocol of account
-func NewProtocol(depositGas DepositGas) *Protocol {
+func NewProtocol(depositGas DepositGasAndBurn) *Protocol {
 	h := hash.Hash160b([]byte(protocolID))
 	addr, err := address.FromBytes(h[:])
 	if err != nil {

action/protocol/account/protocol_test.go

@@ -139,7 +139,7 @@ func TestProtocol_Initialize(t *testing.T) {
 		BlockHeight: 0,
 	})
 	ctx = protocol.WithFeatureCtx(genesis.WithGenesisContext(ctx, ge))
-	p := NewProtocol(rewarding.DepositGas)
+	p := NewProtocol(rewarding.DepositGasAndBurn)
 	require.NoError(
 		p.CreateGenesisStates(
 			ctx,
@@ -164,7 +164,7 @@ func TestProtocol_Initialize(t *testing.T) {
 func TestRegisterOrForceRegister(t *testing.T) {
 	require := require.New(t)
 
-	p := NewProtocol(rewarding.DepositGas)
+	p := NewProtocol(rewarding.DepositGasAndBurn)
 	require.Equal(protocolID, p.Name())
 
 	registry := protocol.NewRegistry()
@@ -185,7 +185,7 @@ func TestRegisterOrForceRegister(t *testing.T) {
 func TestAssertZeroBlockHeight(t *testing.T) {
 	require := require.New(t)
 
-	p := NewProtocol(rewarding.DepositGas)
+	p := NewProtocol(rewarding.DepositGasAndBurn)
 	require.NoError(p.assertZeroBlockHeight(0))
 	// should return an error if height is not zero
 	require.Error(p.assertZeroBlockHeight(1))
@@ -194,7 +194,7 @@ func TestAssertZeroBlockHeight(t *testing.T) {
 func TestAssertAmountsAndEqualLength(t *testing.T) {
 	require := require.New(t)
 
-	p := NewProtocol(rewarding.DepositGas)
+	p := NewProtocol(rewarding.DepositGasAndBurn)
 	amounts := []*big.Int{
 		big.NewInt(0),
 		big.NewInt(1),

action/protocol/account/transfer.go

@@ -39,25 +39,32 @@ func (p *Protocol) handleTransfer(ctx context.Context, tsf *action.Transfer, sm
 		return nil, errors.Wrapf(err, "failed to load or create the account of sender %s", actionCtx.Caller.String())
 	}
 
-	gasFee := big.NewInt(0).Mul(tsf.GasPrice(), big.NewInt(0).SetUint64(actionCtx.IntrinsicGas))
-	if !sender.HasSufficientBalance(big.NewInt(0).Add(tsf.Amount(), gasFee)) {
+	gasFee, baseFee, err := protocol.SplitGas(ctx, tsf.AbstractAction)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to split gas")
+	}
+	total := big.NewInt(0).Add(tsf.Amount(), gasFee)
+	if baseFee != nil {
+		total.Add(total, baseFee)
+	}
+	if !sender.HasSufficientBalance(total) {
 		return nil, errors.Wrapf(
 			state.ErrNotEnoughBalance,
 			"sender %s balance %s, required amount %s",
 			actionCtx.Caller.String(),
 			sender.Balance,
-			big.NewInt(0).Add(tsf.Amount(), gasFee),
+			total,
 		)
 	}
 
-	var depositLog *action.TransactionLog
+	var depositLog []*action.TransactionLog
 	if !fCtx.FixDoubleChargeGas {
 		// charge sender gas
 		if err := sender.SubBalance(gasFee); err != nil {
 			return nil, errors.Wrapf(err, "failed to charge the gas for sender %s", actionCtx.Caller.String())
 		}
 		if p.depositGas != nil {
-			depositLog, err = p.depositGas(ctx, sm, gasFee)
+			depositLog, err = p.depositGas(ctx, sm, gasFee, baseFee)
 			if err != nil {
 				return nil, err
 			}
@@ -91,7 +98,7 @@ func (p *Protocol) handleTransfer(ctx context.Context, tsf *action.Transfer, sm
 		}
 		if fCtx.FixDoubleChargeGas {
 			if p.depositGas != nil {
-				depositLog, err = p.depositGas(ctx, sm, gasFee)
+				depositLog, err = p.depositGas(ctx, sm, gasFee, baseFee)
 				if err != nil {
 					return nil, err
 				}
@@ -104,7 +111,7 @@ func (p *Protocol) handleTransfer(ctx context.Context, tsf *action.Transfer, sm
 			GasConsumed:     actionCtx.IntrinsicGas,
 			ContractAddress: p.addr.String(),
 		}
-		receipt.AddTransactionLogs(depositLog)
+		receipt.AddTransactionLogs(depositLog...)
 		return receipt, nil
 	}
 
@@ -133,7 +140,7 @@ func (p *Protocol) handleTransfer(ctx context.Context, tsf *action.Transfer, sm
 
 	if fCtx.FixDoubleChargeGas {
 		if p.depositGas != nil {
-			depositLog, err = p.depositGas(ctx, sm, gasFee)
+			depositLog, err = p.depositGas(ctx, sm, gasFee, baseFee)
 			if err != nil {
 				return nil, err
 			}
@@ -152,7 +159,8 @@ func (p *Protocol) handleTransfer(ctx context.Context, tsf *action.Transfer, sm
 		Sender:    actionCtx.Caller.String(),
 		Recipient: tsf.Recipient(),
 		Amount:    tsf.Amount(),
-	}, depositLog)
+	})
+	receipt.AddTransactionLogs(depositLog...)
 
 	return receipt, nil
 }

action/protocol/account/transfer_test.go

@@ -31,7 +31,7 @@ import (
 
 func TestProtocol_ValidateTransfer(t *testing.T) {
 	require := require.New(t)
-	p := NewProtocol(rewarding.DepositGas)
+	p := NewProtocol(rewarding.DepositGasAndBurn)
 	t.Run("invalid transfer", func(t *testing.T) {
 		tsf, err := action.NewTransfer(uint64(1), big.NewInt(1), "2", make([]byte, 32683), uint64(0), big.NewInt(0))
 		require.NoError(err)
@@ -60,7 +60,7 @@ func TestProtocol_HandleTransfer(t *testing.T) {
 	sm := testdb.NewMockStateManager(ctrl)
 
 	// set-up protocol and genesis states
-	p := NewProtocol(rewarding.DepositGas)
+	p := NewProtocol(rewarding.DepositGasAndBurn)
 	reward := rewarding.NewProtocol(genesis.Default.Rewarding)
 	registry := protocol.NewRegistry()
 	require.NoError(reward.Register(registry))
@@ -126,6 +126,9 @@ func TestProtocol_HandleTransfer(t *testing.T) {
 			Producer:    identityset.Address(27),
 			GasLimit:    testutil.TestGasLimit,
 		})
+		ctx = protocol.WithBlockchainCtx(ctx, protocol.BlockchainCtx{
+			Tip: protocol.TipInfo{},
+		})
 
 		sender, err := accountutil.AccountState(ctx, sm, v.caller)
 		require.NoError(err)

action/protocol/execution/protocol_test.go

@@ -447,7 +447,7 @@ func (sct *SmartContractTest) prepareBlockchain(
 		cfg.Genesis.InitBalanceMap[expectedBalance.Account] = expectedBalance.Balance().String()
 	}
 	registry := protocol.NewRegistry()
-	acc := account.NewProtocol(rewarding.DepositGas)
+	acc := account.NewProtocol(rewarding.DepositGasAndBurn)
 	r.NoError(acc.Register(registry))
 	rp := rolldpos.NewProtocol(cfg.Genesis.NumCandidateDelegates, cfg.Genesis.NumDelegates, cfg.Genesis.NumSubEpochs)
 	r.NoError(rp.Register(registry))
@@ -703,7 +703,7 @@ func TestProtocol_Handle(t *testing.T) {
 		ctx := genesis.WithGenesisContext(context.Background(), cfg.Genesis)
 
 		registry := protocol.NewRegistry()
-		acc := account.NewProtocol(rewarding.DepositGas)
+		acc := account.NewProtocol(rewarding.DepositGasAndBurn)
 		require.NoError(acc.Register(registry))
 		rp := rolldpos.NewProtocol(cfg.Genesis.NumCandidateDelegates, cfg.Genesis.NumDelegates, cfg.Genesis.NumSubEpochs)
 		require.NoError(rp.Register(registry))

action/protocol/protocol.go

@@ -7,6 +7,7 @@ package protocol
 
 import (
 	"context"
+	"math/big"
 
 	"github.com/iotexproject/go-pkgs/hash"
 	"github.com/iotexproject/iotex-address/address"
@@ -102,3 +103,24 @@ func HashStringToAddress(str string) address.Address {
 	}
 	return addr
 }
+
+func SplitGas(ctx context.Context, tx action.AbstractAction) (*big.Int, *big.Int, error) {
+	var (
+		bcCtx     = MustGetBlockchainCtx(ctx)
+		baseFee   = bcCtx.Tip.BaseFee
+		actionCtx = MustGetActionCtx(ctx)
+		gas       = new(big.Int).SetUint64(actionCtx.IntrinsicGas)
+	)
+	priority, err := tx.EffectiveGas(baseFee)
+	if err != nil {
+		return nil, nil, err
+	}
+	if baseFee == nil {
+		return priority.Mul(priority, gas), nil, nil
+	}
+	// after enabling EIP-1559, fee is split into 2 parts
+	// priority fee goes to the rewarding pool (or block producer) as before
+	// base fee will be burnt
+	base := new(big.Int).Set(baseFee)
+	return priority.Mul(priority, gas), base.Mul(base, gas), nil
+}

action/protocol/rewarding/fund.go

@@ -98,6 +98,79 @@ func (p *Protocol) Deposit(
 	}, nil
 }
 
+func (p *Protocol) depositAndBurn(
+	ctx context.Context,
+	sm protocol.StateManager,
+	burnAddr address.Address,
+	amount, burnAmount *big.Int,
+	rewardLogType, burnLogType iotextypes.TransactionLogType,
+) ([]*action.TransactionLog, error) {
+	var (
+		actionCtx           = protocol.MustGetActionCtx(ctx)
+		fCtx                = protocol.MustGetFeatureCtx(ctx)
+		accountCreationOpts = []state.AccountCreationOption{}
+	)
+	if fCtx.CreateLegacyNonceAccount {
+		accountCreationOpts = append(accountCreationOpts, state.LegacyNonceAccountTypeOption())
+	}
+	// Subtract balance from caller
+	acc, err := accountutil.LoadAccount(sm, actionCtx.Caller, accountCreationOpts...)
+	if err != nil {
+		return nil, err
+	}
+	if err := acc.SubBalance(amount); err != nil {
+		return nil, err
+	}
+	if !isZero(burnAmount) {
+		if err := acc.SubBalance(burnAmount); err != nil {
+			return nil, err
+		}
+	}
+	if err := accountutil.StoreAccount(sm, actionCtx.Caller, acc); err != nil {
+		return nil, err
+	}
+	// Add balance to fund
+	var (
+		f    = fund{}
+		tLog = []*action.TransactionLog{
+			{
+				Type:      rewardLogType,
+				Sender:    actionCtx.Caller.String(),
+				Recipient: address.RewardingPoolAddr,
+				Amount:    amount,
+			},
+		}
+	)
+	if _, err := p.state(ctx, sm, _fundKey, &f); err != nil {
+		return nil, err
+	}
+	f.totalBalance.Add(f.totalBalance, amount)
+	f.unclaimedBalance.Add(f.unclaimedBalance, amount)
+	if !isZero(burnAmount) {
+		// add burnAmount to burnAddr
+		burn, err := accountutil.LoadAccount(sm, burnAddr, accountCreationOpts...)
+		if err != nil {
+			return nil, err
+		}
+		if err := burn.AddBalance(burnAmount); err != nil {
+			return nil, err
+		}
+		if err := accountutil.StoreAccount(sm, burnAddr, burn); err != nil {
+			return nil, err
+		}
+		tLog = append(tLog, &action.TransactionLog{
+			Type:      burnLogType,
+			Sender:    actionCtx.Caller.String(),
+			Recipient: burnAddr.String(),
+			Amount:    burnAmount,
+		})
+	}
+	if err := p.putState(ctx, sm, _fundKey, &f); err != nil {
+		return nil, err
+	}
+	return tLog, nil
+}
+
 // TotalBalance returns the total balance of the rewarding fund
 func (p *Protocol) TotalBalance(
 	ctx context.Context,
@@ -146,3 +219,29 @@ func DepositGas(ctx context.Context, sm protocol.StateManager, amount *big.Int)
 	}
 	return rp.Deposit(ctx, sm, amount, iotextypes.TransactionLogType_GAS_FEE)
 }
+
+// DepositGasAndBurn deposits gas into the rewarding fund and burns the base fee
+func DepositGasAndBurn(ctx context.Context, sm protocol.StateManager, amount, baseFee *big.Int) ([]*action.TransactionLog, error) {
+	// If the gas fee is 0, return immediately
+	if amount.Cmp(big.NewInt(0)) == 0 {
+		return nil, nil
+	}
+	blkCtx := protocol.MustGetBlockCtx(ctx)
+	if blkCtx.BlockHeight == 0 {
+		return nil, nil
+	}
+	reg, ok := protocol.GetRegistry(ctx)
+	if !ok {
+		return nil, nil
+	}
+	rp := FindProtocol(reg)
+	if rp == nil {
+		return nil, nil
+	}
+	burn, _ := address.FromString(address.ZeroAddress)
+	return rp.depositAndBurn(ctx, sm, burn, amount, baseFee, iotextypes.TransactionLogType_GAS_FEE, iotextypes.TransactionLogType_NATIVE_TRANSFER)
+}
+
+func isZero(a *big.Int) bool {
+	return a == nil || len(a.Bytes()) == 0
+}

action/protocol/rewarding/protocol_test.go

@@ -165,7 +165,7 @@ func testProtocol(t *testing.T, test func(*testing.T, context.Context, protocol.
 	)
 	ctx = genesis.WithGenesisContext(ctx, g)
 	ctx = protocol.WithFeatureCtx(ctx)
-	ap := account.NewProtocol(DepositGas)
+	ap := account.NewProtocol(DepositGasAndBurn)
 	require.NoError(t, ap.Register(registry))
 	require.NoError(t, ap.CreateGenesisStates(ctx, sm))
 	require.NoError(t, p.CreateGenesisStates(ctx, sm))
@@ -348,7 +348,7 @@ func TestProtocol_Handle(t *testing.T) {
 
 	ctx = genesis.WithGenesisContext(protocol.WithRegistry(ctx, registry), g)
 	ctx = protocol.WithFeatureCtx(ctx)
-	ap := account.NewProtocol(DepositGas)
+	ap := account.NewProtocol(DepositGasAndBurn)
 	require.NoError(t, ap.Register(registry))
 	require.NoError(t, ap.CreateGenesisStates(ctx, sm))
 	require.NoError(t, p.CreateGenesisStates(ctx, sm))

action/protocol/rewarding/reward_test.go

@@ -411,7 +411,7 @@ func TestProtocol_NoRewardAddr(t *testing.T) {
 		},
 	)
 	ctx = protocol.WithFeatureCtx(ctx)
-	ap := account.NewProtocol(DepositGas)
+	ap := account.NewProtocol(DepositGasAndBurn)
 	require.NoError(t, ap.CreateGenesisStates(ctx, sm))
 	require.NoError(t, p.CreateGenesisStates(ctx, sm))
 	ctx = protocol.WithBlockchainCtx(

actpool/actpool_test.go

@@ -88,7 +88,7 @@ func TestValidate(t *testing.T) {
 	g := genesis.Default
 	g.InitBalanceMap[_addr1] = "100"
 	re := protocol.NewRegistry()
-	acc := account.NewProtocol(rewarding.DepositGas)
+	acc := account.NewProtocol(rewarding.DepositGasAndBurn)
 	require.NoError(acc.Register(re))
 	ctx := genesis.WithGenesisContext(
 		protocol.WithRegistry(context.Background(), re),

api/serverV2_integrity_test.go

@@ -337,7 +337,7 @@ func setupChain(cfg testConfig) (blockchain.Blockchain, blockdao.BlockDAO, block
 		testutil.CleanupPath(testPath)
 	}()
 
-	acc := account.NewProtocol(rewarding.DepositGas)
+	acc := account.NewProtocol(rewarding.DepositGasAndBurn)
 	evm := execution.NewProtocol(dao.GetBlockHash, rewarding.DepositGas, func(u uint64) (time.Time, error) { return time.Time{}, nil })
 	p := poll.NewLifeLongDelegatesProtocol(cfg.genesis.Delegates)
 	rolldposProtocol := rolldpos.NewProtocol(