@secondlayer/sdk 5.9.0 → 6.1.0

package/README.md

@@ -19,9 +19,12 @@ const sl = new SecondLayer({
 });
 ```
 
-Reads are public during open beta — no key needed. Writes require an `sk-sl_`
-API key, created in the platform console at
-https://secondlayer.tools/platform/api-keys.
+`sl.index` and `sl.subgraphs` reads are anonymous — no key needed. **`sl.streams`
+reads require a bearer token** (`apiKey`) and resolve a per-tier tenant; a
+publicly-known free-tier token exists but a bearer is always required. Writes
+require an `sk-sl_` API key, created in the platform console at
+https://secondlayer.tools/platform/api-keys. (Public Streams bulk dumps —
+`client.dumps`, `events.replay` — need no key.)
 
 ## Mental model
 
@@ -31,16 +34,20 @@ https://secondlayer.tools/platform/api-keys.
 
 ## Stacks Streams
 
-Typed L1 HTTP client. Reads are public — no key needed.
+Typed L1 HTTP client. Reads require a bearer token (`apiKey`).
 
 ```typescript
 const tip = await sl.streams.tip();
+// tip.finalized_height — highest immutable (past Bitcoin-anchored finality) block
 const page = await sl.streams.events.list({
   types: ["ft_transfer"],
   contractId: "SP...sbtc-token",
+  sender: "SP...",       // exact payload sender (events that have one)
+  recipient: "SP...",    // exact payload recipient
+  assetIdentifier: "SP...token::asset", // exact FT/NFT asset id
   limit: 10,
 });
-
+// each event carries `finalized: boolean`
 console.log({ tip, firstCursor: page.events[0]?.cursor });
 ```
 
@@ -50,10 +57,19 @@ console.log({ tip, firstCursor: page.events[0]?.cursor });
 import { createStreamsClient } from "@secondlayer/sdk";
 
 const streams = createStreamsClient({
-  apiKey: process.env.SL_API_KEY!, // sk-sl_...
+  apiKey: process.env.SL_API_KEY!, // sk-sl_... — required for reads
+  // verify: true,                 // verify ed25519 X-Signature on every read
+  //                               // (auto-fetches the public key; { publicKey } pins a PEM)
+  // dumpsBaseUrl: process.env.SL_STREAMS_DUMPS_URL, // required to use client.dumps
 });
 ```
 
+Verified responses: every Streams read is signed (ed25519 `X-Signature` +
+`X-Signature-KeyId`). Pass `verify: true` to check it on every read (or
+`{ publicKey }` to pin a PEM); a missing/bad signature throws
+`StreamsSignatureError`. The public key is at
+`GET /public/streams/signing-key`.
+
 Convenience reads:
 
 ```typescript
@@ -102,6 +118,46 @@ for await (const event of streams.events.stream({
 }
 ```
 
