@calimero-network/mero-js 19.24.1 → 19.26.0

package/dist/index.cjs

@@ -67,6 +67,7 @@ __export(index_exports, {
   createNodeAuthApiClient: () => createNodeAuthApiClient,
   createNodeHttpClient: () => createNodeHttpClient,
   createProofSigner: () => createProofSigner,
+  createQuoteVerifier: () => createQuoteVerifier,
   createRetryableMethod: () => createRetryableMethod,
   createSealedFetch: () => createSealedFetch,
   createTimeoutSignal: () => createTimeoutSignal,
@@ -929,6 +930,14 @@ var AdminApiClient = class {
   async healthCheck() {
     return unwrap(await this.httpClient.get("/admin-api/health"));
   }
+  /**
+   * Whether the node has finished starting and its store answers. Public, like
+   * {@link healthCheck}; unlike it, a node that is up but not ready answers
+   * `503`, which this surfaces as an `HTTPError` whose body names the stage.
+   */
+  async readinessCheck() {
+    return unwrap(await this.httpClient.get("/admin-api/ready"));
+  }
   async isAuthed() {
     return this.httpClient.get("/admin-api/is-authed");
   }
@@ -1323,6 +1332,23 @@ var AdminApiClient = class {
       )
     );
   }
+  /**
+   * Read a context as the session's ACCOUNT, without minting a warrant.
+   *
+   * Needs an account-authenticated session — one from {@link login}, not the
+   * admin password login — and refuses otherwise with a `401`. The account must
+   * be a member of the group owning the context (`403` if not), and the method
+   * must be declared read-only in the app's ABI (`409` if not; a write needs
+   * {@link performIntent}).
+   */
+  async queryContext(contextId, request) {
+    return unwrap(
+      await this.httpClient.post(
+        `/admin-api/contexts/${contextId}/query`,
+        request
+      )
+    );
+  }
   /**
    * Ask what this node can do for a member in `contextId`, before they sign
    * anything.
@@ -1645,6 +1671,32 @@ var AdminApiClient = class {
     }
     return response;
   }
+  /**
+   * Member accounts in the group and the devices bound to each. An admin node
+   * sees every account; a plain member only its own. `403` if this node is not a
+   * member of the group.
+   */
+  async listMemberDevices(groupId, options = {}) {
+    const params = new URLSearchParams();
+    if (options.offset !== void 0) params.set("offset", String(options.offset));
+    if (options.limit !== void 0) params.set("limit", String(options.limit));
+    const query = params.toString();
+    const path = `/admin-api/groups/${groupId}/member-devices${query ? `?${query}` : ""}`;
+    return this.httpClient.get(path);
+  }
+  /**
+   * Seal a small payload to a member account's root key. This node must be a
+   * member of the group, and `account` must be an account the group knows, so
+   * the route reaches no further than the caller already does.
+   */
+  async sealToAccount(groupId, account, request) {
+    return unwrap(
+      await this.httpClient.post(
+        `/admin-api/groups/${groupId}/accounts/${account}/seal`,
+        request
+      )
+    );
+  }
   async listGroupContexts(groupId) {
     return unwrap(await this.httpClient.get(`/admin-api/groups/${groupId}/contexts`));
   }
@@ -1903,6 +1955,10 @@ var AdminApiClient = class {
   async teeAttest(request) {
     return unwrap(await this.httpClient.post("/admin-api/tee/attest", request));
   }
+  /**
+   * @deprecated Nodes no longer serve `/admin-api/tee/verify-quote` (removed in
+   * core#3262), so this fails. Verify quotes with `createQuoteVerifier`.
+   */
   async teeVerifyQuote(request) {
     return unwrap(
       await this.httpClient.post("/admin-api/tee/verify-quote", request)
@@ -6701,9 +6757,16 @@ async function initiate(remoteStatic, prologue, fixedEphemeral) {
 }
 async function x25519KeyPair(secret) {
   if (!secret) {
-    const pair = await crypto.subtle.generateKey({ name: "X25519" }, true, [
-      "deriveBits"
-    ]);
+    let pair;
+    try {
+      pair = await crypto.subtle.generateKey({ name: "X25519" }, true, [
+        "deriveBits"
+      ]);
+    } catch (error) {
+      throw new Error(
+        `Sealed transport needs WebCrypto with X25519, which this runtime lacks (${error?.name ?? "no crypto.subtle"}). Current browsers and Node have it; in React Native, install react-native-quick-crypto as the global crypto.`
+      );
+    }
     const publicKey = new Uint8Array(await crypto.subtle.exportKey("raw", pair.publicKey));
     return { privateKey: pair.privateKey, publicKey };
   }
@@ -6796,7 +6859,8 @@ async function fetchAttestedTransportKey(admin, verify, options = {}) {
   const attested = await admin.teeAttest({
     nonce: nonce2,
     applicationId: options.applicationId,
-    bindTransportKey: true
+    bindTransportKey: true,
+    ...verify.includeCollateral ? { includeCollateral: true } : {}
   });
   if (!attested.transportPublicKey) {
     throw new Error("The node did not report a transport key; it predates sealed transport");
@@ -6804,7 +6868,13 @@ async function fetchAttestedTransportKey(admin, verify, options = {}) {
   const transportKey = fromHex(attested.transportPublicKey, "transportPublicKey", 32);
   const inner = options.applicationHash ? fromHex(options.applicationHash, "applicationHash", 32) : new Uint8Array(32);
   const reportDataSuffix = hex(await transportKeyBinding(inner, transportKey));
-  if (!await verify({ quoteB64: attested.quoteB64, nonce: nonce2, reportDataSuffix })) {
+  const verified = await verify({
+    quoteB64: attested.quoteB64,
+    nonce: nonce2,
+    reportDataSuffix,
+    collateral: attested.collateral
+  });
+  if (!verified) {
     throw new Error("The attestation did not verify, so its transport key is not trusted");
   }
   return transportKey;
@@ -7066,6 +7136,83 @@ async function envelopeRefusal(response) {
   return new SealedTransportError(response.status, code, message, retryAfterMs);
 }
 
+// src/sealed/verify.ts
+var MEASUREMENT_HEX = /^[0-9a-f]{96}$/;
+function createQuoteVerifier(options) {
+  const allowedMrtd = measurements(options.allowedMrtd, "allowedMrtd");
+  if (allowedMrtd.length === 0) {
+    throw new Error("allowedMrtd is empty, so no quote would ever be accepted");
+  }
+  const allowedRtmr = [
+    measurements(options.allowedRtmr0 ?? [], "allowedRtmr0"),
+    measurements(options.allowedRtmr1 ?? [], "allowedRtmr1"),
+    measurements(options.allowedRtmr2 ?? [], "allowedRtmr2"),
+    measurements(options.allowedRtmr3 ?? [], "allowedRtmr3")
+  ];
+  const allowedStatuses = options.allowedTcbStatuses ?? ["UpToDate"];
+  const now = options.now ?? Date.now;
+  const verifier = async ({
+    quoteB64,
+    nonce: nonce2,
+    reportDataSuffix,
+    collateral
+  }) => {
+    const quote = fromBase64(quoteB64);
+    const against = collateral ?? await options.fetchCollateral?.(quote);
+    if (!against) {
+      throw new Error(
+        "The node sent no collateral for its quote, and no fetchCollateral was given to get it"
+      );
+    }
+    let verified;
+    try {
+      verified = options.dcapVerify(quote, against, Math.floor(now() / 1e3));
+    } catch (error) {
+      throw new Error(`The quote did not verify: ${error?.message ?? String(error)}`);
+    }
+    if (verified.status === "Revoked" || !allowedStatuses.includes(verified.status)) {
+      throw new Error(`The platform's TCB status is ${verified.status}, which is not accepted`);
+    }
+    const td = tdReport(verified.report);
+    if (!allowedMrtd.includes(hex(td.mrTd))) {
+      throw new Error(`MRTD ${hex(td.mrTd)} is not an image this verifier trusts`);
+    }
+    const registers = [td.rtMr0, td.rtMr1, td.rtMr2, td.rtMr3];
+    registers.forEach((register, index) => {
+      const allowed = allowedRtmr[index];
+      if (allowed.length > 0 && !allowed.includes(hex(register))) {
+        throw new Error(`RTMR${index} ${hex(register)} is not one this verifier trusts`);
+      }
+    });
+    if (hex(td.reportData) !== `${nonce2}${reportDataSuffix}`.toLowerCase()) {
+      throw new Error("The quote does not commit to this nonce and binding");
+    }
+    return true;
+  };
+  return Object.assign(verifier, { includeCollateral: true });
+}
+function measurements(values, label) {
+  return values.map((value) => {
+    const normalized = value.trim().toLowerCase();
+    if (!MEASUREMENT_HEX.test(normalized)) {
+      throw new Error(`${label} holds ${JSON.stringify(value)}, which is not a 48-byte hex measurement`);
+    }
+    return normalized;
+  });
+}
+function tdReport(report) {
+  const data = report.data;
+  if (report.type === "td10" && data) return data;
+  if (report.type === "td15" && data?.base) return data.base;
+  throw new Error(`The quote is a ${report.type} quote, not a TDX one`);
+}
+function fromBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
 // src/namespace-op/namespace-op.ts
 var SIGNED_NAMESPACE_OP_SCHEMA_VERSION = 8;
 var NAMESPACE_SIGN_DOMAIN = new TextEncoder().encode("calimero.namespace.v1");