@secondlayer/sdk 5.8.0 → 6.0.0

package/dist/index.js

@@ -501,6 +501,9 @@ class Index extends BaseClient {
   }
 }
 
+// src/streams/client.ts
+import { ed25519 } from "@secondlayer/shared";
+
 // src/streams/consumer.ts
 async function defaultSleep(ms, signal) {
   if (signal?.aborted)
@@ -529,7 +532,11 @@ async function consumeStreamsEvents(opts) {
       cursor,
       limit: opts.batchSize,
       types: opts.types,
-      contractId: opts.contractId
+      notTypes: opts.notTypes,
+      contractId: opts.contractId,
+      sender: opts.sender,
+      recipient: opts.recipient,
+      assetIdentifier: opts.assetIdentifier
     });
     pages++;
     const returnedCursor = await opts.onBatch(envelope.events, envelope);
@@ -564,7 +571,11 @@ async function* streamStreamsEvents(opts) {
       cursor,
       limit: opts.batchSize,
       types: opts.types,
-      contractId: opts.contractId
+      notTypes: opts.notTypes,
+      contractId: opts.contractId,
+      sender: opts.sender,
+      recipient: opts.recipient,
+      assetIdentifier: opts.assetIdentifier
     });
     pages++;
     for (const event of envelope.events) {
@@ -589,6 +600,9 @@ async function* streamStreamsEvents(opts) {
   }
 }
 
+// src/streams/dumps.ts
+import { createHash } from "node:crypto";
+
 // src/streams/errors.ts
 class AuthError extends Error {
   status = 401;
@@ -630,7 +644,60 @@ class StreamsServerError extends Error {
   }
 }
 
+class StreamsSignatureError extends Error {
+  constructor(message = "Streams response signature verification failed.") {
+    super(message);
+    this.name = "StreamsSignatureError";
+  }
+}
+
+// src/streams/dumps.ts
+function createStreamsDumps(opts) {
+  const baseUrl = opts.baseUrl?.replace(/\/+$/, "");
+  function requireBaseUrl() {
+    if (!baseUrl) {
+      throw new StreamsServerError("Streams dumps require `dumpsBaseUrl` on createStreamsClient.", 0);
+    }
+    return baseUrl;
+  }
+  function fileUrl(file) {
+    return `${requireBaseUrl()}/${file.path.replace(/^\/+/, "")}`;
+  }
+  async function list() {
+    const url = `${requireBaseUrl()}/manifest/latest.json`;
+    const res = await opts.fetchImpl(url);
+    if (!res.ok) {
+      throw new StreamsServerError(`Could not fetch dumps manifest (${res.status}).`, res.status);
+    }
+    return await res.json();
+  }
+  async function download(file) {
+    const res = await opts.fetchImpl(fileUrl(file));
+    if (!res.ok) {
+      throw new StreamsServerError(`Could not download dump ${file.path} (${res.status}).`, res.status);
+    }
+    const bytes = new Uint8Array(await res.arrayBuffer());
+    const digest = createHash("sha256").update(bytes).digest("hex");
+    if (digest !== file.sha256) {
+      throw new StreamsSignatureError(`Dump ${file.path} sha256 mismatch (expected ${file.sha256}, got ${digest}).`);
+    }
+    return bytes;
+  }
+  return { list, fileUrl, download };
+}
+
 // src/streams/client.ts
