@secondlayer/sdk 6.9.1 → 6.10.0

package/dist/subgraphs/index.js

@@ -891,7 +891,7 @@ class Index extends BaseClient {
 }
 
 // src/streams/client.ts
-import { ed25519 } from "@secondlayer/shared";
+import { ed25519 as ed255192 } from "@secondlayer/shared";
 
 // src/streams/errors.ts
 class AuthError extends Error {
@@ -1078,6 +1078,7 @@ async function* streamStreamsEvents(opts) {
 
 // src/streams/dumps.ts
 import { createHash } from "node:crypto";
+import { verifyStreamsBulkManifestSignature } from "@secondlayer/shared/streams-bulk-manifest";
 function createStreamsDumps(opts) {
   const baseUrl = opts.baseUrl?.replace(/\/+$/, "");
   function requireBaseUrl() {
@@ -1095,7 +1096,17 @@ function createStreamsDumps(opts) {
     if (!res.ok) {
       throw new StreamsServerError(`Could not fetch dumps manifest (${res.status}).`, res.status);
     }
-    return await res.json();
+    const manifest = await res.json();
+    if (opts.verifyManifest) {
+      if (!opts.loadPublicKeyPem) {
+        throw new StreamsSignatureError("Manifest verification is on but no signing key source is configured.");
+      }
+      const publicKeyPem = await opts.loadPublicKeyPem();
+      if (!verifyStreamsBulkManifestSignature(manifest, publicKeyPem)) {
+        throw new StreamsSignatureError("Dumps manifest signature is missing or invalid.");
+      }
+    }
+    return manifest;
   }
   async function download(file) {
     const res = await opts.fetchImpl(fileUrl(file));
@@ -1112,6 +1123,135 @@ function createStreamsDumps(opts) {
   return { list, fileUrl, download };
 }
 
+// src/streams/subscribe.ts
+import { ed25519 } from "@secondlayer/shared";
+function subscribeStreamsEvents(opts) {
+  const { params } = opts;
+  const controller = new AbortController;
+  const external = params.signal;
+  if (external) {
+    if (external.aborted)
+      controller.abort();
+    else
+      external.addEventListener("abort", () => controller.abort(), {
+        once: true
+      });
+  }
+  let cursor = params.fromCursor ?? null;
+  const reconnectDelayMs = opts.reconnectDelayMs ?? 1000;
+  const run = async () => {
+    while (!controller.signal.aborted) {
+      try {
+        const url = `${opts.baseUrl}/v1/streams/events/stream${buildQuery({
+          from_cursor: cursor ?? undefined,
+          types: params.types,
+          not_types: params.notTypes,
+          contract_id: params.contractId,
+          sender: params.sender,
+          recipient: params.recipient,
+          asset_identifier: params.assetIdentifier
+        })}`;
+        const res = await opts.fetchImpl(url, {
+          headers: {
+            Authorization: `Bearer ${opts.apiKey}`,
+            Accept: "text/event-stream"
+          },
+          signal: controller.signal
+        });
+        if (!res.ok) {
+          throw new StreamsServerError(`Streams SSE returned ${res.status}.`, res.status);
+        }
+        if (!res.body) {
+          throw new StreamsServerError("Streams SSE response has no body.", 0);
+        }
+        for await (const frame of parseSseFrames(res.body, controller.signal)) {
+          if (frame.event === "ping" || !frame.data)
+            continue;
+          let parsed;
+          try {
+            parsed = JSON.parse(frame.data);
+          } catch {
+            continue;
+          }
+          if (!parsed.event)
+            continue;
+          if (opts.verify) {
+            const key = await opts.loadKey();
+            if (!parsed.sig || !ed25519.verifyEd25519(JSON.stringify(parsed.event), parsed.sig, key.publicKey)) {
+              throw new StreamsSignatureError("Streams SSE frame signature is missing or invalid.");
+            }
+          }
+          cursor = parsed.event.cursor ?? cursor;
+          await params.onEvent(parsed.event);
+        }
+      } catch (err) {
+        if (controller.signal.aborted)
+          return;
+        params.onError?.(err);
+        await sleep(reconnectDelayMs, controller.signal);
+      }
+    }
+  };
+  run();
+  return () => controller.abort();
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function* parseSseFrames(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (!signal.aborted) {
+      const { value, done } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep = buffer.indexOf(`
+
+`);
+      while (sep !== -1) {
+        yield parseFrame(buffer.slice(0, sep));
+        buffer = buffer.slice(sep + 2);
+        sep = buffer.indexOf(`
+
+`);
+      }
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {}
+  }
+}
+function parseFrame(raw) {
+  let event;
+  const data = [];
+  for (const line of raw.split(`
+`)) {
+    if (line.startsWith("data:")) {
+      data.push(line.slice(line.startsWith("data: ") ? 6 : 5));
+    } else if (line.startsWith("event:")) {
+      event = line.slice(line.startsWith("event: ") ? 7 : 6).trim();
+    }
+  }
+  return { event, data: data.length > 0 ? data.join(`
+`) : undefined };
+}
+
 // src/streams/client.ts
 function cursorTuple(cursor) {
   if (!cursor)
@@ -1171,10 +1311,6 @@ function createStreamsClient(options) {
   const baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_STREAMS_BASE_URL);
   const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
   const verify = options.verify ?? false;
-  const dumps = createStreamsDumps({
-    baseUrl: options.dumpsBaseUrl,
-    fetchImpl
-  });
   let keyPromise = null;
   function loadKey() {
     if (keyPromise)
@@ -1182,8 +1318,9 @@ function createStreamsClient(options) {
     keyPromise = (async () => {
       if (typeof verify === "object") {
         return {
-          keyId: ed25519.ed25519KeyId(verify.publicKey),
-          publicKey: ed25519.loadEd25519PublicKey(verify.publicKey)
+          keyId: ed255192.ed25519KeyId(verify.publicKey),
+          publicKeyPem: verify.publicKey,
+          publicKey: ed255192.loadEd25519PublicKey(verify.publicKey)
         };
       }
       const res = await fetchImpl(`${baseUrl}/public/streams/signing-key`);
@@ -1195,12 +1332,19 @@ function createStreamsClient(options) {
         throw new StreamsSignatureError("Signing key response missing key.");
       }
       return {
-        keyId: body.key_id ?? ed25519.ed25519KeyId(body.public_key_pem),
-        publicKey: ed25519.loadEd25519PublicKey(body.public_key_pem)
+        keyId: body.key_id ?? ed255192.ed25519KeyId(body.public_key_pem),
+        publicKeyPem: body.public_key_pem,
+        publicKey: ed255192.loadEd25519PublicKey(body.public_key_pem)
       };
     })();
     return keyPromise;
   }
+  const dumps = createStreamsDumps({
+    baseUrl: options.dumpsBaseUrl,
+    fetchImpl,
+    verifyManifest: options.verifyDumpsManifest ?? false,
+    loadPublicKeyPem: async () => (await loadKey()).publicKeyPem
+  });
   async function request(path) {
     const response = await fetchImpl(`${baseUrl}${path}`, {
       headers: { Authorization: `Bearer ${options.apiKey}` }
@@ -1225,7 +1369,7 @@ function createStreamsClient(options) {
           throw new StreamsSignatureError(`Response signed with key '${responseKeyId}' not served by the signing-key endpoint.`);
         }
       }
-      if (!ed25519.verifyEd25519(text, signature, key.publicKey)) {
+      if (!ed255192.verifyEd25519(text, signature, key.publicKey)) {
         throw new StreamsSignatureError;
       }
     }
@@ -1310,6 +1454,16 @@ function createStreamsClient(options) {
           fetchEvents
         });
       },
+      subscribe(params) {
+        return subscribeStreamsEvents({
+          baseUrl,
+          apiKey: options.apiKey,
+          fetchImpl,
+          verify: Boolean(verify),
+          loadKey,
+          params
+        });
+      },
       async replay(params) {
         const fromCursor = params.from === "genesis" ? null : params.from ?? null;
         const fromBlock = fromCursor ? cursorTuple(fromCursor)[0] : 0;
@@ -1484,5 +1638,5 @@ export {
   Subgraphs
 };
 
-//# debugId=31D759DA70279D1564756E2164756E21
+//# debugId=B6D6E26DCF0C5E6064756E2164756E21
 //# sourceMappingURL=index.js.map