zksync-sso 0.0.0-beta.9 → 0.2.0

package/src/abi/WebAuthValidator.ts

@@ -0,0 +1,357 @@
+export const WebAuthValidatorAbi = [
+  {
+    inputs: [],
+    name: "ACCOUNT_EXISTS",
+    type: "error",
+  },
+  {
+    inputs: [],
+    name: "BAD_CREDENTIAL_ID_LENGTH",
+    type: "error",
+  },
+  {
+    inputs: [],
+    name: "BAD_DOMAIN_LENGTH",
+    type: "error",
+  },
+  {
+    inputs: [],
+    name: "EMPTY_KEY",
+    type: "error",
+  },
+  {
+    inputs: [],
+    name: "KEY_EXISTS",
+    type: "error",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "NOT_KEY_OWNER",
+    type: "error",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "keyOwner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "originDomain",
+        type: "string",
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "credentialId",
+        type: "bytes",
+      },
+    ],
+    name: "PasskeyCreated",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "keyOwner",
+        type: "address",
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "originDomain",
+        type: "string",
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "credentialId",
+        type: "bytes",
+      },
+    ],
+    name: "PasskeyRemoved",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "credentialId",
+        type: "bytes",
+      },
+      {
+        internalType: "bytes32[2]",
+        name: "rawPublicKey",
+        type: "bytes32[2]",
+      },
+      {
+        internalType: "string",
+        name: "originDomain",
+        type: "string",
+      },
+    ],
+    name: "addValidationKey",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "originDomain",
+        type: "string",
+      },
+      {
+        internalType: "bytes",
+        name: "credentialId",
+        type: "bytes",
+      },
+      {
+        internalType: "address",
+        name: "accountAddress",
+        type: "address",
+      },
+    ],
+    name: "getAccountKey",
+    outputs: [
+      {
+        internalType: "bytes32[2]",
+        name: "",
+        type: "bytes32[2]",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes",
+      },
+    ],
+    name: "onInstall",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes",
+      },
+    ],
+    name: "onUninstall",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "originDomain",
+        type: "string",
+      },
+      {
+        internalType: "bytes",
+        name: "credentialId",
+        type: "bytes",
+      },
+    ],
+    name: "registeredAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "accountAddress",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "credentialId",
+        type: "bytes",
+      },
+      {
+        internalType: "string",
+        name: "domain",
+        type: "string",
+      },
+    ],
+    name: "removeValidationKey",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4",
+      },
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "pure",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "signedHash",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes",
+        name: "signature",
+        type: "bytes",
+      },
+    ],
+    name: "validateSignature",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "signedHash",
+        type: "bytes32",
+      },
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "txType",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "from",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "to",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "gasLimit",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "gasPerPubdataByteLimit",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "maxFeePerGas",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "maxPriorityFeePerGas",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "paymaster",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "nonce",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256",
+            name: "value",
+            type: "uint256",
+          },
+          {
+            internalType: "uint256[4]",
+            name: "reserved",
+            type: "uint256[4]",
+          },
+          {
+            internalType: "bytes",
+            name: "data",
+            type: "bytes",
+          },
+          {
+            internalType: "bytes",
+            name: "signature",
+            type: "bytes",
+          },
+          {
+            internalType: "bytes32[]",
+            name: "factoryDeps",
+            type: "bytes32[]",
+          },
+          {
+            internalType: "bytes",
+            name: "paymasterInput",
+            type: "bytes",
+          },
+          {
+            internalType: "bytes",
+            name: "reservedDynamic",
+            type: "bytes",
+          },
+        ],
+        internalType: "struct Transaction",
+        name: "transaction",
+        type: "tuple",
+      },
+    ],
+    name: "validateTransaction",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;

package/src/abi/index.ts

@@ -1,2 +1,5 @@
-export { FactoryAbi } from "./Factory.js";
-export { SessionKeyModuleAbi } from "./SessionKeyModule.js";
+export { AAFactoryAbi } from "./AAFactory.js";
+export { GuardianRecoveryValidatorAbi } from "./GuardianRecoveryValidator.js";
+export { SessionKeyValidatorAbi } from "./SessionKeyValidator.js";
+export { SsoAccountAbi } from "./SsoAccount.js";
+export { WebAuthValidatorAbi } from "./WebAuthValidator.js";

package/src/client/ecdsa/account.ts

