@moon-x/core 0.2.0 → 0.4.0

package/dist/sdk/index.mjs

@@ -1,20 +1,16 @@
 import {
   PostMessageMethod,
   PostMessageType
-} from "../chunk-SOKLPX7V.mjs";
+} from "../chunk-VVL65GIB.mjs";
 import {
   arrayLikeToBytes,
   authState,
   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,12 +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,
@@ -48,27 +40,104 @@ var assertPasskeyInParent = async ({
     challenge,
     allowCredentials: []
   });
-  const result = {
+  if (validateCredentialInAllowList && !allowList.includes(credential.rawIdB64url)) {
+    throw new Error("unknown_passkey_for_this_account");
+  }
+  return {
     userHandleB64url: credential.userHandleB64url,
     credentialIdB64url: credential.rawIdB64url
   };
-  writeParentAssertCache(result);
-  return result;
+};
+
+// src/sdk/get-presence-token.ts
+var getPresenceToken = async ({
+  transport,
+  passkey,
+  publishableKey,
+  relyingPartyOrigin
+}) => {
+  const { token, optionsJSON } = await transport.send(
+    PostMessageType.AUTH,
+    PostMessageMethod.PASSKEY_PRESENCE_BEGIN,
+    { publishableKey, relyingPartyOrigin }
+  );
+  const response = await passkey.assertForServer({ optionsJSON });
+  const verify = await transport.send(
+    PostMessageType.AUTH,
+    PostMessageMethod.PASSKEY_PRESENCE_VERIFY,
+    {
+      publishableKey,
+      relyingPartyOrigin,
+      token,
+      response
+    }
+  );
+  return {
+    presenceToken: verify.presence_token,
+    expiresAt: verify.expires_at
+  };
+};
+
+// 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,
@@ -79,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,
@@ -101,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,
@@ -125,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,
@@ -146,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,
@@ -170,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
@@ -194,7 +293,12 @@ var getHeadlessEthereumMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     if (!signed.serializedSigned) {
@@ -207,7 +311,7 @@ var getHeadlessEthereumMethods = ({
       signed.serializedSigned
     );
     return { hash };
-  }),
+  },
   getEthereumBalance: async (params) => {
     if (!transport.isReady()) throw new Error("SDK not ready");
     return transport.send(
@@ -243,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,
@@ -265,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,
@@ -287,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,
@@ -309,7 +428,12 @@ var getHeadlessSolanaMethods = ({
         wallet: params.wallet,
         options: params.options,
         userHandleB64url,
-        credentialIdB64url
+        credentialIdB64url,
+        presenceTokens: flattenPresenceTokens({
+          tokens,
+          userHandleB64url,
+          credentialIdB64url
+        })
       }
     );
     const broadcastSignature = await broadcastSolanaSigned(
@@ -317,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(
@@ -340,13 +464,17 @@ var getHeadlessSolanaMethods = ({
 var getHeadlessAuthenticationMethods = ({
   transport,
   publishableKey,
-  emailConfig,
   setIsAuthenticated,
   setUser
 }) => ({
-  /** Send a one-time passcode to the user's email address. */
+  /**
+   * Send a one-time passcode to the user's email address. Returns the
+   * server's response — most importantly `expires_at` (unix seconds),
+   * which the UI uses to render a countdown that cannot drift from the
+   * authoritative server-side TTL.
+   */
   sendCode: async (params) => {
-    await transport.send(
+    const response = await transport.send(
       PostMessageType.AUTH,
       PostMessageMethod.LOGIN_CREATE,
       {
@@ -357,6 +485,7 @@ var getHeadlessAuthenticationMethods = ({
     );
     authState.clearEmail();
     authState.setEmail(params.email);
+    return response;
   },
   /**
    * Verify the OTP and complete the login. The iframe-app handles
@@ -372,8 +501,7 @@ var getHeadlessAuthenticationMethods = ({
       {
         email,
         code: params.code,
-        publishableKey,
-        expiresIn: emailConfig?.expiresIn
+        publishableKey
       }
     );
     authState.clearEmail();
@@ -425,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
 }) => ({
@@ -439,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,
@@ -460,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,
@@ -480,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,
@@ -524,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);
@@ -572,8 +730,11 @@ var getHeadlessGeneralMethods = ({
 });
 export {
   assertPasskeyInParent,
+  flattenPresenceTokens,
   getHeadlessAuthenticationMethods,
   getHeadlessEthereumMethods,
   getHeadlessGeneralMethods,
-  getHeadlessSolanaMethods
+  getHeadlessSolanaMethods,
+  getInternalPresenceTokens,
+  getPresenceToken
 };