zksync-sso 0.0.0-beta.1

package/src/client/actions/account.ts

@@ -0,0 +1,198 @@
+import { type Account, type Address, type Chain, type Client, getAddress, type Hash, type Hex, parseAbi, type Prettify, toHex, type TransactionReceipt, type Transport } from "viem";
+import { readContract, waitForTransactionReceipt, writeContract } from "viem/actions";
+import { getGeneralPaymasterInput } from "viem/zksync";
+
+import { FactoryAbi } from "../../abi/Factory.js";
+import { encodeModuleData, encodePasskeyModuleParameters, encodeSession } from "../../utils/encoding.js";
+import { noThrow } from "../../utils/helpers.js";
+import { getPasskeySignatureFromPublicKeyBytes, getPublicKeyBytesFromPasskeySignature } from "../../utils/passkey.js";
+import type { SessionConfig } from "../../utils/session.js";
+
+/* TODO: try to get rid of most of the contract params like passkey, session */
+/* it should come from factory, not passed manually each time */
+export type DeployAccountArgs = {
+  credentialPublicKey: Uint8Array; // Public key of the previously registered
+  paymasterAddress?: Address; // Paymaster used to pay the fees of creating accounts
+  paymasterInput?: Hex; // Input for paymaster (if provided)
+  expectedOrigin?: string; // Expected origin of the passkey
+  uniqueAccountId?: string; // Unique account ID, can be omitted if you don't need it
+  contracts: {
+    accountFactory: Address;
+    passkey: Address;
+    session: Address;
+  };
+  initialSession?: SessionConfig;
+  salt?: Uint8Array; // Random 32 bytes
+  onTransactionSent?: (hash: Hash) => void;
+};
+export type DeployAccountReturnType = {
+  address: Address;
+  transactionReceipt: TransactionReceipt;
+};
+export type FetchAccountArgs = {
+  uniqueAccountId?: string; // Unique account ID, can be omitted if you don't need it
+  expectedOrigin?: string; // Expected origin of the passkey
+  contracts: {
+    accountFactory: Address;
+    passkey: Address;
+    session: Address;
+  };
+};
+export type FetchAccountReturnType = {
+  username: string;
+  address: Address;
+  passkeyPublicKey: Uint8Array;
+};
+
+const NULL_ADDRESS = "0x0000000000000000000000000000000000000000";
+
+export const deployAccount = async <
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account,
+>(
+  client: Client<transport, chain, account>, // Account deployer (any viem client)
+  args: Prettify<DeployAccountArgs>,
+): Promise<DeployAccountReturnType> => {
+  if (!args.salt) {
+    args.salt = crypto.getRandomValues(new Uint8Array(32));
+  }
+
+  let origin: string | undefined = args.expectedOrigin;
+  if (!origin) {
+    try {
+      origin = window.location.origin;
+    } catch {
+      throw new Error("Can't identify expectedOrigin, please provide it manually");
+    }
+  }
+
+  const passkeyPublicKey = getPublicKeyBytesFromPasskeySignature(args.credentialPublicKey);
+  const encodedPasskeyParameters = encodePasskeyModuleParameters({
+    passkeyPublicKey,
+    expectedOrigin: origin,
+  });
+  const encodedPasskeyModuleData = encodeModuleData({
+    address: args.contracts.passkey,
+    parameters: encodedPasskeyParameters,
+  });
+  const accountId = args.uniqueAccountId || encodedPasskeyParameters;
+
+  const encodedSessionKeyModuleData = encodeModuleData({
+    address: args.contracts.session,
+    parameters: args.initialSession == null ? "0x" : encodeSession(args.initialSession),
+  });
+
+  let deployProxyArgs = {
+    account: client.account!,
+    chain: client.chain!,
+    address: args.contracts.accountFactory,
+    abi: FactoryAbi,
+    functionName: "deployProxy7579Account",
+    args: [
+      toHex(args.salt),
+      accountId,
+      [encodedPasskeyModuleData],
+      [encodedSessionKeyModuleData],
+      [],
+    ],
+  } as any;
+
+  if (args.paymasterAddress) {
+    deployProxyArgs = {
+      ...deployProxyArgs,
+      paymaster: args.paymasterAddress,
+      paymasterInput: args.paymasterInput ?? getGeneralPaymasterInput({ innerInput: "0x" }),
+    };
+  }
+
+  const transactionHash = await writeContract(client, deployProxyArgs);
+  if (args.onTransactionSent) {
+    noThrow(() => args.onTransactionSent?.(transactionHash));
+  }
+
+  const transactionReceipt = await waitForTransactionReceipt(client, { hash: transactionHash });
+  if (transactionReceipt.status !== "success") throw new Error("Account deployment transaction reverted");
+
+  const proxyAccountAddress = transactionReceipt.contractAddress;
+  if (!proxyAccountAddress) {
+    throw new Error("No contract address in transaction receipt");
+  }
+
+  return {
+    address: getAddress(proxyAccountAddress),
+    transactionReceipt: transactionReceipt,
+  };
+};
+
+export const fetchAccount = async <
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account,
+>(
+  client: Client<transport, chain, account>, // Account deployer (any viem client)
+  args: Prettify<FetchAccountArgs>,
+): Promise<FetchAccountReturnType> => {
+  let origin: string | undefined = args.expectedOrigin;
+  if (!origin) {
+    try {
+      origin = window.location.origin;
+    } catch {
+      throw new Error("Can't identify expectedOrigin, please provide it manually");
+    }
+  }
+
+  if (!args.contracts.accountFactory) throw new Error("Account factory address is not set");
+  if (!args.contracts.passkey) throw new Error("Passkey module address is not set");
+
+  let username: string | undefined = args.uniqueAccountId;
+  if (!username) {
+    try {
+      const credential = await navigator.credentials.get({
+        publicKey: {
+          challenge: new Uint8Array(32),
+          userVerification: "discouraged",
+        },
+      }) as PublicKeyCredential | null;
+
+      if (!credential) throw new Error("No registered passkeys");
+      username = credential.id;
+    } catch {
+      throw new Error("Unable to retrieve passkey");
+    }
+  }
+
+  if (!username) throw new Error("No account found");
+
+  const accountAddress = await readContract(client, {
+    abi: parseAbi(["function accountMappings(string) view returns (address)"]),
+    address: args.contracts.accountFactory,
+    functionName: "accountMappings",
+    args: [username],
+  });
+
+  if (!accountAddress || accountAddress == NULL_ADDRESS) throw new Error(`No account found for username: ${username}`);
+
+  const lowerKeyHalfBytes = await readContract(client, {
+    abi: parseAbi(["function lowerKeyHalf(string,address) view returns (bytes32)"]),
+    address: args.contracts.passkey,
+    functionName: "lowerKeyHalf",
+    args: [origin, accountAddress],
+  });
+  const upperKeyHalfBytes = await readContract(client, {
+    abi: parseAbi(["function upperKeyHalf(string,address) view returns (bytes32)"]),
+    address: args.contracts.passkey,
+    functionName: "upperKeyHalf",
+    args: [origin, accountAddress],
+  });
+
+  if (!lowerKeyHalfBytes || !upperKeyHalfBytes) throw new Error(`Passkey credentials not found in on-chain module for passkey ${username}`);
+
+  const passkeyPublicKey = getPasskeySignatureFromPublicKeyBytes([lowerKeyHalfBytes, upperKeyHalfBytes]);
+
+  return {
+    username,
+    address: accountAddress,
+    passkeyPublicKey,
+  };
+};

