Add tracing to callGasLimit estimate (#144)

Author: hazim-j

internal/config/values.go

@@ -36,6 +36,7 @@ type Values struct {
 	DebugMode              bool
 	GinMode                string
 	BundlerCollectorTracer string
+	BundlerErrorTracer     string
 }
 
 func envArrayToAddressSlice(s string) []common.Address {
@@ -118,8 +119,8 @@ func GetValues() *Values {
 		}
 	}
 
-	// Load js tracer from embedded file
-	bct, err := tracer.Load()
+	// Load js tracers from embedded file
+	trc, err := tracer.NewTracers()
 	if err != nil {
 		panic(err)
 	}
@@ -154,6 +155,7 @@ func GetValues() *Values {
 		BlocksInTheFuture:       blocksInTheFuture,
 		DebugMode:               debugMode,
 		GinMode:                 ginMode,
-		BundlerCollectorTracer:  bct,
+		BundlerCollectorTracer:  trc.BundlerCollectorTracer,
+		BundlerErrorTracer:      trc.BundlerErrorTracer,
 	}
 }

internal/start/private.go

@@ -83,7 +83,7 @@ func PrivateMode() {
 	c := client.New(mem, chain, conf.SupportedEntryPoints)
 	c.SetGetUserOpReceiptFunc(client.GetUserOpReceiptWithEthClient(eth))
 	c.SetGetSimulateValidationFunc(client.GetSimulateValidationWithRpcClient(rpc))
-	c.SetGetCallGasEstimateFunc(client.GetCallGasEstimateWithEthClient(eth))
+	c.SetGetCallGasEstimateFunc(client.GetCallGasEstimateWithEthClient(rpc, chain, conf.BundlerErrorTracer))
 	c.SetGetUserOpByHashFunc(client.GetUserOpByHashWithEthClient(eth))
 	c.UseLogger(logr)
 	c.UseModules(

internal/start/searcher.go

@@ -85,7 +85,7 @@ func SearcherMode() {
 	c := client.New(mem, chain, conf.SupportedEntryPoints)
 	c.SetGetUserOpReceiptFunc(client.GetUserOpReceiptWithEthClient(eth))
 	c.SetGetSimulateValidationFunc(client.GetSimulateValidationWithRpcClient(rpc))
-	c.SetGetCallGasEstimateFunc(client.GetCallGasEstimateWithEthClient(eth))
+	c.SetGetCallGasEstimateFunc(client.GetCallGasEstimateWithEthClient(rpc, chain, conf.BundlerErrorTracer))
 	c.SetGetUserOpByHashFunc(client.GetUserOpByHashWithEthClient(eth))
 	c.UseLogger(logr)
 	c.UseModules(

pkg/client/utils.go

@@ -65,9 +65,9 @@ func getCallGasEstimateNoop() GetCallGasEstimateFunc {
 
 // GetCallGasEstimateWithEthClient returns an implementation of GetCallGasEstimateFunc that relies on an eth
 // client to fetch an estimate for callGasLimit.
-func GetCallGasEstimateWithEthClient(eth *ethclient.Client) GetCallGasEstimateFunc {
+func GetCallGasEstimateWithEthClient(rpc *rpc.Client, chain *big.Int, tracer string) GetCallGasEstimateFunc {
 	return func(ep common.Address, op *userop.UserOperation) (uint64, error) {
-		return gas.CallGasEstimate(eth, ep, op)
+		return gas.CallGasEstimate(rpc, ep, op, chain, tracer)
 	}
 }
 

pkg/entrypoint/execution/simulate.go

@@ -5,20 +5,21 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/reverts"
 	"github.com/stackup-wallet/stackup-bundler/pkg/errors"
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
 
 func SimulateHandleOp(
-	eth *ethclient.Client,
+	rpc *rpc.Client,
 	entryPoint common.Address,
 	op *userop.UserOperation,
 	target common.Address,
 	data []byte,
 ) (*reverts.ExecutionResultRevert, error) {
-	ep, err := entrypoint.NewEntrypoint(entryPoint, eth)
+	ep, err := entrypoint.NewEntrypoint(entryPoint, ethclient.NewClient(rpc))
 	if err != nil {
 		return nil, err
 	}

pkg/entrypoint/execution/trace.go

@@ -0,0 +1,70 @@
+package execution
+
+import (
+	"context"
+	"math"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"
+	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/utils"
+	"github.com/stackup-wallet/stackup-bundler/pkg/errors"
+	"github.com/stackup-wallet/stackup-bundler/pkg/tracer"
+	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
+)
+
+func TraceSimulateHandleOp(
+	rpc *rpc.Client,
+	entryPoint common.Address,
+	op *userop.UserOperation,
+	chainID *big.Int,
+	customTracer string,
+	target common.Address,
+	data []byte,
+) error {
+	ep, err := entrypoint.NewEntrypoint(entryPoint, ethclient.NewClient(rpc))
+	if err != nil {
+		return err
+	}
+	auth, err := bind.NewKeyedTransactorWithChainID(utils.DummyPk, chainID)
+	if err != nil {
+		return err
+	}
+	auth.GasLimit = math.MaxUint64
+	auth.NoSend = true
+	tx, err := ep.SimulateHandleOp(auth, entrypoint.UserOperation(*op), target, data)
+	if err != nil {
+		return err
+	}
+
+	var res tracer.BundlerErrorReturn
+	req := utils.TraceCallReq{
+		From: common.HexToAddress("0x"),
+		To:   entryPoint,
+		Data: tx.Data(),
+	}
+	opts := utils.TraceCallOpts{
+		Tracer: customTracer,
+	}
+	if err := rpc.CallContext(context.Background(), &res, "debug_traceCall", &req, "latest", &opts); err != nil {
+		return err
+	}
+
+	if len(res.Reverts) != 0 {
+		data, err := hexutil.Decode(res.Reverts[len(res.Reverts)-1])
+		if err != nil {
+			return err
+		}
+
+		reason, err := errors.DecodeRevert(data)
+		if err != nil {
+			return err
+		}
+		return errors.NewRPCError(errors.EXECUTION_REVERTED, reason, reason)
+	}
+	return nil
+}

pkg/entrypoint/simulation/simulateutils.go

@@ -3,28 +3,13 @@ package simulation
 import (
 	mapset "github.com/deckarep/golang-set/v2"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"
 )
 
 // EntityStakes provides a mapping for encountered entity addresses and their stake info on the EntryPoint.
 type EntityStakes map[common.Address]*entrypoint.IStakeManagerDepositInfo
 
-type traceCallReq struct {
-	From common.Address `json:"from"`
-	To   common.Address `json:"to"`
-	Data hexutil.Bytes  `json:"data"`
-}
-
-type traceCallOpts struct {
-	Tracer string `json:"tracer"`
-}
-
 var (
-	// A dummy private key used to build *bind.TransactOpts for simulation.
-	dummyPk, _ = crypto.GenerateKey()
-
 	// Up to the first number marker represents factory validation.
 	factoryNumberLevel = 0
 

pkg/entrypoint/simulation/tracevalidation.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/methods"
+	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/utils"
 	"github.com/stackup-wallet/stackup-bundler/pkg/tracer"
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
@@ -32,7 +33,7 @@ func TraceSimulateValidation(
 	if err != nil {
 		return nil, err
 	}
-	auth, err := bind.NewKeyedTransactorWithChainID(dummyPk, chainID)
+	auth, err := bind.NewKeyedTransactorWithChainID(utils.DummyPk, chainID)
 	if err != nil {
 		return nil, err
 	}
@@ -44,12 +45,12 @@ func TraceSimulateValidation(
 	}
 
 	var res tracer.BundlerCollectorReturn
-	req := traceCallReq{
+	req := utils.TraceCallReq{
 		From: common.HexToAddress("0x"),
 		To:   entryPoint,
 		Data: tx.Data(),
 	}
-	opts := traceCallOpts{
+	opts := utils.TraceCallOpts{
 		Tracer: customTracer,
 	}
 	if err := rpc.CallContext(context.Background(), &res, "debug_traceCall", &req, "latest", &opts); err != nil {

pkg/entrypoint/utils/tracing.go

@@ -0,0 +1,22 @@
+package utils
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/crypto"
+)
+
+type TraceCallReq struct {
+	From common.Address `json:"from"`
+	To   common.Address `json:"to"`
+	Data hexutil.Bytes  `json:"data"`
+}
+
+type TraceCallOpts struct {
+	Tracer string `json:"tracer"`
+}
+
+var (
+	// A dummy private key used to build *bind.TransactOpts for simulation.
+	DummyPk, _ = crypto.GenerateKey()
+)

pkg/gas/callgas.go

@@ -5,16 +5,21 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/execution"
-	"github.com/stackup-wallet/stackup-bundler/pkg/errors"
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
 
+// CallGasEstimate uses the simulateHandleOp method on the EntryPoint to derive an estimate for callGasLimit.
+//
+// TODO: This function requires an eth_call and a debug_traceCall. It could probably be optimized further by
+// just using a debug_traceCall.
 func CallGasEstimate(
-	eth *ethclient.Client,
+	rpc *rpc.Client,
 	from common.Address,
 	op *userop.UserOperation,
+	chainID *big.Int,
+	tracer string,
 ) (uint64, error) {
 	data, err := op.ToMap()
 	if err != nil {
@@ -28,19 +33,20 @@ func CallGasEstimate(
 		return 0, err
 	}
 
-	sim, err := execution.SimulateHandleOp(eth, from, simOp, op.Sender, op.CallData)
+	sim, err := execution.SimulateHandleOp(rpc, from, simOp, common.Address{}, []byte{})
 	if err != nil {
 		return 0, err
 	}
-	if !sim.TargetSuccess {
-		reason, err := errors.DecodeRevert(sim.TargetResult)
-		if err != nil {
-			return 0, err
-		}
-		return 0, errors.NewRPCError(errors.EXECUTION_REVERTED, reason, reason)
+
+	if err := execution.TraceSimulateHandleOp(rpc, from, op, chainID, tracer, common.Address{}, []byte{}); err != nil {
+		return 0, err
 	}
 
 	tg := big.NewInt(0).Div(sim.Paid, op.MaxFeePerGas)
 	cgl := big.NewInt(0).Sub(tg, sim.PreOpGas)
-	return cgl.Uint64(), nil
+	call := NewDefaultOverhead().NonZeroValueCall()
+	if cgl.Cmp(call) >= 1 {
+		return cgl.Uint64(), nil
+	}
+	return call.Uint64(), nil
 }

pkg/tracer/BundlerErrorTracer.js

@@ -0,0 +1,23 @@
+var tracer = {
+  reverts: [],
+  numberCounter: 0,
+
+  fault: function fault(log, db) {},
+  result: function result(ctx, db) {
+    return {
+      reverts: this.reverts,
+    };
+  },
+
+  enter: function enter(frame) {},
+  exit: function exit(frame) {
+    if (frame.getError() !== undefined && this.numberCounter === 3) {
+      this.reverts.push(toHex(frame.getOutput()));
+    }
+  },
+
+  step: function step(log, db) {
+    var opcode = log.op.toString();
+    if (log.getDepth() === 1 && opcode === "NUMBER") this.numberCounter++;
+  },
+};

pkg/tracer/load.go

@@ -10,6 +10,7 @@ import (
 )
 
 //go:embed *BundlerCollectorTracer.js
+//go:embed *BundlerErrorTracer.js
 var files embed.FS
 var (
 	commentRegex    = regexp.MustCompile("(?m)^.*//.*$[\r\n]+")
@@ -28,11 +29,42 @@ func parse(code string) string {
 	return m
 }
 
-// Load reads the BundlerCollectorTracer.js file and returns a string that can be passed to a debug RPC
-// method as a custom tracer.
-func Load() (string, error) {
-	var t string
-	err := fs.WalkDir(files, ".", func(path string, d fs.DirEntry, err error) error {
+type Tracers struct {
+	BundlerCollectorTracer string
+	BundlerErrorTracer     string
+}
+
+// NewBundlerTracers reads the *Tracer.js files and returns a collection of strings that can be passed to a
+// debug RPC method as a custom tracer.
+func NewTracers() (*Tracers, error) {
+	var bct string
+	err := fs.WalkDir(
+		files,
+		"BundlerCollectorTracer.js",
+		func(path string, d fs.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+
+			if d.IsDir() {
+				return nil
+			}
+
+			b, err := fs.ReadFile(files, path)
+			if err != nil {
+				return err
+			}
+
+			bct = parse(string(b))
+			return nil
+		},
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	var et string
+	err = fs.WalkDir(files, "BundlerErrorTracer.js", func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
@@ -46,9 +78,15 @@ func Load() (string, error) {
 			return err
 		}
 
-		t = parse(string(b))
+		et = parse(string(b))
 		return nil
 	})
+	if err != nil {
+		return nil, err
+	}
 
-	return t, err
+	return &Tracers{
+		BundlerCollectorTracer: bct,
+		BundlerErrorTracer:     et,
+	}, nil
 }

pkg/tracer/types.go

@@ -53,3 +53,8 @@ type BundlerCollectorReturn struct {
 	Logs         []LogInfo         `json:"logs"`
 	Debug        []any             `json:"debug"`
 }
+
+// BundlerErrorReturn is the return value from performing an EVM trace with BundlerErrorTracer.js.
+type BundlerErrorReturn struct {
+	Reverts []string `json:"reverts"`
+}