@alchemy/wallet-apis 0.0.0-alpha.14 → 0.0.0-alpha.16

package/dist/types/utils/viemDecode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viemDecode.d.ts","sourceRoot":"","sources":["../../../src/utils/viemDecode.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,KAAK,EAEV,0BAA0B,EAC1B,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,YAAY,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AACpG,OAAO,KAAK,EACV,4BAA4B,EAC5B,8BAA8B,EAC9B,wBAAwB,EACxB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AAEzB,eAAO,MAAM,uBAAuB,GAClC,cAAc,wBAAwB,KACrC,kBA2BF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,MACI,4BAA4B,GAC5B,8BAA8B,GAC9B,4BAA4B,KAE9B,uBAAuB,GACvB,uBAAuB,GACvB,mBAAmB,GACnB,0BAgBH,CAAC;AAwIF,eAAO,MAAM,sBAAsB,GACjC,cAAc,YAAY,GAAG,SAAS,KACrC,qBA6FF,CAAC"}
+{"version":3,"file":"viemDecode.d.ts","sourceRoot":"","sources":["../../../src/utils/viemDecode.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE/D,OAAO,KAAK,EAEV,0BAA0B,EAC1B,mBAAmB,EACnB,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,wBAAwB,IAAI,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AAChH,OAAO,KAAK,EACV,4BAA4B,EAC5B,8BAA8B,EAC9B,wBAAwB,EACxB,4BAA4B,EAC7B,MAAM,iBAAiB,CAAC;AAEzB,eAAO,MAAM,uBAAuB,GAClC,cAAc,wBAAwB,KACrC,kBA2BF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,MACI,4BAA4B,GAC5B,8BAA8B,GAC9B,4BAA4B,KAE9B,uBAAuB,GACvB,uBAAuB,GACvB,mBAAmB,GACnB,0BAgBH,CAAC;AAwIF,eAAO,MAAM,sBAAsB,GACjC,cAAc,YAAY,GAAG,SAAS,KACrC,qBA6FF,CAAC"}

package/dist/types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.0.0-alpha.13";
+export declare const VERSION = "0.0.0-alpha.15";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alchemy/wallet-apis",
-  "version": "0.0.0-alpha.14",
+  "version": "0.0.0-alpha.16",
   "description": "Alchemy Wallet APIs",
   "author": "Alchemy",
   "license": "MIT",
@@ -54,11 +54,12 @@
     "typescript-template": "*"
   },
   "dependencies": {
-    "@alchemy/common": "^0.0.0-alpha.14",
-    "@alchemy/wallet-api-types": "^0.1.0-alpha.18",
+    "@alchemy/common": "^0.0.0-alpha.16",
+    "@alchemy/wallet-api-types": "^0.1.0-alpha.22",
     "deep-equal": "^2.2.3",
-    "ox": "^0.6.12",
-    "viem": "^2.32.0"
+    "ox": "^0.11.1",
+    "viem": "^2.44.2",
+    "webauthn-p256": "^0.0.10"
   },
   "publishConfig": {
     "access": "public",
@@ -72,5 +73,5 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "11e8a88c8ff02396f2e46d47f183eae43b4eb43c"
+  "gitHead": "299dbbeffbba1ee90b8cc4f5f0931cad3645add0"
 }

package/src/actions/grantPermissions.ts

@@ -9,9 +9,10 @@ import {
 import type { InnerWalletApiClient } from "../types.ts";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
 import { signSignatureRequest } from "./signSignatureRequest.js";
-import { AccountNotFoundError } from "@alchemy/common";
+import { AccountNotFoundError, BaseError } from "@alchemy/common";
 import { LOGGER } from "../logger.js";
 import type { OptionalChainId } from "../types.ts";
+import { isWebAuthnAccount } from "../utils/assertions.js";
 
 type RpcSchema = Extract<
   WalletServerRpcSchemaType,
@@ -100,6 +101,13 @@ export async function grantPermissions<
     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",
@@ -113,11 +121,14 @@ export async function grantPermissions<
   });
 
   const signature = await signSignatureRequest(client, signatureRequest);
