Update EntryPoint to eth-infinitism/account-abstraction@9b5f2e4 (#141)

Author: hazim-j

abi/entrypoint.json

@@ -213,6 +213,12 @@
     "name": "AccountDeployed",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [],
+    "name": "BeforeExecution",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -503,6 +509,18 @@
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "sender", "type": "address" },
+      { "internalType": "uint192", "name": "key", "type": "uint192" }
+    ],
+    "name": "getNonce",
+    "outputs": [
+      { "internalType": "uint256", "name": "nonce", "type": "uint256" }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       { "internalType": "bytes", "name": "initCode", "type": "bytes" }
@@ -689,6 +707,13 @@
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [{ "internalType": "uint192", "name": "key", "type": "uint192" }],
+    "name": "incrementNonce",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       { "internalType": "bytes", "name": "callData", "type": "bytes" },
@@ -763,6 +788,16 @@
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "", "type": "address" },
+      { "internalType": "uint192", "name": "", "type": "uint192" }
+    ],
+    "name": "nonceSequenceNumber",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {

internal/config/values.go

@@ -58,7 +58,7 @@ func GetValues() *Values {
 	// Default variables
 	viper.SetDefault("erc4337_bundler_port", 4337)
 	viper.SetDefault("erc4337_bundler_data_directory", "/tmp/stackup_bundler")
-	viper.SetDefault("erc4337_bundler_supported_entry_points", "0x0576a174D229E3cFA37253523E645A78A0C91B57")
+	viper.SetDefault("erc4337_bundler_supported_entry_points", "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789")
 	viper.SetDefault("erc4337_bundler_max_verification_gas", 1500000)
 	viper.SetDefault("erc4337_bundler_max_ops_for_unstaked_sender", 4)
 	viper.SetDefault("erc4337_bundler_blocks_in_the_future", 25)

pkg/entrypoint/bindings.go

@@ -0,0 +1,46 @@
+package execution
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"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,
+	entryPoint common.Address,
+	op *userop.UserOperation,
+	target common.Address,
+	data []byte,
+) (*reverts.ExecutionResultRevert, error) {
+	ep, err := entrypoint.NewEntrypoint(entryPoint, eth)
+	if err != nil {
+		return nil, err
+	}
+
+	rawCaller := &entrypoint.EntrypointRaw{Contract: ep}
+	err = rawCaller.Call(
+		nil,
+		nil,
+		"simulateHandleOp",
+		entrypoint.UserOperation(*op),
+		target,
+		data,
+	)
+
+	sim, simErr := reverts.NewExecutionResult(err)
+	if simErr != nil {
+		fo, foErr := reverts.NewFailedOp(err)
+		if foErr != nil {
+			return nil, fmt.Errorf("%s, %s", simErr, foErr)
+		}
+		return nil, errors.NewRPCError(errors.REJECTED_BY_EP_OR_ACCOUNT, fo.Reason, fo)
+	}
+
+	return sim, nil
+}

pkg/entrypoint/execution/simulate.go

@@ -0,0 +1,70 @@
+package reverts
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+type ExecutionResultRevert struct {
+	PreOpGas      *big.Int
+	Paid          *big.Int
+	ValidAfter    *big.Int
+	ValidUntil    *big.Int
+	TargetSuccess bool
+	TargetResult  []byte
+}
+
+func executionResult() abi.Error {
+	uint256, _ := abi.NewType("uint256", "", nil)
+	uint48, _ := abi.NewType("uint48", "", nil)
+	boolean, _ := abi.NewType("bool", "", nil)
+	bytes, _ := abi.NewType("bytes", "", nil)
+	return abi.NewError("ExecutionResult", abi.Arguments{
+		{Name: "preOpGas", Type: uint256},
+		{Name: "paid", Type: uint256},
+		{Name: "validAfter", Type: uint48},
+		{Name: "validUntil", Type: uint48},
+		{Name: "targetSuccess", Type: boolean},
+		{Name: "targetResult", Type: bytes},
+	})
+}
+
+func NewExecutionResult(err error) (*ExecutionResultRevert, error) {
+	rpcErr, ok := err.(rpc.DataError)
+	if !ok {
+		return nil, errors.New("executionResult: cannot assert type: error is not of type rpc.DataError")
+	}
+
+	data, ok := rpcErr.ErrorData().(string)
+	if !ok {
+		return nil, errors.New("executionResult: cannot assert type: data is not of type string")
+	}
+
+	sim := executionResult()
+	revert, err := sim.Unpack(common.Hex2Bytes(data[2:]))
+	if err != nil {
+		return nil, fmt.Errorf("executionResult: %s", err)
+	}
+
+	args, ok := revert.([]any)
+	if !ok {
+		return nil, errors.New("executionResult: cannot assert type: args is not of type []any")
+	}
+	if len(args) != 6 {
+		return nil, fmt.Errorf("executionResult: invalid args length: expected 6, got %d", len(args))
+	}
+
+	return &ExecutionResultRevert{
+		PreOpGas:      args[0].(*big.Int),
+		Paid:          args[1].(*big.Int),
+		ValidAfter:    args[2].(*big.Int),
+		ValidUntil:    args[3].(*big.Int),
+		TargetSuccess: args[4].(bool),
+		TargetResult:  args[5].([]byte),
+	}, nil
+}

pkg/entrypoint/reverts/executionresult.go

@@ -0,0 +1,33 @@
+package errors
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+)
+
+func revertError() abi.Error {
+	reason, _ := abi.NewType("string", "string", nil)
+	return abi.NewError("Error", abi.Arguments{
+		{Name: "reason", Type: reason},
+	})
+}
+
+func DecodeRevert(data []byte) (string, error) {
+	abi := revertError()
+	revert, err := abi.Unpack(data)
+	if err != nil {
+		return "", fmt.Errorf("revert: %s", err)
+	}
+
+	args, ok := revert.([]any)
+	if !ok {
+		return "", errors.New("revert: cannot assert type: args is not of type []any")
+	}
+	if len(args) != 1 {
+		return "", fmt.Errorf("revert: invalid args length: expected 1, got %d", len(args))
+	}
+
+	return args[0].(string), nil
+}

