feat(userop): add NewUnsignedUserOp, test (#479)

* feat(userop): add NewUnsignedUserOp, test

* refactor(userop): call NewUnsignedUserOp in NewUserOp

Author: nksazonov

pkg/userop/client.go

@@ -40,7 +40,7 @@ type Client interface {
 	//   - error - if failed to calculate it.
 	GetAccountAddress(ctx context.Context, owner common.Address, index decimal.Decimal) (common.Address, error)
 
-	// NewUserOp builds a new UserOperation and fills all the fields.
+	// NewUserOp builds and signs a new UserOperation and fills all the fields.
 	//
 	// NOTE: only `executeBatch` is supported for now.
 	//
@@ -53,8 +53,9 @@ type Client interface {
 	// 	 - overrides - are the overrides for the middleware during the user operation creation. Can be nil.
 	//
 	// Returns:
-	//   - UserOperation - user operation with all fields filled in.
+	//   - UserOperation - signed user operation with all fields filled in.
 	//   - error - if failed to build the user operation.
+	// TODO: rename to NewSignedUserOp when this pkg is extracted.
 	NewUserOp(
 		ctx context.Context,
 		sender common.Address,
@@ -64,6 +65,29 @@ type Client interface {
 		overrides *Overrides,
 	) (UserOperation, error)
 
+	// NewUserOp builds a new UserOperation and fills all the fields.
+	//
+	// NOTE: only `executeBatch` is supported for now.
+	//
+	// Parameters:
+	//   - ctx - is the context of the operation.
+	//   - smartWallet - is the address of the smart wallet that will execute the user operation.
+	//   - calls - is the list of calls to be executed in the user operation. Must not be empty.
+	//   - walletDeploymentOpts - are the options for the smart wallet deployment. Can be nil if the smart wallet is already deployed.
+	// 	 - overrides - are the overrides for the middleware during the user operation creation. Can be nil.
+	//
+	// Returns:
+	//   - UserOperation - user operation with all fields filled in.
+	//   - error - if failed to build the user operation.
+	// TODO: rename to NewUserOp when this pkg is extracted.
+	NewUnsignedUserOp(
+		ctx context.Context,
+		sender common.Address,
+		calls smart_wallet.Calls,
+		walletDeploymentOpts *WalletDeploymentOpts,
+		overrides *Overrides,
+	) (UserOperation, error)
+
 	// SignUserOp signs the user operation with the provided signer.
 	//
 	// Parameters:
@@ -261,12 +285,39 @@ func (c *backend) NewUserOp(
 		return UserOperation{}, ErrNoSigner
 	}
 
+	ctx = context.WithValue(ctx, ctxKeySigner, signer)
+
+	op, err := c.NewUnsignedUserOp(ctx, smartWallet, calls, walletDeploymentOpts, overrides)
+	if err != nil {
+		return UserOperation{}, err
+	}
+
+	// sign
+	err = c.sign(ctx, &op)
+	if err != nil {
+		return UserOperation{}, err
+	}
+
+	b, err := op.MarshalJSON()
+	if err != nil {
+		logger.Error("failed to marshal user operation", "error", err)
+	} else {
+		logger.Debug("signed successfully", "userop", string(b))
+	}
+	return op, nil
+}
+
+func (c *backend) NewUnsignedUserOp(
+	ctx context.Context,
+	smartWallet common.Address,
+	calls smart_wallet.Calls,
+	walletDeploymentOpts *WalletDeploymentOpts,
+	overrides *Overrides,
+) (UserOperation, error) {
 	if len(calls) == 0 {
 		return UserOperation{}, ErrNoCalls
 	}
 
-	ctx = context.WithValue(ctx, ctxKeySigner, signer)
-
 	callData, err := smart_wallet.BuildCallData(*c.smartWallet.Type, calls)
 	if err != nil {
 		return UserOperation{}, fmt.Errorf("failed to build call data: %w", err)
@@ -328,13 +379,13 @@ func (c *backend) NewUserOp(
 		return UserOperation{}, err
 	}
 
-	// sign before estimating gas limits, so that signature is well-formed.
-	// If signature is corrupted, this can cause SmartWallet estimation to fail,
-	// and the bundler will return an error.
-	err = c.sign(ctx, &op)
+	// Use stub signature before estimating gas limits. If signature is corrupted,
+	// this can cause SmartWallet estimation to fail, and the bundler will return an error.
+	stubSig, err := smart_wallet.GetStubSignature(*c.smartWallet.Type)
 	if err != nil {
 		return UserOperation{}, err
 	}
+	op.Signature = stubSig
 
 	// getGasLimits
 	if overridesPresent && overrides.GasLimits != nil {
@@ -353,12 +404,6 @@ func (c *backend) NewUserOp(
 		return UserOperation{}, err
 	}
 
-	// sign
-	err = c.sign(ctx, &op)
-	if err != nil {
-		return UserOperation{}, err
-	}
-
 	b, err := op.MarshalJSON()
 	if err != nil {
 		logger.Error("failed to marshal user operation", "error", err)

pkg/userop/testing/local_blockchain/main_test.go

@@ -25,7 +25,7 @@ func setLogLevel(level slog.Level) {
 	slog.SetDefault(logger)
 }
 
-func TestSimulatedRPC(t *testing.T) {
+func TestNewSend(t *testing.T) {
 	setLogLevel(slog.LevelDebug)
 	ctx := context.Background()
 
@@ -76,6 +76,61 @@ func TestSimulatedRPC(t *testing.T) {
 	require.Equal(t, transferAmount, receiverBalance, "new balance should equal the transfer amount")
 }
 
+func TestNewUnsignedSignSend(t *testing.T) {
+	setLogLevel(slog.LevelDebug)
+	ctx := context.Background()
+
+	// 1. Start a local Ethereum node
+	for i := 0; i < 3; i++ { // starting multiple nodes to test reusing existing nodes
+		ethNode := NewEthNode(ctx, t)
+		slog.Info("connecting to Ethereum node", "rpcURL", ethNode.LocalURL.String())
+	}
+	node := NewEthNode(ctx, t)
+	slog.Info("connecting to Ethereum node", "rpcURL", node.LocalURL.String())
+
+	// 2. Deploy the required contracts
+	addresses := SetupContracts(ctx, t, node)
+
+	// 3. Start the bundler
+	for i := 0; i < 3; i++ { // starting multiple bundlers to test reusing existing bundlers
+		bundler := NewBundler(ctx, t, node, addresses.EntryPoint)
+		slog.Info("connecting to bundler", "bundlerURL", bundler.LocalURL.String())
+	}
+	bundler := NewBundler(ctx, t, node, addresses.EntryPoint)
+
+	// 4. Build client
+	client := BuildClient(t, node.LocalURL, bundler.LocalURL, addresses, userop.PaymasterConfig{
+		Type: &userop.PaymasterDisabled,
+	})
+
+	// 5. Create and fund smart account
+	eoa, receiver, swAddress := setupAccounts(ctx, t, client, node)
+
+	// 6. Submit user operation
+	signer := userop.SignerForKernel(signer.NewLocalSigner(eoa.PrivateKey))
+	transferAmount := decimal.NewFromInt(1 /* 1 wei */).BigInt()
+	calls := smart_wallet.Calls{{To: receiver.Address, Value: transferAmount}}
+	params := &userop.WalletDeploymentOpts{Index: decimal.Zero, Owner: eoa.Address}
+	op, err := client.NewUnsignedUserOp(ctx, swAddress, calls, params, nil)
+	require.NoError(t, err, "failed to create new user operation")
+
+	op, err = client.SignUserOp(ctx, op, signer)
+	require.NoError(t, err, "failed to sign user operation")
+
+	slog.Info("ready to send", "userop", op)
+
+	done, err := client.SendUserOp(ctx, op)
+	require.NoError(t, err, "failed to send user operation")
+
+	receipt := <-done
+	slog.Info("transaction mined", "receipt", receipt)
+	require.True(t, receipt.Success)
+
+	receiverBalance, err := node.Client.BalanceAt(ctx, receiver.Address, nil)
+	require.NoError(t, err, "failed to fetch receiver new balance")
+	require.Equal(t, transferAmount, receiverBalance, "new balance should equal the transfer amount")
+}
+
 func TestSimulatedPaymaster(t *testing.T) {
 	setLogLevel(slog.LevelDebug)
 	ctx := context.Background()