@alchemy/wallet-apis 0.0.0-alpha.13 → 0.0.0-alpha.15

package/dist/esm/actions/grantPermissions.js

@@ -1,7 +1,8 @@
 import { toHex, concatHex, } from "viem";
 import { signSignatureRequest } from "./signSignatureRequest.js";
-import { AccountNotFoundError } from "@alchemy/common";
+import { AccountNotFoundError, BaseError } from "@alchemy/common";
 import { LOGGER } from "../logger.js";
+import { isWebAuthnAccount } from "../utils/assertions.js";
 /**
  * Grants permissions to a smart account by creating a session.
  * This allows another key to perform operations on behalf of the account.
@@ -62,6 +63,10 @@ export async function grantPermissions(client, params) {
         LOGGER.warn("grantPermissions:no-account");
         throw new AccountNotFoundError();
     }
+    if (isWebAuthnAccount(client.owner)) {
+        LOGGER.warn("grantPermissions:unsupported-account");
+        throw new BaseError("WebAuthn signer is not currently supported for grantPermissions");
+    }
     LOGGER.debug("grantPermissions:start", { expirySec: params.expirySec });
     const { sessionId, signatureRequest } = await client.request({
         method: "wallet_createSession",
@@ -78,7 +83,9 @@ export async function grantPermissions(client, params) {
         context: concatHex([
             "0x00", // Remote mode.
             sessionId,
-            signature.data,
+            signature.type === "webauthn-p256"
+                ? signature.data.signature
+                : signature.data,
         ]),
     };
     LOGGER.debug("grantPermissions:done");

package/dist/esm/actions/grantPermissions.js.map

@@ -1 +1 @@
-{"version":3,"file":"grantPermissions.js","sourceRoot":"","sources":["../../../src/actions/grantPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAKL,SAAS,GACV,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAyBtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAGpC,MAA4B,EAC5B,MAAwC;IAExC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;QAC3C,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IACD,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;IACxE,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC3D,MAAM,EAAE,sBAAsB;QAC9B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,OAAO;gBACP,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aAClD;SACF;KACF,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACvE,MAAM,GAAG,GAAG;QACV,OAAO,EAAE,SAAS,CAAC;YACjB,MAAM,EAAE,eAAe;YACvB,SAAS;YACT,SAAS,CAAC,IAAI;SACf,CAAC;KACM,CAAC;IACX,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACtC,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import {\n  toHex,\n  type Address,\n  type Hex,\n  type IsUndefined,\n  type Prettify,\n  concatHex,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../types.ts\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport { AccountNotFoundError } from \"@alchemy/common\";\nimport { LOGGER } from \"../logger.js\";\nimport type { OptionalChainId } from \"../types.ts\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_createSession\";\n    };\n  }\n>;\n\nexport type GrantPermissionsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<\n  OptionalChainId<Omit<RpcSchema[\"Request\"][\"params\"][0], \"account\">> &\n    (IsUndefined<TAccount> extends true\n      ? { account: Address }\n      : { account?: never })\n>;\n\nexport type GrantPermissionsResult = Prettify<{\n  context: Hex;\n}>;\n\n/**\n * Grants permissions to a smart account by creating a session.\n * This allows another key to perform operations on behalf of the account.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {GrantPermissionsParams} params - The parameters for granting permissions\n * @param {Address} [params.account] - The account address (required if client was not initialized with an account)\n * @param {number} params.expirySec - Unix timestamp when the permissions expire\n * @param {sessionKeyData} params.key - The session key information\n * @param {string} params.key.publicKey - The public key of the session key\n * @param {string} params.key.type - The type of the key (e.g., \"secp256k1\")\n * @param {Array} params.permissions - Array of permission objects defining what the session key can do\n * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier\n *\n * @example\n * ```ts\n * // Create a session key and grant root permissions\n * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();\n * const account = await client.requestAccount();\n *\n * const permissions = await client.grantPermissions({\n *   account: account.address,\n *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now\n *   key: {\n *     publicKey: await sessionKey.getAddress(),\n *     type: \"secp256k1\",\n *   },\n *   permissions: [{ type: \"root\" }],\n * });\n *\n * // Use the permissions to prepare a call\n * const preparedCalls = await client.prepareCalls({\n *   calls: [{ to: zeroAddress, value: \"0x0\" }],\n *   from: account.address,\n *   capabilities: {\n *     paymasterService: {\n *       policyId: \"your-paymaster-policy-id\",\n *     },\n *     permissions,\n *   },\n * });\n *\n * // Sign with the session key\n * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);\n *\n * // Send the prepared call using the session key\n * const result = await client.sendPreparedCalls({\n *   ...signedCalls,\n *   capabilities: {\n *     permissions,\n *   },\n * });\n * ```\n */\nexport async function grantPermissions<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: GrantPermissionsParams<TAccount>,\n): Promise<GrantPermissionsResult> {\n  const account = params.account ?? client.account?.address;\n  if (!account) {\n    LOGGER.warn(\"grantPermissions:no-account\");\n    throw new AccountNotFoundError();\n  }\n  LOGGER.debug(\"grantPermissions:start\", { expirySec: params.expirySec });\n  const { sessionId, signatureRequest } = await client.request({\n    method: \"wallet_createSession\",\n    params: [\n      {\n        ...params,\n        account,\n        chainId: params.chainId ?? toHex(client.chain.id),\n      },\n    ],\n  });\n\n  const signature = await signSignatureRequest(client, signatureRequest);\n  const res = {\n    context: concatHex([\n      \"0x00\", // Remote mode.\n      sessionId,\n      signature.data,\n    ]),\n  } as const;\n  LOGGER.debug(\"grantPermissions:done\");\n  return res;\n}\n"]}
+{"version":3,"file":"grantPermissions.js","sourceRoot":"","sources":["../../../src/actions/grantPermissions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAKL,SAAS,GACV,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAwB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAGpC,MAA4B,EAC5B,MAAwC;IAExC,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1D,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAC;QAC3C,MAAM,IAAI,oBAAoB,EAAE,CAAC;IACnC,CAAC;IACD,IAAI,iBAAiB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QACpC,MAAM,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;QACpD,MAAM,IAAI,SAAS,CACjB,iEAAiE,CAClE,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;IACxE,MAAM,EAAE,SAAS,EAAE,gBAAgB,EAAE,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC3D,MAAM,EAAE,sBAAsB;QAC9B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,OAAO;gBACP,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;aAClD;SACF;KACF,CAAC,CAAC;IAEH,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAEvE,MAAM,GAAG,GAAG;QACV,OAAO,EAAE,SAAS,CAAC;YACjB,MAAM,EAAE,eAAe;YACvB,SAAS;YACT,SAAS,CAAC,IAAI,KAAK,eAAe;gBAChC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS;gBAC1B,CAAC,CAAC,SAAS,CAAC,IAAI;SACnB,CAAC;KACM,CAAC;IACX,MAAM,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACtC,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import {\n  toHex,\n  type Address,\n  type Hex,\n  type IsUndefined,\n  type Prettify,\n  concatHex,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../types.ts\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport { AccountNotFoundError, BaseError } from \"@alchemy/common\";\nimport { LOGGER } from \"../logger.js\";\nimport type { OptionalChainId } from \"../types.ts\";\nimport { isWebAuthnAccount } from \"../utils/assertions.js\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_createSession\";\n    };\n  }\n>;\n\nexport type GrantPermissionsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<\n  OptionalChainId<Omit<RpcSchema[\"Request\"][\"params\"][0], \"account\">> &\n    (IsUndefined<TAccount> extends true\n      ? { account: Address }\n      : { account?: never })\n>;\n\nexport type GrantPermissionsResult = Prettify<{\n  context: Hex;\n}>;\n\n/**\n * Grants permissions to a smart account by creating a session.\n * This allows another key to perform operations on behalf of the account.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {GrantPermissionsParams} params - The parameters for granting permissions\n * @param {Address} [params.account] - The account address (required if client was not initialized with an account)\n * @param {number} params.expirySec - Unix timestamp when the permissions expire\n * @param {sessionKeyData} params.key - The session key information\n * @param {string} params.key.publicKey - The public key of the session key\n * @param {string} params.key.type - The type of the key (e.g., \"secp256k1\")\n * @param {Array} params.permissions - Array of permission objects defining what the session key can do\n * @returns {Promise<GrantPermissionsResult>} A Promise that resolves to the result containing a context identifier\n *\n * @example\n * ```ts\n * // Create a session key and grant root permissions\n * const sessionKey = LocalAccountSigner.generatePrivateKeySigner();\n * const account = await client.requestAccount();\n *\n * const permissions = await client.grantPermissions({\n *   account: account.address,\n *   expirySec: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now\n *   key: {\n *     publicKey: await sessionKey.getAddress(),\n *     type: \"secp256k1\",\n *   },\n *   permissions: [{ type: \"root\" }],\n * });\n *\n * // Use the permissions to prepare a call\n * const preparedCalls = await client.prepareCalls({\n *   calls: [{ to: zeroAddress, value: \"0x0\" }],\n *   from: account.address,\n *   capabilities: {\n *     paymasterService: {\n *       policyId: \"your-paymaster-policy-id\",\n *     },\n *     permissions,\n *   },\n * });\n *\n * // Sign with the session key\n * const signedCalls = await signPreparedCalls(sessionKey, preparedCalls);\n *\n * // Send the prepared call using the session key\n * const result = await client.sendPreparedCalls({\n *   ...signedCalls,\n *   capabilities: {\n *     permissions,\n *   },\n * });\n * ```\n */\nexport async function grantPermissions<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: GrantPermissionsParams<TAccount>,\n): Promise<GrantPermissionsResult> {\n  const account = params.account ?? client.account?.address;\n  if (!account) {\n    LOGGER.warn(\"grantPermissions:no-account\");\n    throw new AccountNotFoundError();\n  }\n  if (isWebAuthnAccount(client.owner)) {\n    LOGGER.warn(\"grantPermissions:unsupported-account\");\n    throw new BaseError(\n      \"WebAuthn signer is not currently supported for grantPermissions\",\n    );\n  }\n\n  LOGGER.debug(\"grantPermissions:start\", { expirySec: params.expirySec });\n  const { sessionId, signatureRequest } = await client.request({\n    method: \"wallet_createSession\",\n    params: [\n      {\n        ...params,\n        account,\n        chainId: params.chainId ?? toHex(client.chain.id),\n      },\n    ],\n  });\n\n  const signature = await signSignatureRequest(client, signatureRequest);\n\n  const res = {\n    context: concatHex([\n      \"0x00\", // Remote mode.\n      sessionId,\n      signature.type === \"webauthn-p256\"\n        ? signature.data.signature\n        : signature.data,\n    ]),\n  } as const;\n  LOGGER.debug(\"grantPermissions:done\");\n  return res;\n}\n"]}

package/dist/esm/actions/listAccounts.d.ts

@@ -1,14 +1,22 @@
 import type { InnerWalletApiClient } from "../types.ts";
 import type { Address, Prettify } from "viem";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+import type { WebAuthnPublicKey } from "@alchemy/wallet-api-types";
 type RpcSchema = Extract<WalletServerRpcSchemaType, {
     Request: {
         method: "wallet_listAccounts";
     };
 }>;
-export type ListAccountsParams = Prettify<Omit<RpcSchema["Request"]["params"][0], "signerAddress"> & {
+export type ListAccountsParams = Prettify<Omit<RpcSchema["Request"]["params"][0], "signerAddress"> & ({
     signerAddress?: Address;
-}>;
+    signerPublicKey?: never;
+} | {
+    signerPublicKey: WebAuthnPublicKey;
+    signerAddress?: never;
+} | {
+    signerAddress?: never;
+    signerPublicKey?: never;
+})>;
 export type ListAccountsResult = Prettify<RpcSchema["ReturnType"]>;
 /**
  * Lists all smart accounts for a given signer using the wallet API client.

package/dist/esm/actions/listAccounts.js

@@ -1,4 +1,5 @@
 import { LOGGER } from "../logger.js";
+import { getSignerAddressOrPublicKey } from "../utils/signer.js";
 /**
  * Lists all smart accounts for a given signer using the wallet API client.
  *
@@ -26,14 +27,34 @@ import { LOGGER } from "../logger.js";
  * ```
  */
 export async function listAccounts(client, params) {
-    const signerAddress = params.signerAddress ?? client.owner.account.address;
+    const owner = getSignerAddressOrPublicKey(client.owner);
+    // Coalesce:
+    // signerAddress or signerPublicKey in params takes priority.
+    // if not present, then fallback to client's attached signer.
+    const signerParam = params.signerAddress
+        ? { signerAddress: params.signerAddress }
+        : params.signerPublicKey
+            ? {
+                signerPublicKey: {
+                    type: "webauthn-p256",
+                    ...params.signerPublicKey,
+                },
+            }
+            : owner.type === "webauthn-p256"
+                ? {
+                    signerPublicKey: {
+                        type: "webauthn-p256",
+                        ...owner.publicKey,
+                    },
+                }
+                : { signerAddress: owner.address };
     LOGGER.debug("listAccounts:start", { hasAfter: !!params.after });
     const res = await client.request({
         method: "wallet_listAccounts",
         params: [
             {
                 ...params,
-                signerAddress,
+                ...signerParam,
             },
         ],
     });

package/dist/esm/actions/listAccounts.js.map

@@ -1 +1 @@
-{"version":3,"file":"listAccounts.js","sourceRoot":"","sources":["../../../src/actions/listAccounts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAqBtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA4B,EAC5B,MAA0B;IAE1B,MAAM,aAAa,GAAG,MAAM,CAAC,aAAa,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;IAC3E,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IACjE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,aAAa;aACd;SACF;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAClE,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { InnerWalletApiClient } from \"../types.ts\";\nimport { LOGGER } from \"../logger.js\";\nimport type { Address, Prettify } from \"viem\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_listAccounts\";\n    };\n  }\n>;\n\nexport type ListAccountsParams = Prettify<\n  Omit<RpcSchema[\"Request\"][\"params\"][0], \"signerAddress\"> & {\n    signerAddress?: Address;\n  }\n>;\n\nexport type ListAccountsResult = Prettify<RpcSchema[\"ReturnType\"]>;\n\n/**\n * Lists all smart accounts for a given signer using the wallet API client.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {ListAccountsParams} params - Parameters for listing accounts\n * @param {string} params.signerAddress - The address of the signer to list accounts for\n * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)\n * @param {string} [params.after] - Optional pagination cursor for fetching subsequent pages\n * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata\n *\n * @example\n * ```ts\n * // Fetch the first page of accounts\n * const firstPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10\n * });\n *\n * // If an 'after' cursor exists, use it to fetch the next page\n * const nextPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10,\n *   after: firstPage.meta.after\n * });\n * ```\n */\nexport async function listAccounts(\n  client: InnerWalletApiClient,\n  params: ListAccountsParams,\n): Promise<ListAccountsResult> {\n  const signerAddress = params.signerAddress ?? client.owner.account.address;\n  LOGGER.debug(\"listAccounts:start\", { hasAfter: !!params.after });\n  const res = await client.request({\n    method: \"wallet_listAccounts\",\n    params: [\n      {\n        ...params,\n        signerAddress,\n      },\n    ],\n  });\n  LOGGER.debug(\"listAccounts:done\", { count: res.accounts.length });\n  return res;\n}\n"]}
+{"version":3,"file":"listAccounts.js","sourceRoot":"","sources":["../../../src/actions/listAccounts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AA6BjE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,MAA4B,EAC5B,MAA0B;IAE1B,MAAM,KAAK,GAAG,2BAA2B,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAExD,YAAY;IACZ,6DAA6D;IAC7D,6DAA6D;IAC7D,MAAM,WAAW,GAAsC,MAAM,CAAC,aAAa;QACzE,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,EAAE;QACzC,CAAC,CAAC,MAAM,CAAC,eAAe;YACtB,CAAC,CAAC;gBACE,eAAe,EAAE;oBACf,IAAI,EAAE,eAAe;oBACrB,GAAG,MAAM,CAAC,eAAe;iBAC1B;aACF;YACH,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,eAAe;gBAC9B,CAAC,CAAC;oBACE,eAAe,EAAE;wBACf,IAAI,EAAE,eAAe;wBACrB,GAAG,KAAK,CAAC,SAAS;qBACnB;iBACF;gBACH,CAAC,CAAC,EAAE,aAAa,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IAEzC,MAAM,CAAC,KAAK,CAAC,oBAAoB,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IACjE,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAC/B,MAAM,EAAE,qBAAqB;QAC7B,MAAM,EAAE;YACN;gBACE,GAAG,MAAM;gBACT,GAAG,WAAW;aACf;SACF;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,GAAG,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IAElE,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { InnerWalletApiClient } from \"../types.ts\";\nimport { LOGGER } from \"../logger.js\";\nimport type { Address, Prettify } from \"viem\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport { getSignerAddressOrPublicKey } from \"../utils/signer.js\";\nimport type { WebAuthnPublicKey } from \"@alchemy/wallet-api-types\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_listAccounts\";\n    };\n  }\n>;\n\nexport type ListAccountsParams = Prettify<\n  Omit<RpcSchema[\"Request\"][\"params\"][0], \"signerAddress\"> &\n    (\n      | {\n          signerAddress?: Address;\n          signerPublicKey?: never;\n        }\n      | { signerPublicKey: WebAuthnPublicKey; signerAddress?: never }\n      | {\n          signerAddress?: never;\n          signerPublicKey?: never;\n        }\n    )\n>;\n\nexport type ListAccountsResult = Prettify<RpcSchema[\"ReturnType\"]>;\n\n/**\n * Lists all smart accounts for a given signer using the wallet API client.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {ListAccountsParams} params - Parameters for listing accounts\n * @param {string} params.signerAddress - The address of the signer to list accounts for\n * @param {number} [params.limit] - Optional maximum number of accounts to return (default: 100, max: 100)\n * @param {string} [params.after] - Optional pagination cursor for fetching subsequent pages\n * @returns {Promise<ListAccountsResult>} A Promise that resolves to the list of accounts and pagination metadata\n *\n * @example\n * ```ts\n * // Fetch the first page of accounts\n * const firstPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10\n * });\n *\n * // If an 'after' cursor exists, use it to fetch the next page\n * const nextPage = await client.listAccounts({\n *   signerAddress: \"0x123...\",\n *   limit: 10,\n *   after: firstPage.meta.after\n * });\n * ```\n */\nexport async function listAccounts(\n  client: InnerWalletApiClient,\n  params: ListAccountsParams,\n): Promise<ListAccountsResult> {\n  const owner = getSignerAddressOrPublicKey(client.owner);\n\n  // Coalesce:\n  // signerAddress or signerPublicKey in params takes priority.\n  // if not present, then fallback to client's attached signer.\n  const signerParam: RpcSchema[\"Request\"][\"params\"][0] = params.signerAddress\n    ? { signerAddress: params.signerAddress }\n    : params.signerPublicKey\n      ? {\n          signerPublicKey: {\n            type: \"webauthn-p256\",\n            ...params.signerPublicKey,\n          },\n        }\n      : owner.type === \"webauthn-p256\"\n        ? {\n            signerPublicKey: {\n              type: \"webauthn-p256\",\n              ...owner.publicKey,\n            },\n          }\n        : { signerAddress: owner.address };\n\n  LOGGER.debug(\"listAccounts:start\", { hasAfter: !!params.after });\n  const res = await client.request({\n    method: \"wallet_listAccounts\",\n    params: [\n      {\n        ...params,\n        ...signerParam,\n      },\n    ],\n  });\n  LOGGER.debug(\"listAccounts:done\", { count: res.accounts.length });\n\n  return res;\n}\n"]}

package/dist/esm/actions/requestAccount.d.ts

@@ -1,13 +1,20 @@
 import type { Address } from "abitype";
-import type { Prettify, UnionOmit } from "viem";
+import { type Prettify } from "viem";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
-import type { InnerWalletApiClient, OptionalSignerAddress } from "../types";
+import type { InnerWalletApiClient } from "../types";
+import type { WebAuthnPublicKey } from "@alchemy/wallet-api-types";
 type RpcSchema = Extract<WalletServerRpcSchemaType, {
     Request: {
         method: "wallet_requestAccount";
     };
 }>;
-export type RequestAccountParams = Prettify<OptionalSignerAddress<UnionOmit<RpcSchema["Request"]["params"][0], "includeCounterfactualInfo">>>;
+export type RequestAccountParams = Prettify<Omit<Extract<RpcSchema["Request"]["params"][0], {
+    signerAddress: Address;
+} | {
+    signerPublicKey: WebAuthnPublicKey;
+}>, "signerAddress" | "signerPublicKey" | "includeCounterfactualInfo"> & {
+    accountAddress?: Address;
+}>;
 export type RequestAccountResult = Prettify<{
     address: Address;
 }>;

package/dist/esm/actions/requestAccount.js

@@ -1,5 +1,8 @@
+import { BaseError } from "viem";
 import deepEqual from "deep-equal";
 import { LOGGER } from "../logger.js";
+import { isWebAuthnAccount } from "../utils/assertions.js";
+import { getSignerAddressOrPublicKey } from "../utils/signer.js";
 /**
  * Requests an account for the provided signer using the wallet API client.
  * If an account already exists for the signer, it will always return that account unless a new ID is specified.
@@ -23,26 +26,51 @@ export async function requestAccount(client, params) {
         hasParams: !!params,
         hasAccountOnClient: !!client.account,
     });
-    const args = client.account && !params
+    const { creationHint = {} } = params ?? {};
+    if (isWebAuthnAccount(client.owner)) {
+        if (creationHint.accountType &&
+            creationHint.accountType !== "mav2-webauthn") {
+            throw new BaseError("WebAuthn signers are only supported with mav2-webauthn account type");
+        }
+    }
+    else {
+        // Non-webauthn signers do not support the "mav2-webauthn" account type.
+        if (creationHint.accountType === "mav2-webauthn") {
+            throw new BaseError("ECDSA (secp256k1) signers are not supported with mav2-webauthn account type");
+        }
+    }
+    const owner = getSignerAddressOrPublicKey(client.owner);
+    const args = (client.account && !params) || params?.accountAddress
         ? {
-            accountAddress: client.account.address,
+            accountAddress: params?.accountAddress ?? client.account.address,
             includeCounterfactualInfo: true,
         }
-        : params != null && "accountAddress" in params
-            ? {
-                accountAddress: params.accountAddress,
-                includeCounterfactualInfo: true,
-            }
-            : {
-                ...params,
-                signerAddress: (params && "signerAddress" in params
-                    ? params.signerAddress
-                    : undefined) ?? client.owner.account.address,
-                includeCounterfactualInfo: true,
-            };
+        : {
+            ...(owner.type === "webauthn-p256"
+                ? {
+                    signerPublicKey: {
+                        ...owner.publicKey,
+                        type: "webauthn-p256",
+                    },
+                    // Casts here are safe due to our checks above.
+                    ...(creationHint
+                        ? { creationHint: creationHint }
+                        : {}),
+                }
+                : {
+                    signerAddress: owner.address,
+                    ...(creationHint
+                        ? {
+                            creationHint: creationHint,
+                        }
+                        : {}),
+                }),
+            includeCounterfactualInfo: true,
+        };
     const cachedAccount = client.internal?.getAccount();
     if (cachedAccount &&
-        ((args.accountAddress && cachedAccount.address === args.accountAddress) ||
+        ((params?.accountAddress &&
+            cachedAccount.address === params.accountAddress) ||
             deepEqual(cachedAccount.requestParams, args, { strict: true }))) {
         LOGGER.debug("requestAccount:cache-hit", {
             address: cachedAccount.address,

package/dist/esm/actions/requestAccount.js.map

@@ -1 +1 @@
-{"version":3,"file":"requestAccount.js","sourceRoot":"","sources":["../../../src/actions/requestAccount.ts"],"names":[],"mappings":"AAGA,OAAO,SAAS,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAmBtC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,MAA4B,EAC5B,MAA6B;IAE7B,MAAM,CAAC,KAAK,CAAC,sBAAsB,EAAE;QACnC,SAAS,EAAE,CAAC,CAAC,MAAM;QACnB,kBAAkB,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO;KACrC,CAAC,CAAC;IACH,MAAM,IAAI,GACR,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM;QACvB,CAAC,CAAC;YACE,cAAc,EAAE,MAAM,CAAC,OAAO,CAAC,OAAO;YACtC,yBAAyB,EAAE,IAAI;SAChC;QACH,CAAC,CAAC,MAAM,IAAI,IAAI,IAAI,gBAAgB,IAAI,MAAM;YAC5C,CAAC,CAAC;gBACE,cAAc,EAAE,MAAM,CAAC,cAAc;gBACrC,yBAAyB,EAAE,IAAI;aAChC;YACH,CAAC,CAAC;gBACE,GAAG,MAAM;gBACT,aAAa,EACX,CAAC,MAAM,IAAI,eAAe,IAAI,MAAM;oBAClC,CAAC,CAAC,MAAM,CAAC,aAAa;oBACtB,CAAC,CAAC,SAAS,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO;gBAChD,yBAAyB,EAAE,IAAI;aAChC,CAAC;IAEV,MAAM,aAAa,GAAG,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAC;IAEpD,IACE,aAAa;QACb,CAAC,CAAC,IAAI,CAAC,cAAc,IAAI,aAAa,CAAC,OAAO,KAAK,IAAI,CAAC,cAAc,CAAC;YACrE,SAAS,CAAC,aAAa,CAAC,aAAa,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,EACjE,CAAC;QACD,MAAM,CAAC,KAAK,CAAC,0BAA0B,EAAE;YACvC,OAAO,EAAE,aAAa,CAAC,OAAO;SAC/B,CAAC,CAAC;QACH,OAAO;YACL,OAAO,EAAE,aAAa,CAAC,OAAO;SAC/B,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC;QAChC,MAAM,EAAE,uBAAuB;QAC/B,MAAM,EAAE,CAAC,IAAI,CAAC;KACf,CAAC,CAAC;IAEH,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC;QAC1B,OAAO,EAAE,IAAI,CAAC,cAAc;QAC5B,aAAa,EAAE,IAAI;KACpB,CAAC,CAAC;IAEH,MAAM,CAAC,KAAK,CAAC,qBAAqB,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;IACtE,OAAO;QACL,OAAO,EAAE,IAAI,CAAC,cAAc;KAC7B,CAAC;AACJ,CAAC","sourcesContent":["import type { Address } from \"abitype\";\nimport type { Prettify, UnionOmit } from \"viem\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport deepEqual from \"deep-equal\";\nimport type { InnerWalletApiClient, OptionalSignerAddress } from \"../types\";\nimport { LOGGER } from \"../logger.js\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_requestAccount\";\n    };\n  }\n>;\n\nexport type RequestAccountParams = Prettify<\n  OptionalSignerAddress<\n    UnionOmit<RpcSchema[\"Request\"][\"params\"][0], \"includeCounterfactualInfo\">\n  >\n>;\n\nexport type RequestAccountResult = Prettify<{ address: Address }>;\n\n/**\n * Requests an account for the provided signer using the wallet API client.\n * If an account already exists for the signer, it will always return that account unless a new ID is specified.\n * If an account already exists, the creationHint will be ignored.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {RequestAccountParams} [params] - Optional parameters for requesting a specific account\n * @param {string} [params.id] - Optional identifier for the account. If specified, a new account with this ID will be created even if one already exists for the signer\n * @param {object} [params.creationHint] - Optional hints to guide account creation. These are ignored if an account already exists\n * @returns {Promise<RequestAccountResult>} A Promise that resolves to an object containing a smart account address\n *\n * @example\n * ```ts\n * // Request an account with default parameters using a local signer\n * const signer = LocalAccountSigner.privateKeyToAccountSigner(\"0x...\");\n * const account = await client.requestAccount(signer);\n * ```\n */\nexport async function requestAccount(\n  client: InnerWalletApiClient,\n  params?: RequestAccountParams,\n): Promise<RequestAccountResult> {\n  LOGGER.debug(\"requestAccount:start\", {\n    hasParams: !!params,\n    hasAccountOnClient: !!client.account,\n  });\n  const args =\n    client.account && !params\n      ? {\n          accountAddress: client.account.address,\n          includeCounterfactualInfo: true,\n        }\n      : params != null && \"accountAddress\" in params\n        ? {\n            accountAddress: params.accountAddress,\n            includeCounterfactualInfo: true,\n          }\n        : {\n            ...params,\n            signerAddress:\n              (params && \"signerAddress\" in params\n                ? params.signerAddress\n                : undefined) ?? client.owner.account.address,\n            includeCounterfactualInfo: true,\n          };\n\n  const cachedAccount = client.internal?.getAccount();\n\n  if (\n    cachedAccount &&\n    ((args.accountAddress && cachedAccount.address === args.accountAddress) ||\n      deepEqual(cachedAccount.requestParams, args, { strict: true }))\n  ) {\n    LOGGER.debug(\"requestAccount:cache-hit\", {\n      address: cachedAccount.address,\n    });\n    return {\n      address: cachedAccount.address,\n    };\n  }\n\n  const resp = await client.request({\n    method: \"wallet_requestAccount\",\n    params: [args],\n  });\n\n  client.internal?.setAccount({\n    address: resp.accountAddress,\n    requestParams: args,\n  });\n\n  LOGGER.debug(\"requestAccount:done\", { address: resp.accountAddress });\n  return {\n    address: resp.accountAddress,\n  };\n}\n"]}
+{"version":3,"file":"requestAccount.js","sourceRoot":"","sources":["../../../src/actions/requestAccount.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Address } from \"abitype\";\nimport { BaseError, type Prettify } from \"viem\";\nimport type { WalletServerRpcSchemaType } from \"@alchemy/wallet-api-types/rpc\";\nimport deepEqual from \"deep-equal\";\nimport type { InnerWalletApiClient } from \"../types\";\nimport { LOGGER } from \"../logger.js\";\nimport type {\n  CreationOptionsByPublicKey,\n  CreationOptionsBySignerAddress,\n  WebAuthnPublicKey,\n} from \"@alchemy/wallet-api-types\";\nimport { isWebAuthnAccount } from \"../utils/assertions.js\";\nimport { getSignerAddressOrPublicKey } from \"../utils/signer.js\";\n\ntype RpcSchema = Extract<\n  WalletServerRpcSchemaType,\n  {\n    Request: {\n      method: \"wallet_requestAccount\";\n    };\n  }\n>;\n\nexport type RequestAccountParams = Prettify<\n  Omit<\n    Extract<\n      RpcSchema[\"Request\"][\"params\"][0],\n      { signerAddress: Address } | { signerPublicKey: WebAuthnPublicKey }\n    >,\n    \"signerAddress\" | \"signerPublicKey\" | \"includeCounterfactualInfo\"\n  > & { accountAddress?: Address }\n>;\n\nexport type RequestAccountResult = Prettify<{ address: Address }>;\n\n/**\n * Requests an account for the provided signer using the wallet API client.\n * If an account already exists for the signer, it will always return that account unless a new ID is specified.\n * If an account already exists, the creationHint will be ignored.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {RequestAccountParams} [params] - Optional parameters for requesting a specific account\n * @param {string} [params.id] - Optional identifier for the account. If specified, a new account with this ID will be created even if one already exists for the signer\n * @param {object} [params.creationHint] - Optional hints to guide account creation. These are ignored if an account already exists\n * @returns {Promise<RequestAccountResult>} A Promise that resolves to an object containing a smart account address\n *\n * @example\n * ```ts\n * // Request an account with default parameters using a local signer\n * const signer = LocalAccountSigner.privateKeyToAccountSigner(\"0x...\");\n * const account = await client.requestAccount(signer);\n * ```\n */\nexport async function requestAccount(\n  client: InnerWalletApiClient,\n  params?: RequestAccountParams,\n): Promise<RequestAccountResult> {\n  LOGGER.debug(\"requestAccount:start\", {\n    hasParams: !!params,\n    hasAccountOnClient: !!client.account,\n  });\n\n  const { creationHint = {} } = params ?? {};\n\n  if (isWebAuthnAccount(client.owner)) {\n    if (\n      creationHint.accountType &&\n      creationHint.accountType !== \"mav2-webauthn\"\n    ) {\n      throw new BaseError(\n        \"WebAuthn signers are only supported with mav2-webauthn account type\",\n      );\n    }\n  } else {\n    // Non-webauthn signers do not support the \"mav2-webauthn\" account type.\n    if (creationHint.accountType === \"mav2-webauthn\") {\n      throw new BaseError(\n        \"ECDSA (secp256k1) signers are not supported with mav2-webauthn account type\",\n      );\n    }\n  }\n\n  const owner = getSignerAddressOrPublicKey(client.owner);\n\n  const args: RpcSchema[\"Request\"][\"params\"][0] =\n    (client.account && !params) || params?.accountAddress\n      ? {\n          accountAddress: params?.accountAddress ?? client.account!.address,\n          includeCounterfactualInfo: true,\n        }\n      : {\n          ...(owner.type === \"webauthn-p256\"\n            ? {\n                signerPublicKey: {\n                  ...owner.publicKey,\n                  type: \"webauthn-p256\",\n                },\n                // Casts here are safe due to our checks above.\n                ...(creationHint\n                  ? { creationHint: creationHint as CreationOptionsByPublicKey }\n                  : {}),\n              }\n            : {\n                signerAddress: owner.address,\n                ...(creationHint\n                  ? {\n                      creationHint:\n                        creationHint as CreationOptionsBySignerAddress,\n                    }\n                  : {}),\n              }),\n          includeCounterfactualInfo: true,\n        };\n\n  const cachedAccount = client.internal?.getAccount();\n\n  if (\n    cachedAccount &&\n    ((params?.accountAddress &&\n      cachedAccount.address === params.accountAddress) ||\n      deepEqual(cachedAccount.requestParams, args, { strict: true }))\n  ) {\n    LOGGER.debug(\"requestAccount:cache-hit\", {\n      address: cachedAccount.address,\n    });\n    return {\n      address: cachedAccount.address,\n    };\n  }\n\n  const resp = await client.request({\n    method: \"wallet_requestAccount\",\n    params: [args],\n  });\n\n  client.internal?.setAccount({\n    address: resp.accountAddress,\n    requestParams: args,\n  });\n\n  LOGGER.debug(\"requestAccount:done\", { address: resp.accountAddress });\n  return {\n    address: resp.accountAddress,\n  };\n}\n"]}

package/dist/esm/actions/sendCalls.d.ts

@@ -30,5 +30,9 @@ export type SendCallsResult = Prettify<SendPreparedCallsResult>;
  * // The result contains the prepared call IDs
  * console.log(result.preparedCallIds);
  * ```
+ * <Note>
+ * If using this action with an ERC-20 paymaster in pre-operation mode with `autoPermit`, the contents of the permit will be hidden
+ * from the user. It is recommended to use the `prepareCalls` action instead to manually handle the permit signature.
+ * </Note>
  */
 export declare function sendCalls<TAccount extends Address | undefined = Address | undefined>(client: InnerWalletApiClient, params: SendCallsParams<TAccount>): Promise<SendCallsResult>;

package/dist/esm/actions/sendCalls.js

@@ -2,6 +2,9 @@ import { prepareCalls } from "./prepareCalls.js";
 import { signPreparedCalls } from "./signPreparedCalls.js";
 import { sendPreparedCalls, } from "./sendPreparedCalls.js";
 import { LOGGER } from "../logger.js";
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import { isWebAuthnAccount } from "../utils/assertions.js";
+import { BaseError } from "@alchemy/common";
 /**
  * Prepares, signs, and submits calls. This function internally calls `prepareCalls`, `signPreparedCalls`, and `sendPreparedCalls`.
  *
@@ -28,13 +31,31 @@ import { LOGGER } from "../logger.js";
  * // The result contains the prepared call IDs
  * console.log(result.preparedCallIds);
  * ```
+ * <Note>
+ * If using this action with an ERC-20 paymaster in pre-operation mode with `autoPermit`, the contents of the permit will be hidden
+ * from the user. It is recommended to use the `prepareCalls` action instead to manually handle the permit signature.
+ * </Note>
  */
 export async function sendCalls(client, params) {
     LOGGER.info("sendCalls:start", {
         calls: params.calls?.length,
         hasCapabilities: !!params.capabilities,
     });
-    const calls = await prepareCalls(client, params);
+    let calls = await prepareCalls(client, params);
+    if (calls.type === "paymaster-permit") {
+        if (isWebAuthnAccount(client.owner)) {
+            throw new BaseError("WebAuthn signer is not currently supported for signing paymaster permit signatures");
+        }
+        const signature = await signSignatureRequest(client, calls.signatureRequest);
+        const secondCallParams = {
+            from: calls.modifiedRequest.from,
+            calls: calls.modifiedRequest.calls,
+            capabilities: calls.modifiedRequest.capabilities,
+            // WebAuthn signatures are not supported for paymaster permits (throws above).
+            paymasterPermitSignature: signature,
+        };
+        calls = await prepareCalls(client, secondCallParams);
+    }
     const signedCalls = await signPreparedCalls(client, calls);
     const res = await sendPreparedCalls(client, {
         ...signedCalls,

package/dist/esm/actions/sendCalls.js.map

@@ -1 +1 @@
-{"version":3,"file":"sendCalls.js","sourceRoot":"","sources":["../../../src/actions/sendCalls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAA2B,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,iBAAiB,GAElB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAQtC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAG7B,MAA4B,EAC5B,MAAiC;IAEjC,MAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE;QAC7B,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM;QAC3B,eAAe,EAAE,CAAC,CAAC,MAAM,CAAC,YAAY;KACvC,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjD,MAAM,WAAW,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAE3D,MAAM,GAAG,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE;QAC1C,GAAG,WAAW;QACd,6EAA6E;QAC7E,GAAG,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,IAAI,IAAI;YAC1C,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE;YACpE,CAAC,CAAC,EAAE,CAAC;KACR,CAAC,CAAC;IACH,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC9B,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { Address, Prettify } from \"viem\";\nimport type { InnerWalletApiClient } from \"../types.js\";\nimport { prepareCalls, type PrepareCallsParams } from \"./prepareCalls.js\";\nimport { signPreparedCalls } from \"./signPreparedCalls.js\";\nimport {\n  sendPreparedCalls,\n  type SendPreparedCallsResult,\n} from \"./sendPreparedCalls.js\";\nimport { LOGGER } from \"../logger.js\";\n\nexport type SendCallsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<PrepareCallsParams<TAccount>>;\n\nexport type SendCallsResult = Prettify<SendPreparedCallsResult>;\n\n/**\n * Prepares, signs, and submits calls. This function internally calls `prepareCalls`, `signPreparedCalls`, and `sendPreparedCalls`.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {PrepareCallsParams<TAccount>} params - Parameters for sending calls\n * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute\n * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)\n * @param {object} [params.capabilities] - Optional capabilities to include with the request.\n * @returns {Promise<SendPreparedCallsResult>} A Promise that resolves to the result containing the prepared call IDs.\n *\n *  @example\n * ```ts\n * const result = await client.sendCalls({\n *   calls: [{\n *     to: \"0x1234...\",\n *     data: \"0xabcdef...\",\n *     value: \"0x0\"\n *   }],\n *   capabilities: {\n *     paymasterService: { policyId: \"your-policy-id\" }\n *   }\n * });\n *\n * // The result contains the prepared call IDs\n * console.log(result.preparedCallIds);\n * ```\n */\nexport async function sendCalls<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: SendCallsParams<TAccount>,\n): Promise<SendCallsResult> {\n  LOGGER.info(\"sendCalls:start\", {\n    calls: params.calls?.length,\n    hasCapabilities: !!params.capabilities,\n  });\n  const calls = await prepareCalls(client, params);\n\n  const signedCalls = await signPreparedCalls(client, calls);\n\n  const res = await sendPreparedCalls(client, {\n    ...signedCalls,\n    // The only capability that is supported in sendPreparedCalls is permissions.\n    ...(params.capabilities?.permissions != null\n      ? { capabilities: { permissions: params.capabilities.permissions } }\n      : {}),\n  });\n  LOGGER.info(\"sendCalls:done\");\n  return res;\n}\n"]}
+{"version":3,"file":"sendCalls.js","sourceRoot":"","sources":["../../../src/actions/sendCalls.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAA2B,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EACL,iBAAiB,GAElB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQ5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAG7B,MAA4B,EAC5B,MAAiC;IAEjC,MAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE;QAC7B,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM;QAC3B,eAAe,EAAE,CAAC,CAAC,MAAM,CAAC,YAAY;KACvC,CAAC,CAAC;IACH,IAAI,KAAK,GAAG,MAAM,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE/C,IAAI,KAAK,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QACtC,IAAI,iBAAiB,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACpC,MAAM,IAAI,SAAS,CACjB,oFAAoF,CACrF,CAAC;QACJ,CAAC;QACD,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAC1C,MAAM,EACN,KAAK,CAAC,gBAAgB,CACvB,CAAC;QAEF,MAAM,gBAAgB,GAAG;YACvB,IAAI,EAAE,KAAK,CAAC,eAAe,CAAC,IAAI;YAChC,KAAK,EAAE,KAAK,CAAC,eAAe,CAAC,KAAK;YAClC,YAAY,EAAE,KAAK,CAAC,eAAe,CAAC,YAAY;YAChD,8EAA8E;YAC9E,wBAAwB,EAAE,SAGzB;SACF,CAAC;QAEF,KAAK,GAAG,MAAM,YAAY,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACvD,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAE3D,MAAM,GAAG,GAAG,MAAM,iBAAiB,CAAC,MAAM,EAAE;QAC1C,GAAG,WAAW;QACd,6EAA6E;QAC7E,GAAG,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,IAAI,IAAI;YAC1C,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE;YACpE,CAAC,CAAC,EAAE,CAAC;KACR,CAAC,CAAC;IACH,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IAC9B,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["import type { Address, Prettify } from \"viem\";\nimport type { InnerWalletApiClient } from \"../types.js\";\nimport { prepareCalls, type PrepareCallsParams } from \"./prepareCalls.js\";\nimport { signPreparedCalls } from \"./signPreparedCalls.js\";\nimport {\n  sendPreparedCalls,\n  type SendPreparedCallsResult,\n} from \"./sendPreparedCalls.js\";\nimport { LOGGER } from \"../logger.js\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport { isWebAuthnAccount } from \"../utils/assertions.js\";\nimport { BaseError } from \"@alchemy/common\";\n\nexport type SendCallsParams<\n  TAccount extends Address | undefined = Address | undefined,\n> = Prettify<PrepareCallsParams<TAccount>>;\n\nexport type SendCallsResult = Prettify<SendPreparedCallsResult>;\n\n/**\n * Prepares, signs, and submits calls. This function internally calls `prepareCalls`, `signPreparedCalls`, and `sendPreparedCalls`.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {PrepareCallsParams<TAccount>} params - Parameters for sending calls\n * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute\n * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)\n * @param {object} [params.capabilities] - Optional capabilities to include with the request.\n * @returns {Promise<SendPreparedCallsResult>} A Promise that resolves to the result containing the prepared call IDs.\n *\n *  @example\n * ```ts\n * const result = await client.sendCalls({\n *   calls: [{\n *     to: \"0x1234...\",\n *     data: \"0xabcdef...\",\n *     value: \"0x0\"\n *   }],\n *   capabilities: {\n *     paymasterService: { policyId: \"your-policy-id\" }\n *   }\n * });\n *\n * // The result contains the prepared call IDs\n * console.log(result.preparedCallIds);\n * ```\n * <Note>\n * If using this action with an ERC-20 paymaster in pre-operation mode with `autoPermit`, the contents of the permit will be hidden\n * from the user. It is recommended to use the `prepareCalls` action instead to manually handle the permit signature.\n * </Note>\n */\nexport async function sendCalls<\n  TAccount extends Address | undefined = Address | undefined,\n>(\n  client: InnerWalletApiClient,\n  params: SendCallsParams<TAccount>,\n): Promise<SendCallsResult> {\n  LOGGER.info(\"sendCalls:start\", {\n    calls: params.calls?.length,\n    hasCapabilities: !!params.capabilities,\n  });\n  let calls = await prepareCalls(client, params);\n\n  if (calls.type === \"paymaster-permit\") {\n    if (isWebAuthnAccount(client.owner)) {\n      throw new BaseError(\n        \"WebAuthn signer is not currently supported for signing paymaster permit signatures\",\n      );\n    }\n    const signature = await signSignatureRequest(\n      client,\n      calls.signatureRequest,\n    );\n\n    const secondCallParams = {\n      from: calls.modifiedRequest.from,\n      calls: calls.modifiedRequest.calls,\n      capabilities: calls.modifiedRequest.capabilities,\n      // WebAuthn signatures are not supported for paymaster permits (throws above).\n      paymasterPermitSignature: signature as Exclude<\n        typeof signature,\n        { type: \"webauthn-p256\" }\n      >,\n    };\n\n    calls = await prepareCalls(client, secondCallParams);\n  }\n\n  const signedCalls = await signPreparedCalls(client, calls);\n\n  const res = await sendPreparedCalls(client, {\n    ...signedCalls,\n    // The only capability that is supported in sendPreparedCalls is permissions.\n    ...(params.capabilities?.permissions != null\n      ? { capabilities: { permissions: params.capabilities.permissions } }\n      : {}),\n  });\n  LOGGER.info(\"sendCalls:done\");\n  return res;\n}\n"]}

package/dist/esm/actions/signMessage.js

@@ -1,4 +1,4 @@
-import {} from "viem";
+import { BaseError, } from "viem";
 import { requestAccount } from "./requestAccount.js";
 import { prepareSign } from "./prepareSign.js";
 import { signSignatureRequest } from "./signSignatureRequest.js";
@@ -38,6 +38,10 @@ export async function signMessage(client, params) {
         },
     });
     const signed = await signSignatureRequest(client, prepared.signatureRequest);
+    // TODO: Wallet server needs to be updated to support webauthn here.
+    if (signed.type === "webauthn-p256") {
+        throw new BaseError("WebAuthn account is currently unsupported by wallet_formatSign");
+    }
     const formatted = await formatSign(client, {
         from: account.address,
         signature: {

package/dist/esm/actions/signMessage.js.map

@@ -1 +1 @@
-{"version":3,"file":"signMessage.js","sourceRoot":"","sources":["../../../src/actions/signMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAStC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAA4B,EAC5B,MAAyB;IAEzB,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IACjE,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE;QAChC,kBAAkB,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAC3C,CAAC,CAAC;IAEH,MAAM,OAAO,GAAG,MAAM,cAAc,CAClC,MAAM,EACN,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,SAAS,CACxD,CAAC;IAEF,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,MAAM,EAAE;QACzC,IAAI,EAAE,OAAO,CAAC,OAAO;QACrB,gBAAgB,EAAE;YAChB,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,yBAAyB,CAAC,MAAM,CAAC,OAAO,CAAC;SAChD;KACF,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IAE7E,MAAM,SAAS,GAAG,MAAM,UAAU,CAAC,MAAM,EAAE;QACzC,IAAI,EAAE,OAAO,CAAC,OAAO;QACrB,SAAS,EAAE;YACT,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,MAAM,CAAC,IAAI;SAClB;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAC5D,OAAO,SAAS,CAAC,SAAS,CAAC;AAC7B,CAAC","sourcesContent":["import {\n  type Address,\n  type Hex,\n  type Prettify,\n  type SignableMessage,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../types.js\";\nimport { requestAccount } from \"./requestAccount.js\";\nimport { prepareSign } from \"./prepareSign.js\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport { formatSign } from \"./formatSign.js\";\nimport { signableMessageToJsonSafe } from \"../utils/format.js\";\nimport { LOGGER } from \"../logger.js\";\n\nexport type SignMessageParams = Prettify<{\n  message: SignableMessage;\n  account?: Address;\n}>;\n\nexport type SignMessageResult = Prettify<Hex>;\n\n/**\n * Signs a message using the smart account.\n * This method requests the account associated with the signer and uses it to sign the message.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {SignMessageParams} params - Parameters for signing the message\n * @param {SignableMessage} params.message - The message to sign using EIP-191. Can be a string, or object with raw bytes.\n * @param {Address} [params.account] - Optional account address to use for signing. If not provided, uses the client's current account.\n * @returns {Promise<SignMessageResult>} A Promise that resolves to the signed message as a hex string\n *\n * @example\n * ```ts\n * // Sign a simple text message\n * const signature = await client.signMessage(\"Hello, world!\");\n *\n * // Sign a raw hex message\n * const signature = await client.signMessage({ raw: \"0x48656c6c6f2c20776f726c6421\" });\n * ```\n */\nexport async function signMessage(\n  client: InnerWalletApiClient,\n  params: SignMessageParams,\n): Promise<SignMessageResult> {\n  const accountAddress = params.account ?? client.account?.address;\n  LOGGER.debug(\"signMessage:start\", {\n    hasExplicitAccount: params.account != null,\n  });\n\n  const account = await requestAccount(\n    client,\n    accountAddress != null ? { accountAddress } : undefined,\n  );\n\n  const prepared = await prepareSign(client, {\n    from: account.address,\n    signatureRequest: {\n      type: \"personal_sign\",\n      data: signableMessageToJsonSafe(params.message),\n    },\n  });\n\n  const signed = await signSignatureRequest(client, prepared.signatureRequest);\n\n  const formatted = await formatSign(client, {\n    from: account.address,\n    signature: {\n      type: \"ecdsa\",\n      data: signed.data,\n    },\n  });\n  LOGGER.debug(\"signMessage:done\", { from: account.address });\n  return formatted.signature;\n}\n"]}
+{"version":3,"file":"signMessage.js","sourceRoot":"","sources":["../../../src/actions/signMessage.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,SAAS,GACV,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAStC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAA4B,EAC5B,MAAyB;IAEzB,MAAM,cAAc,GAAG,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC;IACjE,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE;QAChC,kBAAkB,EAAE,MAAM,CAAC,OAAO,IAAI,IAAI;KAC3C,CAAC,CAAC;IAEH,MAAM,OAAO,GAAG,MAAM,cAAc,CAClC,MAAM,EACN,cAAc,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,CAAC,CAAC,SAAS,CACxD,CAAC;IAEF,MAAM,QAAQ,GAAG,MAAM,WAAW,CAAC,MAAM,EAAE;QACzC,IAAI,EAAE,OAAO,CAAC,OAAO;QACrB,gBAAgB,EAAE;YAChB,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,yBAAyB,CAAC,MAAM,CAAC,OAAO,CAAC;SAChD;KACF,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,MAAM,oBAAoB,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IAE7E,oEAAoE;IACpE,IAAI,MAAM,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;QACpC,MAAM,IAAI,SAAS,CACjB,gEAAgE,CACjE,CAAC;IACJ,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,UAAU,CAAC,MAAM,EAAE;QACzC,IAAI,EAAE,OAAO,CAAC,OAAO;QACrB,SAAS,EAAE;YACT,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,MAAM,CAAC,IAAI;SAClB;KACF,CAAC,CAAC;IACH,MAAM,CAAC,KAAK,CAAC,kBAAkB,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAC5D,OAAO,SAAS,CAAC,SAAS,CAAC;AAC7B,CAAC","sourcesContent":["import {\n  type Address,\n  type Hex,\n  type Prettify,\n  type SignableMessage,\n  BaseError,\n} from \"viem\";\nimport type { InnerWalletApiClient } from \"../types.js\";\nimport { requestAccount } from \"./requestAccount.js\";\nimport { prepareSign } from \"./prepareSign.js\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport { formatSign } from \"./formatSign.js\";\nimport { signableMessageToJsonSafe } from \"../utils/format.js\";\nimport { LOGGER } from \"../logger.js\";\n\nexport type SignMessageParams = Prettify<{\n  message: SignableMessage;\n  account?: Address;\n}>;\n\nexport type SignMessageResult = Prettify<Hex>;\n\n/**\n * Signs a message using the smart account.\n * This method requests the account associated with the signer and uses it to sign the message.\n *\n * @param {InnerWalletApiClient} client - The wallet API client to use for the request\n * @param {SignMessageParams} params - Parameters for signing the message\n * @param {SignableMessage} params.message - The message to sign using EIP-191. Can be a string, or object with raw bytes.\n * @param {Address} [params.account] - Optional account address to use for signing. If not provided, uses the client's current account.\n * @returns {Promise<SignMessageResult>} A Promise that resolves to the signed message as a hex string\n *\n * @example\n * ```ts\n * // Sign a simple text message\n * const signature = await client.signMessage(\"Hello, world!\");\n *\n * // Sign a raw hex message\n * const signature = await client.signMessage({ raw: \"0x48656c6c6f2c20776f726c6421\" });\n * ```\n */\nexport async function signMessage(\n  client: InnerWalletApiClient,\n  params: SignMessageParams,\n): Promise<SignMessageResult> {\n  const accountAddress = params.account ?? client.account?.address;\n  LOGGER.debug(\"signMessage:start\", {\n    hasExplicitAccount: params.account != null,\n  });\n\n  const account = await requestAccount(\n    client,\n    accountAddress != null ? { accountAddress } : undefined,\n  );\n\n  const prepared = await prepareSign(client, {\n    from: account.address,\n    signatureRequest: {\n      type: \"personal_sign\",\n      data: signableMessageToJsonSafe(params.message),\n    },\n  });\n\n  const signed = await signSignatureRequest(client, prepared.signatureRequest);\n\n  // TODO: Wallet server needs to be updated to support webauthn here.\n  if (signed.type === \"webauthn-p256\") {\n    throw new BaseError(\n      \"WebAuthn account is currently unsupported by wallet_formatSign\",\n    );\n  }\n\n  const formatted = await formatSign(client, {\n    from: account.address,\n    signature: {\n      type: \"ecdsa\",\n      data: signed.data,\n    },\n  });\n  LOGGER.debug(\"signMessage:done\", { from: account.address });\n  return formatted.signature;\n}\n"]}

package/dist/esm/actions/signPreparedCalls.js

@@ -1,6 +1,7 @@
 import { assertNever, BaseError } from "@alchemy/common";
 import { signSignatureRequest } from "./signSignatureRequest.js";
 import { LOGGER } from "../logger.js";
+import { isWebAuthnAccount } from "../utils/assertions.js";
 /**
  * Signs prepared calls using the provided signer.
  *
@@ -30,6 +31,9 @@ export async function signPreparedCalls(client, params) {
     LOGGER.debug("signPreparedCalls:start", { type: params.type });
     const signAuthorizationCall = async (call) => {
         const { signatureRequest: _signatureRequest, ...rest } = call;
+        if (isWebAuthnAccount(client.owner)) {
+            throw new BaseError("WebAuthn account cannot sign EIP-7702 authorization requests");
+        }
         const signature = await signSignatureRequest(client, {
             type: "eip7702Auth",
             data: {
@@ -37,9 +41,10 @@ export async function signPreparedCalls(client, params) {
                 chainId: call.chainId,
             },
         });
+        // Authorization signatures are never webauthn-256 (throws above).
         return {
             ...rest,
-            signature,
+            signature: signature,
         };
     };
     const signUserOperationCall = async (call) => {

package/dist/esm/actions/signPreparedCalls.js.map

@@ -1 +1 @@
-{"version":3,"file":"signPreparedCalls.js","sourceRoot":"","sources":["../../../src/actions/signPreparedCalls.ts"],"names":[],"mappings":"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","sourcesContent":["import { assertNever, BaseError } from \"@alchemy/common\";\nimport type { PrepareCallsResult } from \"./prepareCalls.ts\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport type { Prettify } from \"viem\";\nimport type {\n  PreparedCall_Authorization,\n  PreparedCall_UserOpV060,\n  PreparedCall_UserOpV070,\n} from \"@alchemy/wallet-api-types\";\nimport type { InnerWalletApiClient } from \"../types.js\";\nimport { LOGGER } from \"../logger.js\";\nimport type { SendPreparedCallsParams } from \"./sendPreparedCalls.js\";\n\nexport type SignPreparedCallsParams = Prettify<PrepareCallsResult>;\n\nexport type SignPreparedCallsResult = SendPreparedCallsParams;\n\n/**\n * Signs prepared calls using the provided signer.\n *\n * @param {InnerWalletApiClient} client - The wallet client to use for signing\n * @param {SignPreparedCallsParams} params - The prepared calls with signature requests\n * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls\n *\n * @example\n * ```ts\n * // Prepare a user operation call.\n * const preparedCalls = await client.prepareCalls({\n *   calls: [{\n *     to: \"0x1234...\",\n *     data: \"0xabcdef...\",\n *     value: \"0x0\"\n *   }],\n * });\n *\n * // Sign the prepared calls.\n * const signedCalls = await client.signPreparedCalls(preparedCalls);\n *\n * // Send the signed calls.\n * const result = await client.sendPreparedCalls(signedCalls);\n * ```\n */\nexport async function signPreparedCalls(\n  client: InnerWalletApiClient,\n  params: SignPreparedCallsParams,\n): Promise<SignPreparedCallsResult> {\n  LOGGER.debug(\"signPreparedCalls:start\", { type: params.type });\n  const signAuthorizationCall = async (call: PreparedCall_Authorization) => {\n    const { signatureRequest: _signatureRequest, ...rest } = call;\n    const signature = await signSignatureRequest(client, {\n      type: \"eip7702Auth\",\n      data: {\n        ...rest.data,\n        chainId: call.chainId,\n      },\n    });\n    return {\n      ...rest,\n      signature,\n    };\n  };\n\n  const signUserOperationCall = async (\n    call: PreparedCall_UserOpV060 | PreparedCall_UserOpV070,\n  ) => {\n    const { signatureRequest, ...rest } = call;\n\n    if (!signatureRequest) {\n      LOGGER.warn(\"signPreparedCalls:missing-signatureRequest\", {\n        type: call.type,\n      });\n      throw new BaseError(\n        \"Signature request is required for signing user operation calls. Ensure `onlyEstimation` is set to `false` when calling `prepareCalls`.\",\n      );\n    }\n\n    const signature = await signSignatureRequest(client, signatureRequest);\n    const res = {\n      ...rest,\n      signature,\n    } as const;\n    LOGGER.debug(\"signPreparedCalls:userOp:ok\");\n    return res;\n  };\n\n  if (params.type === \"array\") {\n    const res = {\n      type: \"array\" as const,\n      data: await Promise.all(\n        params.data.map((call) =>\n          call.type === \"authorization\"\n            ? signAuthorizationCall(call)\n            : signUserOperationCall(call),\n        ),\n      ),\n    };\n    LOGGER.debug(\"signPreparedCalls:array:ok\", { count: res.data.length });\n    return res;\n  } else if (\n    params.type === \"user-operation-v060\" ||\n    params.type === \"user-operation-v070\"\n  ) {\n    const res = await signUserOperationCall(params);\n    LOGGER.debug(\"signPreparedCalls:single-userOp:ok\");\n    return res;\n  } else if (params.type === \"paymaster-permit\") {\n    LOGGER.warn(\"signPreparedCalls:invalid-call-type\", { type: params.type });\n    throw new BaseError(\n      `Invalid call type ${params.type} for signing prepared calls`,\n    );\n  } else {\n    LOGGER.warn(\"signPreparedCalls:unexpected-call-type\", {\n      type: (params as { type?: unknown }).type,\n    });\n    return assertNever(\n      params,\n      `Unexpected call type in ${params} for signing prepared calls`,\n    );\n  }\n}\n"]}
+{"version":3,"file":"signPreparedCalls.js","sourceRoot":"","sources":["../../../src/actions/signPreparedCalls.ts"],"names":[],"mappings":"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","sourcesContent":["import { assertNever, BaseError } from \"@alchemy/common\";\nimport type { PrepareCallsResult } from \"./prepareCalls.ts\";\nimport { signSignatureRequest } from \"./signSignatureRequest.js\";\nimport type { Prettify } from \"viem\";\nimport type {\n  PreparedCall_Authorization,\n  PreparedCall_UserOpV060,\n  PreparedCall_UserOpV070,\n} from \"@alchemy/wallet-api-types\";\nimport type { InnerWalletApiClient } from \"../types.js\";\nimport { LOGGER } from \"../logger.js\";\nimport type { SendPreparedCallsParams } from \"./sendPreparedCalls.js\";\nimport { isWebAuthnAccount } from \"../utils/assertions.js\";\n\nexport type SignPreparedCallsParams = Prettify<PrepareCallsResult>;\n\nexport type SignPreparedCallsResult = SendPreparedCallsParams;\n\n/**\n * Signs prepared calls using the provided signer.\n *\n * @param {InnerWalletApiClient} client - The wallet client to use for signing\n * @param {SignPreparedCallsParams} params - The prepared calls with signature requests\n * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls\n *\n * @example\n * ```ts\n * // Prepare a user operation call.\n * const preparedCalls = await client.prepareCalls({\n *   calls: [{\n *     to: \"0x1234...\",\n *     data: \"0xabcdef...\",\n *     value: \"0x0\"\n *   }],\n * });\n *\n * // Sign the prepared calls.\n * const signedCalls = await client.signPreparedCalls(preparedCalls);\n *\n * // Send the signed calls.\n * const result = await client.sendPreparedCalls(signedCalls);\n * ```\n */\nexport async function signPreparedCalls(\n  client: InnerWalletApiClient,\n  params: SignPreparedCallsParams,\n): Promise<SignPreparedCallsResult> {\n  LOGGER.debug(\"signPreparedCalls:start\", { type: params.type });\n\n  const signAuthorizationCall = async (call: PreparedCall_Authorization) => {\n    const { signatureRequest: _signatureRequest, ...rest } = call;\n\n    if (isWebAuthnAccount(client.owner)) {\n      throw new BaseError(\n        \"WebAuthn account cannot sign EIP-7702 authorization requests\",\n      );\n    }\n\n    const signature = await signSignatureRequest(client, {\n      type: \"eip7702Auth\",\n      data: {\n        ...rest.data,\n        chainId: call.chainId,\n      },\n    });\n    // Authorization signatures are never webauthn-256 (throws above).\n    return {\n      ...rest,\n      signature: signature as Exclude<\n        typeof signature,\n        { type: \"webauthn-p256\" }\n      >,\n    };\n  };\n\n  const signUserOperationCall = async (\n    call: PreparedCall_UserOpV060 | PreparedCall_UserOpV070,\n  ) => {\n    const { signatureRequest, ...rest } = call;\n\n    if (!signatureRequest) {\n      LOGGER.warn(\"signPreparedCalls:missing-signatureRequest\", {\n        type: call.type,\n      });\n      throw new BaseError(\n        \"Signature request is required for signing user operation calls. Ensure `onlyEstimation` is set to `false` when calling `prepareCalls`.\",\n      );\n    }\n\n    const signature = await signSignatureRequest(client, signatureRequest);\n    const res = {\n      ...rest,\n      signature,\n    } as const;\n    LOGGER.debug(\"signPreparedCalls:userOp:ok\");\n    return res;\n  };\n\n  if (params.type === \"array\") {\n    const res = {\n      type: \"array\" as const,\n      data: await Promise.all(\n        params.data.map((call) =>\n          call.type === \"authorization\"\n            ? signAuthorizationCall(call)\n            : signUserOperationCall(call),\n        ),\n      ),\n    };\n    LOGGER.debug(\"signPreparedCalls:array:ok\", { count: res.data.length });\n    return res;\n  } else if (\n    params.type === \"user-operation-v060\" ||\n    params.type === \"user-operation-v070\"\n  ) {\n    const res = await signUserOperationCall(params);\n    LOGGER.debug(\"signPreparedCalls:single-userOp:ok\");\n    return res;\n  } else if (params.type === \"paymaster-permit\") {\n    LOGGER.warn(\"signPreparedCalls:invalid-call-type\", { type: params.type });\n    throw new BaseError(\n      `Invalid call type ${params.type} for signing prepared calls`,\n    );\n  } else {\n    LOGGER.warn(\"signPreparedCalls:unexpected-call-type\", {\n      type: (params as { type?: unknown }).type,\n    });\n    return assertNever(\n      params,\n      `Unexpected call type in ${params} for signing prepared calls`,\n    );\n  }\n}\n"]}

package/dist/esm/actions/signSignatureRequest.d.ts

@@ -1,18 +1,25 @@
 import { type Hex, type Prettify } from "viem";
 import type { PersonalSignSignatureRequest, TypedDataSignatureRequest, AuthorizationSignatureRequest, Eip7702UnsignedAuth } from "@alchemy/wallet-api-types";
 import type { InnerWalletApiClient, WithoutRawPayload } from "../types";
+import type { WebAuthnSignReturnType } from "viem/account-abstraction";
 export type SignSignatureRequestParams = Prettify<WithoutRawPayload<PersonalSignSignatureRequest | TypedDataSignatureRequest | (AuthorizationSignatureRequest & {
     data: Eip7702UnsignedAuth;
 })>>;
-export type SignSignatureRequestResult = Prettify<{
+export type SignSignatureRequestResult = {
     type: "secp256k1";
     data: Hex;
-}>;
+} | {
+    type: "webauthn-p256";
+    data: {
+        signature: Hex;
+        metadata: Pick<WebAuthnSignReturnType["webauthn"], "clientDataJSON" | "authenticatorData">;
+    };
+};
 /**
  * Signs a signature request using the provided signer.
  * This method handles different types of signature requests including personal_sign, eth_signTypedData_v4, and authorization.
  *
- * @param {SmartAccountSigner} signer - The signer to use for signing the request
+ * @param {InnerWalletApiClient} client - The wallet client to use for signing
  * @param {SignSignatureRequestParams} params - The signature request parameters
  * @param {string} params.type - The type of signature request ('personal_sign', 'eth_signTypedData_v4', or 'signature_with_authorization')
  * @param {SignSignatureRequestParams["data"]} params.data - The data to sign, format depends on the signature type