@secondlayer/sdk 6.23.0 → 6.24.0

package/README.md

@@ -40,7 +40,8 @@ Everything is indexing — the question is how much of the indexer you run:
 
 - `sl.index` — decoded rows we keep indexed: query FT/NFT transfers, all event
   types (`events`), and `contractCalls` — or build your own app index on them
-  with `walk()`, resumable cursors, and `reorgs[]` on every page.
+  with the checkpointed `consume()` loop (automatic reorg rewind), `walk()`
+  sweeps, and resumable cursors on every page.
 - `sl.subgraphs` — deploy your own indexer (one `defineSubgraph()` file via the
   CLI), then read your hosted tables here. We run the loop.
 - `sl.streams` — the raw ordered event firehose Index itself is built on, with
@@ -251,6 +252,30 @@ for await (const transfer of sl.index.ftTransfers.walk({
 }
 ```
 
+Checkpointed consumer — build your app index.
+
+`index.events.consume` / `index.contractCalls.consume` is the same contract as
+the Streams consumer: write your rows inside `onBatch`, return the cursor you
+committed, and reorgs rewind automatically to the fork point. `finalizedOnly`
+holds delivery to rows at or below `tip.finalized_height` (Index rows carry no
+per-event flag). Full runnable example: `examples/sales-index/`.
+
+```typescript
+await sl.index.contractCalls.consume({
+  contractId: "SP...marketplace-v4",
+  functionName: "purchase-asset",
+  fromCursor: await loadCheckpoint(), // null on first run
+  fromHeight: 0,                      // first run: backfill from genesis
+  onBatch: async (calls, envelope, ctx) => {
+    await commitRowsAndCheckpoint(calls, ctx.cursor);
+    return ctx.cursor;
+  },
+  onReorg: async (reorg) => {
+    await rollbackAboveHeight(reorg.fork_point_height);
+  },
+});
+```
+
 ## Transaction-inclusion proofs
 
 Verify — **without trusting Secondlayer** — that a transaction is included in a

package/dist/index.d.ts

@@ -649,6 +649,13 @@ type StreamsEventsReplayParams = {
 	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
+	/**
+	* Called when the live-tail phase (after the dump backfill) crosses a reorg,
+	* before the cursor rewinds and re-reads the now-canonical events — same
+	* contract as `consume`. The dump-backfill phase is finalized and never
+	* reorgs; omit this to leave stale rows from an orphaned fork in place.
+	*/
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
 	mode?: "tail" | "bounded"
 	batchSize?: number
 	emptyBackoffMs?: number

package/dist/index.js

@@ -1221,7 +1221,15 @@ function createStreamsDumps(opts) {
     return baseUrl;
   }
   function fileUrl(file) {
-    return `${requireBaseUrl()}/${file.path.replace(/^\/+/, "")}`;
+    const base = requireBaseUrl();
+    const path = file.path.replace(/^\/+/, "");
+    try {
+      const basePath = new URL(base).pathname.replace(/^\/+|\/+$/g, "");
+      if (basePath && path.startsWith(`${basePath}/`)) {
+        return `${base}/${path.slice(basePath.length + 1)}`;
+      }
+    } catch {}
+    return `${base}/${path}`;
   }
   async function list() {
     const url = `${requireBaseUrl()}/manifest/latest.json`;
@@ -1629,6 +1637,7 @@ function createStreamsClient(options) {
           batchSize: params.batchSize ?? 100,
           fetchEvents,
           onBatch: params.onBatch,
+          onReorg: params.onReorg,
           emptyBackoffMs: params.emptyBackoffMs,
           maxPages: params.maxPages,
           maxEmptyPolls: params.maxEmptyPolls,
@@ -2493,5 +2502,5 @@ export {
   ApiError
 };
 
-//# debugId=97CCB6EA784D158564756E2164756E21
+//# debugId=3115754A9CBB338064756E2164756E21
 //# sourceMappingURL=index.js.map