package/src/client/actions/index.ts

@@ -0,0 +1,2 @@
+export * from "./account.js";
+export * from "./session.js";

package/src/client/actions/passkey.ts

@@ -0,0 +1,165 @@
+import { startAuthentication, startRegistration } from "@simplewebauthn/browser";
+import { generateAuthenticationOptions, type GenerateAuthenticationOptionsOpts, generateRegistrationOptions, type GenerateRegistrationOptionsOpts, type VerifiedRegistrationResponse, verifyAuthenticationResponse, verifyRegistrationResponse } from "@simplewebauthn/server";
+import { type AuthenticationResponseJSON, type PublicKeyCredentialCreationOptionsJSON, type PublicKeyCredentialRequestOptionsJSON, type RegistrationResponseJSON } from "@simplewebauthn/types";
+import { type Account, type Address, type Chain, type Client, type Hash, toBytes, type Transport } from "viem";
+import { writeContract } from "viem/actions";
+
+const identifyPasskeyParams = () => {
+  let rpName: string | undefined;
+  let rpID: string | undefined;
+  let origin: string | undefined;
+  try {
+    rpName = window.location.hostname;
+    rpID = window.location.hostname;
+    origin = window.location.origin;
+  } catch {
+    // ignore
+  }
+
+  return { rpName, rpID, origin };
+};
+
+// let pubKey: Uint8Array = new Uint8Array();
+export type GeneratePasskeyRegistrationOptionsArgs = Partial<GenerateRegistrationOptionsOpts> & { userName: string; userDisplayName: string };
+export type GeneratePasskeyRegistrationOptionsReturnType = PublicKeyCredentialCreationOptionsJSON;
+export const generatePasskeyRegistrationOptions = async (args: GeneratePasskeyRegistrationOptionsArgs): Promise<GeneratePasskeyRegistrationOptionsReturnType> => {
+  let { rpName, rpID } = identifyPasskeyParams();
+  rpName = args.rpName || rpName;
+  rpID = args.rpID || rpID;
+  if (!rpName || !rpID) throw new Error("Can't set rpName and rpID automatically, please provide them manually in the arguments");
+
+  const defaultOptions: GenerateRegistrationOptionsOpts = {
+    rpName,
+    rpID,
+    userName: args.userName,
+    userDisplayName: args.userDisplayName,
+    // We want a stable id for the passkey
+    attestationType: "direct",
+    // Not preventing users from re-registering existing authenticators
+    excludeCredentials: [],
+    // See "Guiding use of authenticators via authenticatorSelection" below
+    authenticatorSelection: {
+      residentKey: "required",
+    },
+  };
+  const params: GenerateRegistrationOptionsOpts = Object.assign({}, defaultOptions, args);
+  const options = await generateRegistrationOptions(params);
+  options.pubKeyCredParams = options.pubKeyCredParams.filter(
+    (creds) => creds.alg == 1,
+  );
+
+  return options;
+};
+
+export type GeneratePasskeyAuthenticationOptionsArgs = Partial<GenerateAuthenticationOptionsOpts>;
+export type GeneratePasskeyAuthenticationOptionsReturnType = PublicKeyCredentialRequestOptionsJSON;
+export const generatePasskeyAuthenticationOptions = async (args: GeneratePasskeyAuthenticationOptionsArgs): Promise<GeneratePasskeyAuthenticationOptionsReturnType> => {
+  let { rpID } = identifyPasskeyParams();
+  rpID = args.rpID || rpID;
+  if (!rpID) throw new Error("Can't set rpID automatically, please provide them manually in the arguments");
+
+  const defaultOptions: GenerateAuthenticationOptionsOpts = {
+    rpID: rpID,
+  };
+  const params: GenerateAuthenticationOptionsOpts = Object.assign({}, defaultOptions, args);
+  const options = await generateAuthenticationOptions(params);
+  if ("pubKeyCredParams" in options) {
+    options.pubKeyCredParams = (
+      options.pubKeyCredParams as Array<{ alg: number; type: string }>
+    ).filter((creds) => creds.alg == -7);
+  }
+
+  return options;
+};
+
+export type RegisterNewPasskeyArgs = ({ passkeyRegistrationOptions: PublicKeyCredentialCreationOptionsJSON } | GeneratePasskeyRegistrationOptionsArgs) & { origin?: string };
+export type RegisterNewPasskeyReturnType = {
+  passkeyRegistrationOptions: PublicKeyCredentialCreationOptionsJSON;
+  passkeyRegistrationResponse: RegistrationResponseJSON;
+  verificationResponse: VerifiedRegistrationResponse;
+  credentialPublicKey: Uint8Array;
+  credentialId: string;
+};
+export const registerNewPasskey = async (args: RegisterNewPasskeyArgs): Promise<RegisterNewPasskeyReturnType> => {
+  let { origin } = identifyPasskeyParams();
+  origin = args.origin || origin;
+  if (!origin) throw new Error("Can't set origin automatically, please provide it manually in the arguments");
+
+  const passkeyRegistrationOptions = "passkeyRegistrationOptions" in args ? args.passkeyRegistrationOptions : await generatePasskeyRegistrationOptions(args);
+  const registrationResponse: RegistrationResponseJSON = await startRegistration(passkeyRegistrationOptions);
+  const verification = await verifyRegistrationResponse({
+    response: registrationResponse,
+    expectedChallenge: passkeyRegistrationOptions.challenge,
+    expectedOrigin: origin,
+  });
+  if (!verification.verified || !verification.registrationInfo) throw new Error("Passkey validation failed");
+
+  return {
+    passkeyRegistrationOptions,
+    passkeyRegistrationResponse: registrationResponse,
+    verificationResponse: verification,
+    credentialPublicKey: verification.registrationInfo.credentialPublicKey,
+    credentialId: verification.registrationInfo.credentialID,
+  };
+};
+
+export type RequestPasskeyAuthenticationArgs = {
+  challenge: Hash; // Transaction hash to sign
+  credentialPublicKey: Uint8Array;
+  rpID?: string;
+  origin?: string;
+};
+export type RequestPasskeyAuthenticationReturnType = {
+  passkeyAuthenticationResponse: AuthenticationResponseJSON;
+  passkeyAuthenticationOptions: PublicKeyCredentialRequestOptionsJSON;
+};
+export const requestPasskeyAuthentication = async (args: RequestPasskeyAuthenticationArgs): Promise<RequestPasskeyAuthenticationReturnType> => {
+  const passkeyAuthenticationOptions = await generatePasskeyAuthenticationOptions({
+    challenge: toBytes(args.challenge),
+  });
+  const authenticationResponse: AuthenticationResponseJSON = await startAuthentication(passkeyAuthenticationOptions);
+
+  let { rpID, origin } = identifyPasskeyParams();
+  rpID = args.rpID || passkeyAuthenticationOptions.rpId || rpID;
+  origin = args.origin || origin;
+  if (!rpID || !origin) throw new Error("Can't set rpID and origin automatically, please provide them manually in the arguments");
+
+  const verification = await verifyAuthenticationResponse({
+    response: authenticationResponse,
+    expectedChallenge: passkeyAuthenticationOptions.challenge,
+    expectedOrigin: origin,
+    expectedRPID: rpID,
+    authenticator: {
+      credentialPublicKey: args.credentialPublicKey,
+      credentialID: authenticationResponse.id,
+      counter: 0, // TODO: figure out if this has to be dynamic
+    },
+  });
+  if (!verification.verified || !verification.authenticationInfo) throw new Error("Passkey validation failed");
+
+  return {
+    passkeyAuthenticationResponse: authenticationResponse,
+    passkeyAuthenticationOptions,
+  };
+};
+
+export type AddAccountOwnerPasskeyArgs = {
+  passkeyPublicKey: Uint8Array;
+  contracts: { session: Address };
+};
+export type AddAccountOwnerPasskeyReturnType = Hash;
+export const addAccountOwnerPasskey = async <
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account,
+>(client: Client<transport, chain, account>, args: AddAccountOwnerPasskeyArgs): Promise<AddAccountOwnerPasskeyReturnType> => {
+  /* TODO: Implement set owner passkey */
+  const transactionHash = await writeContract(client, {
+    address: args.contracts.session,
+    args: [args.passkeyPublicKey],
+    abi: [] as const,
+    functionName: "USE_ACTUAL_METHOD_HERE",
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any);
+  return transactionHash;
+};

package/src/client/actions/session.ts

@@ -0,0 +1,118 @@
+import { type Account, type Address, type Chain, type Client, encodeFunctionData, type Hash, type Prettify, type TransactionReceipt, type Transport } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+import { getGeneralPaymasterInput, sendTransaction } from "viem/zksync";
+
+import { SessionKeyModuleAbi } from "../../abi/SessionKeyModule.js";
+import { noThrow } from "../../utils/helpers.js";
+import type { SessionConfig } from "../../utils/session.js";
+
+/* DO NOT USE THIS. USE FUNCTION FROM PASSKEY ACTIONS INSTEAD */
+/* TODO: Remove */
+/* export type RequestSessionArgs = Prettify<SessionPreferences & {
+  sessionKey?: Hash;
+  contracts: {
+    session: Address
+  }
+}> & ({ passkeyRegistrationResponse: RegistrationResponseJSON } | { passkeyRegistrationOptions: GeneratePasskeyRegistrationOptionsArgs });
+export type RequestSessionReturnType<chain extends Chain> = {
+  transactionReceipt: ExtractChainFormatterReturnType<chain, "transactionReceipt", TransactionReceipt>;
+  sessionKey: Hash;
+}
+export const requestSession = async <
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account
+>(client: Client<transport, chain, account>, args: RequestSessionArgs): Promise<RequestSessionReturnType<chain>> => {
+  const passkeyRegistrationResponse: RegistrationResponseJSON =
+    'passkeyRegistrationResponse' in args
+      ? args.passkeyRegistrationResponse
+      : (await requestPasskeySignature(args.passkeyRegistrationOptions)).passkeyRegistrationResponse;
+
+  const sessionKey = args.sessionKey || generatePrivateKey();
+  const sessionKeyPublicAddress = publicKeyToAddress(sessionKey);
+  const transactionHash = await createSessionWithPasskey(client, {
+    sessionKeyPublicAddress,
+    passkeyRegistrationResponse,
+    contracts: args.contracts,
+    spendLimit: args.spendLimit,
+    validUntil: args.validUntil,
+  });
+  const receipt = await waitForTransactionReceipt(client, { hash: transactionHash });
+  if (receipt.status === "reverted") throw new Error("Transaction reverted");
+  return {
+    transactionReceipt: receipt,
+    sessionKey,
+  };
+} */
+
+/* DO NOT USE THIS. USE FUNCTION FROM PASSKEY ACTIONS INSTEAD */
+/* TODO: Remove */
+/* export type CreateSessionWithPasskeyArgs = Prettify<SessionPreferences & {
+  sessionKeyPublicAddress: Address;
+  passkeyRegistrationResponse: RegistrationResponseJSON;
+  contracts: { session: Address };
+}>
+export type CreateSessionWithPasskeyReturnType = Hash;
+export const createSessionWithPasskey = async <
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account,
+>(client: Client<transport, chain, account>, args: CreateSessionWithPasskeyArgs): Promise<CreateSessionWithPasskeyReturnType> => {
+  // TODO: Implement set session
+  const transactionHash = await writeContract(client, {
+    address: args.contracts.session,
+    args: [args.sessionKeyPublicAddress, args.passkeyRegistrationResponse, args.spendLimit, args.validUntil],
+    abi: [] as const,
+    functionName: "USE_ACTUAL_METHOD_HERE2222",
+  } as any);
+  return transactionHash;
+} */
+
+export type CreateSessionArgs = {
+  sessionConfig: SessionConfig;
+  contracts: {
+    session: Address; // session module
+  };
+  onTransactionSent?: (hash: Hash) => void;
+};
+export type CreateSessionReturnType = {
+  transactionReceipt: TransactionReceipt;
+};
+export const createSession = async <
+  transport extends Transport,
+  chain extends Chain,
+  account extends Account,
+>(client: Client<transport, chain, account>, args: Prettify<CreateSessionArgs>): Promise<Prettify<CreateSessionReturnType>> => {
+  const callData = encodeFunctionData({
+    abi: SessionKeyModuleAbi,
+    functionName: "createSession",
+    args: [args.sessionConfig],
+  });
+
+  let sendTransactionArgs = {
+    to: args.contracts.session,
+    data: callData,
+    gas: 10_000_000n, // TODO: Remove when gas estimation is fixed
+  } as any;
+
+  if ((client as any).paymasterAddress) {
+    sendTransactionArgs = {
+      ...sendTransactionArgs,
+      account: client.account,
+      paymaster: (client as any).paymasterAddress,
+      paymasterInput: (client as any).paymasterInput ?? getGeneralPaymasterInput({ innerInput: "0x" }),
+    };
+  }
+
+  const transactionHash = await sendTransaction(client, sendTransactionArgs);
+  if (args.onTransactionSent) {
+    noThrow(() => args.onTransactionSent?.(transactionHash));
+  }
+
+  const transactionReceipt = await waitForTransactionReceipt(client, { hash: transactionHash });
+  if (transactionReceipt.status !== "success") throw new Error("createSession transaction reverted");
+
+  return {
+    transactionReceipt,
+  };
+};

package/src/client/clients/passkey.ts

@@ -0,0 +1,107 @@
+import { type Account, type Address, type Chain, type Client, createClient, getAddress, type Hex, type Prettify, type PublicActions, publicActions, type PublicRpcSchema, type RpcSchema, type Transport, type WalletActions, walletActions, type WalletClientConfig, type WalletRpcSchema } from "viem";
+import { eip712WalletActions } from "viem/zksync";
+
+import { passkeyHashSignatureResponseFormat } from "../../utils/passkey.js";
+import { requestPasskeyAuthentication } from "../actions/passkey.js";
+import { type ZksyncSsoPasskeyActions, zksyncSsoPasskeyActions } from "../decorators/passkey.js";
+import { toSmartAccount } from "../smart-account.js";
+
+export function createZksyncPasskeyClient<
+  transport extends Transport,
+  chain extends Chain,
+  rpcSchema extends RpcSchema | undefined = undefined,
+>(_parameters: ZksyncSsoPasskeyClientConfig<transport, chain, rpcSchema>): ZksyncSsoPasskeyClient<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 || "wallet",
+    name: _parameters.name || "ZKsync SSO Passkey Client",
+  };
+
+  const account = toSmartAccount({
+    address: parameters.address,
+    sign: async ({ hash }) => {
+      const passkeySignature = await requestPasskeyAuthentication({
+        challenge: hash,
+        credentialPublicKey: parameters.credentialPublicKey,
+      });
+
+      return passkeyHashSignatureResponseFormat(passkeySignature.passkeyAuthenticationResponse.response, parameters.contracts);
+    },
+  });
+  const client = createClient<transport, chain, Account, rpcSchema>({
+    ...parameters,
+    account,
+    type: "walletClient",
+  })
+    .extend(() => ({
+      credentialPublicKey: parameters.credentialPublicKey,
+      userName: parameters.userName,
+      userDisplayName: parameters.userDisplayName,
+      contracts: parameters.contracts,
+      paymasterAddress: parameters.paymasterAddress,
+      paymasterInput: parameters.paymasterInput,
+    }))
+    .extend(publicActions)
+    .extend(walletActions)
+    .extend(eip712WalletActions())
+    .extend(zksyncSsoPasskeyActions);
+  return client;
+}
+
+export type PasskeyRequiredContracts = {
+  session: Address; // Session, spend limit, etc.
+  passkey: Address; // Validator for passkey signature
+  accountFactory?: Address; // For account creation
+};
+type ZksyncSsoPasskeyData = {
+  credentialPublicKey: Uint8Array; // Public key of the passkey
+  userName: string; // Basically unique user id (which is called `userName` in webauthn)
+  userDisplayName: string; // Also option required for webauthn
+  contracts: PasskeyRequiredContracts;
+  paymasterAddress?: Address;
+  paymasterInput?: Hex;
+};
+
+export type ClientWithZksyncSsoPasskeyData<
+  transport extends Transport = Transport,
+  chain extends Chain = Chain,
+> = Client<transport, chain, Account> & ZksyncSsoPasskeyData;
+
+export type ZksyncSsoPasskeyClient<
+  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],
+    PublicActions<transport, chain, account> & WalletActions<chain, account> & ZksyncSsoPasskeyActions
+  > & ZksyncSsoPasskeyData
+>;
+
+export interface ZksyncSsoPasskeyClientConfig<
+  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;
+  credentialPublicKey: Uint8Array;
+  userName: string;
+  userDisplayName: string;
+  contracts: PasskeyRequiredContracts;
+  paymasterAddress?: Address;
+  paymasterInput?: Hex;
+  key?: string;
+  name?: string;
+}