@calimero-network/mero-js 24.6.0 → 24.7.0

package/dist/index.cjs

@@ -166,6 +166,7 @@ __export(index_exports, {
   fetchNodeReleaseVersion: () => fetchNodeReleaseVersion,
   fetchRegistryBundles: () => fetchRegistryBundles,
   forgetMethodKinds: () => forgetMethodKinds,
+  forgetRelaySealing: () => forgetRelaySealing,
   foundDelegatedNamespace: () => foundDelegatedNamespace,
   foundedNamespaceId: () => foundedNamespaceId,
   generateAccountRoot: () => generateAccountRoot,
@@ -226,6 +227,7 @@ __export(index_exports, {
   readRelayMap: () => readRelayMap,
   redeemInvitation: () => redeemInvitation,
   relayForContext: () => relayForContext,
+  relayTransportFetch: () => relayTransportFetch,
   rememberGroupNamespace: () => rememberGroupNamespace,
   rememberRelay: () => rememberRelay,
   reportDataOf: () => reportDataOf,
@@ -9118,7 +9120,7 @@ function missingNodeKey(surface) {
     `this relay-transport client cannot open ${surface}: it was given no relay node key. A relay is an ordinary node and does serve /sse and /ws \u2014 but the login statement must be signed against the node's device signing key, learned out of band (never read from the node, and never derived from its peerId). Pass it as \`observe: { nodeKey }\`. For a cloud-hosted relay the cloud does not publish it yet \u2014 see mdma #312.`
   );
 }
-function buildObserver(relay, observe) {
+function buildObserver(relay, observe, fetchImpl) {
   const nodeKey = observe?.nodeKey;
   if (!nodeKey) return null;
   return new RelayObserver({
@@ -9129,7 +9131,7 @@ function buildObserver(relay, observe) {
     signer: observe?.signer ? async () => observe.signer : () => relay.authorSigner(),
     clientName: observe?.clientName,
     ttlSeconds: observe?.ttlSeconds,
-    fetch: observe?.fetch,
+    fetch: observe?.fetch ?? fetchImpl,
     timeoutMs: observe?.timeoutMs
   });
 }
@@ -9150,12 +9152,16 @@ var MeroClient = class {
     this.proofAuthorizer = null;
     this.relayUrl = null;
     this.proofEvents = null;
+    /** The relay transport's `fetch`, if one was given. */
+    this.relayFetch = void 0;
     this.relayPresence = null;
     if (config.transport === "relay") {
       this.transport = "relay";
       this.nodeClient = null;
-      const relay = config.relay instanceof RelayClient ? config.relay : new RelayClient(config.relay);
-      this.relayObserver = buildObserver(relay, config.observe);
+      const fetchImpl = config.fetch;
+      this.relayFetch = fetchImpl;
+      const relay = config.relay instanceof RelayClient ? config.relay : new RelayClient({ ...config.relay, fetch: config.relay.fetch ?? fetchImpl });
+      this.relayObserver = buildObserver(relay, config.observe, fetchImpl);
       this.rpcTransport = new RelayTransport(relay, this.relayObserver);
       this.relayUrl = relay.relayUrl;
       if (config.proof) {
@@ -9165,13 +9171,14 @@ var MeroClient = class {
         const token = config.session;
         this.relayAdmin = createAdminApiClient({
           baseUrl: relay.relayUrl,
-          getAuthToken: typeof token === "string" ? async () => token : token
+          getAuthToken: typeof token === "string" ? async () => token : token,
+          fetch: fetchImpl
         });
       } else if (this.proofAuthorizer) {
         const authorizeRequest = this.proofAuthorizer;
         this.relayAdmin = createAdminApiClientFromHttpClient(
           createHttpClient({
-            fetch: (url, init) => globalThis.fetch(url, init),
+            fetch: (url, init) => fetchImpl ? fetchImpl(url, init) : globalThis.fetch(url, init),
             baseUrl: relay.relayUrl,
             authorizeRequest
           }),
@@ -9285,7 +9292,8 @@ var MeroClient = class {
     if (this.proofAuthorizer && this.relayUrl) {
       this.proofEvents ?? (this.proofEvents = new SseClient({
         baseUrl: this.relayUrl,
-        authorize: this.proofAuthorizer
+        authorize: this.proofAuthorizer,
+        fetch: this.relayFetch
       }));
       return this.proofEvents;
     }
@@ -9535,8 +9543,8 @@ function relayQuoteVerifier(relayUrl, fetchRelay) {
   };
   return Object.assign(verify, { includeCollateral: true });
 }
-async function attemptRelayNodeKey(relayUrl) {
-  const pinned = readPinnedRelayNodeKey(relayUrl);
+async function attemptRelayNodeKey(relayUrl, options = {}) {
+  const pinned = options.fresh ? null : readPinnedRelayNodeKey(relayUrl);
   if (pinned) return { kind: "learned", nodeKey: pinned };
   const marked = { failure: null };
   const fetchRelay = relayFetch(marked);
@@ -9600,6 +9608,54 @@ function jwtExpiryMs2(token) {
     return null;
   }
 }
+var sealedFetches = /* @__PURE__ */ new Map();
+function forgetRelaySealing() {
+  sealedFetches.clear();
+}
+async function isUnguardedRefusal(response) {
+  if (response.status !== 403) return false;
+  try {
+    const body = await response.clone().json();
+    return body.error?.code === "sealed_route_unguarded";
+  } catch {
+    return false;
+  }
+}
+function needsSession(request) {
+  return request.headers.has("authorization") || new URL(request.url).pathname.startsWith("/auth/");
+}
+function sealedRelayFetch(relayUrl) {
+  const plain = (input, init) => globalThis.fetch(input, init);
+  const sealed = createAttestedSealedFetch({
+    baseUrl: relayUrl,
+    verify: relayQuoteVerifier(relayUrl, plain),
+    fetch: plain
+  });
+  let unguarded = false;
+  return async (input, init) => {
+    const request = new Request(input, init);
+    if (unguarded && needsSession(request)) return plain(request);
+    const response = await sealed(request.clone());
+    if (!await isUnguardedRefusal(response)) return response;
+    if (!unguarded) {
+      unguarded = true;
+      console.warn(
+        `[mero-js] ${relayOrigin(relayUrl)} cannot guard logged-in calls sealed (no forward_auth); they go over its TLS until it does`
+      );
+    }
+    return plain(request);
+  };
+}
+function relayTransportFetch(relayUrl) {
+  if (isLoopback(relayUrl)) return void 0;
+  const origin2 = relayOrigin(relayUrl);
+  let found = sealedFetches.get(origin2);
+  if (!found) {
+    found = sealedRelayFetch(relayUrl);
+    sealedFetches.set(origin2, found);
+  }
+  return found;
+}
 function relaySession(s, nodeKey) {
   let token = null;
   let inflight = null;
@@ -9609,6 +9665,8 @@ function relaySession(s, nodeKey) {
     if (!inflight) {
       inflight = login({
         nodeUrl: s.relayUrl,
+        // Sealed: the token is the session, and the TLS ends outside the TD.
+        fetch: relayTransportFetch(s.relayUrl),
         node: nodeKey,
         deviceSecret: s.deviceSecret,
         accountProof: s.credential,
@@ -9704,6 +9762,9 @@ function buildDelegatedClient(s, _contextId) {
   const nodeKey = readPinnedRelayNodeKey(s.relayUrl);
   const client2 = createMeroClient({
     transport: "relay",
+    // Every request sealed to the relay's attested TD: intents, admin reads,
+    // queries, the login and events (see `relayTransportFetch`).
+    fetch: relayTransportFetch(s.relayUrl),
     relay: {
       relayUrl: s.relayUrl,
       authorAccount: s.account,
@@ -10793,7 +10854,7 @@ function client(s, relayUrl, nonces, fetch2) {
     authorProof: s.credential,
     deviceSecret: s.deviceSecret,
     nonces,
-    fetch: fetch2
+    fetch: fetch2 ?? relayTransportFetch(relayUrl)
   });
 }
 async function createDelegatedContext(s, req, deps = {}) {
@@ -10880,10 +10941,10 @@ async function foundingExecutor(s, relay, fetch2) {
   return { executorAccount: described.executorAccount, executorKey };
 }
 async function attestedNodeKey(relay) {
-  const key = await attemptRelayNodeKey(relay);
+  const key = await attemptRelayNodeKey(relay, { fresh: true });
   if (key.kind === "learned") return key.nodeKey;
   throw new Error(
-    key.kind === "unavailable" ? "the relay's signing key could not be learned: its attestation did not answer, try again" : "the relay's attestation was refused, so founding through it is not possible (only a key from its operator, pinned with pinRelayNodeKey, can stand in)"
+    key.kind === "unavailable" ? "the relay's signing key could not be learned: its attestation did not answer, try again" : "the relay's attestation was refused, so founding through it is not possible: it is not a signed locked-read-only release"
   );
 }
 var HA_ACCOUNT_NOT_LINKED_MESSAGE = "link this account to your cloud user in the wallet so invitees can find this namespace";