+Bulk parquet dumps.
+
+Finalized history is published as public parquet files. Set `dumpsBaseUrl`
+(or `SL_STREAMS_DUMPS_URL`) — no API key needed for dumps. The SDK does **not**
+decode parquet; `download` hands you sha256-verified bytes to process with your
+own tooling.
+
+```typescript
+const streams = createStreamsClient({
+  apiKey: process.env.SL_API_KEY!,
+  dumpsBaseUrl: process.env.SL_STREAMS_DUMPS_URL!,
+});
+
+const manifest = await streams.dumps.list();       // parse the manifest
+for (const file of manifest.files) {
+  const bytes = await streams.dumps.download(file); // fetch + verify sha256
+  await myParquetReader(bytes);
+}
+```
+
+Backfill then tail (`events.replay`).
+
+Backfills from bulk dumps, then tails live from the manifest's
+`latest_finalized_cursor` — no gap or dupe at the seam. `onDumpFile` hands you
+each finalized file; `onBatch` receives live events after the seam.
+
+```typescript
+await streams.events.replay({
+  from: lastCheckpoint,
+  async onDumpFile(file) {
+    const bytes = await streams.dumps.download(file);
+    await ingestParquet(bytes); // your tooling
+  },
+  async onBatch(events, envelope) {
+    for (const event of events) await handle(event);
+    return envelope.next_cursor;
+  },
+});
+```
+
 Decoder helper.
 
 ```typescript

package/dist/index.d.ts

@@ -346,8 +346,82 @@ declare class Index extends BaseClient {
 }
 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 = {
+	/**
+	* Globally unique, monotonic position of this event (`<block>:<index>`). Use
+	* it as the primary key of your projection rows — replaying a batch then
+	* upserts cleanly. Don't synthesize your own id from `tx_id`/`event_index`.
+	*/
 	cursor: string
 	block_height: number
 	block_hash: string
@@ -355,9 +429,7 @@ 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).
@@ -365,6 +437,16 @@ type StreamsEvent = {
 	*/
 	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
@@ -407,23 +489,28 @@ 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
-	sender?: string
-	recipient?: 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
-	sender?: string
-	recipient?: string
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
 	assetIdentifier?: string
 	batchSize?: number
 	emptyBackoffMs?: number
@@ -431,16 +518,53 @@ type StreamsEventsStreamParams = {
 	maxEmptyPolls?: number
 	signal?: AbortSignal
 };
+/**
+* The checkpoint the SDK computes for a batch. Persist `cursor` inside the same
+* transaction as your projection writes, then resume from it via `fromCursor`.
+* It is the position to advance to: `next_cursor` normally, or the last
+* finalized event when `finalizedOnly` is set.
+*/
+type StreamsBatchContext = {
+	cursor: string | null
+};
+/**
+* The checkpoint for a reorg rollback. Persist `cursor` (the rewind position)
+* inside the same transaction as your rollback so the two commit atomically.
+*/
+type StreamsReorgContext = {
+	cursor: string
+};
 type StreamsEventsConsumeParams = {
 	fromCursor?: string | null
 	mode?: "tail" | "bounded"
+	/**
+	* Emit only finalized (immutable) events and never surface reorgs. The SDK
+	* checkpoints at the last finalized event and re-reads the unfinalized tail
+	* until it settles. Trades finality lag for zero reorg handling; `onReorg` is
+	* ignored.
+	*/
+	finalizedOnly?: boolean
 	types?: readonly StreamsEventType[]
-	contractId?: string
-	sender?: string
-	recipient?: 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
+	/**
+	* Apply a page of canonical events. Persist `ctx.cursor` in the same
+	* transaction as your writes. Returning a cursor overrides `ctx.cursor` as
+	* the resume point (advanced manual control); returning nothing uses it.
+	*/
+	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
+	/**
+	* Roll your projection back to `reorg.fork_point_height`, persisting
+	* `ctx.cursor` in the same transaction. Called once per *new* reorg
+	* (deduped in-memory, fork-ascending) before the SDK rewinds and re-reads the
+	* now-canonical events. Omit it to ignore reorgs (events stay canonical, but
+	* stale rows from an orphaned fork are left in place).
+	*/
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
 	emptyBackoffMs?: number
 	maxPages?: number
 	maxEmptyPolls?: number
@@ -647,16 +771,9 @@ declare class StreamsServerError extends Error {
 declare class StreamsSignatureError extends Error {
 	constructor(message?: string);
 }
-type FtTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
-};
-type FtTransferEvent = StreamsEvent & {
+type FtTransferEvent = Extract<StreamsEvent, {
 	event_type: "ft_transfer"
-	payload: FtTransferPayload
-};
+}>;
 type DecodedFtTransferPayload = {
 	asset_identifier: string
 	contract_id: string
@@ -677,18 +794,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
@@ -912,6 +1020,25 @@ type DecodedEventColumns = {
 	/** JSONB overflow for non-flat types (e.g. print's decoded value). */
 	payload?: unknown
 };
+/**
+* Helpers for Streams cursors. A cursor is the opaque `<block>:<index>` string
+* that marks a position in the event stream; treat the format as an
+* implementation detail and go through these helpers instead of string-building
+* it at call sites.
+*/
+declare const Cursor: {
+	/**
+	* Cursor at the foot of `height`. Resuming from it re-reads every event
+	* strictly above block `height` (cursors are exclusive), so this is the
+	* position to rewind to after a reorg whose fork point is `height`.
+	*/
+	atHeight(height: number): string
+	/** Parse a `<block>:<index>` cursor. Throws `ValidationError` if malformed. */
+	parse(cursor: string): {
+		blockHeight: number
+		eventIndex: number
+	}
+};
 type DecodedEventRow = DecodedFtTransfer | DecodedNftTransfer | DecodedStxTransfer | DecodedStxMint | DecodedStxBurn | DecodedStxLock | DecodedFtMint | DecodedFtBurn | DecodedNftMint | DecodedNftBurn | DecodedPrint;
 /**
 * Typed client for the Foundation Datasets REST API (`/v1/datasets/*`).
@@ -1036,7 +1163,9 @@ declare class Datasets extends BaseClient {
 		summary: DatasetRow
 	}>;
 	private get;
-	private buildParams;
+	/** Map camelCase filter fields to snake_case query keys (dropping pagination
+	*  controls) and build the canonical query suffix. */
+	private paramsToQuery;
 	private cursorDataset;
 }
 import { SubgraphAgentSchema as SubgraphAgentSchema3, SubgraphSpecFormat as SubgraphSpecFormat2, SubgraphSpecOptions as SubgraphSpecOptions3 } from "@secondlayer/shared/subgraphs/spec";
@@ -1157,4 +1286,4 @@ declare function toJsonSafe(value: unknown): unknown;
 /** Decode a hex-encoded Clarity value to JSON-safe JS (uints as strings,
 *  buffers as `0x…` hex, tuples as objects). Returns the input hex on failure. */
 declare function decodeClarityValue(hex: string): unknown;
-export { verifyWebhookSignature, toJsonSafe, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createStreamsClient, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsClient, StreamsCanonicalBlock, SecondLayerOptions, SecondLayer, RotateSecretResponse2 as RotateSecretResponse, ReplayResult2 as ReplayResult, RateLimitError, Pox4CallsParams, NftTransfersWalkParams, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, IndexTip, IndexEventType, IndexEvent, IndexContractCall, Index, FtTransfersWalkParams, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, 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, DeadRow2 as DeadRow, Datasets, DatasetRow, CursorListParams, CursorEnvelope, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, CURSOR_SLUGS, AuthError, ApiError };
+export { verifyWebhookSignature, toJsonSafe, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createStreamsClient, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorgContext, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsClient, StreamsCanonicalBlock, StreamsBatchContext, SecondLayerOptions, SecondLayer, RotateSecretResponse2 as RotateSecretResponse, ReplayResult2 as ReplayResult, RateLimitError, Pox4CallsParams, NftTransfersWalkParams, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, IndexTip, IndexEventType, IndexEvent, IndexContractCall, Index, FtTransfersWalkParams, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, 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, DeadRow2 as DeadRow, Datasets, DatasetRow, CursorListParams, CursorEnvelope, Cursor, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, CURSOR_SLUGS, AuthError, ApiError };