@@ -0,0 +1,56 @@
+import type { Address } from "abitype";
+import type { CustomSource, LocalAccount } from "viem";
+import { toAccount } from "viem/accounts";
+import { serializeTransaction, type ZksyncTransactionSerializableEIP712 } from "viem/zksync";
+
+import { getEip712Domain } from "../utils/getEip712Domain.js";
+import { type Signer, toOwner } from "./types.js";
+
+export type ToEcdsaAccountParameters = {
+  /** Address of the deployed SSO Wallet */
+  address: Address;
+  /** Owner of the EOA */
+  owner: Signer;
+};
+
+export type EcdsaAccount = LocalAccount<"ssoEcdsaAccount"> & {
+  sign: NonNullable<CustomSource["sign"]>;
+};
+
+export async function toEcdsaAccount(
+  parameters: ToEcdsaAccountParameters,
+): Promise<EcdsaAccount> {
+  const { address, owner } = parameters;
+
+  const localOwner = await toOwner({ owner, address });
+
+  const account = toAccount({
+    address,
+    async signMessage({ message }) {
+      return localOwner.signMessage({ message });
+    },
+    async signTransaction(transaction) {
+      const signableTransaction = {
+        ...transaction,
+        from: this.address!,
+        type: "eip712",
+      } as ZksyncTransactionSerializableEIP712;
+
+      const eip712DomainAndMessage = getEip712Domain(signableTransaction);
+      const signature = await localOwner.signTypedData(eip712DomainAndMessage);
+
+      return serializeTransaction({
+        ...signableTransaction,
+        customSignature: signature,
+      });
+    },
+    async signTypedData(typedData) {
+      return localOwner.signTypedData(typedData);
+    },
+  });
+
+  return {
+    ...account,
+    source: "ssoEcdsaAccount",
+  } as EcdsaAccount;
+}

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

