@calimero-network/mero-js 19.24.0 → 19.25.0

package/dist/index.mjs

@@ -823,6 +823,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");
   }
@@ -1217,6 +1225,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.
@@ -1539,6 +1564,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`));
   }
@@ -6654,6 +6705,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];
@@ -6665,10 +6718,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";
   }
 };
@@ -6772,6 +6826,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",
@@ -6781,7 +6844,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) {
@@ -6907,6 +6970,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);
@@ -6915,6 +6982,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}`;
@@ -6925,7 +7006,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