+
   const res = {
     context: concatHex([
       "0x00", // Remote mode.
       sessionId,
-      signature.data,
+      signature.type === "webauthn-p256"
+        ? signature.data.signature
+        : signature.data,
     ]),
   } as const;
   LOGGER.debug("grantPermissions:done");

package/src/actions/listAccounts.ts

@@ -2,6 +2,8 @@ import type { InnerWalletApiClient } from "../types.ts";
 import { LOGGER } from "../logger.js";
 import type { Address, Prettify } from "viem";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+import { getSignerAddressOrPublicKey } from "../utils/signer.js";
+import type { WebAuthnPublicKey } from "@alchemy/wallet-api-types";
 
 type RpcSchema = Extract<
   WalletServerRpcSchemaType,
@@ -13,9 +15,18 @@ type RpcSchema = Extract<
 >;
 
 export type ListAccountsParams = Prettify<
-  Omit<RpcSchema["Request"]["params"][0], "signerAddress"> & {
-    signerAddress?: Address;
-  }
+  Omit<RpcSchema["Request"]["params"][0], "signerAddress"> &
+    (
+      | {
+          signerAddress?: Address;
+          signerPublicKey?: never;
+        }
+      | { signerPublicKey: WebAuthnPublicKey; signerAddress?: never }
+      | {
+          signerAddress?: never;
+          signerPublicKey?: never;
+        }
+    )
 >;
 
 export type ListAccountsResult = Prettify<RpcSchema["ReturnType"]>;
@@ -50,17 +61,40 @@ export async function listAccounts(
   client: InnerWalletApiClient,
   params: ListAccountsParams,
 ): Promise<ListAccountsResult> {
-  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: RpcSchema["Request"]["params"][0] = 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,
       },
     ],
   });
   LOGGER.debug("listAccounts:done", { count: res.accounts.length });
+
   return res;
 }

package/src/actions/requestAccount.ts

@@ -1,9 +1,16 @@
 import type { Address } from "abitype";
-import type { Prettify, UnionOmit } from "viem";
+import { BaseError, type Prettify } from "viem";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
 import deepEqual from "deep-equal";
-import type { InnerWalletApiClient, OptionalSignerAddress } from "../types";
+import type { InnerWalletApiClient } from "../types";
 import { LOGGER } from "../logger.js";
+import type {
+  CreationOptionsByPublicKey,
+  CreationOptionsBySignerAddress,
+  WebAuthnPublicKey,
+} from "@alchemy/wallet-api-types";
+import { isWebAuthnAccount } from "../utils/assertions.js";
+import { getSignerAddressOrPublicKey } from "../utils/signer.js";
 
 type RpcSchema = Extract<
   WalletServerRpcSchemaType,
@@ -15,9 +22,13 @@ type RpcSchema = Extract<
 >;
 
 export type RequestAccountParams = Prettify<
-  OptionalSignerAddress<
-    UnionOmit<RpcSchema["Request"]["params"][0], "includeCounterfactualInfo">
-  >
+  Omit<
+    Extract<
+      RpcSchema["Request"]["params"][0],
+      { signerAddress: Address } | { signerPublicKey: WebAuthnPublicKey }
+    >,
+    "signerAddress" | "signerPublicKey" | "includeCounterfactualInfo"
+  > & { accountAddress?: Address }
 >;
 
 export type RequestAccountResult = Prettify<{ address: Address }>;
@@ -48,31 +59,65 @@ export async function requestAccount(
     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: RpcSchema["Request"]["params"][0] =
+    (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 as CreationOptionsByPublicKey }
+                  : {}),
+              }
+            : {
+                signerAddress: owner.address,
+                ...(creationHint
+                  ? {
+                      creationHint:
+                        creationHint as CreationOptionsBySignerAddress,
+                    }
+                  : {}),
+              }),
+          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", {

