Account for 63/64 rule in callGasLimit estimate (#207)

Author: hazim-j

pkg/entrypoint/execution/trace.go

@@ -20,6 +20,26 @@ import (
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
 
+type TraceInput struct {
+	Rpc        *ethRpc.Client
+	EntryPoint common.Address
+	Op         *userop.UserOperation
+	ChainID    *big.Int
+
+	// Tracer for debug_traceCall
+	CustomTracer string
+
+	// Optional params for simulateHandleOps
+	Target common.Address
+	Data   []byte
+}
+
+type TraceOutput struct {
+	Trace  *tracer.BundlerErrorReturn
+	Result *reverts.ExecutionResultRevert
+	Event  *entrypoint.EntrypointUserOperationEvent
+}
+
 func parseUserOperationEvent(
 	entryPoint common.Address,
 	ep *entrypoint.Entrypoint,
@@ -50,82 +70,79 @@ func parseUserOperationEvent(
 	return ev, nil
 }
 
-func TraceSimulateHandleOp(
-	rpc *ethRpc.Client,
-	entryPoint common.Address,
-	op *userop.UserOperation,
-	chainID *big.Int,
-	customTracer string,
-	target common.Address,
-	data []byte,
-) (*reverts.ExecutionResultRevert, *entrypoint.EntrypointUserOperationEvent, error) {
-	ep, err := entrypoint.NewEntrypoint(entryPoint, ethclient.NewClient(rpc))
+func TraceSimulateHandleOp(in *TraceInput) (*TraceOutput, error) {
+	ep, err := entrypoint.NewEntrypoint(in.EntryPoint, ethclient.NewClient(in.Rpc))
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
-	auth, err := bind.NewKeyedTransactorWithChainID(utils.DummyPk, chainID)
+	auth, err := bind.NewKeyedTransactorWithChainID(utils.DummyPk, in.ChainID)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	auth.GasLimit = math.MaxUint64
 	auth.NoSend = true
-	tx, err := ep.SimulateHandleOp(auth, entrypoint.UserOperation(*op), target, data)
+	tx, err := ep.SimulateHandleOp(auth, entrypoint.UserOperation(*in.Op), in.Target, in.Data)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
+	out := &TraceOutput{}
 
 	var res tracer.BundlerErrorReturn
 	req := utils.TraceCallReq{
 		From: common.HexToAddress("0x"),
-		To:   entryPoint,
+		To:   in.EntryPoint,
 		Data: tx.Data(),
 	}
 	opts := utils.TraceCallOpts{
-		Tracer: customTracer,
+		Tracer: in.CustomTracer,
 	}
-	if err := rpc.CallContext(context.Background(), &res, "debug_traceCall", &req, "latest", &opts); err != nil {
-		return nil, nil, err
+	if err := in.Rpc.CallContext(context.Background(), &res, "debug_traceCall", &req, "latest", &opts); err != nil {
+		return nil, err
 	}
 	outErr, err := errors.ParseHexToRpcDataError(res.Output)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 	if res.ValidationOOG {
-		return nil, nil, errors.NewRPCError(errors.EXECUTION_REVERTED, "validation OOG", nil)
+		return nil, errors.NewRPCError(errors.EXECUTION_REVERTED, "validation OOG", nil)
 	}
+	out.Trace = &res
 
 	sim, simErr := reverts.NewExecutionResult(outErr)
 	if simErr != nil {
 		fo, foErr := reverts.NewFailedOp(outErr)
 		if foErr != nil {
-			return nil, nil, fmt.Errorf("%s, %s", simErr, foErr)
+			return nil, fmt.Errorf("%s, %s", simErr, foErr)
 		}
-		return nil, nil, errors.NewRPCError(errors.REJECTED_BY_EP_OR_ACCOUNT, fo.Reason, fo)
+		return nil, errors.NewRPCError(errors.REJECTED_BY_EP_OR_ACCOUNT, fo.Reason, fo)
 	}
+	out.Result = sim
 
 	if len(res.Reverts) != 0 {
 		data, err := hexutil.Decode(res.Reverts[len(res.Reverts)-1])
 		if err != nil {
-			return sim, nil, err
+			return out, err
 		}
 
 		if len(data) == 0 {
 			if res.ExecutionOOG {
-				return sim, nil, errors.NewRPCError(errors.EXECUTION_REVERTED, "execution OOG", nil)
+				return out, errors.NewRPCError(errors.EXECUTION_REVERTED, "execution OOG", nil)
 			}
-			return sim, nil, errors.NewRPCError(errors.EXECUTION_REVERTED, "execution reverted", nil)
+			return out, errors.NewRPCError(errors.EXECUTION_REVERTED, "execution reverted", nil)
 		}
 
 		reason, err := errors.DecodeRevert(data)
 		if err != nil {
-			return sim, nil, err
+			return out, err
 		}
-		return sim, nil, errors.NewRPCError(errors.EXECUTION_REVERTED, reason, reason)
+		return out, errors.NewRPCError(errors.EXECUTION_REVERTED, reason, reason)
 	}
 
-	ev, err := parseUserOperationEvent(entryPoint, ep, res.UserOperationEvent)
+	ev, err := parseUserOperationEvent(in.EntryPoint, ep, res.UserOperationEvent)
 	if err != nil {
-		return nil, nil, err
+		return out, err
 	}
-	return sim, ev, nil
+	out.Event = ev
+
+	return out, nil
 }

pkg/gas/estimate.go

@@ -66,15 +66,13 @@ func EstimateGas(
 		if err != nil {
 			return 0, 0, err
 		}
-		sim, _, err := execution.TraceSimulateHandleOp(
-			rpc,
-			from,
-			simOp,
-			chainID,
-			tracer,
-			common.Address{},
-			[]byte{},
-		)
+		out, err := execution.TraceSimulateHandleOp(&execution.TraceInput{
+			Rpc:          rpc,
+			EntryPoint:   from,
+			Op:           simOp,
+			ChainID:      chainID,
+			CustomTracer: tracer,
+		})
 		simErr = err
 		if err != nil {
 			if isPrefundNotPaid(err) {
@@ -95,7 +93,7 @@ func EstimateGas(
 
 		// Optimal VGL found.
 		data["verificationGasLimit"] = hexutil.EncodeBig(
-			big.NewInt(0).Sub(sim.PreOpGas, op.PreVerificationGas),
+			big.NewInt(0).Sub(out.Result.PreOpGas, op.PreVerificationGas),
 		)
 		break
 	}
@@ -112,26 +110,24 @@ func EstimateGas(
 	if err != nil {
 		return 0, 0, err
 	}
-	sim, ev, err := execution.TraceSimulateHandleOp(
-		rpc,
-		from,
-		simOp,
-		chainID,
-		tracer,
-		common.Address{},
-		[]byte{},
-	)
+	out, err := execution.TraceSimulateHandleOp(&execution.TraceInput{
+		Rpc:          rpc,
+		EntryPoint:   from,
+		Op:           simOp,
+		ChainID:      chainID,
+		CustomTracer: tracer,
+	})
 	if err != nil {
 		return 0, 0, err
 	}
 
 	// Calculate final values for verificationGasLimit and callGasLimit.
 	vgl := simOp.VerificationGasLimit
-	cgl := big.NewInt(0).
-		Add(big.NewInt(0).Sub(ev.ActualGasUsed, sim.PreOpGas), big.NewInt(int64(ov.intrinsicFixed)))
-	min := ov.NonZeroValueCall()
-	if min.Cmp(cgl) >= 1 {
-		cgl = min
+	cg := big.NewInt(0).Sub(out.Event.ActualGasUsed, out.Result.PreOpGas)
+	cgb := big.NewInt(int64(out.Trace.ExecutionGasBuffer))
+	cgl := big.NewInt(0).Add(cg, cgb)
+	if cgl.Cmp(ov.NonZeroValueCall()) < 0 {
+		cgl = ov.NonZeroValueCall()
 	}
 
 	// Run a final simulation to check wether or not value transfers are still okay when factoring in the
@@ -144,17 +140,15 @@ func EstimateGas(
 	if err != nil {
 		return 0, 0, err
 	}
-	_, _, err = execution.TraceSimulateHandleOp(
-		rpc,
-		from,
-		simOp,
-		chainID,
-		tracer,
-		common.Address{},
-		[]byte{},
-	)
+	_, err = execution.TraceSimulateHandleOp(&execution.TraceInput{
+		Rpc:          rpc,
+		EntryPoint:   from,
+		Op:           simOp,
+		ChainID:      chainID,
+		CustomTracer: tracer,
+	})
 	if err != nil {
 		return 0, 0, err
 	}
-	return vgl.Uint64(), cgl.Uint64(), nil
+	return simOp.VerificationGasLimit.Uint64(), simOp.CallGasLimit.Uint64(), nil
 }

pkg/gas/overhead.go

@@ -20,7 +20,7 @@ type Overhead struct {
 	nonZeroByte         float64
 	minBundleSize       float64
 	warmStorageRead     float64
-	nonZeroValueCall    float64
+	callWithValue       float64
 	callOpcode          float64
 	nonZeroValueStipend float64
 	sanitizedPVG        *big.Int
@@ -40,7 +40,7 @@ func NewDefaultOverhead() *Overhead {
 		nonZeroByte:         16,
 		minBundleSize:       1,
 		warmStorageRead:     100,
-		nonZeroValueCall:    9000,
+		callWithValue:       9000,
 		callOpcode:          700,
 		nonZeroValueStipend: 2300,
 		sanitizedPVG:        big.NewInt(100000),
@@ -137,12 +137,12 @@ func (ov *Overhead) CalcPreVerificationGasWithBuffer(op *userop.UserOperation) (
 	return utils.AddBuffer(pvg, ov.pvgBufferFactor), nil
 }
 
-// NonZeroValueCall returns an expected gas cost of using the CALL opcode in the context of EIP-4337.
+// NonZeroValueCall returns an expected gas cost of using the CALL opcode with non-zero value.
 // See https://github.com/wolflo/evm-opcodes/blob/main/gas.md#aa-1-call.
 func (ov *Overhead) NonZeroValueCall() *big.Int {
 	return big.NewInt(
 		int64(
-			ov.intrinsicFixed + ov.warmStorageRead + ov.nonZeroValueCall + ov.callOpcode + ov.nonZeroValueStipend,
+			ov.callOpcode + ov.callWithValue + ov.warmStorageRead + ov.nonZeroValueStipend,
 		),
 	)
 }

pkg/tracer/BundlerErrorTracer.js

@@ -2,7 +2,9 @@ var tracer = {
   reverts: [],
   validationOOG: false,
   executionOOG: false,
+  executionGasBuffer: 0,
 
+  _depth: 0,
   _marker: 0,
   _validationMarker: 1,
   _executionMarker: 3,
@@ -46,25 +48,32 @@ var tracer = {
       reverts: this.reverts,
       validationOOG: this.validationOOG,
       executionOOG: this.executionOOG,
+      executionGasBuffer: this.executionGasBuffer,
       userOperationEvent: this.userOperationEvent,
       output: toHex(ctx.output),
     };
   },
 
   enter: function enter(frame) {},
   exit: function exit(frame) {
-    if (frame.getError() !== undefined && this._isExecution()) {
-      this.reverts.push(toHex(frame.getOutput()));
+    if (this._isExecution()) {
+      if (frame.getError() !== undefined) {
+        this.reverts.push(toHex(frame.getOutput()));
+      }
+
+      if (this._depth > 2) {
+        this.executionGasBuffer += 2300 + Math.ceil(frame.getGasUsed() / 63);
+      }
     }
   },
 
   step: function step(log, db) {
     var opcode = log.op.toString();
-    var depth = log.getDepth();
-    if (depth === 1 && opcode === "NUMBER") this._marker++;
+    this._depth = log.getDepth();
+    if (this._depth === 1 && opcode === "NUMBER") this._marker++;
 
     if (
-      depth <= 2 &&
+      this._depth <= 2 &&
       opcode.startsWith("LOG") &&
       this._isUserOperationEvent(log)
     )

pkg/tracer/types.go

@@ -59,6 +59,7 @@ type BundlerErrorReturn struct {
 	Reverts            []string `json:"reverts"`
 	ValidationOOG      bool     `json:"validationOOG"`
 	ExecutionOOG       bool     `json:"executionOOG"`
+	ExecutionGasBuffer float64  `json:"executionGasBuffer"`
 	UserOperationEvent *LogInfo `json:"userOperationEvent,omitempty"`
 	Output             string   `json:"output"`
 }