@calimero-network/mero-js 19.25.0 → 19.27.0

package/dist/index.mjs

@@ -1848,6 +1848,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)
@@ -6463,92 +6467,6 @@ function createLocalStorageNonceSource(key, storage) {
   };
 }
 
-// src/cloud/connect.ts
-async function connectCloud(options) {
-  if (!options.sessionToken && !options.googleIdToken) {
-    throw new Error("connectCloud needs either a sessionToken or a googleIdToken");
-  }
-  const cloud = new CloudClient({
-    cloudBaseUrl: options.cloudBaseUrl,
-    sessionToken: options.sessionToken,
-    onSession: options.onSession,
-    fetch: options.fetch,
-    timeoutMs: options.timeoutMs
-  });
-  if (!options.sessionToken && options.googleIdToken) {
-    await cloud.signInWithGoogle(options.googleIdToken);
-  }
-  const namespaces = await cloud.getMyNamespaces();
-  const namespace = pickNamespace(namespaces, options.namespaceId);
-  const relays = await cloud.getNamespaceRelays(namespace.namespaceId);
-  const relayInfo = relays.find((r) => r.authorshipReady && r.relayUrl !== null && r.executorAccount !== null) ?? null;
-  if (!relayInfo) {
-    throw new Error(explainNoRelay(namespace, relays));
-  }
-  const relay = new RelayClient({
-    // Checked by `findExecutingRelay`, which is the only thing that returns a
-    // relay — narrowed here rather than re-validated, so the invariant lives in
-    // one place.
-    relayUrl: relayInfo.relayUrl,
-    executorAccount: relayInfo.executorAccount,
-    authorAccount: options.authorAccount,
-    authorProof: options.authorProof,
-    deviceSecret: options.deviceSecret,
-    nonces: options.nonces ?? await defaultNonceSource(options.deviceSecret),
-    ttlSeconds: options.ttlSeconds,
-    fetch: options.fetch,
-    timeoutMs: options.timeoutMs
-  });
-  return {
-    cloud,
-    relay,
-    namespaceId: namespace.namespaceId,
-    namespace,
-    relayInfo,
-    execute: (contextId, method, argsJson) => relay.execute(contextId, method, argsJson)
-  };
-}
-function pickNamespace(namespaces, requested) {
-  if (requested) {
-    const found = namespaces.find((n) => n.namespaceId === requested);
-    if (!found) {
-      throw new Error(
-        `this account owns no namespace ${requested}; it owns: ${namespaces.map((n) => n.namespaceId).join(", ") || "(none)"}`
-      );
-    }
-    return found;
-  }
-  if (namespaces.length === 0) {
-    throw new Error(
-      "this account owns no namespaces in the cloud: claim one first, then enable HA on it so a relay is assigned"
-    );
-  }
-  if (namespaces.length > 1) {
-    throw new Error(
-      `this account owns ${namespaces.length} namespaces \u2014 pass namespaceId to say which: ${namespaces.map((n) => n.namespaceId).join(", ")}`
-    );
-  }
-  return namespaces[0];
-}
-function explainNoRelay(namespace, relays) {
-  if (relays.length === 0) {
-    return namespace.haStatus === "enabled" ? `namespace ${namespace.namespaceId} has HA enabled but no relay has been assigned to it yet \u2014 retry shortly` : `namespace ${namespace.namespaceId} has no relays: enable HA on it in the cloud to have an attested node assigned`;
-  }
-  const waitingOnGrant = relays.filter((r) => !r.authorshipReady);
-  if (waitingOnGrant.length === relays.length) {
-    return `every relay on namespace ${namespace.namespaceId} is waiting for the authorship grant: an admin of the namespace must grant CAN_AUTHOR_ON_BEHALF to ${waitingOnGrant.map((r) => r.executorAccount ?? r.peerId).join(", ") || "the relay account"} \u2014 with AdminClient.grantAuthorship(namespaceId, account) for these relays, and AdminClient.openToDelegatedExecution(namespaceId) so relays assigned later need no further op`;
-  }
-  return `namespace ${namespace.namespaceId} has ${relays.length} relay(s), but none reported both a URL and an executor account yet \u2014 retry shortly`;
-}
-async function defaultNonceSource(deviceSecret) {
-  const key = `mero-js:warrant-nonce:${hex(await derivePublicKey(deviceSecret))}`;
-  try {
-    return createLocalStorageNonceSource(key);
-  } catch {
-    return createMemoryNonceSource(1);
-  }
-}
-
 // src/sealed/noise.ts
 var PROTOCOL_NAME = "Noise_NK_25519_AESGCM_SHA256";
 var DH_LEN = 32;
@@ -6646,9 +6564,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 };
   }
@@ -6741,7 +6666,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");
@@ -6749,11 +6675,44 @@ 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;
 }