package/src/actions/sendCalls.ts

@@ -7,6 +7,10 @@ import {
   type SendPreparedCallsResult,
 } from "./sendPreparedCalls.js";
 import { LOGGER } from "../logger.js";
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import { isWebAuthnAccount } from "../utils/assertions.js";
+import { extractCapabilitiesForSending } from "../utils/capabilities.js";
+import { BaseError } from "@alchemy/common";
 
 export type SendCallsParams<
   TAccount extends Address | undefined = Address | undefined,
@@ -40,6 +44,10 @@ 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 async function sendCalls<
   TAccount extends Address | undefined = Address | undefined,
@@ -51,15 +59,43 @@ export async function sendCalls<
     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 as Exclude<
+        typeof signature,
+        { type: "webauthn-p256" }
+      >,
+    };
+
+    calls = await prepareCalls(client, secondCallParams);
+  }
 
   const signedCalls = await signPreparedCalls(client, calls);
 
+  const sendPreparedCallsCapabilities = extractCapabilitiesForSending(
+    params.capabilities,
+  );
+
   const res = await sendPreparedCalls(client, {
     ...signedCalls,
-    // The only capability that is supported in sendPreparedCalls is permissions.
-    ...(params.capabilities?.permissions != null
-      ? { capabilities: { permissions: params.capabilities.permissions } }
+    ...(sendPreparedCallsCapabilities != null
+      ? { capabilities: sendPreparedCallsCapabilities }
       : {}),
   });
   LOGGER.info("sendCalls:done");

package/src/actions/sendPreparedCalls.ts

@@ -2,6 +2,7 @@ import { toHex, type Prettify } from "viem";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
 import type { InnerWalletApiClient, OptionalChainId } from "../types.ts";
 import { LOGGER } from "../logger.js";
+import { mergeClientCapabilities } from "../utils/capabilities.js";
 
 type RpcSchema = Extract<
   WalletServerRpcSchemaType,
@@ -53,6 +54,8 @@ export async function sendPreparedCalls(
   client: InnerWalletApiClient,
   params: SendPreparedCallsParams,
 ): Promise<SendPreparedCallsResult> {
+  params.capabilities = mergeClientCapabilities(client, params.capabilities);
+
   LOGGER.debug("sendPreparedCalls:start", { type: params.type });
   const res = await client.request({
     method: "wallet_sendPreparedCalls",

package/src/actions/signMessage.ts

@@ -3,6 +3,7 @@ import {
   type Hex,
   type Prettify,
   type SignableMessage,
+  BaseError,
 } from "viem";
 import type { InnerWalletApiClient } from "../types.js";
 import { requestAccount } from "./requestAccount.js";
@@ -62,6 +63,13 @@ export async function signMessage(
 
   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/src/actions/signPreparedCalls.ts

@@ -10,6 +10,7 @@ import type {
 import type { InnerWalletApiClient } from "../types.js";
 import { LOGGER } from "../logger.js";
 import type { SendPreparedCallsParams } from "./sendPreparedCalls.js";
+import { isWebAuthnAccount } from "../utils/assertions.js";
 
 export type SignPreparedCallsParams = Prettify<PrepareCallsResult>;
 
@@ -45,8 +46,16 @@ export async function signPreparedCalls(
   params: SignPreparedCallsParams,
 ): Promise<SignPreparedCallsResult> {
   LOGGER.debug("signPreparedCalls:start", { type: params.type });
+
   const signAuthorizationCall = async (call: PreparedCall_Authorization) => {
     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: {
@@ -54,9 +63,13 @@ export async function signPreparedCalls(
         chainId: call.chainId,
       },
     });
+    // Authorization signatures are never webauthn-256 (throws above).
     return {
       ...rest,
-      signature,
+      signature: signature as Exclude<
+        typeof signature,
+        { type: "webauthn-p256" }
+      >,
     };
   };