@secondlayer/sdk 5.8.0 → 6.0.0

package/dist/streams/index.d.ts

@@ -1,7 +1,76 @@
 declare const STREAMS_EVENT_TYPES: readonly ["stx_transfer", "stx_mint", "stx_burn", "stx_lock", "ft_transfer", "ft_mint", "ft_burn", "nft_transfer", "nft_mint", "nft_burn", "print"];
 type StreamsEventType = (typeof STREAMS_EVENT_TYPES)[number];
-type StreamsEventPayload = Record<string, unknown>;
-type StreamsEvent = {
+/** A Clarity value as Streams serves it: the canonical hex string, a typed
+*  object carrying that hex (`{ hex }`), or a decoded Clarity-JSON object.
+*  Decode helpers (`decodeNftTransfer`, etc.) resolve it to a concrete value. */
+type StreamsClarityValue = string | {
+	hex: string
+} | Record<string, unknown>;
+type StxTransferPayload = {
+	sender: string
+	recipient: string
+	amount: string
+	memo?: string
+};
+type StxMintPayload = {
+	recipient: string
+	amount: string
+};
+type StxBurnPayload = {
+	sender: string
+	amount: string
+};
+type StxLockPayload = {
+	locked_address: string
+	locked_amount: string
+	unlock_height: string
+};
+type FtTransferPayload = {
+	asset_identifier: string
+	sender: string
+	recipient: string
+	amount: string
+};
+type FtMintPayload = {
+	asset_identifier: string
+	recipient: string
+	amount: string
+};
+type FtBurnPayload = {
+	asset_identifier: string
+	sender: string
+	amount: string
+};
+type NftTransferPayload = {
+	asset_identifier: string
+	sender: string
+	recipient: string
+	value: StreamsClarityValue
+	/** Canonical serialized hex of `value`, when the stream carries it. */
+	raw_value?: string
+};
+type NftMintPayload = {
+	asset_identifier: string
+	recipient: string
+	value: StreamsClarityValue
+	raw_value?: string
+};
+type NftBurnPayload = {
+	asset_identifier: string
+	sender: string
+	value: StreamsClarityValue
+	raw_value?: string
+};
+type PrintPayload = {
+	contract_id?: string | null
+	topic?: string
+	value?: unknown
+	raw_value?: string
+};
+/** Union of every Streams payload shape, discriminated by `event_type` on the
+*  parent `StreamsEvent`. */
+type StreamsEventPayload = StxTransferPayload | StxMintPayload | StxBurnPayload | StxLockPayload | FtTransferPayload | FtMintPayload | FtBurnPayload | NftTransferPayload | NftMintPayload | NftBurnPayload | PrintPayload;
+type StreamsEventBase = {
 	cursor: string
 	block_height: number
 	block_hash: string
@@ -9,15 +78,33 @@ type StreamsEvent = {
 	tx_id: string
 	tx_index: number
 	event_index: number
-	event_type: StreamsEventType
 	contract_id: string | null
-	payload: StreamsEventPayload
 	ts: string
-};
+	/**
+	* True when this event's block is past the finality boundary (immutable).
+	* Optional for back-compat; the API always sets it on Streams responses.
+	*/
+	finalized?: boolean
+};
+type StreamsEventOf<
+	T extends StreamsEventType,
+	P
+> = StreamsEventBase & {
+	event_type: T
+	payload: P
+};
+/** A raw Streams event. Discriminated on `event_type`, so `event.payload`
+*  narrows to the matching payload shape once the type is checked. */
+type StreamsEvent = StreamsEventOf<"stx_transfer", StxTransferPayload> | StreamsEventOf<"stx_mint", StxMintPayload> | StreamsEventOf<"stx_burn", StxBurnPayload> | StreamsEventOf<"stx_lock", StxLockPayload> | StreamsEventOf<"ft_transfer", FtTransferPayload> | StreamsEventOf<"ft_mint", FtMintPayload> | StreamsEventOf<"ft_burn", FtBurnPayload> | StreamsEventOf<"nft_transfer", NftTransferPayload> | StreamsEventOf<"nft_mint", NftMintPayload> | StreamsEventOf<"nft_burn", NftBurnPayload> | StreamsEventOf<"print", PrintPayload>;
 type StreamsTip = {
 	block_height: number
 	block_hash: string
 	burn_block_height: number
+	/**
+	* Highest Stacks block past the burn-confirmation finality boundary.
+	* Optional for back-compat; the API always sets it.
+	*/
+	finalized_height?: number
 	lag_seconds: number
 };
 type StreamsCanonicalBlock = {
@@ -51,18 +138,29 @@ type StreamsReorgsListEnvelope = {
 	reorgs: StreamsReorg[]
 	next_since: string | null
 };
+/** A filter that matches a single value or any value in a list. */
+type StreamsFilterValue = string | readonly string[];
 type StreamsEventsListParams = {
 	cursor?: string | null
 	fromHeight?: number
 	toHeight?: number
 	types?: readonly StreamsEventType[]
-	contractId?: string
+	/** Event types to exclude (applied after `types`). */
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
 	limit?: number
 };
 type StreamsEventsStreamParams = {
 	fromCursor?: string | null
 	types?: readonly StreamsEventType[]
-	contractId?: string
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
 	batchSize?: number
 	emptyBackoffMs?: number
 	maxPages?: number
@@ -73,7 +171,11 @@ type StreamsEventsConsumeParams = {
 	fromCursor?: string | null
 	mode?: "tail" | "bounded"
 	types?: readonly StreamsEventType[]
-	contractId?: string
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
 	batchSize?: number
 	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined
 	emptyBackoffMs?: number
@@ -86,7 +188,63 @@ type StreamsEventsConsumeResult = {
 	pages: number
 	emptyPolls: number
 };
+type StreamsEventsReplayParams = {
+	/** Start point: `"genesis"` (default) or a `<block>:<index>` cursor. */
+	from?: "genesis" | string
+	/**
+	* Called once per finalized dump file, in block order, before live tailing.
+	* Process the parquet with your own tooling (e.g. DuckDB) — the SDK does not
+	* decode parquet. Use `client.dumps.download(file)` to fetch + verify bytes.
+	*/
+	onDumpFile: (file: StreamsDumpFile) => Promise<void> | void
+	/** Called per live page after the dump phase, like `consume`. */
+	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined
+	mode?: "tail" | "bounded"
+	batchSize?: number
+	emptyBackoffMs?: number
+	maxPages?: number
+	maxEmptyPolls?: number
+	signal?: AbortSignal
+};
 type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/** One bulk parquet file in the dumps manifest. `path` is the object key under
+*  the dumps base URL. */
+type StreamsDumpFile = {
+	path: string
+	from_block: number
+	to_block: number
+	min_cursor: string | null
+	max_cursor: string | null
+	row_count: number
+	byte_size: number
+	sha256: string
+	schema_version: number
+	created_at: string
+};
+type StreamsDumpsManifest = {
+	dataset: string
+	network: string
+	version: string
+	schema_version: number
+	generated_at: string
+	producer_version: string
+	finality_lag_blocks: number
+	/** Cursor at the end of the finalized bulk coverage — hand to live tailing. */
+	latest_finalized_cursor: string | null
+	coverage: {
+		from_block: number
+		to_block: number
+	}
+	files: StreamsDumpFile[]
+};
+type StreamsDumps = {
+	/** Fetch and parse the latest dumps manifest. */
+	list(): Promise<StreamsDumpsManifest>
+	/** Absolute URL for a manifest file. */
+	fileUrl(file: StreamsDumpFile): string
+	/** Download a parquet file and verify its sha256 against the manifest. */
+	download(file: StreamsDumpFile): Promise<Uint8Array>
+};
 type StreamsClient = {
 	events: {
 		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
@@ -102,6 +260,14 @@ type StreamsClient = {
 		*/
 		consume(params: StreamsEventsConsumeParams): Promise<StreamsEventsConsumeResult>
 		/**
+		* Backfill from bulk dumps, then continue live from the dump→live seam in
+		* one call. Iterates finalized dump files (via `onDumpFile`) in block
+		* order, then tails live from the manifest's `latest_finalized_cursor`
+		* (exclusive input → no gap or duplicate at the seam). Requires
+		* `dumpsBaseUrl`.
+		*/
+		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>
+		/**
 		* Follow Streams as an async iterator.
 		*
 		* Use `stream` for live processors and watch-style apps. It tails
@@ -116,6 +282,8 @@ type StreamsClient = {
 	reorgs: {
 		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>
 	}
+	/** Bulk parquet dumps. Requires `dumpsBaseUrl` on the client. */
+	dumps: StreamsDumps
 	canonical(height: number): Promise<StreamsCanonicalBlock>
 	tip(): Promise<StreamsTip>
 };
@@ -123,6 +291,20 @@ type CreateStreamsClientOptions = {
 	apiKey: string
 	baseUrl?: string
 	fetchImpl?: FetchLike
+	/**
+	* Public base URL for bulk parquet dumps (the R2/CDN bucket root). Required
+	* to use `client.dumps`. See `GET /public/streams/dumps/manifest`.
+	*/
+	dumpsBaseUrl?: string
+	/**
+	* Verify the ed25519 `X-Signature` on every response (default off). Pass
+	* `true` to fetch the server's public key from
+	* `/public/streams/signing-key`, or `{ publicKey }` to pin a known PEM. A
+	* failed or missing signature throws `StreamsSignatureError`.
+	*/
+	verify?: boolean | {
+		publicKey: string
+	}
 };
 declare function createStreamsClient(options: CreateStreamsClientOptions): StreamsClient;
 declare class AuthError extends Error {
@@ -144,16 +326,13 @@ declare class StreamsServerError extends Error {
 	readonly body?: unknown;
 	constructor(message: string, status: number, body?: unknown);
 }
-type FtTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
-};
-type FtTransferEvent = StreamsEvent & {
+/** Thrown when response signature verification is enabled and fails. */
+declare class StreamsSignatureError extends Error {
+	constructor(message?: string);
+}
+type FtTransferEvent = Extract<StreamsEvent, {
 	event_type: "ft_transfer"
-	payload: FtTransferPayload
-};
+}>;
 type DecodedFtTransferPayload = {
 	asset_identifier: string
 	contract_id: string
@@ -174,18 +353,9 @@ type DecodedFtTransfer = {
 };
 declare function isFtTransfer(event: StreamsEvent): event is FtTransferEvent;
 declare function decodeFtTransfer(event: StreamsEvent): DecodedFtTransfer;
-type NftTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: string | {
-		hex: string
-	}
-};
-type NftTransferEvent = StreamsEvent & {
+type NftTransferEvent = Extract<StreamsEvent, {
 	event_type: "nft_transfer"
-	payload: NftTransferPayload
-};
+}>;
 type DecodedNftTransferPayload = {
 	asset_identifier: string
 	contract_id: string
@@ -410,4 +580,4 @@ type DecodedEventColumns = {
 	payload?: unknown
 };
 type DecodedEventRow = DecodedFtTransfer | DecodedNftTransfer | DecodedStxTransfer | DecodedStxMint | DecodedStxBurn | DecodedStxLock | DecodedFtMint | DecodedFtBurn | DecodedNftMint | DecodedNftBurn | DecodedPrint;
-export { isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, createStreamsClient, ValidationError, StreamsTip, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsClient, StreamsCanonicalBlock, STREAMS_EVENT_TYPES, RateLimitError, NftTransferPayload, NftTransferEvent, FtTransferPayload, FtTransferEvent, FetchLike, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, AuthError };
+export { isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, createStreamsClient, ValidationError, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsClient, StreamsCanonicalBlock, STREAMS_EVENT_TYPES, RateLimitError, NftTransferPayload, NftTransferEvent, FtTransferPayload, FtTransferEvent, FetchLike, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, AuthError };

package/dist/streams/index.js

@@ -1,3 +1,6 @@
+// src/streams/client.ts
+import { ed25519 } from "@secondlayer/shared";
+
 // src/streams/consumer.ts
 async function defaultSleep(ms, signal) {
   if (signal?.aborted)
@@ -26,7 +29,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);
@@ -61,7 +68,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) {
@@ -86,6 +97,9 @@ async function* streamStreamsEvents(opts) {
   }
 }
 
+// src/streams/dumps.ts
+import { createHash } from "node:crypto";
+
 // src/streams/errors.ts
 class AuthError extends Error {
   status = 401;
@@ -127,7 +141,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(/\/+$/, "");
@@ -137,6 +204,13 @@ function appendSearchParam(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)
@@ -175,21 +249,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;
@@ -197,10 +337,16 @@ function createStreamsClient(options) {
     appendSearchParam(searchParams, "from_height", params.fromHeight);
     appendSearchParam(searchParams, "to_height", params.toHeight);
     appendSearchParam(searchParams, "limit", params.limit);
-    appendSearchParam(searchParams, "contract_id", params.contractId);
+    appendListParam(searchParams, "contract_id", params.contractId);
+    appendListParam(searchParams, "sender", params.sender);
+    appendListParam(searchParams, "recipient", params.recipient);
+    appendSearchParam(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}` : ""}`);
   }
@@ -215,7 +361,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,
@@ -229,7 +379,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,
@@ -237,6 +391,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: {
@@ -253,6 +430,7 @@ function createStreamsClient(options) {
         return request(`/v1/streams/reorgs${query ? `?${query}` : ""}`);
       }
     },
+    dumps,
     canonical(height) {
       return request(`/v1/streams/canonical/${height}`);
     },
@@ -652,11 +830,12 @@ export {
   decodeFtBurn,
   createStreamsClient,
   ValidationError,
+  StreamsSignatureError,
   StreamsServerError,
   STREAMS_EVENT_TYPES,
   RateLimitError,
   AuthError
 };
 
-//# debugId=3A844A761118CEDE64756E2164756E21
+//# debugId=E556011474C772DE64756E2164756E21
 //# sourceMappingURL=index.js.map