+function createAttestedSealedFetch(options) {
+  const baseFetch = options.fetch ?? ((input, init) => fetch(input, init));
+  const attestUrl = `${options.baseUrl.replace(/\/+$/, "")}/admin-api/tee/attest`;
+  const admin = {
+    async teeAttest(request) {
+      const response = await baseFetch(attestUrl, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(request)
+      });
+      if (!response.ok) {
+        throw new Error(`The node refused to attest: HTTP ${response.status}`);
+      }
+      const body = await response.json();
+      if (!body.data) throw new Error("The attestation response is malformed");
+      return body.data;
+    }
+  };
+  return createSealedFetch({
+    baseUrl: options.baseUrl,
+    transportPublicKey: () => fetchAttestedTransportKey(admin, options.verify, {
+      applicationId: options.applicationId,
+      applicationHash: options.applicationHash
+    }),
+    fetch: baseFetch
+  });
+}
 function createSealedFetch(options) {
   const base = new URL(options.baseUrl);
   const basePath = base.pathname.replace(/\/+$/, "");
@@ -6761,6 +6720,7 @@ function createSealedFetch(options) {
   const baseFetch = options.fetch ?? ((input, init) => fetch(input, init));
   const attest = typeof options.transportPublicKey === "function" ? options.transportPublicKey : void 0;
   let transportKey = attest ? Promise.resolve().then(attest) : Promise.resolve(options.transportPublicKey);
+  transportKey.catch(() => void 0);
   let session;
   const openSession = async () => {
     try {
@@ -7011,6 +6971,175 @@ async function envelopeRefusal(response) {
   return new SealedTransportError(response.status, code, message, retryAfterMs);
 }
 
+// src/cloud/connect.ts
+async function connectCloud(options) {
+  if (!options.sessionToken && !options.googleIdToken) {
+    throw new Error("connectCloud needs either a sessionToken or a googleIdToken");
+  }
+  const cloud = new CloudClient({
+    cloudBaseUrl: options.cloudBaseUrl,
+    sessionToken: options.sessionToken,
+    onSession: options.onSession,
+    fetch: options.fetch,
+    timeoutMs: options.timeoutMs
+  });
+  if (!options.sessionToken && options.googleIdToken) {
+    await cloud.signInWithGoogle(options.googleIdToken);
+  }
+  const namespaces = await cloud.getMyNamespaces();
+  const namespace = pickNamespace(namespaces, options.namespaceId);
+  const relays = await cloud.getNamespaceRelays(namespace.namespaceId);
+  const relayInfo = relays.find((r) => r.authorshipReady && r.relayUrl !== null && r.executorAccount !== null) ?? null;
+  if (!relayInfo) {
+    throw new Error(explainNoRelay(namespace, relays));
+  }
+  const relay = new RelayClient({
+    // Checked by `findExecutingRelay`, which is the only thing that returns a
+    // relay — narrowed here rather than re-validated, so the invariant lives in
+    // one place.
+    relayUrl: relayInfo.relayUrl,
+    executorAccount: relayInfo.executorAccount,
+    authorAccount: options.authorAccount,
+    authorProof: options.authorProof,
+    deviceSecret: options.deviceSecret,
+    nonces: options.nonces ?? await defaultNonceSource(options.deviceSecret),
+    ttlSeconds: options.ttlSeconds,
+    // Only the relay is sealed: a sealed fetch is bound to one node and refuses
+    // any other URL, and the cloud calls above carry no intent.
+    fetch: options.seal ? createAttestedSealedFetch({
+      baseUrl: relayInfo.relayUrl,
+      verify: options.seal,
+      fetch: options.fetch
+    }) : options.fetch,
+    timeoutMs: options.timeoutMs
+  });
+  return {
+    cloud,
+    relay,
+    namespaceId: namespace.namespaceId,
+    namespace,
+    relayInfo,
+    execute: (contextId, method, argsJson) => relay.execute(contextId, method, argsJson)
+  };
+}
+function pickNamespace(namespaces, requested) {
+  if (requested) {
+    const found = namespaces.find((n) => n.namespaceId === requested);
+    if (!found) {
+      throw new Error(
+        `this account owns no namespace ${requested}; it owns: ${namespaces.map((n) => n.namespaceId).join(", ") || "(none)"}`
+      );
+    }
+    return found;
+  }
+  if (namespaces.length === 0) {
+    throw new Error(
+      "this account owns no namespaces in the cloud: claim one first, then enable HA on it so a relay is assigned"
+    );
+  }
+  if (namespaces.length > 1) {
+    throw new Error(
+      `this account owns ${namespaces.length} namespaces \u2014 pass namespaceId to say which: ${namespaces.map((n) => n.namespaceId).join(", ")}`
+    );
+  }
+  return namespaces[0];
+}
+function explainNoRelay(namespace, relays) {
+  if (relays.length === 0) {
+    return namespace.haStatus === "enabled" ? `namespace ${namespace.namespaceId} has HA enabled but no relay has been assigned to it yet \u2014 retry shortly` : `namespace ${namespace.namespaceId} has no relays: enable HA on it in the cloud to have an attested node assigned`;
+  }
+  const waitingOnGrant = relays.filter((r) => !r.authorshipReady);
+  if (waitingOnGrant.length === relays.length) {
+    return `every relay on namespace ${namespace.namespaceId} is waiting for the authorship grant: an admin of the namespace must grant CAN_AUTHOR_ON_BEHALF to ${waitingOnGrant.map((r) => r.executorAccount ?? r.peerId).join(", ") || "the relay account"} \u2014 with AdminClient.grantAuthorship(namespaceId, account) for these relays, and AdminClient.openToDelegatedExecution(namespaceId) so relays assigned later need no further op`;
+  }
+  return `namespace ${namespace.namespaceId} has ${relays.length} relay(s), but none reported both a URL and an executor account yet \u2014 retry shortly`;
+}
+async function defaultNonceSource(deviceSecret) {
+  const key = `mero-js:warrant-nonce:${hex(await derivePublicKey(deviceSecret))}`;
+  try {
+    return createLocalStorageNonceSource(key);
+  } catch {
+    return createMemoryNonceSource(1);
+  }
+}
+
+// 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");
@@ -7373,6 +7502,7 @@ export {
   connectCloud,
   createAdminApiClient,
   createAdminApiClientFromHttpClient,
+  createAttestedSealedFetch,
   createAuthApiClient,
   createAuthApiClientFromHttpClient,
   createBrowserAdminApiClient,
@@ -7386,6 +7516,7 @@ export {
   createNodeAuthApiClient,
   createNodeHttpClient,
   createProofSigner,
+  createQuoteVerifier,
   createRetryableMethod,
   createSealedFetch,
   createTimeoutSignal,