@account-kit/wallet-client 4.76.0 → 4.77.0

package/src/client/actions/requestAccount.ts

@@ -1,13 +1,20 @@
-import {
-  type SmartAccountSigner,
-  type SmartContractAccount,
-} from "@aa-sdk/core";
+import { BaseError, type SmartContractAccount } from "@aa-sdk/core";
 import type { Address } from "abitype";
 import deepEqual from "deep-equal";
 import { custom } from "viem";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
 import type { InnerWalletApiClient } from "../../types.js";
 import { createAccount } from "../../internal/account.js";
+import type { SmartWalletSigner } from "../index.js";
+import {
+  credentialToWebAuthnPublicKey,
+  isWebAuthnSigner,
+} from "../../utils.js";
+import {
+  CreationOptionsByPublicKey,
+  CreationOptionsBySignerAddress,
+  type WebAuthnPublicKey,
+} from "@alchemy/wallet-api-types";
 
 type RpcSchema = Extract<
   WalletServerRpcSchemaType,
@@ -19,8 +26,11 @@ type RpcSchema = Extract<
 >;
 
 export type RequestAccountParams = Omit<
-  Extract<RpcSchema["Request"]["params"][0], { signerAddress: Address }>,
-  "signerAddress" | "includeCounterfactualInfo"
+  Extract<
+    RpcSchema["Request"]["params"][0],
+    { signerAddress: Address } | { signerPublicKey: WebAuthnPublicKey }
+  >,
+  "signerAddress" | "signerPublicKey" | "includeCounterfactualInfo"
 > & { accountAddress?: Address };
 
 export type RequestAccountResult = SmartContractAccount;
@@ -31,7 +41,7 @@ export type RequestAccountResult = SmartContractAccount;
  * If an account already exists, the creationHint will be ignored.
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
- * @param {SmartAccountSigner} signer - The signer that will be associated with the account
+ * @param {SmartAccountSigner | WebAuthnSigner} signer - The signer that will be associated with the account
  * @param {RequestAccountParams} [params] - Optional parameters for requesting a specific account
  * @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
  * @param {object} [params.creationHint] - Optional hints to guide account creation. These are ignored if an account already exists
