Fix failing bundler spec tests (#77)

Author: hazim-j

internal/start/private.go

@@ -82,7 +82,8 @@ func PrivateMode() {
 	paymaster := paymaster.New(db)
 
 	// Init Client
-	c := client.New(mem, chain, conf.SupportedEntryPoints)
+	c := client.New(mem, chain, conf.SupportedEntryPoints, conf.MaxVerificationGas)
+	c.SetGetUserOpReceiptFunc(client.GetUserOpReceiptWithEthClient(eth))
 	c.UseLogger(logr)
 	c.UseModules(
 		check.ValidateOpValues(),
@@ -91,12 +92,6 @@ func PrivateMode() {
 		paymaster.IncOpsSeen(),
 	)
 
-	// init Debug
-	var d *client.Debug
-	if conf.DebugMode {
-		d = client.NewDebug(eoa, eth, mem, chain, conf.SupportedEntryPoints[0], beneficiary)
-	}
-
 	// Init Bundler
 	b := bundler.New(mem, chain, conf.SupportedEntryPoints)
 	b.UseLogger(logr)
@@ -109,6 +104,13 @@ func PrivateMode() {
 		log.Fatal(err)
 	}
 
+	// init Debug
+	var d *client.Debug
+	if conf.DebugMode {
+		d = client.NewDebug(eoa, eth, mem, b, chain, conf.SupportedEntryPoints[0], beneficiary)
+		relayer.SetBannedThreshold(relay.NoBanThreshold)
+	}
+
 	// Init HTTP server
 	gin.SetMode(conf.GinMode)
 	r := gin.New()

internal/testutils/checksmock.go

@@ -31,7 +31,7 @@ func MockGetNotStakeZeroDeposit(addr common.Address) (*entrypoint.IStakeManagerD
 	return NonStakedZeroDepositInfo, nil
 }
 
-func GetMockGasTipFunc(val *big.Int) func() (*big.Int, error) {
+func GetMockBaseFeeFunc(val *big.Int) func() (*big.Int, error) {
 	return func() (*big.Int, error) {
 		return val, nil
 	}

pkg/bundler/bundler.go

@@ -22,6 +22,8 @@ type Bundler struct {
 	supportedEntryPoints []common.Address
 	batchHandler         modules.BatchHandlerFunc
 	logger               logr.Logger
+	isRunning            bool
+	stop                 chan bool
 }
 
 // New initializes a new EIP-4337 bundler which can be extended with modules for validating batches and
@@ -33,6 +35,8 @@ func New(mempool *mempool.Mempool, chainID *big.Int, supportedEntryPoints []comm
 		supportedEntryPoints: supportedEntryPoints,
 		batchHandler:         noop.BatchHandler,
 		logger:               logger.NewZeroLogr().WithName("bundler"),
+		isRunning:            false,
+		stop:                 make(chan bool),
 	}
 }
 
@@ -48,58 +52,78 @@ func (i *Bundler) UseModules(handlers ...modules.BatchHandlerFunc) {
 
 // Run starts a goroutine that will continuously process batches from the mempool.
 func (i *Bundler) Run() error {
+	if i.isRunning {
+		return nil
+	}
+
 	go func(i *Bundler) {
 		logger := i.logger.WithName("run")
 
 		for {
-			for _, ep := range i.supportedEntryPoints {
-				start := time.Now()
-				l := logger.
-					WithValues("entrypoint", ep.String()).
-					WithValues("chain_id", i.chainID.String())
-
-				batch, err := i.mempool.BundleOps(ep)
-				if err != nil {
-					l.Error(err, "bundler run error")
-					continue
-				}
-				if len(batch) == 0 {
-					continue
-				}
+			select {
+			case <-i.stop:
+				return
+			default:
+				for _, ep := range i.supportedEntryPoints {
+					start := time.Now()
+					l := logger.
+						WithValues("entrypoint", ep.String()).
+						WithValues("chain_id", i.chainID.String())
 
-				ctx := modules.NewBatchHandlerContext(batch, ep, i.chainID)
-				if err := i.batchHandler(ctx); err != nil {
-					l.Error(err, "bundler run error")
-					continue
-				}
+					batch, err := i.mempool.BundleOps(ep)
+					if err != nil {
+						l.Error(err, "bundler run error")
+						continue
+					}
+					if len(batch) == 0 {
+						continue
+					}
 
-				rmOps := append([]*userop.UserOperation{}, ctx.Batch...)
-				rmOps = append(rmOps, ctx.PendingRemoval...)
-				if err := i.mempool.RemoveOps(ep, rmOps...); err != nil {
-					l.Error(err, "bundler run error")
-					continue
-				}
+					ctx := modules.NewBatchHandlerContext(batch, ep, i.chainID)
+					if err := i.batchHandler(ctx); err != nil {
+						l.Error(err, "bundler run error")
+						continue
+					}
 
-				bat := []string{}
-				for _, op := range ctx.Batch {
-					bat = append(bat, op.GetUserOpHash(ep, i.chainID).String())
-				}
-				l = l.WithValues("batch_userop_hashes", bat)
+					rmOps := append([]*userop.UserOperation{}, ctx.Batch...)
+					rmOps = append(rmOps, ctx.PendingRemoval...)
+					if err := i.mempool.RemoveOps(ep, rmOps...); err != nil {
+						l.Error(err, "bundler run error")
+						continue
+					}
 
-				drp := []string{}
-				for _, op := range ctx.PendingRemoval {
-					drp = append(drp, op.GetUserOpHash(ep, i.chainID).String())
-				}
-				l = l.WithValues("dropped_userop_hashes", drp)
+					bat := []string{}
+					for _, op := range ctx.Batch {
+						bat = append(bat, op.GetUserOpHash(ep, i.chainID).String())
+					}
+					l = l.WithValues("batch_userop_hashes", bat)
+
+					drp := []string{}
+					for _, op := range ctx.PendingRemoval {
+						drp = append(drp, op.GetUserOpHash(ep, i.chainID).String())
+					}
+					l = l.WithValues("dropped_userop_hashes", drp)
 
-				for k, v := range ctx.Data {
-					l = l.WithValues(k, v)
+					for k, v := range ctx.Data {
+						l = l.WithValues(k, v)
+					}
+					l = l.WithValues("duration", time.Since(start))
+					l.Info("bundler run ok")
 				}
-				l = l.WithValues("duration", time.Since(start))
-				l.Info("bundler run ok")
 			}
 		}
 	}(i)
 
+	i.isRunning = true
 	return nil
 }
+
+// Stop signals the bundler to stop continuously processing batches from the mempool.
+func (i *Bundler) Stop() {
+	if !i.isRunning {
+		return
+	}
+
+	i.isRunning = false
+	i.stop <- true
+}

pkg/client/client.go

@@ -9,6 +9,8 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/go-logr/logr"
 	"github.com/stackup-wallet/stackup-bundler/internal/logger"
+	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"
+	"github.com/stackup-wallet/stackup-bundler/pkg/gas"
 	"github.com/stackup-wallet/stackup-bundler/pkg/mempool"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules"
 	"github.com/stackup-wallet/stackup-bundler/pkg/modules/noop"
@@ -21,19 +23,28 @@ type Client struct {
 	mempool              *mempool.Mempool
 	chainID              *big.Int
 	supportedEntryPoints []common.Address
+	maxVerificationGas   *big.Int
 	userOpHandler        modules.UserOpHandlerFunc
 	logger               logr.Logger
+	getUserOpReceipt     GetUserOpReceiptFunc
 }
 
 // New initializes a new ERC-4337 client which can be extended with modules for validating UserOperations
 // that are allowed to be added to the mempool.
-func New(mempool *mempool.Mempool, chainID *big.Int, supportedEntryPoints []common.Address) *Client {
+func New(
+	mempool *mempool.Mempool,
+	chainID *big.Int,
+	supportedEntryPoints []common.Address,
+	maxVerificationGas *big.Int,
+) *Client {
 	return &Client{
 		mempool:              mempool,
 		chainID:              chainID,
 		supportedEntryPoints: supportedEntryPoints,
+		maxVerificationGas:   maxVerificationGas,
 		userOpHandler:        noop.UserOpHandler,
 		logger:               logger.NewZeroLogr().WithName("client"),
+		getUserOpReceipt:     getUserOpReceiptNoop(),
 	}
 }
 
@@ -57,6 +68,12 @@ func (i *Client) UseModules(handlers ...modules.UserOpHandlerFunc) {
 	i.userOpHandler = modules.ComposeUserOpHandlerFunc(handlers...)
 }
 
+// SetGetUserOpReceiptFunc defines a general function for fetching a UserOpReceipt given a userOpHash and
+// EntryPoint address. This function is called in *Client.GetUserOperationReceipt.
+func (i *Client) SetGetUserOpReceiptFunc(fn GetUserOpReceiptFunc) {
+	i.getUserOpReceipt = fn
+}
+
 // SendUserOperation implements the method call for eth_sendUserOperation.
 // It returns true if userOp was accepted otherwise returns an error.
 func (i *Client) SendUserOperation(op map[string]any, ep string) (string, error) {
@@ -105,6 +122,59 @@ func (i *Client) SendUserOperation(op map[string]any, ep string) (string, error)
 	return hash.String(), nil
 }
 
+// EstimateUserOperationGas returns estimates for PreVerificationGas, VerificationGas, and CallGasLimit given
+// a UserOperation and EntryPoint address. The signature field and current gas values will not be validated
+// although there should be dummy values in place for the most reliable results (e.g. a signature with the
+// correct length).
+func (i *Client) EstimateUserOperationGas(op map[string]any, ep string) (*gas.GasEstimates, error) {
+	// Init logger
+	l := i.logger.WithName("eth_estimateUserOperationGas")
+
+	// Check EntryPoint and userOp is valid.
+	epAddr, err := i.parseEntryPointAddress(ep)
+	if err != nil {
+		l.Error(err, "eth_estimateUserOperationGas error")
+		return nil, err
+	}
+	l = l.
+		WithValues("entrypoint", epAddr.String()).
+		WithValues("chain_id", i.chainID.String())
+
+	userOp, err := userop.New(op)
+	if err != nil {
+		l.Error(err, "eth_estimateUserOperationGas error")
+		return nil, err
+	}
+	hash := userOp.GetUserOpHash(epAddr, i.chainID)
+	l = l.WithValues("userop_hash", hash)
+
+	l.Info("eth_estimateUserOperationGas ok")
+	// TODO: Return more reliable values
+	return &gas.GasEstimates{
+		PreVerificationGas: gas.NewDefaultOverhead().CalcPreVerificationGas(userOp),
+		VerificationGas:    i.maxVerificationGas,
+		CallGasLimit:       gas.NewDefaultOverhead().NonZeroValueCall(),
+	}, nil
+}
+
+// GetUserOperationReceipt fetches a UserOperation receipt based on a userOpHash returned by
+// *Client.SendUserOperation.
+func (i *Client) GetUserOperationReceipt(
+	hash string,
+) (*entrypoint.UserOperationReceipt, error) {
+	// Init logger
+	l := i.logger.WithName("eth_getUserOperationReceipt").WithValues("userop_hash", hash)
+
+	ev, err := i.getUserOpReceipt(hash, i.supportedEntryPoints[0])
+	if err != nil {
+		l.Error(err, "eth_getUserOperationReceipt error")
+		return nil, err
+	}
+
+	l.Info("eth_getUserOperationReceipt ok")
+	return ev, nil
+}
+
 // SupportedEntryPoints implements the method call for eth_supportedEntryPoints. It returns the array of
 // EntryPoint addresses that is supported by the client. The first address in the array is the preferred
 // EntryPoint.

pkg/client/debug.go

@@ -1,11 +1,14 @@
 package client
 
 import (
+	"encoding/json"
 	"errors"
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/stackup-wallet/stackup-bundler/pkg/bundler"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"
 	"github.com/stackup-wallet/stackup-bundler/pkg/mempool"
 	"github.com/stackup-wallet/stackup-bundler/pkg/signer"
@@ -16,6 +19,7 @@ type Debug struct {
 	eoa         *signer.EOA
 	eth         *ethclient.Client
 	mempool     *mempool.Mempool
+	bundler     *bundler.Bundler
 	chainID     *big.Int
 	entrypoint  common.Address
 	beneficiary common.Address
@@ -25,11 +29,46 @@ func NewDebug(
 	eoa *signer.EOA,
 	eth *ethclient.Client,
 	mempool *mempool.Mempool,
+	bundler *bundler.Bundler,
 	chainID *big.Int,
 	entrypoint common.Address,
 	beneficiary common.Address,
 ) *Debug {
-	return &Debug{eoa, eth, mempool, chainID, entrypoint, beneficiary}
+	return &Debug{eoa, eth, mempool, bundler, chainID, entrypoint, beneficiary}
+}
+
+// ClearState clears the bundler mempool and reputation data of paymasters/accounts/factories/aggregators.
+func (d *Debug) ClearState() (string, error) {
+	if err := d.mempool.Clear(); err != nil {
+		return "", err
+	}
+
+	return "ok", nil
+}
+
+// DumpMempool dumps the current UserOperations mempool in order of arrival.
+func (d *Debug) DumpMempool(ep string) ([]map[string]any, error) {
+	ops, err := d.mempool.Dump(common.HexToAddress(ep))
+	if err != nil {
+		return []map[string]any{}, err
+	}
+
+	res := []map[string]any{}
+	for _, op := range ops {
+		data, err := op.MarshalJSON()
+		if err != nil {
+			return []map[string]any{}, err
+		}
+
+		item := make(map[string]any)
+		if err := json.Unmarshal(data, &item); err != nil {
+			return []map[string]any{}, err
+		}
+
+		res = append(res, item)
+	}
+
+	return res, nil
 }
 
 // SendBundleNow forces the bundler to build and execute a bundle from the mempool as handleOps() transaction.
@@ -61,8 +100,6 @@ func (d *Debug) SendBundleNow() (string, error) {
 		batch,
 		d.beneficiary,
 		est,
-		big.NewInt((int64(est))),
-		big.NewInt((int64(est))),
 	)
 	if err != nil {
 		return "", err
@@ -72,3 +109,20 @@ func (d *Debug) SendBundleNow() (string, error) {
 
 	return txn.Hash().String(), nil
 }
+
+// SetBundlingMode allows the bundler to be stopped so that an explicit call to debug_bundler_sendBundleNow is
+// required to send a bundle.
+func (d *Debug) SetBundlingMode(mode string) (string, error) {
+	switch mode {
+	case "manual":
+		d.bundler.Stop()
+	case "auto":
+		if err := d.bundler.Run(); err != nil {
+			return "", err
+		}
+	default:
+		return "", fmt.Errorf("debug: unrecognized mode %s", mode)
+	}
+
+	return "ok", nil
+}