Merge pull request #413 from bane-labs/antimev-envelope-price

antimev: add envelope fee policy and check

Author: txhsl

antimev/envelope.go

@@ -40,15 +40,24 @@ var (
 // IsEnvelope checks whether a transaction is an Envelope transaction. The criteria
 // include receiver's address, data prefix and data length check.
 func IsEnvelope(tx *types.Transaction) bool {
-	if tx.To() == nil || *(tx.To()) != systemcontracts.GovernanceRewardProxyHash {
+	return IsEnvelopeToAddress(tx.To()) && IsEnvelopeData(tx.Data())
+}
+
+// IsEnvelopeToAddress checks whether an address pointer has the expected value for
+// Envelope To address.
+func IsEnvelopeToAddress(addr *common.Address) bool {
+	if addr == nil || *addr != systemcontracts.GovernanceRewardProxyHash {
 		return false
 	}
+	return true
+}
 
-	data := tx.Data()
+// IsEnvelopeData checks whether the input data bytes has the expected prefix for
+// Envelope specification.
+func IsEnvelopeData(data []byte) bool {
 	if len(data) < minEncryptedDataSize || !bytes.HasPrefix(data, EncryptedDataPrefix) {
 		return false
 	}
-
 	return true
 }
 

contracts/solidity/Policy.sol

@@ -17,6 +17,7 @@ contract Policy is IPolicy, GovernanceVote, GovProxyUpgradeable {
     uint256 public minGasTipCap;
     uint256 public baseFee;
     uint256 internal candidateLimit;
+    uint256 public envelopeFee;
 
     // Only for precompiled uups implementation in genesis file, need to be removed when upgrading the contract.
     // This override is added because "immutable __self" in UUPSUpgradeable is not avaliable in precompiled contract.
@@ -130,4 +131,21 @@ contract Policy is IPolicy, GovernanceVote, GovProxyUpgradeable {
         if (limit > 0) return limit;
         else return DEFAULT_CANDIDATE_LIMIT;
     }
+
+    function setEnvelopeFee(
+        uint256 _fee
+    )
+        external
+        needVote(
+            bytes32(
+                // keccak256("setEnvelopeFee")
+                0xab26bca1cb5d7b0a97ee434cabffdf1efbc3073c1645a8ed4d1732335c51df49
+            ),
+            keccak256(abi.encode(_fee))
+        )
+    {
+        if (_fee <= 0) revert Errors.InvalidEnvelopeFee();
+        envelopeFee = _fee;
+        emit SetEnvelopeFee(_fee);
+    }
 }

contracts/solidity/interfaces/IPolicy.sol

@@ -7,6 +7,7 @@ interface IPolicy {
     event SetMinGasTipCap(uint256 gasTipCap);
     event SetBaseFee(uint256 baseFee);
     event SetCandidateLimit(uint256 candidateLimit);
+    event SetEnvelopeFee(uint256 envelopeFee);
 
     // add an address to blacklist policy
     function addBlackList(address _addr) external;

contracts/solidity/libraries/Errors.sol

@@ -20,6 +20,7 @@ library Errors {
     error InvalidMinGasTipCap();
     error InvalidBaseFee();
     error InvalidCandidateLimit();
+    error InvalidEnvelopeFee();
 
     // Governance Errors
     error SideCallNotAllowed();

core/state_transition.go

@@ -21,6 +21,7 @@ import (
 	"math"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/antimev"
 	"github.com/ethereum/go-ethereum/common"
 	cmath "github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/systemcontracts"
@@ -328,9 +329,13 @@ func (st *StateTransition) preCheck() error {
 			// For LegacyTx, GasFeeCap and GasPrice are equal, so checking GasTipCap and GasFeeCap is enough.
 			if st.evm.ChainConfig().DBFT != nil {
 				var minGasTipCap = st.state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMinGasTipCapStateHash()).Big()
+				if antimev.IsEnvelopeToAddress(msg.To) && antimev.IsEnvelopeData(msg.Data) {
+					var envelopeFee = st.state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetEnvelopeFeeStateHash()).Big()
+					minGasTipCap.Add(minGasTipCap, envelopeFee)
+				}
 				if cmath.BigMin(msg.GasTipCap, new(big.Int).Sub(msg.GasFeeCap, st.evm.Context.BaseFee)).Cmp(minGasTipCap) < 0 {
-					return fmt.Errorf("%w: address %v, gasTipCap %v, gasFeeCap %v, policy minGasTipCap %v, baseFee %v ", ErrUnderpriced,
-						msg.From.Hex(), msg.GasTipCap, msg.GasFeeCap, minGasTipCap, st.evm.Context.BaseFee)
+					return fmt.Errorf("%w: address %v, gasTipCap %v, gasFeeCap %v, policy minGasTipCap (including Envelope fee for Envelopes) %v, baseFee %v ",
+						ErrUnderpriced, msg.From.Hex(), msg.GasTipCap, msg.GasFeeCap, minGasTipCap, st.evm.Context.BaseFee)
 				}
 			}
 		}

core/systemcontracts/contracts.go

@@ -24,6 +24,7 @@ const (
 const blackListSlotIndex = 1
 const minGasTipCapSlotIndex = 2
 const baseFeeSlotIndex = 3
+const envelopeFeeSlotIndex = 5
 
 // A set of genesis contract hashes.
 var (
@@ -95,3 +96,9 @@ func GetBaseFeeStateHash() common.Hash {
 func GetBlackListStateHash(addr common.Address) common.Hash {
 	return crypto.Keccak256Hash(common.LeftPadBytes(addr.Bytes(), 32), common.LeftPadBytes([]byte{blackListSlotIndex}, 32))
 }
+
+// GetEnvelopeFeeStateHash computes and returns the storage key of envelopeFee
+// in policy contract, for reading corresponding values from statedb.
+func GetEnvelopeFeeStateHash() common.Hash {
+	return common.BytesToHash([]byte{envelopeFeeSlotIndex})
+}

core/txpool/validation.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/antimev"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core"
@@ -215,8 +216,13 @@ func ValidateTransactionWithState(tx *types.Transaction, signer types.Signer, op
 	// For LegacyTx, GasFeeCap and GasPrice are equal, so checking GasTipCap and GasFeeCap is enough
 	var minGasTipCap = opts.State.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetMinGasTipCapStateHash()).Big()
 	var baseFee = opts.State.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetBaseFeeStateHash()).Big()
+	// Apply policy envelope fee check
+	if antimev.IsEnvelope(tx) {
+		var envelopeFee = opts.State.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetEnvelopeFeeStateHash()).Big()
+		minGasTipCap.Add(minGasTipCap, envelopeFee)
+	}
 	if math.BigMin(tx.GasTipCap(), new(big.Int).Sub(tx.GasFeeCap(), baseFee)).Cmp(minGasTipCap) < 0 {
-		return fmt.Errorf("%w: policy minGasTipCap needed %v, baseFee needed %v, gasTipCap %v, gasFeeCap %v ",
+		return fmt.Errorf("%w: policy minGasTipCap (including Envelope fee for Envelopes) needed %v, baseFee needed %v, gasTipCap %v, gasFeeCap %v ",
 			ErrUnderpriced, minGasTipCap, baseFee, tx.GasTipCap(), tx.GasFeeCap())
 	}
 	// Apply policy blacklist

eth/api_backend.go

@@ -377,6 +377,10 @@ func (b *EthAPIBackend) SuggestGasTipCap(ctx context.Context) (*big.Int, error)
 	return suggestTipCap, nil
 }
 
+func (b *EthAPIBackend) EnvelopeFee(ctx context.Context) (*big.Int, error) {
+	return b.gpo.EnvelopeFee(ctx)
+}
+
 func (b *EthAPIBackend) FeeHistory(ctx context.Context, blockCount uint64, lastBlock rpc.BlockNumber, rewardPercentiles []float64) (firstBlock *big.Int, reward [][]*big.Int, baseFee []*big.Int, gasUsedRatio []float64, err error) {
 	return b.gpo.FeeHistory(ctx, blockCount, lastBlock, rewardPercentiles)
 }

eth/gasprice/gasprice.go

@@ -72,6 +72,7 @@ type Oracle struct {
 	lastPrice        *big.Int
 	lastBaseFee      *big.Int // lastBaseFee contains next BaseFee value calculated based on the lastHead block.
 	lastMinGasTipCap *big.Int // lastMinGasTipCap contains next MinGasTipCap value calculated based on the lastHead block.
+	lastEnvelopeFee  *big.Int // lastEnvelopeFee contains next EnvelopeFee value calculated based on the lastHead block.
 	maxPrice         *big.Int
 	ignorePrice      *big.Int
 	cacheLock        sync.RWMutex
@@ -161,6 +162,40 @@ func (oracle *Oracle) SuggestTipCap(ctx context.Context) (*big.Int, *big.Int, er
 	return price, minGasTipCap, err
 }
 
+// EnvelopeFee returns an extra tip cap so that newly created envelope transactions
+// can have a very high chance to be included in the following blocks.
+func (oracle *Oracle) EnvelopeFee(ctx context.Context) (*big.Int, error) {
+	head, _ := oracle.backend.HeaderByNumber(ctx, rpc.LatestBlockNumber)
+	headHash := head.Hash()
+
+	// If the latest envelope fee is still available, return it.
+	oracle.cacheLock.RLock()
+	lastHead, lastEnvelopeFee := oracle.lastHead, oracle.lastEnvelopeFee
+	oracle.cacheLock.RUnlock()
+	if headHash == lastHead {
+		return new(big.Int).Set(lastEnvelopeFee), nil
+	}
+	oracle.fetchLock.Lock()
+	defer oracle.fetchLock.Unlock()
+
+	// Try checking the cache again, maybe the last fetch fetched what we need.
+	oracle.cacheLock.RLock()
+	lastHead, lastPrice, lastEnvelopeFee := oracle.lastHead, oracle.lastPrice, oracle.lastEnvelopeFee
+	oracle.cacheLock.RUnlock()
+	if headHash == lastHead {
+		return new(big.Int).Set(lastEnvelopeFee), nil
+	}
+
+	// It's a new head, then update.
+	err := oracle.updateCache(ctx, head, lastPrice)
+	if err != nil {
+		return new(big.Int).Set(lastEnvelopeFee), err
+	}
+	oracle.cacheLock.RLock()
+	defer oracle.cacheLock.RUnlock()
+	return new(big.Int).Set(oracle.lastEnvelopeFee), nil
+}
+
 // suggestTipCapInternal return GAS price, BaseFee and minGasTipCap for the specified block.
 // It updates the cache for the specified block height if needed. Zero BaseFee is returned if
 // London is not active yet.
@@ -184,12 +219,35 @@ func (oracle *Oracle) suggestTipCapInternal(ctx context.Context, head *types.Hea
 	if headHash == lastHead {
 		return new(big.Int).Set(lastPrice), new(big.Int).Set(lastBaseFee), new(big.Int).Set(lastMinGasTipCap), nil
 	}
+
+	// It's a new head, then update.
+	err := oracle.updateCache(ctx, head, lastPrice)
+	if err != nil {
+		return new(big.Int).Set(lastPrice), new(big.Int).Set(lastBaseFee), new(big.Int).Set(lastMinGasTipCap), err
+	}
+	oracle.cacheLock.RLock()
+	defer oracle.cacheLock.RUnlock()
+	return new(big.Int).Set(oracle.lastPrice), new(big.Int).Set(oracle.lastBaseFee), new(big.Int).Set(oracle.lastMinGasTipCap), nil
+}
+
+type results struct {
+	values []*big.Int
+	err    error
+}
+
+// updateCache updates the cache for the specified block height.
+func (oracle *Oracle) updateCache(ctx context.Context, head *types.Header, lastPrice *big.Int) error {
+	headHash := head.Hash()
 	var (
-		sent, exp int
-		number    = head.Number.Uint64()
-		result    = make(chan results, oracle.checkBlocks)
-		quit      = make(chan struct{})
-		results   []*big.Int
+		state            *state.StateDB
+		sent, exp        int
+		number           = head.Number.Uint64()
+		result           = make(chan results, oracle.checkBlocks)
+		quit             = make(chan struct{})
+		results          []*big.Int
+		lastBaseFee      *big.Int
+		lastMinGasTipCap *big.Int
+		lastEnvelopeFee  *big.Int
 	)
 	for sent < oracle.checkBlocks && number > 0 {
 		go oracle.getBlockValues(ctx, number, sampleNumber, oracle.ignorePrice, result, quit)
@@ -201,7 +259,7 @@ func (oracle *Oracle) suggestTipCapInternal(ctx context.Context, head *types.Hea
 		res := <-result
 		if res.err != nil {
 			close(quit)
-			return new(big.Int).Set(lastPrice), new(big.Int).Set(lastBaseFee), new(big.Int).Set(lastMinGasTipCap), res.err
+			return res.err
 		}
 		exp--
 		// Nothing returned. There are two special cases here:
@@ -231,9 +289,10 @@ func (oracle *Oracle) suggestTipCapInternal(ctx context.Context, head *types.Hea
 		price = new(big.Int).Set(oracle.maxPrice)
 	}
 	if cfg := oracle.backend.ChainConfig(); cfg.IsLondon(head.Number) {
-		state, _, err := oracle.backend.StateAndHeaderByNumber(ctx, rpc.BlockNumber(head.Number.Uint64()))
+		var err error
+		state, _, err = oracle.backend.StateAndHeaderByNumber(ctx, rpc.BlockNumber(head.Number.Uint64()))
 		if err != nil {
-			return nil, nil, nil, fmt.Errorf("failed to get state at %d to calculate base fee: %w", head.Number.Uint64(), err)
+			return fmt.Errorf("failed to get state at %d to calculate base fee: %w", head.Number.Uint64(), err)
 		}
 		lastBaseFee = eip1559.CalcBaseFeeDBFT(cfg, head, state)
 		if cfg.DBFT != nil {
@@ -245,19 +304,31 @@ func (oracle *Oracle) suggestTipCapInternal(ctx context.Context, head *types.Hea
 		lastBaseFee = new(big.Int)
 		lastMinGasTipCap = new(big.Int)
 	}
+	if cfg := oracle.backend.ChainConfig(); cfg.IsNeoXAMEV(head.Number) {
+		if cfg.DBFT != nil {
+			if state == nil {
+				var err error
+				state, _, err = oracle.backend.StateAndHeaderByNumber(ctx, rpc.BlockNumber(head.Number.Uint64()))
+				if err != nil {
+					return fmt.Errorf("failed to get state at %d to get envelope fee: %w", head.Number.Uint64(), err)
+				}
+			}
+			lastEnvelopeFee = state.GetState(systemcontracts.PolicyProxyHash, systemcontracts.GetEnvelopeFeeStateHash()).Big()
+		} else {
+			lastEnvelopeFee = new(big.Int)
+		}
+	} else {
+		lastEnvelopeFee = new(big.Int)
+	}
 	oracle.cacheLock.Lock()
 	oracle.lastHead = headHash
 	oracle.lastPrice = price
 	oracle.lastBaseFee = lastBaseFee
 	oracle.lastMinGasTipCap = lastMinGasTipCap
+	oracle.lastEnvelopeFee = lastEnvelopeFee
 	oracle.cacheLock.Unlock()
 
-	return new(big.Int).Set(price), new(big.Int).Set(lastBaseFee), new(big.Int).Set(lastMinGasTipCap), nil
-}
-
-type results struct {
-	values []*big.Int
-	err    error
+	return nil
 }
 
 // getBlockValues calculates the lowest transaction gas price in a given block

ethclient/ethclient.go

@@ -567,6 +567,16 @@ func (ec *Client) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
 	return (*big.Int)(&hex), nil
 }
 
+// EnvelopeFee retrieves the currently envelope fee after NeoXAMEV to allow a
+// timely execution of an antimev envelope.
+func (ec *Client) EnvelopeFee(ctx context.Context) (*big.Int, error) {
+	var hex hexutil.Big
+	if err := ec.c.CallContext(ctx, &hex, "eth_envelopeFee"); err != nil {
+		return nil, err
+	}
+	return (*big.Int)(&hex), nil
+}
+
 type feeHistoryResultMarshaling struct {
 	OldestBlock  *hexutil.Big     `json:"oldestBlock"`
 	Reward       [][]*hexutil.Big `json:"reward,omitempty"`