@@ -46,20 +56,57 @@ export type RequestAccountResult = SmartContractAccount;
  */
 export async function requestAccount(
   client: InnerWalletApiClient,
-  signer: SmartAccountSigner,
+  signer: SmartWalletSigner,
   params?: RequestAccountParams,
 ): Promise<RequestAccountResult> {
-  const args =
+  const { creationHint = {} } = params ?? {};
+
+  if (isWebAuthnSigner(signer)) {
+    if (creationHint.accountType !== "mav2-webauthn") {
+      // todo: validate error details
+      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 args = (
     (client.account && !params) || params?.accountAddress
       ? {
           accountAddress: params?.accountAddress ?? client.account!.address,
           includeCounterfactualInfo: true,
         }
       : {
-          ...params,
-          signerAddress: await signer.getAddress(),
+          ...(isWebAuthnSigner(signer)
+            ? {
+                signerPublicKey: {
+                  ...credentialToWebAuthnPublicKey(signer.credential),
+                  type: "webauthn-p256",
+                },
+                // todo: re-enable after fixing type assertions above
+                ...(creationHint
+                  ? { creationHint: creationHint as CreationOptionsByPublicKey }
+                  : {}),
+              }
+            : {
+                signerAddress: await signer.getAddress(),
+                ...(creationHint
+                  ? {
+                      creationHint:
+                        creationHint as CreationOptionsBySignerAddress,
+                    }
+                  : {}),
+              }),
           includeCounterfactualInfo: true,
-        };
+        }
+  ) satisfies RpcSchema["Request"]["params"][0];
 
   const cachedAccount = client.internal.getAccount();
 

package/src/client/actions/sendCalls.ts

@@ -3,12 +3,13 @@ import type { InnerWalletApiClient } from "../../types.js";
 import { prepareCalls, type PrepareCallsParams } from "./prepareCalls.js";
 import { metrics } from "../../metrics.js";
 import { signPreparedCalls } from "./signPreparedCalls.js";
-import { type SmartAccountSigner } from "@aa-sdk/core";
 import {
   sendPreparedCalls,
   type SendPreparedCallsResult,
 } from "./sendPreparedCalls.js";
 import { signSignatureRequest } from "./signSignatureRequest.js";
+import type { SmartWalletSigner } from "../index.js";
+import { isWebAuthnSigner } from "../../utils.js";
 
 export type SendCallsParams<
   TAccount extends Address | undefined = Address | undefined,
@@ -25,7 +26,7 @@ export type SendCallsResult = SendPreparedCallsResult;
  * </Note>
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
- * @param {SmartAccountSigner} signer - The signer to use
+ * @param {SmartAccountSigner | WebAuthnSigner} signer - The signer to use
  * @param {PrepareCallsParams<TAccount>} params - Parameters for sending calls
  * @param {Array<{to: Address, data?: Hex, value?: Hex}>} params.calls - Array of contract calls to execute
  * @param {Address} [params.from] - The address to execute the calls from (required if the client wasn't initialized with an account)
@@ -53,7 +54,7 @@ export async function sendCalls<
   TAccount extends Address | undefined = Address | undefined,
 >(
   client: InnerWalletApiClient,
-  signer: SmartAccountSigner,
+  signer: SmartWalletSigner,
   params: SendCallsParams<TAccount>,
 ): Promise<SendCallsResult> {
   metrics.trackEvent({
@@ -63,6 +64,11 @@ export async function sendCalls<
   let calls = await prepareCalls(client, params);
 
   if (calls.type === "paymaster-permit") {
+    if (isWebAuthnSigner(signer)) {
+      throw new Error(
+        "WebAuthn signer is not currently supported for signing paymaster permit signatures",
+      );
+    }
     const signature = await signSignatureRequest(
       signer,
       calls.signatureRequest,

package/src/client/actions/signMessage.ts

@@ -1,8 +1,8 @@
-import { type SmartAccountSigner } from "@aa-sdk/core";
 import { type Address, type Hex, type SignableMessage } from "viem";
 import type { InnerWalletApiClient } from "../../types.ts";
 import { requestAccount } from "./requestAccount.js";
 import { metrics } from "../../metrics.js";
+import type { SmartWalletSigner } from "../index.js";
 
 export type SignMessageParams = { message: SignableMessage; account?: Address };
 
@@ -13,7 +13,7 @@ export type SignMessageResult = Hex;
  * This method requests the account associated with the signer and uses it to sign the message.
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
- * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {SmartAccountSigner | WebAuthnSigner} signer - The signer of the smart account
  * @param {SignMessageParams} params - Parameters for signing the message
  * @param {SignableMessage} params.message - The message to sign using EIP-191. Can be a string, or object with raw bytes.
  * @param {Address} [params.account] - Optional account address to use for signing. If not provided, uses the client's current account.
@@ -30,7 +30,7 @@ export type SignMessageResult = Hex;
  */
 export async function signMessage(
   client: InnerWalletApiClient,
-  signer: SmartAccountSigner,
+  signer: SmartWalletSigner,
   params: SignMessageParams,
 ): Promise<SignMessageResult> {
   metrics.trackEvent({

package/src/client/actions/signPreparedCalls.ts

@@ -1,5 +1,5 @@
 import type { PrepareCallsResult } from "./prepareCalls.ts";
-import { BaseError, type SmartAccountSigner } from "@aa-sdk/core";
+import { BaseError } from "@aa-sdk/core";
 import { signSignatureRequest } from "./signSignatureRequest.js";
 import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
 import type {
@@ -8,7 +8,8 @@ import type {
   PreparedCall_UserOpV070,
 } from "@alchemy/wallet-api-types";
 import { metrics } from "../../metrics.js";
-import { assertNever } from "../../utils.js";
+import { assertNever, isWebAuthnSigner } from "../../utils.js";
+import type { SmartWalletSigner } from "../index.js";
 
 type RpcSchema = Extract<
   WalletServerRpcSchemaType,
@@ -26,12 +27,12 @@ export type SignPreparedCallsResult = RpcSchema["Request"]["params"][0];
 /**
  * Signs prepared calls using the provided signer.
  *
- * @param {SmartAccountSigner} signer - The signer to use
+ * @param {SmartAccountSigner | WebAuthnSigner} signer - The signer to use
  * @param {SignPreparedCallsParams} params - The prepared calls with signature requests
  * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls
  */
 export async function signPreparedCalls(
-  signer: SmartAccountSigner,
+  signer: SmartWalletSigner,
   params: SignPreparedCallsParams,
 ): Promise<SignPreparedCallsResult> {
   metrics.trackEvent({
@@ -43,6 +44,11 @@ export async function signPreparedCalls(
 
   const signAuthorizationCall = async (call: PreparedCall_Authorization) => {
     const { signatureRequest: _signatureRequest, ...rest } = call;
+    if (isWebAuthnSigner(signer)) {
+      throw new Error(
+        "WebAuthn account cannot sign EIP-7702 authorization requests",
+      );
+    }
     const signature = await signSignatureRequest(signer, {
       type: "eip7702Auth",
       data: {

package/src/client/actions/signSignatureRequest.ts

@@ -1,15 +1,20 @@
 import type { SmartAccountSigner } from "@aa-sdk/core";
-import { type Hex, hexToNumber, serializeSignature } from "viem";
-import { assertNever } from "../../utils.js";
+import { hexToNumber, serializeSignature } from "viem";
+import { assertNever, isWebAuthnSigner } from "../../utils.js";
 import type {
   PersonalSignSignatureRequest,
   TypedDataSignatureRequest,
   AuthorizationSignatureRequest,
   Eip7702UnsignedAuth,
+  UserOpSig,
+  EcdsaSig,
+  WebauthnSig,
 } from "@alchemy/wallet-api-types";
 import { vToYParity } from "ox/Signature";
 import type { WithoutRawPayload } from "../../types.ts";
 import { metrics } from "../../metrics.js";
+import type { SmartWalletSigner, WebAuthnSigner } from "../index.js";
+import { toWebAuthnAccount } from "viem/account-abstraction";
 
 export type SignSignatureRequestParams = WithoutRawPayload<
   | PersonalSignSignatureRequest
@@ -19,16 +24,41 @@ export type SignSignatureRequestParams = WithoutRawPayload<
     })
 >;
 
-export type SignSignatureRequestResult = {
-  type: "secp256k1";
-  data: Hex;
-};
+export type SignSignatureRequestResult = UserOpSig["signature"];
+
+// Overload: Always an ECDSA signer, can sign any type of request
+export async function signSignatureRequest(
+  signer: SmartAccountSigner,
+  params: WithoutRawPayload<
+    | PersonalSignSignatureRequest
+    | TypedDataSignatureRequest
+    | (AuthorizationSignatureRequest & {
+        data: Eip7702UnsignedAuth;
+      })
+  >,
+): Promise<EcdsaSig["signature"]>;
+
+// Overload: WebAuthn signer, can only sign personal_sign and eth_signTypedData_v4
+export async function signSignatureRequest(
+  signer: WebAuthnSigner,
+  params: WithoutRawPayload<
+    PersonalSignSignatureRequest | TypedDataSignatureRequest
+  >,
+): Promise<WebauthnSig["signature"]>;
+
+// Overload: Union type of signer, can only sign personal_sign and eth_signTypedData_v4
+export async function signSignatureRequest(
+  signer: SmartAccountSigner | WebAuthnSigner,
+  params: WithoutRawPayload<
+    PersonalSignSignatureRequest | TypedDataSignatureRequest
+  >,
+): Promise<UserOpSig["signature"]>;
 
 /**
  * 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 {SmartAccountSigner | WebAuthnSigner} signer - The signer to use for signing the request
  * @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
@@ -56,7 +86,7 @@ export type SignSignatureRequestResult = {
  */
 
 export async function signSignatureRequest(
-  signer: SmartAccountSigner,
+  signer: SmartWalletSigner,
   params: SignSignatureRequestParams,
 ): Promise<SignSignatureRequestResult> {
   metrics.trackEvent({
@@ -68,18 +98,55 @@ export async function signSignatureRequest(
 
   switch (params.type) {
     case "personal_sign": {
+      if (isWebAuthnSigner(signer)) {
+        const webAuthnAccount = toWebAuthnAccount({ ...signer });
+
+        const { signature, webauthn: metadata } =
+          await webAuthnAccount.signMessage({
+            message: params.data,
+          });
+
+        return {
+          type: "webauthn-p256",
+          data: {
+            signature,
+            metadata,
+          },
+        };
+      }
+
       return {
         type: "secp256k1",
         data: await signer.signMessage(params.data),
       };
     }
     case "eth_signTypedData_v4": {
+      if (isWebAuthnSigner(signer)) {
+        const webAuthnAccount = toWebAuthnAccount({ ...signer });
+
+        const { signature, webauthn: metadata } =
+          await webAuthnAccount.signTypedData(params.data);
+
+        return {
+          type: "webauthn-p256",
+          data: {
+            signature,
+            metadata,
+          },
+        };
+      }
       return {
         type: "secp256k1",
         data: await signer.signTypedData(params.data),
       };
     }
     case "eip7702Auth": {
+      if (isWebAuthnSigner(signer)) {
+        throw new Error(
+          "WebAuthn account cannot sign EIP-7702 authorization requests",
+        );
+      }
+
       if (!signer.signAuthorization) {
         throw new Error("Signer does not implement signAuthorization");
       }

package/src/client/actions/signTypedData.ts

@@ -1,8 +1,8 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
 import { type Address, type Hex, type TypedDataDefinition } from "viem";
 import type { InnerWalletApiClient } from "../../types.ts";
 import { requestAccount } from "./requestAccount.js";
 import { metrics } from "../../metrics.js";
+import type { SmartWalletSigner } from "../index.js";
 
 export type SignTypedDataParams = TypedDataDefinition & {
   account?: Address;
@@ -15,7 +15,7 @@ export type SignTypedDataResult = Hex;
  * This method requests the account associated with the signer and uses it to sign the typed data.
  *
  * @param {InnerWalletApiClient} client - The wallet API client to use for the request
- * @param {SmartAccountSigner} signer - The signer of the smart account
+ * @param {SmartAccountSigner | WebAuthnSigner} signer - The signer of the smart account
  * @param {TypedDataDefinition} params - The typed data to sign, following EIP-712 format
  * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string
  *
@@ -45,7 +45,7 @@ export type SignTypedDataResult = Hex;
  */
 export async function signTypedData(
   client: InnerWalletApiClient,
-  signer: SmartAccountSigner,
+  signer: SmartWalletSigner,
   params: SignTypedDataParams,
 ): Promise<SignTypedDataResult> {
   metrics.trackEvent({

package/src/client/decorator.ts

@@ -1,4 +1,3 @@
-import type { SmartAccountSigner } from "@aa-sdk/core";
 import type { Address, Hex } from "viem";
 import {
   type WaitForCallsStatusParameters,
@@ -56,6 +55,25 @@ import {
   type SendCallsParams,
   type SendCallsResult,
 } from "./actions/sendCalls.js";
+import type { SmartWalletSigner } from "./index.js";
+import { isWebAuthnSigner } from "../utils.js";
+
+async function signSignatureRequestSafe(
+  signer: SmartWalletSigner,
+  params: SignSignatureRequestParams,
+): Promise<SignSignatureRequestResult> {
+  if (params.type === "eip7702Auth") {
+    if (isWebAuthnSigner(signer)) {
+      throw new Error(
+        "WebAuthn signer cannot sign EIP-7702 authorization requests",
+      );
+    }
+    // We must split up the call to signSignatureRequest across two conditionals for the TS compiler to
+    // correctly infer which overload to use.
+    return signSignatureRequest(signer, params);
+  }
+  return signSignatureRequest(signer, params);
+}
 
 export type SmartWalletActions<
   TAccount extends Address | undefined = Address | undefined,
@@ -94,7 +112,7 @@ export function smartWalletClientActions<
   TAccount extends Address | undefined = Address | undefined,
 >(
   client: InnerWalletApiClient,
-  signer: SmartAccountSigner,
+  signer: SmartWalletSigner,
 ): SmartWalletActions<TAccount> {
   return {
     requestAccount: (params) => requestAccount(client, signer, params),
@@ -104,7 +122,7 @@ export function smartWalletClientActions<
     sendCalls: (params) => sendCalls(client, signer, params),
     getCallsStatus: (params) => getCallsStatus(client, params),
     waitForCallsStatus: (params) => waitForCallsStatus(client, params),
-    signSignatureRequest: (params) => signSignatureRequest(signer, params),
+    signSignatureRequest: (params) => signSignatureRequestSafe(signer, params),
     signPreparedCalls: (params) => signPreparedCalls(signer, params),
     signMessage: (params) => signMessage(client, signer, params),
     signTypedData: (params) => signTypedData(client, signer, params),

package/src/client/index.ts

@@ -21,6 +21,15 @@ import type {
 } from "@alchemy/wallet-api-types/rpc";
 import { internalStateDecorator } from "../internal/decorator.js";
 import { metrics } from "../metrics.js";
+import type { ToWebAuthnAccountParameters } from "viem/account-abstraction";
+
+export type WebAuthnSigner = {
+  credential: ToWebAuthnAccountParameters["credential"];
+  getFn?: ToWebAuthnAccountParameters["getFn"] | undefined;
+  rpId?: ToWebAuthnAccountParameters["rpId"] | undefined;
+};
+
+export type SmartWalletSigner = SmartAccountSigner<any> | WebAuthnSigner;
 
 export type SmartWalletClientParams<
   TAccount extends Address | undefined = Address | undefined,
@@ -28,7 +37,7 @@ export type SmartWalletClientParams<
   {
     transport: AlchemyTransport;
     chain: Chain;
-    signer: SmartAccountSigner;
+    signer: SmartWalletSigner;
     account?: TAccount | Address | undefined;
   } & (
     | { policyId?: string; policyIds?: never }
@@ -46,7 +55,7 @@ export type SmartWalletClient<
  * @param {SmartWalletClientParams} params - The parameters for creating the smart wallet client
  * @param {AlchemyTransport} params.transport - The Alchemy transport to use
  * @param {Chain} params.chain - The chain to use
- * @param {SmartAccountSigner} params.signer - The signer to use for the smart account
+ * @param {SmartAccountSigner | WebAuthnSigner} params.signer - The signer to use for the smart account
  * @param {string} [params.policyId] - The policy ID for gas sponsorship (optional)
  * @param {Address} [params.account] - The smart account address to use (optional)
  * @returns {SmartWalletClient} - A viem-compatible client

package/src/internal/account.ts

@@ -1,4 +1,7 @@
-import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
+import {
+  InvalidSignerTypeError,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
 import {
   createModularAccountV2,
   createLightAccount,
@@ -14,13 +17,14 @@ import {
 } from "viem";
 import type { SerializedInitcode } from "@alchemy/wallet-api-types";
 import { InternalError, InvalidRequestError } from "ox/RpcResponse";
-import { assertNever } from "../utils.js";
+import { assertNever, isWebAuthnSigner } from "../utils.js";
 import { metrics } from "../metrics.js";
+import type { SmartWalletSigner } from "../client/index.js";
 
 type CreateAccountParams = {
   chain: Chain;
   transport: Transport;
-  signer: SmartAccountSigner;
+  signer: SmartWalletSigner;
   accountAddress: Address;
   counterfactualInfo?: SerializedInitcode; // undefined for 7702 accounts
   delegation?: Address; // for 7702 accounts
@@ -48,14 +52,20 @@ type CreateAccountParams = {
 export async function createAccount(
   params: CreateAccountParams,
 ): Promise<SmartContractAccount> {
-  const { counterfactualInfo: ci, ...accountParams } = params;
+  const { counterfactualInfo: ci, signer, ...accountParams } = params;
 
   if (params.delegation) {
     if (!isAddressEqual(params.delegation, MAV2_7702_DELEGATION_ADDRESS)) {
       throw new Error("7702 mode currently only supports ModularAccountV2");
     }
+
+    if (isWebAuthnSigner(signer)) {
+      throw new InvalidSignerTypeError("WebAuthn");
+    }
+
     return createModularAccountV2({
       ...accountParams,
+      signer,
       mode: "7702",
     });
   }
@@ -82,45 +92,68 @@ export async function createAccount(
     },
   });
 
+  // WebAuthn accounts must use a different signer type, so they are handled separately.
+  if (factoryType === "MAv2.0.0-ma-webauthn") {
+    if (!isWebAuthnSigner(signer)) {
+      throw new InvalidSignerTypeError(signer.signerType);
+    }
+
+    return createModularAccountV2({
+      ...commonParams,
+      ...signer,
+      mode: "webauthn",
+    });
+  }
+
+  if (isWebAuthnSigner(signer)) {
+    throw new InvalidSignerTypeError("WebAuthn");
+  }
+
   // Return the account created based on the factory type
   switch (factoryType) {
     case "MAv2.0.0-sma-b":
       return createModularAccountV2({
         ...commonParams,
+        signer,
         mode: "default",
       });
     case "LightAccountV2.0.0":
       return createLightAccount({
         ...commonParams,
+        signer,
         version: "v2.0.0",
       });
     case "LightAccountV1.0.1":
       return createLightAccount({
         ...commonParams,
+        signer,
         version: "v1.0.1",
       });
     case "LightAccountV1.0.2":
       return createLightAccount({
         ...commonParams,
+        signer,
         version: "v1.0.2",
       });
     case "LightAccountV1.1.0":
       return createLightAccount({
         ...commonParams,
+        signer,
         version: "v1.1.0",
       });
     case "MAv1.0.0-MultiOwner":
       return createMultiOwnerModularAccount({
         ...commonParams,
+        signer,
       });
     case "LightAccountV2.0.0-MultiOwner":
       return createMultiOwnerLightAccount({
         ...commonParams,
         version: "v2.0.0",
+        signer,
       });
     case "MAv1.0.0-MultiSig":
     case "MAv2.0.0-ma-ssv":
-    case "MAv2.0.0-ma-webauthn":
     case "unknown":
     case undefined:
       throw new InvalidRequestError({

package/src/utils.ts

@@ -1,4 +1,8 @@
-import { isHex, toHex, type Hex } from "viem";
+import { isHex, sliceHex, toHex, type Hex } from "viem";
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type { WebAuthnPublicKey } from "@alchemy/wallet-api-types";
+import type { ToWebAuthnAccountParameters } from "viem/account-abstraction";
+import type { WebAuthnSigner } from "./client";
 
 export type Expect<T extends true> = T;
 
@@ -25,3 +29,23 @@ export const castToHex = (val: string | number | bigint | Hex): Hex => {
   }
   return toHex(val);
 };
+
+export function isWebAuthnSigner(
+  signer: SmartAccountSigner | WebAuthnSigner,
+): signer is WebAuthnSigner {
+  return "credential" in signer;
+}
+
+export function credentialToWebAuthnPublicKey(
+  credential: ToWebAuthnAccountParameters["credential"],
+): WebAuthnPublicKey {
+  const { x, y } = {
+    x: sliceHex(credential.publicKey, 0, 32, { strict: true }),
+    y: sliceHex(credential.publicKey, 32, 64, { strict: true }),
+  };
+
+  return {
+    x,
+    y,
+  };
+}

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is autogenerated by inject-version.ts. Any changes will be
 // overwritten on commit!
-export const VERSION = "4.76.0";
+export const VERSION = "4.77.0";