pkg/errors/revert.go

@@ -1,11 +1,12 @@
 package gas
 
 import (
-	"context"
+	"math/big"
 
-	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/ethclient"
+	"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"
 )
@@ -15,14 +16,31 @@ func CallGasEstimate(
 	from common.Address,
 	op *userop.UserOperation,
 ) (uint64, error) {
-	est, err := eth.EstimateGas(context.Background(), ethereum.CallMsg{
-		From: from,
-		To:   &op.Sender,
-		Data: op.CallData,
-	})
+	data, err := op.ToMap()
 	if err != nil {
-		return 0, errors.NewRPCError(errors.EXECUTION_REVERTED, err.Error(), err.Error())
+		return 0, err
 	}
 
-	return est, nil
+	// Set MaxPriorityFeePerGas = MaxFeePerGas to simplify callGasLimit calculation.
+	data["maxPriorityFeePerGas"] = hexutil.EncodeBig(op.MaxFeePerGas)
+	simOp, err := userop.New(data)
+	if err != nil {
+		return 0, err
+	}
+
+	sim, err := execution.SimulateHandleOp(eth, from, simOp, op.Sender, op.CallData)
+	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)
+	}
+
+	tg := big.NewInt(0).Div(sim.Paid, op.MaxFeePerGas)
+	cgl := big.NewInt(0).Sub(tg, sim.PreOpGas)
+	return cgl.Uint64(), nil
 }

pkg/gas/callgas.go