@@ -0,0 +1,145 @@
+import type { Account, Address, Chain, Client, Hash, Hex, Prettify, TransactionReceipt, Transport } from "viem";
+import { concat, encodePacked, getAddress, keccak256, parseEventLogs, toHex } from "viem";
+import { readContract, waitForTransactionReceipt, writeContract } from "viem/actions";
+import { getGeneralPaymasterInput } from "viem/zksync";
+
+import { AAFactoryAbi } from "../../../abi/AAFactory.js";
+import { type CustomPaymasterHandler } from "../../../paymaster/index.js";
+import { encodeModuleData, encodeSession } from "../../../utils/encoding.js";
+import { noThrow } from "../../../utils/helpers.js";
+import type { SessionConfig } from "../../../utils/session.js";
+
+export type DeployAccountArgs = {
+  owner: Address; // Wallet owner
+  contracts: {
+    accountFactory: Address;
+    session: Address;
+  };
+  initialSession?: SessionConfig;
+  salt?: Uint8Array; // Random 32 bytes
+  prefix?: string; // vendor prefix
+  onTransactionSent?: (hash: Hash) => void;
+  paymasterHandler?: CustomPaymasterHandler;
+  paymaster?: {
+    address: Address;
+    paymasterInput?: Hex;
+  };
+};
+
+export type DeployAccountReturnType = {
+  address: Address;
+  transactionReceipt: TransactionReceipt;
+};
+
+export type FetchAccountArgs = {
+  prefix?: string; // vendor prefix
+  owner: Address; // Wallet owner
+  contracts: {
+    accountFactory: Address;
+    session: Address;
+  };
+};
+
+export type FetchAccountReturnType = {
+  address: Address;
+  owner: Address;
+};
+
+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));
+  }
+
+  if (args.prefix && args.prefix.length > 12) throw new Error("prefix must not be longer than 12");
+
+  const uniqueId = concat([toHex(args.prefix || "", { size: 12 }), args.owner]);
+
+  const encodedSessionKeyModuleData = encodeModuleData({
+    address: args.contracts.session,
+    parameters: args.initialSession ? encodeSession(args.initialSession) : "0x",
+  });
+
+  let deployProxyArgs = {
+    account: client.account!,
+    chain: client.chain!,
+    address: args.contracts.accountFactory,
+    abi: AAFactoryAbi,
+    functionName: "deployProxySsoAccount",
+    args: [
+      uniqueId,
+      [encodedSessionKeyModuleData],
+      [args.owner],
+    ],
+  } as any;
+
+  if (args.paymaster) {
+    deployProxyArgs = {
+      ...deployProxyArgs,
+      paymaster: args.paymaster.address,
+      paymasterInput: args.paymaster.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 accountCreatedEvent = parseEventLogs({ abi: AAFactoryAbi, logs: transactionReceipt.logs })
+    .find((log) => log && log.eventName === "AccountCreated");
+
+  if (!accountCreatedEvent) {
+    throw new Error("No contract address in transaction receipt");
+  }
+
+  const { accountAddress } = accountCreatedEvent.args;
+
+  return {
+    address: getAddress(accountAddress),
+    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> => {
+  if (!args.contracts.accountFactory) throw new Error("Account factory address is not set");
+
+  if (args.prefix && args.prefix.length > 12) throw new Error("prefix must not be longer than 12");
+
+  const uniqueId = concat([toHex(args.prefix || "", { size: 12 }), args.owner]);
+  const accountId = keccak256(encodePacked(["bytes32", "address"], [uniqueId, client.account.address]));
+
+  if (!accountId) throw new Error("No account ID provided");
+
+  const accountAddress = await readContract(client, {
+    abi: AAFactoryAbi,
+    address: args.contracts.accountFactory,
+    functionName: "accountMappings",
+    args: [accountId],
+  });
+
+  if (!accountAddress || accountAddress == NULL_ADDRESS) throw new Error(`No account found for ID: ${accountId}`);
+
+  return {
+    address: accountAddress,
+    owner: args.owner,
+  };
+};

package/src/client/ecdsa/client.ts

@@ -0,0 +1,90 @@
+import { type Account, type Address, type Chain, type Client, createClient, getAddress, 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 type { CustomPaymasterHandler } from "../../paymaster/index.js";
+import { toEcdsaAccount } from "./account.js";
+import { type ZksyncSsoEcdsaActions, zksyncSsoEcdsaActions } from "./decorators/ecdsa.js";
+import { zksyncSsoEcdsaWalletActions } from "./decorators/wallet.js";
+import type { Signer } from "./types.js";
+
+export async function createZksyncEcdsaClient<
+  transport extends Transport,
+  chain extends Chain,
+  rpcSchema extends RpcSchema | undefined = undefined,
+>(_parameters: ZksyncSsoEcdsaClientConfig<transport, chain, rpcSchema>): Promise<ZksyncSsoEcdsaClient<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-ecdsa-wallet",
+    name: _parameters.name || "ZKsync SSO ECDSA Client",
+  };
+
+  const account = await toEcdsaAccount({
+    address: parameters.address,
+    owner: parameters.owner,
+  });
+
+  const client = createClient<transport, chain, Account, rpcSchema>({
+    ...parameters,
+    account,
+    type: "walletClient",
+  })
+    .extend(() => ({
+      contracts: parameters.contracts,
+    }))
+    .extend(publicActions)
+    .extend(walletActions)
+    .extend(eip712WalletActions())
+    .extend(zksyncSsoEcdsaActions)
+    .extend(zksyncSsoEcdsaWalletActions);
+  return client;
+}
+
+export type EcdsaRequiredContracts = {
+  session: Address; // Session, spend limit, etc.
+  accountFactory?: Address; // For account creation
+};
+
+type ZksyncSsoEcdsaData = {
+  contracts: EcdsaRequiredContracts;
+  paymasterHandler?: CustomPaymasterHandler;
+};
+
+export type ClientWithZksyncSsoEcdsaData<
+  transport extends Transport = Transport,
+  chain extends Chain = Chain,
+> = Client<transport, chain, Account> & ZksyncSsoEcdsaData;
+
+export type ZksyncSsoEcdsaClient<
+  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> & ZksyncSsoEcdsaActions
+  > & ZksyncSsoEcdsaData
+>;
+
+export interface ZksyncSsoEcdsaClientConfig<
+  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;
+  owner: Signer;
+  contracts: EcdsaRequiredContracts;
+  key?: string;
+  name?: string;
+}

package/src/client/ecdsa/decorators/ecdsa.ts

@@ -0,0 +1,32 @@
+import { type Chain, type Transport } from "viem";
+
+import {
+  createSession, type CreateSessionArgs, type CreateSessionReturnType,
+  revokeSession, type RevokeSessionArgs, type RevokeSessionReturnType,
+} from "../../session/actions/session.js";
+import type { ClientWithZksyncSsoEcdsaData } from "../client.js";
+
+export type ZksyncSsoEcdsaActions = {
+  createSession: (args: Omit<CreateSessionArgs, "contracts">) => Promise<CreateSessionReturnType>;
+  revokeSession: (args: Omit<RevokeSessionArgs, "contracts">) => Promise<RevokeSessionReturnType>;
+};
+
+export const zksyncSsoEcdsaActions = <
+  transport extends Transport = Transport,
+  chain extends Chain = Chain,
+>(client: ClientWithZksyncSsoEcdsaData<transport, chain>) => {
+  return {
+    createSession: async (args: Omit<CreateSessionArgs, "contracts">) => {
+      return await createSession(client, {
+        ...args,
+        contracts: client.contracts,
+      });
+    },
+    revokeSession: async (args: Omit<RevokeSessionArgs, "contracts">) => {
+      return await revokeSession(client, {
+        ...args,
+        contracts: client.contracts,
+      });
+    },
+  };
+};