@moon-x/core 0.3.0 → 0.4.0

package/dist/sdk/index.mjs

@@ -8,13 +8,9 @@ import {
   broadcastEthereumRaw,
   broadcastSolanaSigned,
   bs58ToBytes,
-  clearParentAssertCache,
-  readParentAssertCache,
   serializeEthereumTransaction,
-  toB64url,
-  withClearOnFailure,
-  writeParentAssertCache
-} from "../chunk-CDT4MC7S.mjs";
+  toB64url
+} from "../chunk-6LTEG7VN.mjs";
 import "../chunk-GQKIA37O.mjs";
 
 // src/sdk/parent-passkey-assert.ts
@@ -22,13 +18,8 @@ var assertPasskeyInParent = async ({
   transport,
   passkey,
   publishableKey,
-  requireFreshAssertion = false,
   validateCredentialInAllowList = false
 }) => {
-  if (!requireFreshAssertion) {
-    const cached = readParentAssertCache();
-    if (cached) return cached;
-  }
   const dekInfo = await transport.send(
     PostMessageType.AUTH,
     PostMessageMethod.GET_DEK_INFO,
@@ -52,12 +43,10 @@ var assertPasskeyInParent = async ({
   if (validateCredentialInAllowList && !allowList.includes(credential.rawIdB64url)) {
     throw new Error("unknown_passkey_for_this_account");
   }
-  const result = {
+  return {
     userHandleB64url: credential.userHandleB64url,
     credentialIdB64url: credential.rawIdB64url
   };
-  writeParentAssertCache(result);
-  return result;
 };
 
 // src/sdk/get-presence-token.ts
@@ -89,19 +78,66 @@ var getPresenceToken = async ({
   };
 };
 
+// src/sdk/get-internal-presence-tokens.ts
+var getInternalPresenceTokens = async ({
+  transport,
+  passkey,
+  publishableKey,
+  relyingPartyOrigin,
+  scopes
+}) => {
+  const { token, optionsJSON } = await transport.send(
+    PostMessageType.AUTH,
+    PostMessageMethod.PASSKEY_PRESENCE_BEGIN,
+    { publishableKey, relyingPartyOrigin }
+  );
+  const { response, userHandleB64url, credentialIdB64url } = await passkey.assertForInternalPresence({ optionsJSON });
+  const verify = await transport.send(
+    PostMessageType.AUTH,
+    PostMessageMethod.PASSKEY_PRESENCE_VERIFY,
+    {
+      publishableKey,
+      relyingPartyOrigin,
+      token,
+      response,
+      purpose: "internal",
+      scopes
+    }
+  );
+  const out = {};
+  for (const [scope, t] of Object.entries(verify.tokens ?? {})) {
+    out[scope] = { token: t.token, expiresAt: t.expires_at };
+  }
+  return {
+    tokens: out,
+    userHandleB64url,
+    credentialIdB64url
+  };
+};
+var flattenPresenceTokens = (result) => {
+  const out = {};
+  for (const [scope, t] of Object.entries(result.tokens)) {
+    out[scope] = t.token;
+  }
+  return out;
+};
+
 // src/sdk/headless-ethereum.ts
+var SCOPES_SIGN = ["keyshare_read", "sign"];
 var getHeadlessEthereumMethods = ({
   transport,
   passkey,
-  publishableKey
+  publishableKey,
+  relyingPartyOrigin
 }) => ({
-  signEthereumMessageHeadless: async (params) => withClearOnFailure(async () => {
+  signEthereumMessageHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN
     });
     return transport.send(
       PostMessageType.WALLET,
@@ -112,17 +148,23 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         uiOptions: params.options?.uiOptions,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
-  }),
-  signEthereumTransactionHeadless: async (params) => withClearOnFailure(async () => {
+  },
+  signEthereumTransactionHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN
     });
     return transport.send(
       PostMessageType.WALLET,
@@ -134,17 +176,23 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
-  }),
-  signEthereumTypedDataHeadless: async (params) => withClearOnFailure(async () => {
+  },
+  signEthereumTypedDataHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN
     });
     return transport.send(
       PostMessageType.WALLET,
@@ -158,17 +206,23 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
-  }),
-  signEthereumHashHeadless: async (params) => withClearOnFailure(async () => {
+  },
+  signEthereumHashHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN
     });
     return transport.send(
       PostMessageType.WALLET,
@@ -179,17 +233,23 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
-  }),
-  signEthereum7702AuthorizationHeadless: async (params) => withClearOnFailure(async () => {
+  },
+  signEthereum7702AuthorizationHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN
     });
     return transport.send(
       PostMessageType.WALLET,
@@ -203,17 +263,23 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
-  }),
-  sendEthereumTransactionHeadless: async (params) => withClearOnFailure(async () => {
+  },
+  sendEthereumTransactionHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN
     });
     const serializedTransaction = await serializeEthereumTransaction(
       params.transaction
@@ -227,7 +293,12 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     if (!signed.serializedSigned) {
@@ -240,7 +311,7 @@ var getHeadlessEthereumMethods = ({
       signed.serializedSigned
     );
     return { hash };
-  }),
+  },
   getEthereumBalance: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
     return transport.send(
@@ -276,18 +347,21 @@ var getHeadlessEthereumMethods = ({
 });
 
 // src/sdk/headless-solana.ts
+var SCOPES_SIGN2 = ["keyshare_read", "sign"];
 var getHeadlessSolanaMethods = ({
   transport,
   passkey,
-  publishableKey
+  publishableKey,
+  relyingPartyOrigin
 }) => ({
-  signSolanaMessageHeadless: async (params) => withClearOnFailure(async () => {
+  signSolanaMessageHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN2
     });
     const { signature } = await transport.send(
       PostMessageType.WALLET,
@@ -298,18 +372,24 @@ var getHeadlessSolanaMethods = ({
         wallet: params.wallet,
         uiOptions: params.options?.uiOptions,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     return { signature: arrayLikeToBytes(signature) };
-  }),
-  signSolanaTransactionHeadless: async (params) => withClearOnFailure(async () => {
+  },
+  signSolanaTransactionHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN2
     });
     const { signedTransaction } = await transport.send(
       PostMessageType.WALLET,
@@ -320,18 +400,24 @@ var getHeadlessSolanaMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     return { signedTransaction: await bs58ToBytes(signedTransaction) };
-  }),
-  sendSolanaTransactionHeadless: async (params) => withClearOnFailure(async () => {
+  },
+  sendSolanaTransactionHeadless: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: params.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_SIGN2
     });
     const { signedTransaction } = await transport.send(
       PostMessageType.WALLET,
@@ -342,7 +428,12 @@ var getHeadlessSolanaMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     const broadcastSignature = await broadcastSolanaSigned(
@@ -350,7 +441,7 @@ var getHeadlessSolanaMethods = ({
       signedTransaction
     );
     return { signature: await bs58ToBytes(broadcastSignature) };
-  }),
+  },
   getSolanaBalance: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
     return transport.send(
@@ -462,11 +553,15 @@ var getHeadlessAuthenticationMethods = ({
 });
 
 // src/sdk/headless-general.ts
+var SCOPES_CREATE_WALLET = ["dek_bootstrap", "keyshare_write"];
+var SCOPES_IMPORT_KEY = ["dek_bootstrap", "keyshare_write"];
+var SCOPES_REMOVE_PASSKEY = ["passkey_remove"];
 var getHeadlessGeneralMethods = ({
   transport,
   passkey,
   storage,
   publishableKey,
+  relyingPartyOrigin,
   setIsAuthenticated,
   setUser
 }) => ({
@@ -476,18 +571,34 @@ var getHeadlessGeneralMethods = ({
     { publishableKey }
   ),
   removePasskey: async (credentialIdB64url) => {
+    const { tokens, userHandleB64url, credentialIdB64url: assertedCredId } = await getInternalPresenceTokens({
+      transport,
+      passkey,
+      publishableKey,
+      relyingPartyOrigin,
+      scopes: SCOPES_REMOVE_PASSKEY
+    });
     await transport.send(
       PostMessageType.AUTH,
       PostMessageMethod.REMOVE_PASSKEY,
-      { publishableKey, credentialIdB64url }
+      {
+        publishableKey,
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url: assertedCredId
+        })
+      }
     );
   },
-  createWallet: (walletType, options) => withClearOnFailure(async () => {
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+  createWallet: async (walletType, options) => {
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: options?.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_CREATE_WALLET
     });
     const wallet = await transport.send(
       PostMessageType.WALLET,
@@ -497,17 +608,23 @@ var getHeadlessGeneralMethods = ({
         publishableKey,
         options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     return { wallet };
-  }),
-  importKey: (walletType, key, options) => withClearOnFailure(async () => {
-    const { userHandleB64url, credentialIdB64url } = await assertPasskeyInParent({
+  },
+  importKey: async (walletType, key) => {
+    const { userHandleB64url, credentialIdB64url, tokens } = await getInternalPresenceTokens({
       transport,
       passkey,
       publishableKey,
-      requireFreshAssertion: options?.requireFreshAssertion
+      relyingPartyOrigin,
+      scopes: SCOPES_IMPORT_KEY
     });
     const wallet = await transport.send(
       PostMessageType.WALLET,
@@ -517,11 +634,16 @@ var getHeadlessGeneralMethods = ({
         publishableKey,
         key,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     return { wallet };
-  }),
+  },
   getWallets: async (walletType) => {
     const { wallets } = await transport.send(
       PostMessageType.WALLET,
@@ -561,7 +683,6 @@ var getHeadlessGeneralMethods = ({
       await transport.send(PostMessageType.AUTH, PostMessageMethod.LOGOUT, {
         publishableKey
       });
-      clearParentAssertCache();
       await storage.remove("id_token");
       if (setIsAuthenticated) setIsAuthenticated(false);
       if (setUser) setUser(null);
@@ -609,9 +730,11 @@ var getHeadlessGeneralMethods = ({
 });
 export {
   assertPasskeyInParent,
+  flattenPresenceTokens,
   getHeadlessAuthenticationMethods,
   getHeadlessEthereumMethods,
   getHeadlessGeneralMethods,
   getHeadlessSolanaMethods,
+  getInternalPresenceTokens,
   getPresenceToken
 };

package/dist/types/index.d.mts

@@ -280,7 +280,6 @@ type Sign7702AuthorizationResponse = Sign7702AuthorizationResult | Sign7702Autho
 interface EthereumSignMessageParams {
     message: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: {
             title?: string;
@@ -298,7 +297,6 @@ interface EthereumSignMessageResult {
 interface EthereumSignTransactionParams {
     transaction: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         preflightCommitment?: "finalized" | "confirmed" | "processed";
         minContextSlot?: number;
@@ -324,7 +322,6 @@ interface EthereumSignTypedDataParams {
     primaryType: SignTypedDataParams["primaryType"];
     message: SignTypedDataParams["message"];
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: any;
     };
@@ -335,7 +332,6 @@ interface EthereumSignTypedDataResult {
 interface EthereumSignHashParams {
     hash: `0x${string}` | string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: any;
     };
@@ -349,7 +345,6 @@ interface EthereumSign7702AuthorizationParams {
     nonce?: number;
     executor?: "self" | `0x${string}`;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: any;
     };
@@ -378,7 +373,6 @@ interface EthereumSendTransactionParams {
     };
     wallet: PublicWallet;
     rpcUrl: string;
-    requireFreshAssertion?: boolean;
     options?: {
         commitment?: TransactionCommitment;
         skipPreflight?: boolean;
@@ -522,7 +516,6 @@ interface UseFundWalletInterface {
 interface SolanaSignMessageParams {
     message: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: {
             title?: string;
@@ -541,7 +534,6 @@ interface SolanaSignMessageResult {
 interface SolanaSignTransactionParams {
     transaction: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         preflightCommitment?: "finalized" | "confirmed" | "processed";
         minContextSlot?: number;
@@ -564,7 +556,6 @@ interface SolanaSendTransactionParams {
     transaction: string;
     wallet: PublicWallet;
     rpcUrl: string;
-    requireFreshAssertion?: boolean;
     options?: {
         commitment?: TransactionCommitment;
         skipPreflight?: boolean;

package/dist/types/index.d.ts

@@ -280,7 +280,6 @@ type Sign7702AuthorizationResponse = Sign7702AuthorizationResult | Sign7702Autho
 interface EthereumSignMessageParams {
     message: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: {
             title?: string;
@@ -298,7 +297,6 @@ interface EthereumSignMessageResult {
 interface EthereumSignTransactionParams {
     transaction: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         preflightCommitment?: "finalized" | "confirmed" | "processed";
         minContextSlot?: number;
@@ -324,7 +322,6 @@ interface EthereumSignTypedDataParams {
     primaryType: SignTypedDataParams["primaryType"];
     message: SignTypedDataParams["message"];
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: any;
     };
@@ -335,7 +332,6 @@ interface EthereumSignTypedDataResult {
 interface EthereumSignHashParams {
     hash: `0x${string}` | string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: any;
     };
@@ -349,7 +345,6 @@ interface EthereumSign7702AuthorizationParams {
     nonce?: number;
     executor?: "self" | `0x${string}`;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: any;
     };
@@ -378,7 +373,6 @@ interface EthereumSendTransactionParams {
     };
     wallet: PublicWallet;
     rpcUrl: string;
-    requireFreshAssertion?: boolean;
     options?: {
         commitment?: TransactionCommitment;
         skipPreflight?: boolean;
@@ -522,7 +516,6 @@ interface UseFundWalletInterface {
 interface SolanaSignMessageParams {
     message: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         uiOptions?: {
             title?: string;
@@ -541,7 +534,6 @@ interface SolanaSignMessageResult {
 interface SolanaSignTransactionParams {
     transaction: string;
     wallet: PublicWallet;
-    requireFreshAssertion?: boolean;
     options?: {
         preflightCommitment?: "finalized" | "confirmed" | "processed";
         minContextSlot?: number;
@@ -564,7 +556,6 @@ interface SolanaSendTransactionParams {
     transaction: string;
     wallet: PublicWallet;
     rpcUrl: string;
-    requireFreshAssertion?: boolean;
     options?: {
         commitment?: TransactionCommitment;
         skipPreflight?: boolean;

package/dist/web/index.d.mts

@@ -1,5 +1,5 @@
 import { P as PostMessageClient } from '../post-message-CmgAfkOS.mjs';
-import { T as Transport, P as PasskeyAssertor, K as KvStorage } from '../interfaces-CYtJHALV.mjs';
+import { T as Transport, P as PasskeyAssertor, K as KvStorage } from '../interfaces-cdKh3sLA.mjs';
 
 declare const getCachedPostMessageClient: (contentWindow: Window) => PostMessageClient;
 /**

package/dist/web/index.d.ts

@@ -1,5 +1,5 @@
 import { P as PostMessageClient } from '../post-message-CmgAfkOS.js';
-import { T as Transport, P as PasskeyAssertor, K as KvStorage } from '../interfaces-Bm7fGOAI.js';
+import { T as Transport, P as PasskeyAssertor, K as KvStorage } from '../interfaces-pNTEOKaK.js';
 
 declare const getCachedPostMessageClient: (contentWindow: Window) => PostMessageClient;
 /**

package/dist/web/index.js

@@ -338,6 +338,35 @@ var createWebAuthnPasskey = () => ({
       authenticatorAttachment: result.authenticatorAttachment
     };
     return sanitized;
+  },
+  assertForInternalPresence: async ({ optionsJSON }) => {
+    const result = await (0, import_browser.startAuthentication)({
+      optionsJSON: {
+        ...optionsJSON,
+        allowCredentials: []
+      }
+    });
+    if (!result.response.userHandle) {
+      throw new Error("user_handle_missing");
+    }
+    const sanitized = {
+      id: result.id,
+      rawId: result.rawId,
+      type: result.type,
+      response: {
+        clientDataJSON: result.response.clientDataJSON,
+        authenticatorData: result.response.authenticatorData,
+        signature: result.response.signature,
+        userHandle: void 0
+      },
+      clientExtensionResults: result.clientExtensionResults,
+      authenticatorAttachment: result.authenticatorAttachment
+    };
+    return {
+      response: sanitized,
+      userHandleB64url: result.response.userHandle,
+      credentialIdB64url: result.rawId
+    };
   }
 });