@@ -12,6 +12,10 @@ import (
 )
 
 var (
+	address, _ = abi.NewType("address", "", nil)
+	uint256, _ = abi.NewType("uint256", "", nil)
+	bytes32, _ = abi.NewType("bytes32", "", nil)
+
 	// UserOpPrimitives is the primitive ABI types for each UserOperation field.
 	UserOpPrimitives = []abi.ArgumentMarshaling{
 		{Name: "sender", InternalType: "Sender", Type: "address"},
@@ -34,12 +38,6 @@ var (
 	UserOpArr, _ = abi.NewType("tuple[]", "ops", UserOpPrimitives)
 )
 
-func getAbiArgs() abi.Arguments {
-	return abi.Arguments{
-		{Name: "UserOp", Type: UserOpType},
-	}
-}
-
 // UserOperation represents an EIP-4337 style transaction for a smart contract account.
 type UserOperation struct {
 	Sender               common.Address `json:"sender"               mapstructure:"sender"               validate:"required"`
@@ -92,7 +90,9 @@ func (op *UserOperation) GetMaxPrefund() *big.Int {
 
 // Pack returns a standard message of the userOp. This cannot be used to generate a userOpHash.
 func (op *UserOperation) Pack() []byte {
-	args := getAbiArgs()
+	args := abi.Arguments{
+		{Name: "UserOp", Type: UserOpType},
+	}
 	packed, _ := args.Pack(&struct {
 		Sender               common.Address
 		Nonce                *big.Int
@@ -126,37 +126,32 @@ func (op *UserOperation) Pack() []byte {
 
 // PackForSignature returns a minimal message of the userOp. This can be used to generate a userOpHash.
 func (op *UserOperation) PackForSignature() []byte {
-	args := getAbiArgs()
-	packed, _ := args.Pack(&struct {
-		Sender               common.Address
-		Nonce                *big.Int
-		InitCode             []byte
-		CallData             []byte
-		CallGasLimit         *big.Int
-		VerificationGasLimit *big.Int
-		PreVerificationGas   *big.Int
-		MaxFeePerGas         *big.Int
-		MaxPriorityFeePerGas *big.Int
-		PaymasterAndData     []byte
-		Signature            []byte
-	}{
+	args := abi.Arguments{
+		{Name: "sender", Type: address},
+		{Name: "nonce", Type: uint256},
+		{Name: "hashInitCode", Type: bytes32},
+		{Name: "hashCallData", Type: bytes32},
+		{Name: "callGasLimit", Type: uint256},
+		{Name: "verificationGasLimit", Type: uint256},
+		{Name: "preVerificationGas", Type: uint256},
+		{Name: "maxFeePerGas", Type: uint256},
+		{Name: "maxPriorityFeePerGas", Type: uint256},
+		{Name: "hashPaymasterAndData", Type: bytes32},
+	}
+	packed, _ := args.Pack(
 		op.Sender,
 		op.Nonce,
-		op.InitCode,
-		op.CallData,
+		crypto.Keccak256Hash(op.InitCode),
+		crypto.Keccak256Hash(op.CallData),
 		op.CallGasLimit,
 		op.VerificationGasLimit,
 		op.PreVerificationGas,
 		op.MaxFeePerGas,
 		op.MaxPriorityFeePerGas,
-		op.PaymasterAndData,
-		[]byte{},
-	})
+		crypto.Keccak256Hash(op.PaymasterAndData),
+	)
 
-	// Return with stripped leading word (total length) and trailing word (zero-length signature).
-	enc := hexutil.Encode(packed)
-	enc = "0x" + enc[66:len(enc)-64]
-	return (hexutil.MustDecode(enc))
+	return packed
 }
 
 // GetUserOpHash returns the hash of the userOp + entryPoint address + chainID.
@@ -196,3 +191,17 @@ func (op *UserOperation) MarshalJSON() ([]byte, error) {
 		Signature:            hexutil.Encode(op.Signature),
 	})
 }
+
+// ToMap returns the current UserOp struct as a map type.
+func (op *UserOperation) ToMap() (map[string]any, error) {
+	data, err := op.MarshalJSON()
+	if err != nil {
+		return nil, err
+	}
+
+	var opData map[string]any
+	if err := json.Unmarshal(data, &opData); err != nil {
+		return nil, err
+	}
+	return opData, nil
+}