Improve results for eth_estimateUserOperationGas (#82)

Author: hazim-j

internal/start/private.go

@@ -87,8 +87,10 @@ func PrivateMode() {
 	paymaster := paymaster.New(db)
 
 	// Init Client
-	c := client.New(mem, chain, conf.SupportedEntryPoints, conf.MaxVerificationGas)
+	c := client.New(mem, chain, conf.SupportedEntryPoints)
 	c.SetGetUserOpReceiptFunc(client.GetUserOpReceiptWithEthClient(eth))
+	c.SetGetSimulateValidationFunc(client.GetSimulateValidationWithRpcClient(rpc))
+	c.SetGetCallGasEstimateFunc(client.GetCallGasEstimateWithEthClient(eth))
 	c.UseLogger(logr)
 	c.UseModules(
 		check.ValidateOpValues(),

pkg/client/client.go

@@ -20,13 +20,14 @@ import (
 // Client controls the end to end process of adding incoming UserOperations to the mempool. It also
 // implements the required RPC methods as specified in EIP-4337.
 type Client struct {
-	mempool              *mempool.Mempool
-	chainID              *big.Int
-	supportedEntryPoints []common.Address
-	maxVerificationGas   *big.Int
-	userOpHandler        modules.UserOpHandlerFunc
-	logger               logr.Logger
-	getUserOpReceipt     GetUserOpReceiptFunc
+	mempool               *mempool.Mempool
+	chainID               *big.Int
+	supportedEntryPoints  []common.Address
+	userOpHandler         modules.UserOpHandlerFunc
+	logger                logr.Logger
+	getUserOpReceipt      GetUserOpReceiptFunc
+	getSimulateValidation GetSimulateValidationFunc
+	getCallGasEstimate    GetCallGasEstimateFunc
 }
 
 // New initializes a new ERC-4337 client which can be extended with modules for validating UserOperations
@@ -35,16 +36,16 @@ 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(),
+		mempool:               mempool,
+		chainID:               chainID,
+		supportedEntryPoints:  supportedEntryPoints,
+		userOpHandler:         noop.UserOpHandler,
+		logger:                logger.NewZeroLogr().WithName("client"),
+		getUserOpReceipt:      getUserOpReceiptNoop(),
+		getSimulateValidation: getSimulateValidationNoop(),
+		getCallGasEstimate:    getCallGasEstimateNoop(),
 	}
 }
 
@@ -74,6 +75,18 @@ func (i *Client) SetGetUserOpReceiptFunc(fn GetUserOpReceiptFunc) {
 	i.getUserOpReceipt = fn
 }
 
+// SetGetSimulateValidationFunc defines a general function for fetching simulateValidation results given a
+// userOp and EntryPoint address. This function is called in *Client.EstimateUserOperationGas.
+func (i *Client) SetGetSimulateValidationFunc(fn GetSimulateValidationFunc) {
+	i.getSimulateValidation = fn
+}
+
+// SetGetCallGasEstimateFunc defines a general function for fetching an estimate for callGasLimit given a
+// userOp and EntryPoint address. This function is called in *Client.EstimateUserOperationGas.
+func (i *Client) SetGetCallGasEstimateFunc(fn GetCallGasEstimateFunc) {
+	i.getCallGasEstimate = 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) {
@@ -148,12 +161,23 @@ func (i *Client) EstimateUserOperationGas(op map[string]any, ep string) (*gas.Ga
 	hash := userOp.GetUserOpHash(epAddr, i.chainID)
 	l = l.WithValues("userop_hash", hash)
 
+	sim, err := i.getSimulateValidation(epAddr, userOp)
+	if err != nil {
+		l.Error(err, "eth_estimateUserOperationGas error")
+		return nil, err
+	}
+
+	cg, err := i.getCallGasEstimate(epAddr, userOp)
+	if err != nil {
+		l.Error(err, "eth_estimateUserOperationGas error")
+		return nil, err
+	}
+
 	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(),
+		VerificationGas:    sim.ReturnInfo.PreOpGas,
+		CallGasLimit:       big.NewInt(int64(cg)),
 	}, nil
 }
 

pkg/client/utils.go

@@ -5,7 +5,10 @@ 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/gas"
+	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
 
 // GetUserOpReceiptFunc is a general interface for fetching a UserOperationReceipt given a userOpHash and
@@ -26,3 +29,41 @@ func GetUserOpReceiptWithEthClient(eth *ethclient.Client) GetUserOpReceiptFunc {
 		return entrypoint.GetUserOperationReceipt(eth, hash, ep)
 	}
 }
+
+// GetSimulateValidationFunc is a general interface for fetching simulateValidation results given a userOp
+// and EntryPoint address.
+type GetSimulateValidationFunc = func(ep common.Address, op *userop.UserOperation) (*entrypoint.ValidationResultRevert, error)
+
+func getSimulateValidationNoop() GetSimulateValidationFunc {
+	return func(ep common.Address, op *userop.UserOperation) (*entrypoint.ValidationResultRevert, error) {
+		//lint:ignore ST1005 This needs to match the bundler test spec.
+		return nil, errors.New("Missing/invalid userOpHash")
+	}
+}
+
+// GetSimulateValidationWithRpcClient returns an implementation of GetSimulateValidationFunc that relies on a
+// rpc client to fetch simulateValidation results.
+func GetSimulateValidationWithRpcClient(rpc *rpc.Client) GetSimulateValidationFunc {
+	return func(ep common.Address, op *userop.UserOperation) (*entrypoint.ValidationResultRevert, error) {
+		return entrypoint.SimulateValidation(rpc, ep, op)
+	}
+}
+
+// GetCallGasEstimateFunc is a general interface for fetching an estimate for callGasLimit given a userOp and
+// EntryPoint address.
+type GetCallGasEstimateFunc = func(ep common.Address, op *userop.UserOperation) (uint64, error)
+
+func getCallGasEstimateNoop() GetCallGasEstimateFunc {
+	return func(ep common.Address, op *userop.UserOperation) (uint64, error) {
+		//lint:ignore ST1005 This needs to match the bundler test spec.
+		return 0, errors.New("Missing/invalid userOpHash")
+	}
+}
+
+// GetCallGasEstimateWithEthClient returns an implementation of GetCallGasEstimateFunc that relies on an eth
+// client to fetch an estimate for callGasLimit.
+func GetCallGasEstimateWithEthClient(eth *ethclient.Client) GetCallGasEstimateFunc {
+	return func(ep common.Address, op *userop.UserOperation) (uint64, error) {
+		return gas.CallGasEstimate(eth, ep, op)
+	}
+}

pkg/entrypoint/simulatevalidation.go

@@ -1,12 +1,13 @@
 package entrypoint
 
 import (
-	"errors"
+	stdError "errors"
 	"fmt"
 
 	"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/errors"
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
 
@@ -26,7 +27,7 @@ func SimulateValidation(
 	rawCaller := &EntrypointRaw{Contract: ep}
 	err = rawCaller.Call(nil, &res, "simulateValidation", UserOperation(*op))
 	if err == nil {
-		return nil, errors.New("unexpected result from simulateValidation")
+		return nil, stdError.New("unexpected result from simulateValidation")
 	}
 
 	sim, simErr := newValidationResultRevert(err)
@@ -35,7 +36,7 @@ func SimulateValidation(
 		if foErr != nil {
 			return nil, fmt.Errorf("%s, %s", simErr, foErr)
 		}
-		return nil, errors.New(fo.Reason)
+		return nil, errors.NewRPCError(errors.REJECTED_BY_EP_OR_ACCOUNT, fo.Reason, fo)
 	}
 
 	return sim, nil

pkg/errors/rpc.go

@@ -9,6 +9,8 @@ var (
 	INVALID_PAYMASTER_STAKE       = -32505
 	INVALID_AGGREGATOR            = -32506
 	INVALID_FIELDS                = -32602
+
+	EXECUTION_REVERTED = -32521
 )
 
 // RPCError is a custom error that fits the JSON-RPC error spec.

pkg/gas/callgas.go

@@ -0,0 +1,28 @@
+package gas
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/stackup-wallet/stackup-bundler/pkg/errors"
+	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
+)
+
+func CallGasEstimate(
+	eth *ethclient.Client,
+	from common.Address,
+	op *userop.UserOperation,
+) (uint64, error) {
+	est, err := eth.EstimateGas(context.Background(), ethereum.CallMsg{
+		From: from,
+		To:   &op.Sender,
+		Data: op.CallData,
+	})
+	if err != nil {
+		return 0, errors.NewRPCError(errors.EXECUTION_REVERTED, err.Error(), err.Error())
+	}
+
+	return est, nil
+}