@moon-x/core 0.3.0 → 0.4.0

package/dist/sdk/index.js

@@ -31,10 +31,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var sdk_exports = {};
 __export(sdk_exports, {
   assertPasskeyInParent: () => assertPasskeyInParent,
+  flattenPresenceTokens: () => flattenPresenceTokens,
   getHeadlessAuthenticationMethods: () => getHeadlessAuthenticationMethods,
   getHeadlessEthereumMethods: () => getHeadlessEthereumMethods,
   getHeadlessGeneralMethods: () => getHeadlessGeneralMethods,
   getHeadlessSolanaMethods: () => getHeadlessSolanaMethods,
+  getInternalPresenceTokens: () => getInternalPresenceTokens,
   getPresenceToken: () => getPresenceToken
 });
 module.exports = __toCommonJS(sdk_exports);
@@ -66,34 +68,6 @@ var toB64url = (bytes) => {
   return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 };
 
-// src/lib/passkey/passkey-cache.ts
-var cacheTtlMs = 0;
-var cache = null;
-var clearParentAssertCache = () => {
-  cache = null;
-};
-var readParentAssertCache = () => {
-  if (cacheTtlMs <= 0) return null;
-  if (!cache) return null;
-  if (Date.now() - cache.ts >= cacheTtlMs) return null;
-  return {
-    userHandleB64url: cache.userHandleB64url,
-    credentialIdB64url: cache.credentialIdB64url
-  };
-};
-var writeParentAssertCache = (entry) => {
-  if (cacheTtlMs <= 0) return;
-  cache = { ...entry, ts: Date.now() };
-};
-var withClearOnFailure = async (fn) => {
-  try {
-    return await fn();
-  } catch (error) {
-    clearParentAssertCache();
-    throw error;
-  }
-};
-
 // src/lib/ethereum/chains.ts
 var import_viem = require("viem");
 
@@ -317,13 +291,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,
@@ -347,12 +316,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
@@ -384,19 +351,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,
@@ -407,17 +421,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,
@@ -429,17 +449,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,
@@ -453,17 +479,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,
@@ -474,17 +506,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,
@@ -498,17 +536,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
@@ -522,7 +566,12 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     if (!signed.serializedSigned) {
@@ -535,7 +584,7 @@ var getHeadlessEthereumMethods = ({
       signed.serializedSigned
     );
     return { hash };
-  }),
+  },
   getEthereumBalance: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
     return transport.send(
@@ -571,18 +620,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,
@@ -593,18 +645,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,
@@ -615,18 +673,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,
@@ -637,7 +701,12 @@ var getHeadlessSolanaMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     const broadcastSignature = await broadcastSolanaSigned(
@@ -645,7 +714,7 @@ var getHeadlessSolanaMethods = ({
       signedTransaction
     );
     return { signature: await bs58ToBytes(broadcastSignature) };
-  }),
+  },
   getSolanaBalance: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
     return transport.send(
@@ -757,11 +826,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
 }) => ({
@@ -771,18 +844,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,
@@ -792,17 +881,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,
@@ -812,11 +907,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,
@@ -856,7 +956,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);
@@ -905,9 +1004,11 @@ var getHeadlessGeneralMethods = ({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   assertPasskeyInParent,
+  flattenPresenceTokens,
   getHeadlessAuthenticationMethods,
   getHeadlessEthereumMethods,
   getHeadlessGeneralMethods,
   getHeadlessSolanaMethods,
+  getInternalPresenceTokens,
   getPresenceToken
 });