zksync-sso 0.5.0-beta.3 → 1.0.0-beta.2

package/src/client/common/smart-account-client-actions.ts

@@ -0,0 +1,317 @@
+import {
+  type Account,
+  type Address,
+  type Chain,
+  type Client,
+  encodeFunctionData,
+  type Hash,
+  type Hex,
+  type Transport,
+  type WalletActions,
+} from "viem";
+import type { BundlerClient, ToSmartAccountReturnType } from "viem/account-abstraction";
+import {
+  getAddresses,
+  getCallsStatus,
+  getCapabilities,
+  getChainId,
+  sendRawTransaction as viemSendRawTransaction,
+  showCallsStatus,
+  waitForCallsStatus,
+} from "viem/actions";
+
+import type { PaymasterConfig } from "../../actions/sendUserOperation.js";
+import { addPasskey as addPasskeyAction } from "../actions/passkey.js";
+
+/**
+ * Generic smart account client configuration
+ */
+export type SmartAccountClientData<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = {
+  /** Bundler client for sending user operations */
+  bundler: BundlerClient;
+  /** Factory function to create smart account (lazy-loaded) */
+  accountFactory: () => Promise<ToSmartAccountReturnType>;
+  /** Client for making RPC calls */
+  client: Client<TTransport, TChain, Account | undefined>;
+  /** Smart account address */
+  accountAddress: Address;
+  /** Optional paymaster configuration for sponsoring transactions - can be either a full config object or just an address string */
+  paymaster?: PaymasterConfig | Address;
+};
+
+/**
+ * Wallet actions type for smart account client
+ * Based on WalletActions but omits methods that don't make sense for smart accounts or are overridden
+ */
+export type SmartAccountClientActions<TChain extends Chain = Chain, TAccount extends Account = Account> = Omit<
+  WalletActions<TChain, TAccount>,
+  "addChain" | "getPermissions" | "requestAddresses" | "requestPermissions" | "switchChain" | "watchAsset" | "prepareTransactionRequest" | "signTransaction"
+> & {
+
+  /**
+   * Add a passkey to the smart account.
+   * Returns the transaction hash.
+   */
+  addPasskey: (params: {
+    credentialId: Hex;
+    publicKey: { x: Hex; y: Hex };
+    originDomain: string;
+    webauthnValidatorAddress: Address;
+  }) => Promise<Hash>;
+
+  /**
+   * Wait for a user operation receipt.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  waitForUserOperationReceipt: (params: { hash: Hash }) => Promise<any>;
+};
+
+/**
+ * Generic decorator that provides wallet actions for smart account clients.
+ * Overrides standard wallet methods to use ERC-4337 bundler under the hood.
+ * Works with any smart account type (passkey, ECDSA, etc.) that returns ToSmartAccountReturnType.
+ */
+export function smartAccountClientActions<
+  TTransport extends Transport,
+  TChain extends Chain,
+  TAccount extends Account | undefined = undefined,
+>(
+  config: SmartAccountClientData<TTransport, TChain>,
+): SmartAccountClientActions<TChain, TAccount extends Account ? TAccount : Account> {
+  // Normalize paymaster to PaymasterConfig format at the start
+  // config.paymaster can be either PaymasterConfig object OR string address
+  const normalizedPaymaster = config.paymaster
+    ? typeof config.paymaster === "string"
+      ? {
+          address: config.paymaster as Address,
+          verificationGasLimit: 500_000n,
+          postOpGasLimit: 1_000_000n,
+          data: "0x" as `0x${string}`,
+        }
+      : config.paymaster
+    : undefined;
+
+  // Lazy-load the smart account (cached after first load)
+  let smartAccountPromise: Promise<ToSmartAccountReturnType> | null = null;
+  const getSmartAccount = async (): Promise<ToSmartAccountReturnType> => {
+    if (!smartAccountPromise) {
+      smartAccountPromise = config.accountFactory();
+    }
+    return smartAccountPromise;
+  };
+
+  return {
+    // Read-only actions - pass through
+    getAddresses: () => getAddresses(config.client),
+    getChainId: () => getChainId(config.client),
+    getCallsStatus: (args) => getCallsStatus(config.client, args),
+    getCapabilities: (args) => getCapabilities(config.client, args),
+    showCallsStatus: (args) => showCallsStatus(config.client, args),
+    waitForCallsStatus: (args) => waitForCallsStatus(config.client, args),
+
+    // Send raw transaction - pass through to transport
+    sendRawTransaction: (args) => viemSendRawTransaction(config.client, args),
+
+    deployContract: () => {
+      throw new Error("deployContract is not supported for smart accounts.");
+    },
+
+    // Send multiple calls in a single userOp
+    sendCalls: async (args) => {
+      const account = await getSmartAccount();
+
+      // For v0.8 EntryPoint, pass separate paymaster fields (not packed paymasterAndData)
+      // These fields get included in the UserOp BEFORE signing
+      const paymasterParams = normalizedPaymaster
+        ? {
+            paymaster: normalizedPaymaster.address,
+            paymasterData: normalizedPaymaster.data ?? ("0x" as Hex),
+            paymasterVerificationGasLimit: normalizedPaymaster.verificationGasLimit ?? 500_000n,
+            paymasterPostOpGasLimit: normalizedPaymaster.postOpGasLimit ?? 1_000_000n,
+          }
+        : {};
+
+      // Send all calls through bundler in a single userOp
+      const userOpHash = await config.bundler.sendUserOperation({
+        account,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        calls: args.calls.map((call: any) => ({
+          to: call.to!,
+          value: call.value ?? 0n,
+          data: call.data ?? "0x",
+        })),
+        ...paymasterParams,
+      });
+
+      // Return the userOp hash as the ID in the expected format
+      return {
+        id: userOpHash,
+      };
+    },
+
+    signTypedData: async () => {
+      throw new Error("signTypedData is not supported for this smart account type");
+    },
+    signMessage: async () => {
+      throw new Error("signMessage is not supported for this smart account type");
+    },
+
+    // Unsupported signing actions - throw errors
+    signAuthorization: () => {
+      throw new Error("signAuthorization is not supported for smart accounts");
+    },
+    prepareAuthorization: () => {
+      throw new Error("prepareAuthorization is not supported for smart accounts");
+    },
+
+    // Override sendTransaction to use bundler
+    // Note: We accept an extended parameter set with optional paymaster
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendTransaction: async (args: any) => {
+      const account = await getSmartAccount();
+
+      // Use per-transaction paymaster if provided, otherwise fall back to config
+      const paymasterAddress = args.paymaster ?? normalizedPaymaster?.address;
+
+      // For v0.8 EntryPoint, pass separate paymaster fields (not packed paymasterAndData)
+      // These fields get included in the UserOp BEFORE signing
+      const paymasterParams
+        = normalizedPaymaster || paymasterAddress
+          ? {
+              paymaster: paymasterAddress!,
+              paymasterData: normalizedPaymaster?.data ?? ("0x" as Hex),
+              paymasterVerificationGasLimit: normalizedPaymaster?.verificationGasLimit ?? 500_000n,
+              paymasterPostOpGasLimit: normalizedPaymaster?.postOpGasLimit ?? 1_000_000n,
+            }
+          : {};
+
+      // Send user operation through bundler
+      const userOpHash = await config.bundler.sendUserOperation({
+        account,
+        calls: [
+          {
+            to: args.to!,
+            value: args.value ?? 0n,
+            data: args.data ?? "0x",
+          },
+        ],
+        ...paymasterParams,
+      });
+
+      // Wait for the user operation to be included and get the actual transaction hash
+      const receipt = await config.bundler.waitForUserOperationReceipt({
+        hash: userOpHash,
+      });
+
+      // Return the actual transaction hash (not the userOp hash)
+      // This makes the client fully compatible with EOA behavior
+      return receipt.receipt.transactionHash;
+    },
+
+    // Override writeContract to use bundler
+    writeContract: async (args) => {
+      const account = await getSmartAccount();
+
+      // Encode the contract call data
+      const data = encodeFunctionData({
+        abi: args.abi,
+        functionName: args.functionName,
+        args: args.args,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any);
+
+      // For paymaster to be included in signature, use paymasterContext not callback
+      const paymasterParams = normalizedPaymaster
+        ? {
+            paymaster: normalizedPaymaster.address,
+            paymasterData: normalizedPaymaster.data ?? ("0x" as Hex),
+            paymasterVerificationGasLimit: normalizedPaymaster.verificationGasLimit ?? 500_000n,
+            paymasterPostOpGasLimit: normalizedPaymaster.postOpGasLimit ?? 1_000_000n,
+          }
+        : {};
+
+      // Send through bundler
+      const userOpHash = await config.bundler.sendUserOperation({
+        account,
+        calls: [
+          {
+            to: args.address,
+            value: args.value ?? 0n,
+            data,
+          },
+        ],
+        ...paymasterParams,
+      });
+
+      // Wait for confirmation and return actual tx hash
+      const receipt = await config.bundler.waitForUserOperationReceipt({
+        hash: userOpHash,
+      });
+
+      return receipt.receipt.transactionHash;
+    },
+
+    // Add passkey to the smart account
+    addPasskey: async (params: {
+      credentialId: Hex;
+      publicKey: { x: Hex; y: Hex };
+      originDomain: string;
+      webauthnValidatorAddress: Address;
+    }) => {
+      const account = await getSmartAccount();
+
+      // Generate the transaction using the existing addPasskey function
+      const { transaction } = addPasskeyAction({
+        account: config.accountAddress,
+        contracts: {
+          webauthnValidator: params.webauthnValidatorAddress,
+        },
+        passkeySigner: {
+          credentialId: params.credentialId,
+          publicKey: params.publicKey,
+          originDomain: params.originDomain,
+        },
+      });
+
+      const paymasterParams = normalizedPaymaster
+        ? {
+            paymaster: normalizedPaymaster.address,
+            paymasterData: normalizedPaymaster.data ?? ("0x" as Hex),
+            paymasterVerificationGasLimit: normalizedPaymaster.verificationGasLimit ?? 500_000n,
+            paymasterPostOpGasLimit: normalizedPaymaster.postOpGasLimit ?? 1_000_000n,
+          }
+        : {};
+
+      // Send the transaction through bundler
+      const userOpHash = await config.bundler.sendUserOperation({
+        account,
+        calls: [
+          {
+            to: transaction.to,
+            data: transaction.data,
+            value: 0n,
+          },
+        ],
+        ...paymasterParams,
+      });
+
+      // Wait for the user operation to be included
+      const receipt = await config.bundler.waitForUserOperationReceipt({
+        hash: userOpHash,
+      });
+
+      // Return the actual transaction hash from the receipt
+      return receipt.receipt.transactionHash;
+    },
+
+    // Bundler-specific helper
+    waitForUserOperationReceipt: (params: { hash: Hash }) => {
+      return config.bundler.waitForUserOperationReceipt({
+        hash: params.hash,
+      });
+    },
+  };
+}

package/src/client/ecdsa/account.ts

@@ -1,56 +1,160 @@
-import type { Address } from "abitype";
-import type { CustomSource, LocalAccount } from "viem";
-import { toAccount } from "viem/accounts";
-import { serializeTransaction, type ZksyncTransactionSerializableEIP712 } from "viem/zksync";
+import {
+  type Address,
+  type Chain,
+  type Hash,
+  hashMessage,
+  type Hex,
+  type PublicClient,
+  type Transport,
+} from "viem";
+import {
+  entryPoint08Abi,
+  entryPoint08Address,
+  getUserOperationHash,
+  toSmartAccount,
+  type ToSmartAccountReturnType,
+} from "viem/account-abstraction";
+import {
+  decode_nonce_result,
+  encode_execute_call_data,
+  encode_get_nonce_call_data,
+  generate_eoa_stub_signature,
+  sign_eoa_message,
+  sign_eoa_user_operation_hash,
+} from "zksync-sso-web-sdk/bundler";
 
-import { getEip712Domain } from "../utils/getEip712Domain.js";
-import { type Signer, toOwner } from "./types.js";
-
-export type ToEcdsaAccountParameters = {
-  /** Address of the deployed SSO Wallet */
+export type ToEcdsaSmartAccountParams<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = {
+  /** Public client used internally by the smart account implementation (must have chain). */
+  client: PublicClient<TTransport, TChain>;
+  /** EOA signer private key. */
+  signerPrivateKey: Hash;
+  /** Smart account address (required - no counterfactual support). */
   address: Address;
-  /** Owner of the EOA */
-  owner: Signer;
+  /** EOA validator contract address (required for stub signature generation). */
+  eoaValidatorAddress: Address;
+  /** Optional override for EntryPoint address (defaults to viem's entryPoint08Address). */
+  entryPointAddress?: Address;
 };
 
-export type EcdsaAccount = LocalAccount<"ssoEcdsaAccount"> & {
-  sign: NonNullable<CustomSource["sign"]>;
-};
+/**
+ * Builds a SSO SmartAccount instance which uses an ECDSA EOA for signing.
+ */
+export async function toEcdsaSmartAccount<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+>({
+  client,
+  signerPrivateKey,
+  address,
+  eoaValidatorAddress,
+  entryPointAddress,
+}: ToEcdsaSmartAccountParams<TTransport, TChain>): Promise<ToSmartAccountReturnType> {
+  const epAddress = entryPointAddress ?? entryPoint08Address;
+  return toSmartAccount({
+    client,
+    entryPoint: {
+      abi: entryPoint08Abi,
+      address: epAddress,
+      version: "0.8",
+    },
+    async getNonce() {
+      const sender = await this.getAddress();
+      const calldata = encode_get_nonce_call_data(sender, "0") as Hex;
+      const result = await client.request({
+        method: "eth_call",
+        params: [{
+          from: sender,
+          to: epAddress,
+          data: calldata,
+        }],
+      });
+      const nonceStr = decode_nonce_result(result);
+      return BigInt(nonceStr as string);
+    },
 
-export async function toEcdsaAccount(
-  parameters: ToEcdsaAccountParameters,
-): Promise<EcdsaAccount> {
-  const { address, owner } = parameters;
+    // --- Calls encoding (execute only - batch not supported yet) ---
+    async encodeCalls(calls) {
+      // Only support single calls (no batch operations)
+      if (calls.length !== 1) {
+        throw new Error("Batch transactions are not supported. Only single execute() calls are allowed.");
+      }
 
-  const localOwner = await toOwner({ owner, address });
+      const call = calls[0];
 
-  const account = toAccount({
-    address,
-    async signMessage({ message }) {
-      return localOwner.signMessage({ message });
+      // Use Rust SDK for encoding
+      // Convert value to string (Rust expects string representation)
+      const valueStr = (call.value ?? 0n).toString();
+
+      // Call Rust SDK to encode
+      const encoded = encode_execute_call_data(
+        call.to,
+        valueStr,
+        call.data ?? "0x",
+      ) as Hex;
+
+      return encoded;
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async decodeCalls(data) {
+      throw new Error("decodeCalls is not supported yet.");
     },
-    async signTransaction(transaction) {
-      const signableTransaction = {
-        ...transaction,
-        from: this.address!,
-        type: "eip712",
-      } as ZksyncTransactionSerializableEIP712;
 
-      const eip712DomainAndMessage = getEip712Domain(signableTransaction);
-      const signature = await localOwner.signTypedData(eip712DomainAndMessage);
+    // --- Address & factory args ---
+    async getAddress() {
+      // Simply return the provided address (no counterfactual support yet)
+      return address;
+    },
+    async getFactoryArgs() {
+      // No counterfactual deployment support yet
+      throw new Error("getFactoryArgs is not supported. Deploy the account first and provide the address.");
+    },
 
-      return serializeTransaction({
-        ...signableTransaction,
-        customSignature: signature,
-      });
+    // --- Stubs & signing ---
+    async getStubSignature() {
+      // Use Rust SDK to generate proper stub signature
+      return generate_eoa_stub_signature(eoaValidatorAddress) as Hex;
     },
-    async signTypedData(typedData) {
-      return localOwner.signTypedData(typedData);
+    async signMessage({ message }) {
+      // Hash the message if it's not already hashed
+      const messageToSign = typeof message === "string" ? message : hashMessage(message);
+      return sign_eoa_message(signerPrivateKey, messageToSign) as Hex;
     },
-  });
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async signTypedData({ domain, types, primaryType, message }) {
+      throw new Error("signTypedData is not supported for ECDSA smart accounts");
+    },
+    async signUserOperation(params) {
+      const sender = await this.getAddress();
+      // Compute user operation hash locally with full fields (including paymaster)
+      const userOpHash = getUserOperationHash({
+        chainId: Number(client.chain!.id),
+        entryPointAddress: this.entryPoint.address,
+        entryPointVersion: "0.8",
+        userOperation: {
+          sender,
+          nonce: params.nonce,
+          initCode: (params.initCode ?? "0x") as Hex,
+          callData: (params.callData ?? "0x") as Hex,
+          callGasLimit: params.callGasLimit,
+          verificationGasLimit: params.verificationGasLimit,
+          preVerificationGas: params.preVerificationGas,
+          maxFeePerGas: params.maxFeePerGas,
+          maxPriorityFeePerGas: params.maxPriorityFeePerGas,
+          paymasterAndData: (params.paymasterAndData ?? "0x") as Hex,
+          signature: "0x",
+        },
+      } as any) as Hex;
+
+      const signature = sign_eoa_user_operation_hash(
+        userOpHash,
+        signerPrivateKey,
+        eoaValidatorAddress,
+      ) as Hex;
 
-  return {
-    ...account,
-    source: "ssoEcdsaAccount",
-  } as EcdsaAccount;
+      return signature;
+    },
+  });
 }

package/src/client/ecdsa/client-actions.ts

@@ -0,0 +1,54 @@
+import type {
+  Account,
+  Address,
+  Chain,
+  Client,
+  Transport,
+} from "viem";
+import type { BundlerClient } from "viem/account-abstraction";
+
+import {
+  type SmartAccountClientActions,
+  smartAccountClientActions,
+} from "../common/smart-account-client-actions.js";
+import { toEcdsaSmartAccount, type ToEcdsaSmartAccountParams } from "./account.js";
+
+/**
+ * Extended client type that includes bundler-specific configuration for ECDSA
+ */
+export type EcdsaClientData<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = {
+  bundler: BundlerClient;
+  ecdsaAccount: ToEcdsaSmartAccountParams<TTransport, TChain>;
+  accountAddress: Address;
+};
+
+/**
+ * Wallet actions type for ECDSA client
+ * Uses generic smart account actions (no ECDSA-specific actions needed)
+ */
+export type EcdsaClientActions<TChain extends Chain = Chain, TAccount extends Account = Account> = SmartAccountClientActions<TChain, TAccount>;
+
+/**
+ * Decorator that provides wallet actions for ECDSA client.
+ * Overrides standard wallet methods to use ERC-4337 bundler under the hood.
+ */
+export function ecdsaClientActions<
+  TTransport extends Transport,
+  TChain extends Chain,
+  TAccount extends Account | undefined = undefined,
+>(
+  config: EcdsaClientData<TTransport, TChain> & {
+    client: Client<TTransport, TChain, TAccount>;
+  },
+): EcdsaClientActions<TChain, TAccount extends Account ? TAccount : Account> {
+  // Return generic smart account actions
+  return smartAccountClientActions<TTransport, TChain, TAccount>({
+    bundler: config.bundler,
+    accountFactory: () => toEcdsaSmartAccount(config.ecdsaAccount),
+    client: config.client,
+    accountAddress: config.accountAddress,
+  });
+}