@calimero-network/mero-js 19.23.0 → 19.24.1

package/dist/index.mjs

@@ -1677,6 +1677,15 @@ var AdminApiClient = class {
   async setTeeAuthoringPolicy(groupId, request) {
     await this.httpClient.put(`/admin-api/groups/${groupId}/settings/tee-authoring-policy`, request);
   }
+  /**
+   * Turns TEE authorship off in the namespace: every TEE loses its authority,
+   * and admitted TEEs stay members. The node applies the same op as
+   * `setTeeAuthoringPolicy(groupId, { allowedMrtd: [] })`. `groupId` must be a
+   * namespace root.
+   */
+  async disableTeeAuthoringPolicy(groupId) {
+    await this.httpClient.delete(`/admin-api/groups/${groupId}/settings/tee-authoring-policy`);
+  }
   // ---- Group / member / context metadata ----
   async setGroupMetadata(groupId, request) {
     await this.httpClient.put(`/admin-api/groups/${groupId}/metadata`, request);
@@ -6645,6 +6654,8 @@ var HEADER_LEN = 1 + SESSION_ID_LEN + 8;
 var FRAME_HEAD = 0;
 var FRAME_DATA = 1;
 var FRAME_END = 2;
+var MAX_FRAME_LEN = 1 + 64 * 1024 + 16;
+var MAX_HANDSHAKE_REPLY = 1024;
 var RENEW_BEFORE_MS = 6e4;
 var TRANSPORT_BINDING_DOMAIN = "calimero.tee-attest.transport-key.v1";
 var NULL_BODY_STATUSES = [101, 204, 205, 304];
@@ -6656,10 +6667,11 @@ var StaleTransportKeyError = class extends Error {
   }
 };
 var SealedTransportError = class extends Error {
-  constructor(status, code, message) {
+  constructor(status, code, message, retryAfterMs) {
     super(message);
     this.status = status;
     this.code = code;
+    this.retryAfterMs = retryAfterMs;
     this.name = "SealedTransportError";
   }
 };
@@ -6763,6 +6775,15 @@ async function checkedKey(key) {
   return bytes;
 }
 async function handshake(baseFetch, nodeUrl, transportKey) {
+  try {
+    return await handshakeOnce(baseFetch, nodeUrl, transportKey);
+  } catch (error) {
+    if (!(error instanceof SealedTransportError) || error.code !== "busy") throw error;
+    await new Promise((resolve) => setTimeout(resolve, error.retryAfterMs ?? 1e3));
+    return handshakeOnce(baseFetch, nodeUrl, transportKey);
+  }
+}
+async function handshakeOnce(baseFetch, nodeUrl, transportKey) {
   const noise = await initiate(transportKey, PROLOGUE);
   const response = await baseFetch(`${nodeUrl}${HANDSHAKE_PATH}`, {
     method: "POST",
@@ -6772,7 +6793,7 @@ async function handshake(baseFetch, nodeUrl, transportKey) {
   if (response.headers.get("content-type") !== SEALED_CONTENT_TYPE) {
     throw await envelopeRefusal(response);
   }
-  const reply = new Uint8Array(await response.arrayBuffer());
+  const reply = await readAtMost(response, MAX_HANDSHAKE_REPLY);
   return sessionFrom(noise, reply);
 }
 async function sessionFrom(noise, reply) {
@@ -6898,6 +6919,10 @@ function frameReader(reader) {
     async next() {
       if (!await fill(4)) return null;
       const length = new DataView(buffer.buffer, buffer.byteOffset).getUint32(0, false);
+      if (length > MAX_FRAME_LEN) {
+        await reader.cancel();
+        throw new Error("The sealed response is malformed: a frame is larger than the node sends");
+      }
       if (!await fill(4 + length)) return null;
       const frame = buffer.slice(4, 4 + length);
       buffer = buffer.slice(4 + length);
@@ -6906,6 +6931,20 @@ function frameReader(reader) {
     cancel: () => reader.cancel()
   };
 }
+async function readAtMost(response, limit) {
+  if (!response.body) return new Uint8Array();
+  const reader = response.body.getReader();
+  let bytes = new Uint8Array();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) return bytes;
+    bytes = concat(bytes, value);
+    if (bytes.length > limit) {
+      await reader.cancel();
+      throw new Error("The handshake reply is malformed: it is too long");
+    }
+  }
+}
 async function envelopeRefusal(response) {
   let code;
   let message = `Sealed request refused: HTTP ${response.status}`;
@@ -6916,7 +6955,9 @@ async function envelopeRefusal(response) {
   } catch {
   }
   if (code === "stale_transport_key") return new StaleTransportKeyError();
-  return new SealedTransportError(response.status, code, message);
+  const retryAfter = Number(response.headers.get("retry-after"));
+  const retryAfterMs = Number.isFinite(retryAfter) && retryAfter > 0 ? Math.min(retryAfter, 5) * 1e3 : void 0;
+  return new SealedTransportError(response.status, code, message, retryAfterMs);
 }
 
 // src/namespace-op/namespace-op.ts