@calimero-network/mero-js 19.8.0 → 19.9.0

package/dist/index.cjs

@@ -78,6 +78,7 @@ __export(index_exports, {
   probeNodeHealth: () => probeNodeHealth,
   routingProofHeaders: () => routingProofHeaders,
   signAccountLink: () => signAccountLink,
+  signAccountLogin: () => signAccountLogin,
   signDeviceCert: () => signDeviceCert,
   signLoginStatement: () => signLoginStatement,
   signMemberJoinOp: () => signMemberJoinOp,
@@ -127,10 +128,13 @@ var TERMINAL_AUTH_ERRORS = /* @__PURE__ */ new Set(["token_reuse", "token_revoke
 function extractErrorMessage(bodyText) {
   if (!bodyText) return void 0;
   try {
-    const error = JSON.parse(bodyText)?.error;
+    const body = JSON.parse(bodyText);
+    const error = body?.error;
     if (typeof error === "string" && error.trim() !== "") return error;
     const nested = error?.message;
     if (typeof nested === "string" && nested.trim() !== "") return nested;
+    const detail = body?.detail;
+    if (typeof detail === "string" && detail.trim() !== "") return detail;
   } catch {
   }
   return void 0;
@@ -4752,6 +4756,9 @@ var ENGLISH_WORDLIST = [
 var ACCOUNT_LINK_DOMAIN = new TextEncoder().encode(
   "calimero.mdma.account-link.v1\0"
 );
+var ACCOUNT_LOGIN_DOMAIN = new TextEncoder().encode(
+  "calimero.mdma.account-login.v1\0"
+);
 var ENTROPY_BITS = 256;
 var CHECKSUM_BITS = ENTROPY_BITS / 32;
 var PHRASE_WORDS = (ENTROPY_BITS + CHECKSUM_BITS) / 11;
@@ -4783,6 +4790,18 @@ async function signAccountLink(input) {
   );
   return base64(signature);
 }
+async function signAccountLogin(input) {
+  if (!input.nonce) throw new Error("nonce is required to sign an account login");
+  const key = await importSigningKey(input.rootSecret);
+  const signature = new Uint8Array(
+    await crypto.subtle.sign(
+      "Ed25519",
+      key,
+      concat(ACCOUNT_LOGIN_DOMAIN, new TextEncoder().encode(input.nonce))
+    )
+  );
+  return base64(signature);
+}
 async function withPhrase(secret, phrase) {
   return { ...await accountRootFromSecret(secret), phrase };
 }
@@ -4913,6 +4932,70 @@ var CloudClient = class {
     const body = await this.request("POST", "/api/auth/google", { body: { id_token: idToken }, anonymous: true });
     return this.adoptSession(body);
   }
+  /**
+   * Sign in as a Calimero account, proving it with its root key.
+   *
+   * The password-free counterpart to {@link signInWithGoogle}: no Google, no
+   * password, no server-held secret — the cloud mints a challenge, the account
+   * root signs it, and the session that comes back is the same MDMA session
+   * token every other cloud route already accepts.
+   *
+   * Doing this **once** is what makes an account's later device proofs mean
+   * something. A routing read shows that the caller holds a device the root
+   * certified, but certificates are public, so it can never show that anyone
+   * held the root; the cloud records this claim and from then on knows the
+   * account behind those reads was claimed by its owner. The claim is recorded
+   * even when the session is refused.
+   *
+   * @param rootSecret the account root's signing secret, 64 hex. It never
+   *   leaves this process — only a signature over the cloud's nonce travels.
+   *
+   * A `403` means either the signature did not verify, or the account is not
+   * linked to a cloud login: ownership alone says who you are, and the link
+   * says what you are entitled to. Anyone can mint a root offline, so a session
+   * on the proof alone would authenticate perfectly and authorize nothing. The
+   * ownership claim is recorded either way, so linking later needs no re-proof.
+   */
+  async signInWithAccount(rootSecret) {
+    const root = await accountRootFromSecret(rootSecret);
+    const { nonce } = await this.getAccountLoginChallenge();
+    return this.submitAccountLogin({
+      rootPublicKey: root.publicKey,
+      nonce,
+      signature: await signAccountLogin({ rootSecret, nonce })
+    });
+  }
+  /**
+   * Mint a challenge for an account root to sign.
+   *
+   * Public, and deliberately so: the caller has no session — obtaining one is
+   * what this exchange does. The nonce is not a capability, it is the thing a
+   * capability gets demonstrated against, and demonstrating it needs the root.
+   *
+   * Split out of {@link signInWithAccount} for the case that call cannot serve:
+   * a root held by a hardware key, a desktop app or an air-gapped machine,
+   * which signs without the secret ever reaching this process.
+   */
+  async getAccountLoginChallenge() {
+    const body = await this.request(
+      "GET",
+      "/api/auth/account/challenge",
+      { anonymous: true }
+    );
+    return { nonce: body.nonce, expiresAtMs: body.expires_at_ms };
+  }
+  /** Post a proof assembled elsewhere. The other half of {@link getAccountLoginChallenge}. */
+  async submitAccountLogin(proof) {
+    const body = await this.request("POST", "/api/auth/account", {
+      body: {
+        root_public_key: proof.rootPublicKey,
+        nonce: proof.nonce,
+        signature: proof.signature
+      },
+      anonymous: true
+    });
+    return this.adoptSession(body);
+  }
   /**
    * Refresh the session token explicitly.
    *