Use custom JS tracing (#54)

Author: hazim-j

README.md

@@ -13,6 +13,7 @@ See the `Bundler` documentation at [docs.stackup.sh](https://docs.stackup.sh/doc
 ## Prerequisites
 
 - Go 1.19 or later
+- Access to a node with `debug` API enabled for custom tracing.
 
 ## Setup
 

internal/config/values.go

@@ -9,6 +9,7 @@ import (
 	"github.com/gin-gonic/gin"
 	"github.com/spf13/viper"
 	"github.com/stackup-wallet/stackup-bundler/pkg/signer"
+	"github.com/stackup-wallet/stackup-bundler/pkg/tracer"
 )
 
 type Values struct {
@@ -22,7 +23,8 @@ type Values struct {
 	Beneficiary          string
 
 	// Undocumented variables.
-	GinMode string
+	GinMode                string
+	BundlerCollectorTracer string
 }
 
 func envArrayToAddressSlice(s string) []common.Address {
@@ -85,15 +87,22 @@ func GetValues() *Values {
 		viper.SetDefault("erc4337_bundler_beneficiary", s.Address.String())
 	}
 
+	// Load js tracer from embedded file
+	bct, err := tracer.Load()
+	if err != nil {
+		panic(err)
+	}
+
 	// Return Values
 	return &Values{
-		PrivateKey:           viper.GetString("erc4337_bundler_private_key"),
-		EthClientUrl:         viper.GetString("erc4337_bundler_eth_client_url"),
-		Port:                 viper.GetInt("erc4337_bundler_port"),
-		DataDirectory:        viper.GetString("erc4337_bundler_data_directory"),
-		SupportedEntryPoints: envArrayToAddressSlice(viper.GetString("erc4337_bundler_supported_entry_points")),
-		Beneficiary:          viper.GetString("erc4337_bundler_beneficiary"),
-		MaxVerificationGas:   big.NewInt(int64(viper.GetInt("erc4337_bundler_max_verification_gas"))),
-		GinMode:              viper.GetString("erc4337_bundler_gin_mode"),
+		PrivateKey:             viper.GetString("erc4337_bundler_private_key"),
+		EthClientUrl:           viper.GetString("erc4337_bundler_eth_client_url"),
+		Port:                   viper.GetInt("erc4337_bundler_port"),
+		DataDirectory:          viper.GetString("erc4337_bundler_data_directory"),
+		SupportedEntryPoints:   envArrayToAddressSlice(viper.GetString("erc4337_bundler_supported_entry_points")),
+		Beneficiary:            viper.GetString("erc4337_bundler_beneficiary"),
+		MaxVerificationGas:     big.NewInt(int64(viper.GetInt("erc4337_bundler_max_verification_gas"))),
+		GinMode:                viper.GetString("erc4337_bundler_gin_mode"),
+		BundlerCollectorTracer: bct,
 	}
 }

internal/start/private.go

@@ -77,7 +77,7 @@ func PrivateMode() {
 		log.Fatal(err)
 	}
 
-	check := checks.New(rpc, conf.MaxVerificationGas)
+	check := checks.New(rpc, conf.MaxVerificationGas, conf.BundlerCollectorTracer)
 	relayer := relay.New(db, eoa, eth, chain, beneficiary, logr)
 	paymaster := paymaster.New(db)
 

pkg/entrypoint/simulation.go

@@ -14,44 +14,28 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/stackup-wallet/stackup-bundler/pkg/tracer"
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
 
 var (
 	// A dummy private key used to build *bind.TransactOpts for simulation.
 	dummyPk, _ = crypto.GenerateKey()
 
-	// A marker to delimit between account and paymaster simulation.
-	markerOpCode = "NUMBER"
+	// Pre number marker represents account validation.
+	accountNumberLevel = "0"
 
-	// Pre-marker represents account validation.
-	preMarker = "account"
-
-	// Post-marker represents paymaster validation.
-	postMarker = "paymaster"
-
-	// All opcodes executed at this depth are from the EntryPoint and allowed.
-	allowedDepth = float64(1)
-
-	// The gas opcode is only allowed if followed immediately by callOpcodes.
-	gasOpCode = "GAS"
+	// Post number marker represents paymaster validation.
+	paymasterNumberLevel = "1"
 
 	// Only one create2 opcode is allowed if these two conditions are met:
 	// 	1. op.initcode.length != 0
 	// 	2. During account simulation (i.e. before markerOpCode)
 	create2OpCode = "CREATE2"
 
-	// List of opcodes related to CALL.
-	callOpcodes = mapset.NewSet(
-		"CALL",
-		"DELEGATECALL",
-		"CALLCODE",
-		"STATICCALL",
-	)
-
-	// List of opcodes not allowed during simulation for depth > allowedDepth (i.e. account, paymaster, or
-	// contracts called by them).
-	baseForbiddenOpCodes = mapset.NewSet(
+	// List of opcodes not allowed during simulation for depth > 1 (i.e. account, paymaster, or contracts
+	// called by them).
+	bannedOpCodes = mapset.NewSet(
 		"GASPRICE",
 		"GASLIMIT",
 		"DIFFICULTY",
@@ -62,6 +46,7 @@ var (
 		"SELFBALANCE",
 		"BALANCE",
 		"ORIGIN",
+		"GAS",
 		"CREATE",
 		"COINBASE",
 	)
@@ -94,36 +79,25 @@ func SimulateValidation(rpc *rpc.Client, entryPoint common.Address, op *userop.U
 	return sim, nil
 }
 
-type structLog struct {
-	Depth   float64  `json:"depth"`
-	Gas     float64  `json:"gas"`
-	GasCost float64  `json:"gasCost"`
-	Op      string   `json:"op"`
-	Pc      float64  `json:"pc"`
-	Stack   []string `json:"stack"`
-}
-
-type traceCallRes struct {
-	Failed      bool        `json:"failed"`
-	Gas         float64     `json:"gas"`
-	ReturnValue []byte      `json:"returnValue"`
-	StructLogs  []structLog `json:"structLogs"`
-}
-
 type traceCallReq struct {
 	From common.Address `json:"from"`
 	To   common.Address `json:"to"`
 	Data hexutil.Bytes  `json:"data"`
 }
 
 type traceCallOpts struct {
-	DisableStorage bool `json:"disableStorage"`
-	DisableMemory  bool `json:"disableMemory"`
+	Tracer string `json:"tracer"`
 }
 
 // TraceSimulateValidation makes a debug_traceCall to Entrypoint.simulateValidation(userop) and returns the
 // results without any state changes.
-func TraceSimulateValidation(rpc *rpc.Client, entryPoint common.Address, op *userop.UserOperation, chainID *big.Int) error {
+func TraceSimulateValidation(
+	rpc *rpc.Client,
+	entryPoint common.Address,
+	op *userop.UserOperation,
+	chainID *big.Int,
+	customTracer string,
+) error {
 	ep, err := NewEntrypoint(entryPoint, ethclient.NewClient(rpc))
 	if err != nil {
 		return err
@@ -139,48 +113,51 @@ func TraceSimulateValidation(rpc *rpc.Client, entryPoint common.Address, op *use
 		return err
 	}
 
-	var res traceCallRes
 	req := traceCallReq{
 		From: common.HexToAddress("0x"),
 		To:   entryPoint,
 		Data: tx.Data(),
 	}
+
+	var res tracer.BundlerCollectorReturn
 	opts := traceCallOpts{
-		DisableStorage: false,
-		DisableMemory:  false,
+		Tracer: customTracer,
 	}
 	if err := rpc.CallContext(context.Background(), &res, "debug_traceCall", &req, "latest", &opts); err != nil {
 		return err
 	}
 
-	var prev structLog
-	create2count := 0
-	simFor := preMarker
-	for _, sl := range res.StructLogs {
-		if sl.Depth == allowedDepth {
-			if sl.Op == markerOpCode {
-				simFor = postMarker
-			}
-			continue
-		}
+	var accountOpCodes, paymasterOpCodes tracer.Counts
+	if len(res.NumberLevels) == 1 {
+		accountOpCodes = res.NumberLevels[accountNumberLevel].Opcodes
+		paymasterOpCodes = make(tracer.Counts)
+	} else if len(res.NumberLevels) == 2 {
+		accountOpCodes = res.NumberLevels[accountNumberLevel].Opcodes
+		paymasterOpCodes = res.NumberLevels[paymasterNumberLevel].Opcodes
+	} else {
+		return fmt.Errorf("unexpected tracing result for op: %s", op.GetUserOpHash(entryPoint, chainID))
+	}
 
-		if prev.Op == gasOpCode && !callOpcodes.Contains(sl.Op) {
-			return fmt.Errorf("%s: uses opcode %s incorrectly", simFor, gasOpCode)
+	for key := range accountOpCodes {
+		if bannedOpCodes.Contains(key) {
+			return fmt.Errorf("account contains banned opcode: %s", key)
 		}
+	}
 
-		if sl.Op == create2OpCode {
-			create2count++
-
-			if create2count > 1 || len(op.InitCode) == 0 || simFor != preMarker {
-				return fmt.Errorf("%s: uses opcode %s incorrectly", simFor, sl.Op)
-			}
+	for key := range paymasterOpCodes {
+		if bannedOpCodes.Contains(key) {
+			return fmt.Errorf("paymaster contains banned opcode: %s", key)
 		}
+	}
 
-		if baseForbiddenOpCodes.Contains(sl.Op) {
-			return fmt.Errorf("%s: uses forbidden opcode %s", simFor, sl.Op)
-		}
+	create2Count, ok := accountOpCodes[create2OpCode]
+	if ok && (create2Count > 1 || len(op.InitCode) == 0) {
+		return fmt.Errorf("account with too many %s", create2OpCode)
+	}
 
-		prev = sl
+	_, ok = paymasterOpCodes[create2OpCode]
+	if ok {
+		return fmt.Errorf("paymaster uses banned %s opcode: %s", create2OpCode, op.GetPaymaster())
 	}
 
 	return nil

pkg/modules/checks/standalone.go

@@ -20,13 +20,14 @@ type Standalone struct {
 	rpc                *rpc.Client
 	eth                *ethclient.Client
 	maxVerificationGas *big.Int
+	tracer             string
 }
 
 // New returns a Standalone instance with methods that can be used in Client and Bundler modules to perform
 // standard checks as specified in EIP-4337.
-func New(rpc *rpc.Client, maxVerificationGas *big.Int) *Standalone {
+func New(rpc *rpc.Client, maxVerificationGas *big.Int, tracer string) *Standalone {
 	eth := ethclient.NewClient(rpc)
-	return &Standalone{rpc, eth, maxVerificationGas}
+	return &Standalone{rpc, eth, maxVerificationGas, tracer}
 }
 
 // ValidateOpValues returns a UserOpHandler that runs through some first line sanity checks for new UserOps
@@ -58,7 +59,7 @@ func (s *Standalone) SimulateOp() modules.UserOpHandlerFunc {
 			return err
 		})
 		g.Go(func() error {
-			return entrypoint.TraceSimulateValidation(s.rpc, ctx.EntryPoint, ctx.UserOp, ctx.ChainID)
+			return entrypoint.TraceSimulateValidation(s.rpc, ctx.EntryPoint, ctx.UserOp, ctx.ChainID, s.tracer)
 		})
 
 		return g.Wait()