Add tracing to callGasLimit estimate (#144)

hazim-j · web-flow · commit 0bb9e26564da · 2023-04-17T16:52:31.000+10:00
diff --git a/internal/config/values.go b/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,
 	}
 }
diff --git a/internal/start/private.go b/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(
diff --git a/internal/start/searcher.go b/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(
diff --git a/pkg/client/utils.go b/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)
 	}
 }
 
diff --git a/pkg/entrypoint/execution/simulate.go b/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
 	}
diff --git a/pkg/entrypoint/execution/trace.go b/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
+}
diff --git a/pkg/entrypoint/simulation/simulateutils.go b/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
 
diff --git a/pkg/entrypoint/simulation/tracevalidation.go b/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 {
diff --git a/pkg/entrypoint/utils/tracing.go b/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()
+)
diff --git a/pkg/gas/callgas.go b/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
 }
diff --git a/pkg/tracer/BundlerErrorTracer.js b/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++;
+  },
+};
diff --git a/pkg/tracer/load.go b/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
 }
diff --git a/pkg/tracer/types.go b/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"`
+}

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ type Values struct {`
`36`	`36`	`DebugMode bool`
`37`	`37`	`GinMode string`
`38`	`38`	`BundlerCollectorTracer string`
	`39`	`+ BundlerErrorTracer string`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`func envArrayToAddressSlice(s string) []common.Address {`
`@@ -118,8 +119,8 @@ func GetValues() *Values {`
`118`	`119`	`}`
`119`	`120`	`}`
`120`	`121`
`121`		`- // Load js tracer from embedded file`
`122`		`- bct, err := tracer.Load()`
	`122`	`+ // Load js tracers from embedded file`
	`123`	`+ trc, err := tracer.NewTracers()`
`123`	`124`	`if err != nil {`
`124`	`125`	`panic(err)`
`125`	`126`	`}`
`@@ -154,6 +155,7 @@ func GetValues() *Values {`
`154`	`155`	`BlocksInTheFuture: blocksInTheFuture,`
`155`	`156`	`DebugMode: debugMode,`
`156`	`157`	`GinMode: ginMode,`
`157`		`- BundlerCollectorTracer: bct,`
	`158`	`+ BundlerCollectorTracer: trc.BundlerCollectorTracer,`
	`159`	`+ BundlerErrorTracer: trc.BundlerErrorTracer,`
`158`	`160`	`}`
`159`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,9 +65,9 @@ func getCallGasEstimateNoop() GetCallGasEstimateFunc {`
`65`	`65`
`66`	`66`	`// GetCallGasEstimateWithEthClient returns an implementation of GetCallGasEstimateFunc that relies on an eth`
`67`	`67`	`// client to fetch an estimate for callGasLimit.`
`68`		`-func GetCallGasEstimateWithEthClient(eth *ethclient.Client) GetCallGasEstimateFunc {`
	`68`	`+func GetCallGasEstimateWithEthClient(rpc rpc.Client, chain big.Int, tracer string) GetCallGasEstimateFunc {`
`69`	`69`	`return func(ep common.Address, op *userop.UserOperation) (uint64, error) {`
`70`		`- return gas.CallGasEstimate(eth, ep, op)`
	`70`	`+ return gas.CallGasEstimate(rpc, ep, op, chain, tracer)`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ import (`
`14`	`14`	`"github.com/ethereum/go-ethereum/rpc"`
`15`	`15`	`"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"`
`16`	`16`	`"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/methods"`
	`17`	`+ "github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/utils"`
`17`	`18`	`"github.com/stackup-wallet/stackup-bundler/pkg/tracer"`
`18`	`19`	`"github.com/stackup-wallet/stackup-bundler/pkg/userop"`
`19`	`20`	`)`
`@@ -32,7 +33,7 @@ func TraceSimulateValidation(`
`32`	`33`	`if err != nil {`
`33`	`34`	`return nil, err`
`34`	`35`	`}`
`35`		`- auth, err := bind.NewKeyedTransactorWithChainID(dummyPk, chainID)`
	`36`	`+ auth, err := bind.NewKeyedTransactorWithChainID(utils.DummyPk, chainID)`
`36`	`37`	`if err != nil {`
`37`	`38`	`return nil, err`
`38`	`39`	`}`
`@@ -44,12 +45,12 @@ func TraceSimulateValidation(`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`var res tracer.BundlerCollectorReturn`
`47`		`- req := traceCallReq{`
	`48`	`+ req := utils.TraceCallReq{`
`48`	`49`	`From: common.HexToAddress("0x"),`
`49`	`50`	`To: entryPoint,`
`50`	`51`	`Data: tx.Data(),`
`51`	`52`	`}`
`52`		`- opts := traceCallOpts{`
	`53`	`+ opts := utils.TraceCallOpts{`
`53`	`54`	`Tracer: customTracer,`
`54`	`55`	`}`
`55`	`56`	`if err := rpc.CallContext(context.Background(), &res, "debug_traceCall", &req, "latest", &opts); err != nil {`