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

package/src/client/session/account.ts

@@ -1,59 +1,224 @@
-import type { Address } from "abitype";
-import { type CustomSource, type Hash, hashTypedData, type Hex, type LocalAccount } from "viem";
-import { toAccount } from "viem/accounts";
-import { serializeTransaction, type ZksyncTransactionSerializableEIP712 } from "viem/zksync";
+import {
+  type Address,
+  type Chain,
+  type Hash,
+  type Hex,
+  type PublicClient,
+  type Transport,
+} from "viem";
+import {
+  entryPoint08Abi,
+  entryPoint08Address,
+  getUserOperationHash,
+  toSmartAccount,
+  type ToSmartAccountReturnType,
+} from "viem/account-abstraction";
+import {
+  decode_nonce_result,
+  encode_get_nonce_call_data,
+  encode_session_execute_call_data,
+  generate_session_stub_signature_wasm,
+  keyed_nonce_decimal,
+  session_signature_no_validation_wasm,
+} from "zksync-sso-web-sdk/bundler";
 
-import { getEip712Domain } from "../utils/getEip712Domain.js";
+import type { SessionSpec } from "./types.js";
+import { sessionSpecToJSON } from "./utils.js";
 
-export type ToSessionAccountParameters = {
-  /** Address of the deployed Account's Contract implementation. */
-  address: Address;
-  signTransaction: (parameters: { hash: Hash; to: Address; callData?: Hash }) => Promise<Hex>;
+export type SessionRequiredContracts = {
+  /** Session validator contract address (required for signature generation). */
+  sessionValidator: Address;
 };
 
-export type SessionAccount = LocalAccount<"ssoSessionAccount"> & {
-  sign: NonNullable<CustomSource["sign"]>;
+export type ToSessionSmartAccountParams<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = {
+  /** Public client used internally by the smart account implementation (must have chain). */
+  client: PublicClient<TTransport, TChain>;
+  /** Session key private key (used to sign user operations within policy limits). */
+  sessionKeyPrivateKey: Hash;
+  /** Smart account address (required - no counterfactual support). */
+  address: Address;
+  /** Session specification defining policies and limits. */
+  sessionSpec: SessionSpec;
+  /** Optional timestamp override (for testing or special timestamp handling). */
+  currentTimestamp?: bigint;
+  /** Session required contracts. */
+  contracts: SessionRequiredContracts;
+  /** Optional override for EntryPoint address (defaults to viem's entryPoint08Address). */
+  entryPointAddress?: Address;
 };
 
-export function toSessionAccount(
-  parameters: ToSessionAccountParameters,
-): SessionAccount {
-  const { address, signTransaction } = parameters;
-
-  const account = toAccount({
-    address,
-    async signTransaction(transaction) {
-      const signableTransaction = {
-        ...transaction,
-        from: this.address!,
-        type: "eip712",
-      } as ZksyncTransactionSerializableEIP712;
-
-      const eip712DomainAndMessage = getEip712Domain(signableTransaction);
-      const digest = hashTypedData(eip712DomainAndMessage);
-
-      return serializeTransaction({
-        ...signableTransaction,
-        customSignature: await signTransaction({
-          hash: digest,
-          to: signableTransaction.to!,
-          callData: signableTransaction.data,
-        }),
+/**
+ * Builds a SSO SmartAccount instance which uses a session key for signing within policy limits.
+ * This allows delegated transaction signing with enforced limits on gas fees, transfer values, and call parameters.
+ */
+export async function toSessionSmartAccount<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+>({
+  client,
+  sessionKeyPrivateKey,
+  address,
+  contracts,
+  sessionSpec,
+  currentTimestamp,
+  entryPointAddress,
+}: ToSessionSmartAccountParams<TTransport, TChain>): Promise<ToSmartAccountReturnType> {
+  // Precompute session spec JSON once
+  const sessionSpecJSON = sessionSpecToJSON(sessionSpec);
+  const epAddress = entryPointAddress ?? entryPoint08Address;
+
+  return toSmartAccount({
+    client,
+    entryPoint: {
+      abi: entryPoint08Abi,
+      address: epAddress,
+      version: "0.8",
+    },
+    async getNonce() {
+      const sender = await this.getAddress();
+
+      // Get the nonce key for this session signer
+      const nonceKeyDecimal = keyed_nonce_decimal(sessionSpec.signer);
+
+      // Encode the getNonce call with the session's nonce key
+      const calldata = encode_get_nonce_call_data(sender, nonceKeyDecimal) 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);
+    },
+
+    // --- Calls encoding (session 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 for session accounts. Only single execute() calls are allowed.",
+        );
+      }
+
+      const call = calls[0];
+
+      // Use Rust SDK for encoding session execute
+      const valueStr = (call.value ?? 0n).toString();
+
+      const encoded = encode_session_execute_call_data(
+        call.to,
+        valueStr,
+        call.data ?? "0x",
+      ) as Hex;
+
+      return encoded;
+    },
+
+    async decodeCalls() {
+      throw new Error("decodeCalls is not supported yet for session accounts.");
     },
-    sign: async () => {
-      throw new Error(`account.sign not supported for SSO Session Client`);
+
+    // --- Address & factory args ---
+    async getAddress() {
+      // Return the provided address (no counterfactual support yet)
+      return address;
     },
-    signMessage: async () => {
-      throw new Error(`account.signMessage not supported for SSO Session Client`);
+    async getFactoryArgs() {
+      // No counterfactual deployment support yet
+      throw new Error(
+        "getFactoryArgs is not supported for session accounts. Deploy the account first and provide the address.",
+      );
     },
-    signTypedData: async () => {
-      throw new Error(`account.signTypedData not supported for SSO Session Client`);
+
+    // --- Stubs & signing ---
+    async getStubSignature() {
+      // Generate session stub signature for gas estimation
+      const timestampStr = currentTimestamp?.toString();
+      return generate_session_stub_signature_wasm(
+        contracts.sessionValidator,
+        sessionSpecJSON,
+        timestampStr,
+      ) as Hex;
     },
-  });
+    async signMessage({ message }) {
+      throw new Error(
+        `signMessage is not supported for session accounts. Message: ${String(message)}`,
+      );
+    },
+
+    async signTypedData() {
+      throw new Error("signTypedData is not supported for session accounts");
+    },
+    async signUserOperation(params) {
+      const sender = await this.getAddress();
+
+      // Default undefined fields to 0n to avoid runtime errors during early signing.
+      const nonce = params.nonce ?? 0n;
+      const callGasLimit = params.callGasLimit ?? 0n;
+      const verificationGasLimit = params.verificationGasLimit ?? 0n;
+      const preVerificationGas = params.preVerificationGas ?? 0n;
+      const maxFeePerGas = params.maxFeePerGas ?? 0n;
+      const maxPriorityFeePerGas = params.maxPriorityFeePerGas ?? 0n;
+      const paymasterAndData = (params.paymasterAndData ?? "0x") as Hex;
 
-  return {
-    ...account,
-    source: "ssoSessionAccount",
-  } as SessionAccount;
+      // Debug: Log effective gas & nonce passed into signing to diagnose zero-gas AA23 issues
+      console.debug(
+        "[toSessionSmartAccount] signUserOperation params:",
+        {
+          nonce: nonce.toString(),
+          callGasLimit: callGasLimit.toString(),
+          verificationGasLimit: verificationGasLimit.toString(),
+          preVerificationGas: preVerificationGas.toString(),
+          maxFeePerGas: maxFeePerGas.toString(),
+          maxPriorityFeePerGas: maxPriorityFeePerGas.toString(),
+        },
+      );
+
+      // Compute user operation hash locally using viem helper (includes paymasterAndData)
+      const userOpHash = getUserOperationHash({
+        chainId: Number(client.chain!.id),
+        entryPointAddress: this.entryPoint.address,
+        entryPointVersion: "0.8",
+        userOperation: {
+          sender,
+          nonce,
+          initCode: (params.initCode ?? "0x") as Hex,
+          callData: (params.callData ?? "0x") as Hex,
+          callGasLimit,
+          verificationGasLimit,
+          preVerificationGas,
+          maxFeePerGas,
+          maxPriorityFeePerGas,
+          paymasterAndData,
+          signature: "0x",
+        },
+      } as any) as Hex;
+
+      // Parse target and selector from callData for validation
+      // The callData is already encoded by encodeCalls, so we need to extract execute() params
+      // For now, we'll trust that the session policies are validated at contract level
+      // In a full implementation, you'd decode the execute call to validate against session spec
+
+      const timestampStr = currentTimestamp?.toString();
+
+      // Sign using session key with no validation (contract will validate)
+      const signature = session_signature_no_validation_wasm(
+        sessionKeyPrivateKey,
+        contracts.sessionValidator,
+        sessionSpecJSON,
+        userOpHash,
+        timestampStr,
+      ) as Hex;
+
+      return signature;
+    },
+  });
 }

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

@@ -0,0 +1,62 @@
+import type {
+  Account,
+  Address,
+  Chain,
+  Client,
+  Transport,
+} from "viem";
+import type { BundlerClient } from "viem/account-abstraction";
+
+import type { PaymasterConfig } from "../../actions/sendUserOperation.js";
+import {
+  type SmartAccountClientActions,
+  smartAccountClientActions,
+} from "../common/smart-account-client-actions.js";
+import { toSessionSmartAccount, type ToSessionSmartAccountParams } from "./account.js";
+
+/**
+ * Extended client data needed for session smart account wrapper
+ */
+export type SessionClientData<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = {
+  bundler: BundlerClient;
+  sessionAccount: ToSessionSmartAccountParams<TTransport, TChain>;
+  accountAddress: Address;
+  paymaster?: PaymasterConfig;
+};
+
+/**
+ * Session client actions extend generic smart account actions but:
+ *  - Remove addPasskey (not applicable for pure session key accounts)
+ */
+export type SessionClientActions<
+  TChain extends Chain = Chain,
+  TAccount extends Account = Account,
+> = Omit<SmartAccountClientActions<TChain, TAccount>, "addPasskey">;
+
+/**
+ * Decorator providing session-specific client actions
+ */
+export function sessionClientActions<
+  TTransport extends Transport,
+  TChain extends Chain,
+  TAccount extends Account | undefined = undefined,
+>(
+  config: SessionClientData<TTransport, TChain> & { client: Client<TTransport, TChain, TAccount> },
+): SessionClientActions<TChain, TAccount extends Account ? TAccount : Account> {
+  const base = smartAccountClientActions<TTransport, TChain, TAccount>({
+    bundler: config.bundler,
+    accountFactory: () => toSessionSmartAccount(config.sessionAccount),
+    client: config.client,
+    accountAddress: config.accountAddress,
+    paymaster: config.paymaster,
+  });
+
+  return {
+    ...base,
+    // Remove addPasskey (not valid for session-only signing)
+    addPasskey: undefined as never,
+  } as SessionClientActions<TChain, TAccount extends Account ? TAccount : Account>;
+}

package/src/client/session/client.ts

@@ -1,173 +1,134 @@
-import { type Account, type Address, type Chain, type Client, createClient, createPublicClient, encodeAbiParameters, getAddress, type Hash, type Prettify, publicActions, type PublicRpcSchema, type RpcSchema, type Transport, type WalletClientConfig, type WalletRpcSchema } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-import { zksyncInMemoryNode } from "viem/chains";
+import {
+  type Address,
+  type Chain,
+  type Client,
+  createClient,
+  createPublicClient,
+  type Hash,
+  type Prettify,
+  type PublicActions,
+  publicActions,
+  type PublicRpcSchema,
+  type RpcSchema,
+  type Transport,
+  walletActions,
+  type WalletRpcSchema,
+} from "viem";
+import type { BundlerClient } from "viem/account-abstraction";
 
-import type { CustomPaymasterHandler } from "../../paymaster/index.js";
-import { encodeSessionTx } from "../../utils/encoding.js";
-import type { SessionConfig, SessionStateEventCallback } from "../../utils/session.js";
-import { toSessionAccount } from "./account.js";
-import { getSessionState, sessionStateNotify } from "./actions/session.js";
-import { publicActionsRewrite } from "./decorators/publicActionsRewrite.js";
-import { type ZksyncSsoWalletActions, zksyncSsoWalletActions } from "./decorators/wallet.js";
+import type { PaymasterConfig } from "../../actions/sendUserOperation.js";
+import type { SessionRequiredContracts, ToSessionSmartAccountParams } from "./account.js";
+import { type SessionClientActions, sessionClientActions } from "./client-actions.js";
+import type { SessionSpec } from "./types.js";
 
-export const signSessionTransaction = (args: {
-  sessionKeySignedHash: Hash;
-  sessionContract: Address;
-  sessionConfig: SessionConfig;
-  to: Address;
-  callData?: Hash;
-  timestamp?: bigint;
-}) => {
-  return encodeAbiParameters(
-    [
-      { type: "bytes", name: "sessionKeySignedHash" },
-      { type: "address", name: "sessionContract" },
-      { type: "bytes", name: "validatorData" },
-    ],
-    [
-      args.sessionKeySignedHash,
-      args.sessionContract,
-      encodeSessionTx({
-        sessionConfig: args.sessionConfig,
-        to: args.to,
-        callData: args.callData,
-        timestamp: args.timestamp,
-      }),
-    ],
-  );
+/** Parameters for creating a Session smart account client */
+export type CreateSessionClientParams<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = {
+  /** Smart account address (already deployed) */
+  address: Address;
+  /** Session key private key */
+  sessionKeyPrivateKey: Hash;
+  /** Session specification governing allowed actions */
+  sessionSpec: SessionSpec;
+  /** Session required contracts */
+  contracts: SessionRequiredContracts;
+  /** Bundler client instance */
+  bundlerClient: BundlerClient;
+  /** Chain config */
+  chain: TChain;
+  /** Transport for public RPC */
+  transport: TTransport;
+  /** Optional paymaster configuration for sponsoring transactions */
+  paymaster?: PaymasterConfig;
+  /** Optional timestamp override for signature generation */
+  currentTimestamp?: bigint;
+  /** Optional override for EntryPoint address used by the account implementation. */
+  entryPointAddress?: Address;
+  /** Optional client metadata */
+  key?: string;
+  name?: string;
 };
 
-export function createZksyncSessionClient<
-  transport extends Transport,
-  chain extends Chain,
-  rpcSchema extends RpcSchema | undefined = undefined,
->(_parameters: ZksyncSsoSessionClientConfig<transport, chain, rpcSchema>): ZksyncSsoSessionClient<transport, chain, rpcSchema> {
-  type WalletClientParameters = typeof _parameters;
-  const parameters: WalletClientParameters & {
-    key: NonNullable<WalletClientParameters["key"]>;
-    name: NonNullable<WalletClientParameters["name"]>;
-  } = {
-    ..._parameters,
-    address: getAddress(_parameters.address),
-    key: _parameters.key || "zksync-sso-session-wallet",
-    name: _parameters.name || "ZKsync SSO Session Client",
-  };
+/** Session client type with actions */
+export type SessionClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+  TRpcSchema extends RpcSchema | undefined = undefined,
+> = Prettify<
+  Client<
+    TTransport,
+    TChain,
+    undefined,
+    TRpcSchema extends RpcSchema
+      ? [...PublicRpcSchema, ...WalletRpcSchema, ...TRpcSchema]
+      : [...PublicRpcSchema, ...WalletRpcSchema]
+  > &
+  PublicActions<TTransport, TChain> &
+  SessionClientActions & {
+    bundler: BundlerClient;
+  }
+>;
 
-  const getInMemoryNodeTimestamp = async () => {
-    const publicClient = createPublicClient({ chain: parameters.chain, transport: parameters.transport });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const timestamp: number = await publicClient.request({ method: "config_getCurrentTimestamp" as any });
-    return BigInt(timestamp);
-  };
+/**
+ * Create a client wrapping a session smart account. Provides wallet-like API
+ * plus helpers for session creation & state queries. Transactions sent via
+ * sendTransaction or sendSessionTransaction are encoded as session execute() calls.
+ */
+export function createSessionClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+  TRpcSchema extends RpcSchema | undefined = undefined,
+>(
+  params: CreateSessionClientParams<TTransport, TChain>,
+): SessionClient<TTransport, TChain, TRpcSchema> {
+  const {
+    address,
+    contracts,
+    sessionKeyPrivateKey,
+    sessionSpec,
+    bundlerClient,
+    chain,
+    transport,
+    currentTimestamp,
+    paymaster,
+  } = params;
 
-  const account = toSessionAccount({
-    address: parameters.address,
-    signTransaction: async ({ hash, to, callData }) => {
-      // In Memory Node uses a different timestamp mechanism which isn't equal to actual timestamp
-      const timestamp = parameters.chain.id === zksyncInMemoryNode.id
-        ? await getInMemoryNodeTimestamp()
-        : undefined;
+  const publicClient = createPublicClient({ chain, transport });
 
-      const sessionKeySigner = privateKeyToAccount(parameters.sessionKey);
-      const hashSignature = await sessionKeySigner.sign({ hash });
+  const sessionAccountParams: ToSessionSmartAccountParams = {
+    client: publicClient as ToSessionSmartAccountParams["client"],
+    address,
+    contracts,
+    sessionKeyPrivateKey,
+    sessionSpec,
+    currentTimestamp,
+    entryPointAddress: params.entryPointAddress,
+  };
 
-      return signSessionTransaction({
-        sessionKeySignedHash: hashSignature,
-        sessionContract: parameters.contracts.session,
-        sessionConfig: parameters.sessionConfig,
-        to,
-        callData,
-        timestamp,
-      });
-    },
-  });
-  const client = createClient<transport, chain, Account, rpcSchema>({
-    ...parameters,
-    account,
+  const client = createClient({
+    chain,
+    transport,
+    account: undefined,
     type: "walletClient",
+    key: params.key || "zksync-sso-session-client",
+    name: params.name || "ZKsync SSO Session Client",
   })
-    .extend(() => ({
-      sessionKey: parameters.sessionKey,
-      sessionConfig: parameters.sessionConfig,
-      contracts: parameters.contracts,
-      paymasterHandler: parameters.paymasterHandler,
-      onSessionStateChange: parameters.onSessionStateChange,
-      _sessionNotifyTimeout: undefined as NodeJS.Timeout | undefined,
-    }))
     .extend(publicActions)
-    .extend(publicActionsRewrite)
-    .extend(zksyncSsoWalletActions);
-
-  // Check session state on initialization if callback is provided
-  if (client.onSessionStateChange) {
-    getSessionState(client, {
-      account: client.account.address,
-      sessionConfig: client.sessionConfig,
-      contracts: client.contracts,
-    }).then(({ sessionState }) => {
-      sessionStateNotify({
-        sessionConfig: client.sessionConfig,
-        sessionState,
-        onSessionStateChange: client.onSessionStateChange!,
-        sessionNotifyTimeout: client._sessionNotifyTimeout,
-      });
-    }).catch((error) => {
-      console.error("Failed to get session state on initialization:", error);
-    });
-  }
-
-  return client;
-}
-
-export type SessionRequiredContracts = {
-  session: Address; // Session, spend limit, etc.
-};
-type ZksyncSsoSessionData = {
-  sessionKey: Hash;
-  sessionConfig: SessionConfig;
-  contracts: SessionRequiredContracts;
-  paymasterHandler?: CustomPaymasterHandler;
-  onSessionStateChange?: SessionStateEventCallback;
-  skipPreTransactionStateValidation?: boolean;
-  _sessionNotifyTimeout?: NodeJS.Timeout;
-};
-
-export type ClientWithZksyncSsoSessionData<
-  transport extends Transport = Transport,
-  chain extends Chain = Chain,
-  account extends Account = Account,
-> = Client<transport, chain, account> & ZksyncSsoSessionData;
-
-export type ZksyncSsoSessionClient<
-  transport extends Transport = Transport,
-  chain extends Chain = Chain,
-  rpcSchema extends RpcSchema | undefined = undefined,
-  account extends Account = Account,
-> = Prettify<
-  Client<
-    transport,
-    chain,
-    account,
-    rpcSchema extends RpcSchema
-      ? [...PublicRpcSchema, ...WalletRpcSchema, ...rpcSchema]
-      : [...PublicRpcSchema, ...WalletRpcSchema],
-    ZksyncSsoWalletActions<chain, account>
-  > & ZksyncSsoSessionData
->;
+    .extend(walletActions)
+    .extend((client) =>
+      sessionClientActions({
+        client,
+        bundler: bundlerClient,
+        sessionAccount: sessionAccountParams,
+        accountAddress: address,
+        paymaster,
+      }),
+    )
+    .extend(() => ({
+      bundler: bundlerClient,
+    }));
 
-export interface ZksyncSsoSessionClientConfig<
-  transport extends Transport = Transport,
-  chain extends Chain = Chain,
-  rpcSchema extends RpcSchema | undefined = undefined,
-> extends Omit<WalletClientConfig<transport, chain, Account, rpcSchema>, "account"> {
-  chain: NonNullable<chain>;
-  address: Address;
-  sessionKey: Hash;
-  sessionConfig: SessionConfig;
-  contracts: SessionRequiredContracts;
-  key?: string;
-  name?: string;
-  paymasterHandler?: CustomPaymasterHandler;
-  onSessionStateChange?: SessionStateEventCallback;
-  skipPreTransactionStateValidation?: boolean; // Useful if you want to send session transactions really fast
+  return client as SessionClient<TTransport, TChain, TRpcSchema>;
 }