+function cursorTuple(cursor) {
+  if (!cursor)
+    return [-1, -1];
+  const [block, index] = cursor.split(":");
+  return [Number(block), Number(index)];
+}
+function maxCursor(a, b) {
+  const [ah, ai] = cursorTuple(a);
+  const [bh, bi] = cursorTuple(b);
+  return ah > bh || ah === bh && ai >= bi ? a : b;
+}
 var DEFAULT_STREAMS_BASE_URL = "https://api.secondlayer.tools";
 function normalizeBaseUrl(baseUrl) {
   return baseUrl.replace(/\/+$/, "");
@@ -640,6 +707,13 @@ function appendSearchParam2(params, name, value) {
     return;
   params.set(name, String(value));
 }
+function appendListParam(params, name, value) {
+  if (value === undefined || value === null)
+    return;
+  const joined = Array.isArray(value) ? value.join(",") : value;
+  if (joined.length > 0)
+    params.set(name, joined);
+}
 async function responseBody(response) {
   const text = await response.text();
   if (text.length === 0)
@@ -678,21 +752,87 @@ async function mapStreamsError(response) {
 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)
+      return keyPromise;
+    keyPromise = (async () => {
+      if (typeof verify === "object") {
+        return {
+          keyId: ed25519.ed25519KeyId(verify.publicKey),
+          publicKey: ed25519.loadEd25519PublicKey(verify.publicKey)
+        };
+      }
+      const res = await fetchImpl(`${baseUrl}/public/streams/signing-key`);
+      if (!res.ok) {
+        throw new StreamsSignatureError(`Could not fetch signing key (${res.status}).`);
+      }
+      const body = await res.json();
+      if (!body.public_key_pem) {
+        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)
+      };
+    })();
+    return keyPromise;
+  }
   async function request(path) {
     const response = await fetchImpl(`${baseUrl}${path}`, {
       headers: { Authorization: `Bearer ${options.apiKey}` }
     });
     if (!response.ok)
       await mapStreamsError(response);
-    return await response.json();
+    const text = await response.text();
+    if (verify) {
+      const signature = response.headers.get("X-Signature");
+      if (!signature) {
+        throw new StreamsSignatureError("Response is missing X-Signature.");
+      }
+      const responseKeyId = response.headers.get("X-Signature-KeyId");
+      let key = await loadKey();
+      if (responseKeyId && responseKeyId !== key.keyId) {
+        if (typeof verify === "object") {
+          throw new StreamsSignatureError(`Response signed with key '${responseKeyId}', expected pinned key '${key.keyId}'.`);
+        }
+        keyPromise = null;
+        key = await loadKey();
+        if (responseKeyId !== key.keyId) {
+          throw new StreamsSignatureError(`Response signed with key '${responseKeyId}' not served by the signing-key endpoint.`);
+        }
+      }
+      if (!ed25519.verifyEd25519(text, signature, key.publicKey)) {
+        throw new StreamsSignatureError;
+      }
+    }
+    return JSON.parse(text);
   }
   const fetchEvents = async ({
     cursor,
     limit,
     types,
-    contractId
+    notTypes,
+    contractId,
+    sender,
+    recipient,
+    assetIdentifier
   }) => {
-    return listEvents({ cursor, limit, types, contractId });
+    return listEvents({
+      cursor,
+      limit,
+      types,
+      notTypes,
+      contractId,
+      sender,
+      recipient,
+      assetIdentifier
+    });
   };
   async function listEvents(params = {}) {
     const searchParams = new URLSearchParams;
@@ -700,10 +840,16 @@ function createStreamsClient(options) {
     appendSearchParam2(searchParams, "from_height", params.fromHeight);
     appendSearchParam2(searchParams, "to_height", params.toHeight);
     appendSearchParam2(searchParams, "limit", params.limit);
-    appendSearchParam2(searchParams, "contract_id", params.contractId);
+    appendListParam(searchParams, "contract_id", params.contractId);
+    appendListParam(searchParams, "sender", params.sender);
+    appendListParam(searchParams, "recipient", params.recipient);
+    appendSearchParam2(searchParams, "asset_identifier", params.assetIdentifier);
     if (params.types?.length) {
       searchParams.set("types", params.types.join(","));
     }
+    if (params.notTypes?.length) {
+      searchParams.set("not_types", params.notTypes.join(","));
+    }
     const query = searchParams.toString();
     return request(`/v1/streams/events${query ? `?${query}` : ""}`);
   }
@@ -718,7 +864,11 @@ function createStreamsClient(options) {
           fromCursor: params.fromCursor,
           mode: params.mode,
           types: params.types,
+          notTypes: params.notTypes,
           contractId: params.contractId,
+          sender: params.sender,
+          recipient: params.recipient,
+          assetIdentifier: params.assetIdentifier,
           batchSize: params.batchSize ?? 100,
           fetchEvents,
           onBatch: params.onBatch,
@@ -732,7 +882,11 @@ function createStreamsClient(options) {
         return streamStreamsEvents({
           fromCursor: params.fromCursor,
           types: params.types,
+          notTypes: params.notTypes,
           contractId: params.contractId,
+          sender: params.sender,
+          recipient: params.recipient,
+          assetIdentifier: params.assetIdentifier,
           batchSize: params.batchSize ?? 100,
           emptyBackoffMs: params.emptyBackoffMs,
           maxPages: params.maxPages,
@@ -740,6 +894,29 @@ function createStreamsClient(options) {
           signal: params.signal,
           fetchEvents
         });
+      },
+      async replay(params) {
+        const fromCursor = params.from === "genesis" ? null : params.from ?? null;
+        const fromBlock = fromCursor ? cursorTuple(fromCursor)[0] : 0;
+        const manifest = await dumps.list();
+        const files = manifest.files.filter((file) => file.to_block >= fromBlock).sort((a, b) => a.from_block - b.from_block || a.to_block - b.to_block);
+        for (const file of files) {
+          if (params.signal?.aborted)
+            break;
+          await params.onDumpFile(file);
+        }
+        const seam = maxCursor(fromCursor, manifest.latest_finalized_cursor);
+        return consumeStreamsEvents({
+          fromCursor: seam,
+          mode: params.mode ?? "tail",
+          batchSize: params.batchSize ?? 100,
+          fetchEvents,
+          onBatch: params.onBatch,
+          emptyBackoffMs: params.emptyBackoffMs,
+          maxPages: params.maxPages,
+          maxEmptyPolls: params.maxEmptyPolls,
+          signal: params.signal
+        });
       }
     },
     blocks: {
@@ -756,6 +933,7 @@ function createStreamsClient(options) {
         return request(`/v1/streams/reorgs${query ? `?${query}` : ""}`);
       }
     },
+    dumps,
     canonical(height) {
       return request(`/v1/streams/canonical/${height}`);
     },
@@ -1402,6 +1580,7 @@ export {
   ValidationError,
   Subscriptions,
   Subgraphs,
+  StreamsSignatureError,
   StreamsServerError,
   SecondLayer,
   RateLimitError,
@@ -1412,5 +1591,5 @@ export {
   ApiError
 };
 
-//# debugId=45667C0DA2C290D964756E2164756E21
+//# debugId=4712778CA4B6FFB664756E2164756E21
 //# sourceMappingURL=index.js.map