Account for network specific PVG buffer values (#187)

Author: hazim-j

internal/start/private.go

@@ -60,11 +60,13 @@ func PrivateMode() {
 	ov := gas.NewDefaultOverhead()
 	if chain.Cmp(config.ArbitrumOneChainID) == 0 || chain.Cmp(config.ArbitrumGoerliChainID) == 0 {
 		ov.SetCalcPreVerificationGasFunc(gas.CalcArbitrumPVGWithEthClient(rpc, conf.SupportedEntryPoints[0]))
+		ov.SetPreVerificationGasBufferFactor(16)
 	}
 	if chain.Cmp(config.OptimismChainID) == 0 || chain.Cmp(config.OptimismGoerliChainID) == 0 {
 		ov.SetCalcPreVerificationGasFunc(
 			gas.CalcOptimismPVGWithEthClient(rpc, chain, conf.SupportedEntryPoints[0]),
 		)
+		ov.SetPreVerificationGasBufferFactor(1)
 	}
 
 	mem, err := mempool.New(db)

pkg/client/client.go

@@ -173,22 +173,12 @@ func (i *Client) EstimateUserOperationGas(op map[string]any, ep string) (*gas.Ga
 	}
 
 	// Calculate PreVerificationGas
-	pvg, err := i.ov.CalcPreVerificationGas(userOp)
+	pvg, err := i.ov.CalcPreVerificationGasWithBuffer(userOp)
 	if err != nil {
 		l.Error(err, "eth_estimateUserOperationGas error")
 		return nil, err
 	}
 
-	// Add a buffer to PVG for non-static values
-	static, err := gas.NewDefaultOverhead().CalcPreVerificationGas(userOp)
-	if err != nil {
-		return nil, err
-	}
-	if pvg.Cmp(static) == 1 {
-		// Using a custom PVG calculation. Add a small buffer to account for variability.
-		pvg = addBuffer(pvg, 1)
-	}
-
 	l.Info("eth_estimateUserOperationGas ok")
 	return &gas.GasEstimates{
 		PreVerificationGas: pvg,

pkg/client/buffer.go renamed to pkg/gas/buffer.go

@@ -1,4 +1,4 @@
-package client
+package gas
 
 import "math/big"
 

pkg/gas/overhead.go

@@ -26,6 +26,7 @@ type Overhead struct {
 	sanitizedVGL        *big.Int
 	sanitizedCGL        *big.Int
 	calcPVGFunc         CalcPreVerificationGasFunc
+	pvgBufferFactor     int64
 }
 
 // NewDefaultOverhead returns an instance of Overhead using parameters defined by the Ethereum protocol.
@@ -45,6 +46,7 @@ func NewDefaultOverhead() *Overhead {
 		sanitizedVGL:        big.NewInt(1000000),
 		sanitizedCGL:        big.NewInt(1000000),
 		calcPVGFunc:         calcPVGFuncNoop(),
+		pvgBufferFactor:     0,
 	}
 }
 
@@ -54,6 +56,14 @@ func (ov *Overhead) SetCalcPreVerificationGasFunc(fn CalcPreVerificationGasFunc)
 	ov.calcPVGFunc = fn
 }
 
+// SetPreVerificationGasBufferFactor defines the percentage to increase the preVerificationGas by during an
+// estimation. This is useful for rollups that use 2D gas values where the L1 gas component is
+// non-deterministic. This buffer accounts for any variability in-between eth_estimateUserOperationGas and
+// eth_sendUserOperation. Defaults to 0.
+func (ov *Overhead) SetPreVerificationGasBufferFactor(factor int64) {
+	ov.pvgBufferFactor = factor
+}
+
 // CalcPreVerificationGas returns an expected gas cost for processing a UserOperation from a batch.
 func (ov *Overhead) CalcPreVerificationGas(op *userop.UserOperation) (*big.Int, error) {
 	// Sanitize fields to reduce as much variability due to length and zero bytes
@@ -95,6 +105,15 @@ func (ov *Overhead) CalcPreVerificationGas(op *userop.UserOperation) (*big.Int,
 	return static, nil
 }
 
+// CalcPreVerificationGasWithBuffer returns CalcPreVerificationGas increased by the set PVG buffer factor.
+func (ov *Overhead) CalcPreVerificationGasWithBuffer(op *userop.UserOperation) (*big.Int, error) {
+	pvg, err := ov.CalcPreVerificationGas(op)
+	if err != nil {
+		return nil, err
+	}
+	return addBuffer(pvg, ov.pvgBufferFactor), nil
+}
+
 // NonZeroValueCall returns an expected gas cost of using the CALL opcode in the context of EIP-4337.
 // See https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-1-call.
 func (ov *Overhead) NonZeroValueCall() *big.Int {