@secondlayer/sdk 6.46.1 → 6.48.0

package/dist/index.d.ts

@@ -69,9 +69,9 @@ interface SubgraphRowsEnvelope<T = unknown> {
 	rows: T[];
 	next_cursor: string | null;
 	tip: {
-		block_height: number
-		subgraph_height: number
-		blocks_behind: number
+		block_height: number;
+		subgraph_height: number;
+		blocks_behind: number;
 	};
 }
 interface BundleSubgraphResponse {
@@ -87,34 +87,34 @@ interface BundleSubgraphResponse {
 }
 declare class Subgraphs extends BaseClient {
 	list(): Promise<{
-		data: SubgraphSummary[]
+		data: SubgraphSummary[];
 	}>;
 	get(name: string): Promise<SubgraphDetail>;
 	openapi(name: string, options?: SubgraphSpecOptions): Promise<Record<string, unknown>>;
 	schema(name: string, options?: SubgraphSpecOptions): Promise<SubgraphAgentSchema>;
 	markdown(name: string, options?: SubgraphSpecOptions): Promise<string>;
 	reindex(name: string, options?: {
-		fromBlock?: number
-		toBlock?: number
+		fromBlock?: number;
+		toBlock?: number;
 	}): Promise<ReindexResponse>;
 	stop(name: string): Promise<{
-		message: string
-		operationId?: string
-		status?: string
+		message: string;
+		operationId?: string;
+		status?: string;
 	}>;
 	backfill(name: string, options: {
-		fromBlock: number
-		toBlock: number
+		fromBlock: number;
+		toBlock: number;
 	}): Promise<ReindexResponse>;
 	gaps(name: string, opts?: {
-		limit?: number
-		offset?: number
-		resolved?: boolean
+		limit?: number;
+		offset?: number;
+		resolved?: boolean;
 	}): Promise<SubgraphGapsResponse>;
 	delete(name: string, options?: {
-		force?: boolean
+		force?: boolean;
 	}): Promise<{
-		message: string
+		message: string;
 	}>;
 	/**
 	* Publish: claim the name in the global public namespace and open anon
@@ -122,14 +122,14 @@ declare class Subgraphs extends BaseClient {
 	* holds the public name.
 	*/
 	publish(name: string): Promise<{
-		name: string
-		visibility: "public"
-		url: string
+		name: string;
+		visibility: "public";
+		url: string;
 	}>;
 	/** Make reads private again (owning account's bearer key required). */
 	unpublish(name: string): Promise<{
-		name: string
-		visibility: "private"
+		name: string;
+		visibility: "private";
 	}>;
 	/**
 	* Open /v1 read: cursor-paginated rows. Anon works for public subgraphs;
@@ -137,11 +137,11 @@ declare class Subgraphs extends BaseClient {
 	* `next_cursor`.
 	*/
 	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset" | "sort"> & {
-		cursor?: string
+		cursor?: string;
 	}): Promise<SubgraphRowsEnvelope<T>>;
 	/** Recent reindex/backfill operations for a subgraph, newest first. */
 	operations(name: string): Promise<{
-		operations: SubgraphOperationStatus[]
+		operations: SubgraphOperationStatus[];
 	}>;
 	/** Status of a single operation (poll the `operationId` returned by
 	*  reindex/backfill/stop until `status` is terminal). */
@@ -153,11 +153,11 @@ declare class Subgraphs extends BaseClient {
 	* authoring loop so Vercel's serverless runtime doesn't have to run esbuild.
 	*/
 	bundle(data: {
-		code: string
+		code: string;
 	}): Promise<BundleSubgraphResponse>;
 	queryTable(name: string, table: string, params?: SubgraphQueryParams): Promise<unknown[]>;
 	queryTableCount(name: string, table: string, params?: SubgraphQueryParams): Promise<{
-		count: number
+		count: number;
 	}>;
 	queryTableAggregate(name: string, table: string, params?: SubgraphAggregateParams): Promise<SubgraphAggregateResponse>;
 	/**
@@ -173,8 +173,8 @@ declare class Subgraphs extends BaseClient {
 	* ```
 	*/
 	typed<T extends {
-		name: string
-		schema: Record<string, unknown>
+		name: string;
+		schema: Record<string, unknown>;
 	}>(def: T): InferSubgraphClient<T>;
 	private createTableClient;
 }
@@ -229,12 +229,12 @@ declare class ApiKeys extends BaseClient {
 	* account-level (owner) key or a dashboard session.
 	*/
 	list(): Promise<{
-		keys: ApiKeySummary[]
+		keys: ApiKeySummary[];
 	}>;
 	/** Revoke a key by id. Existing requests with that key stop working. */
 	revoke(id: string): Promise<{
-		revoked: true
-		id: string
+		revoked: true;
+		id: string;
 	}>;
 }
 /**
@@ -282,7 +282,7 @@ declare class Contracts extends BaseClient {
 	* Pass `{ includeAbi: true }` for the full ABI blob. Resolves null on 404.
 	*/
 	get(contractId: string, opts?: {
-		includeAbi?: boolean
+		includeAbi?: boolean;
 	}): Promise<ContractSummary | null>;
 }
 import { Pox5EventTopic } from "@secondlayer/stacks/pox5";
@@ -320,8 +320,8 @@ interface TransactionProof {
 	/** Present when consensus-level verification is available: the reward cycle and
 	*  its signer set, against which the header's signer signatures are checked. */
 	consensus?: {
-		reward_cycle: number
-		reward_set: RewardSet
+		reward_cycle: number;
+		reward_set: RewardSet;
 	};
 }
 interface TransactionProofVerifyResult {
@@ -353,9 +353,9 @@ interface TransactionProofVerifyResult {
 * `verifyTransactionProof(proof, { rewardSet })`.
 */
 declare function fetchRewardSet(opts: {
-	nodeUrl: string
-	cycle: number
-	fetchImpl?: typeof fetch
+	nodeUrl: string;
+	cycle: number;
+	fetchImpl?: typeof fetch;
 }): Promise<RewardSet | null>;
 /**
 * Verify a transaction-inclusion proof. Every check is recomputed client-side,
@@ -365,7 +365,7 @@ declare function fetchRewardSet(opts: {
 * embedded in the proof.
 */
 declare function verifyTransactionProof(proof: TransactionProof, opts?: {
-	rewardSet?: RewardSet
+	rewardSet?: RewardSet;
 }): TransactionProofVerifyResult;
 /**
 * A consumer sink: the destination adapter a consume loop writes through.
@@ -382,12 +382,83 @@ declare function verifyTransactionProof(proof: TransactionProof, opts?: {
 * The interface is dependency-free on purpose: implementations with real
 * database drivers live behind subpath exports (`@secondlayer/sdk/sinks/*`)
 * so the root entry ships no DB dependency.
+*
+* ## The contract
+*
+* Binding on every implementation; the conformance kit
+* (`@secondlayer/sdk/sinks/testing`) probes each one. Violations are SILENT
+* in production — they surface as gaps or duplicates weeks later, never as
+* errors at the violation site — which is why they are spelled out here and
+* mechanically tested.
+*
+* What the loop guarantees the sink:
+*
+* 1. **Init-before-first-page.** `loadCursor` is called exactly once, before
+*    the first fetch — even when the caller passed an explicit `fromCursor`.
+*    It is the sink's init hook: create checkpoint storage, validate
+*    rollback preconditions.
+* 2. **Deterministic replay.** Re-reading from the same cursor yields the
+*    same rows in the same order. `cursor` is therefore a valid idempotency
+*    key: an append-only sink can dedup on it with no contract change.
+* 3. **At-least-once delivery.** A batch whose commit outcome was lost (crash
+*    after commit, before the loop observed it) is re-committed on restart
+*    with the SAME cursor and the same rows.
+*
+* What the sink must guarantee — `commitBatch`:
+*
+* 4. **Rows+cursor atomicity.** The handler's writes and `cursor` commit in
+*    ONE transaction. Committing them separately is the classic torn-batch
+*    bug: a crash between the two either re-delivers (duplicates) or skips
+*    (gap) depending on the order.
+* 5. **Abort on throw.** A throw from `write` aborts the WHOLE transaction —
+*    neither rows nor cursor land — so a crashed batch is simply re-read.
+* 6. **The lent transaction is the real one.** `write(tx)` receives the same
+*    live transaction the cursor commits in; every handler write must go
+*    through it. Writes outside `tx` escape atomicity AND rollback.
+* 7. **Replay safety.** Committing the same cursor twice must not corrupt
+*    state (per #3 the rows are identical; upsert/dedup make it exact).
+*
+* What the sink must guarantee — `rollback`:
+*
+* 8. **Delete+rewind atomicity.** Undoing rows at/above the fork and
+*    committing `rewindCursor` happen in ONE transaction. A crash between
+*    them resumes above the fork and the deleted range is never re-read —
+*    the silent-gap bug.
+* 9. **Inclusive fork point.** Undo AT OR ABOVE `forkPointHeight` (`>=`) —
+*    the new canonical chain re-supplies the fork block itself.
+* 10. **Idempotent.** The loop may re-apply the same rollback after a crash
+*     (reorgs are deduped in memory only); a second application must be a
+*     harmless no-op.
+* 11. **Scope by height, not cursor.** On a page reporting several forks the
+*     loop calls `rollback` once per fork: each call carries its own
+*     `forkPointHeight` but ALL carry the same `rewindCursor` (the lowest
+*     fork point). Derive the undo range from `forkPointHeight` only; a
+*     sink that derives it from `rewindCursor` under-deletes silently.
+*
+* Error semantics and concurrency:
+*
+* 12. **Throw, don't swallow; no internal retry.** The loop owns retry
+*     policy. A swallowed commit error advances the loop past unwritten
+*     data; an internal retry can double-apply around a partial failure.
+* 13. **Single writer per checkpoint id.** The loop assumes one live
+*     consumer per checkpoint identity. A sink that can detect a second
+*     writer (e.g. a lock) must fail loudly — never block or interleave.
 */
 interface ConsumerSink<Tx = unknown> {
 	/** Phantom marker carrying `Tx` in a directly-inferable position, so the
 	*  consume loops' `TTx` type parameter resolves from the `sink` option
 	*  (never set at runtime). */
 	readonly _tx?: Tx;
+	/** Static capabilities, read by the loop before the first fetch to fail
+	*  fast on impossible pairings. */
+	readonly capabilities?: {
+		/** This sink cannot undo committed rows (append-only store, ClickHouse,
+		*  parquet, …), so `rollback` is unimplementable and following the
+		*  unfinalized tip would corrupt it on the first fork. The loop throws
+		*  loudly unless consuming with `finalizedOnly: true` — in that mode
+		*  reorgs never reach the sink and `rollback` may simply throw. */
+		finalizedOnly?: boolean;
+	};
 	/** The committed checkpoint, or `null` on first run. Called once, before
 	*  the first page. Implementations may create their checkpoint storage
 	*  here and SHOULD validate their rollback preconditions (e.g. that every
@@ -407,6 +478,11 @@ interface ConsumerSink<Tx = unknown> {
 	* without the rewound cursor is the classic silent-gap bug: a crash
 	* between the two writes resumes above the fork and the deleted range is
 	* never re-read.
+	*
+	* On a multi-fork page this is called once PER fork, every call with the
+	* same `rewindCursor` (the lowest fork point) but its own
+	* `forkPointHeight` — scope the undo by `forkPointHeight` only (contract
+	* invariant #11), and expect re-application after a crash (#10).
 	*/
 	rollback(forkPointHeight: number, rewindCursor: string): Promise<void>;
 }
@@ -416,75 +492,75 @@ type SinkTx<S> = S extends ConsumerSink<infer Tx> ? Tx : never;
 *  is unchanged (an intersection with `unknown` is an identity, so
 *  contextual typing of `onBatch` callbacks never degrades to a union). */
 type WithSinkTx<TTx> = [TTx] extends [never] ? unknown : {
-	tx: TTx
+	tx: TTx;
 };
 import { StreamsEventType } from "@secondlayer/shared";
 /** 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
+	hex: string;
 } | Record<string, unknown>;
 type StxTransferPayload = {
-	sender: string
-	recipient: string
-	amount: string
-	memo?: string
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo?: string;
 };
 type StxMintPayload = {
-	recipient: string
-	amount: string
+	recipient: string;
+	amount: string;
 };
 type StxBurnPayload = {
-	sender: string
-	amount: string
+	sender: string;
+	amount: string;
 };
 type StxLockPayload = {
-	locked_address: string
-	locked_amount: string
-	unlock_height: string
+	locked_address: string;
+	locked_amount: string;
+	unlock_height: string;
 };
 type FtTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type FtMintPayload = {
-	asset_identifier: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	recipient: string;
+	amount: string;
 };
 type FtBurnPayload = {
-	asset_identifier: string
-	sender: string
-	amount: string
+	asset_identifier: string;
+	sender: string;
+	amount: string;
 };
 type NftTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: StreamsClarityValue
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: StreamsClarityValue;
 	/** Canonical serialized hex of `value`, when the stream carries it. */
-	raw_value?: string
+	raw_value?: string;
 };
 type NftMintPayload = {
-	asset_identifier: string
-	recipient: string
-	value: StreamsClarityValue
-	raw_value?: string
+	asset_identifier: string;
+	recipient: string;
+	value: StreamsClarityValue;
+	raw_value?: string;
 };
 type NftBurnPayload = {
-	asset_identifier: string
-	sender: string
-	value: StreamsClarityValue
-	raw_value?: string
+	asset_identifier: string;
+	sender: string;
+	value: StreamsClarityValue;
+	raw_value?: string;
 };
 type PrintPayload = {
-	contract_id?: string | null
-	topic?: string
-	value?: unknown
-	raw_value?: string
+	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`. */
@@ -495,92 +571,97 @@ type StreamsEventBase = {
 	* 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
-	burn_block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	contract_id: string | null
-	ts: string
+	cursor: string;
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	contract_id: string | null;
+	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
+	finalized?: boolean;
 	/**
 	* Labels whose filter group this event satisfied, present only when the
 	* request used a labelled `filters` map. The SDK dispatches on it for you
 	* (`on.<label>`), so handlers rarely read it directly.
 	*/
-	matched?: string[]
+	matched?: string[];
 };
 type StreamsEventOf<
 	T extends StreamsEventType,
 	P
 > = StreamsEventBase & {
-	event_type: T
-	payload: P
+	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
+	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
+	finalized_height?: number;
+	lag_seconds: number;
 	/**
 	* Oldest height still seekable on the live API for the caller's tier
 	* (`tip - retention`). `null` = unlimited retention. Older reads must use the
 	* cold dumps lane. Optional for back-compat.
 	*/
-	oldest_seekable_height?: number | null
+	oldest_seekable_height?: number | null;
 	/** Oldest seekable cursor (`<oldest_seekable_height>:0`); `null` = unlimited. */
-	oldest_cursor?: string | null
+	oldest_cursor?: string | null;
 };
 type StreamsCanonicalBlock = {
-	block_height: number
-	block_hash: string
-	burn_block_height: number
-	burn_block_hash: string | null
-	is_canonical: true
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
+	burn_block_hash: string | null;
+	is_canonical: true;
 };
 type StreamsReorg = {
-	detected_at: string
-	fork_point_height: number
+	detected_at: string;
+	fork_point_height: number;
 	orphaned_range: {
-		from: string
-		to: string
-	}
+		from: string;
+		to: string;
+	};
 	/**
 	* First position of the new canonical chain at the fork, `fork:0`
 	* (INCLUSIVE). Not an exclusive resume token — resuming directly from it
 	* skips `fork:0`. The consumer rewinds to the foot of `fork_point_height`
 	* (`Cursor.atHeight`) to re-read the new run from `fork:0` inclusive.
 	*/
-	new_canonical_tip: string
+	new_canonical_tip: string;
 };
-type StreamsEventsEnvelope = {
-	events: StreamsEvent[]
-	next_cursor: string | null
-	tip: StreamsTip
-	reorgs: StreamsReorg[]
+type StreamsEventsEnvelope<TEvent = StreamsEvent> = {
+	events: TEvent[];
+	next_cursor: string | null;
+	tip: StreamsTip;
+	reorgs: StreamsReorg[];
 };
 type StreamsEventsListEnvelope = Omit<StreamsEventsEnvelope, "next_cursor">;
+/** The StreamsEvent union narrowed to a `types` selection — what a
+*  const-generic `types: ["ft_transfer"]` buys at the type level. */
+type StreamsEventOfTypes<T extends readonly StreamsEventType[]> = Extract<StreamsEvent, {
+	event_type: T[number];
+}>;
 type StreamsReorgsListParams = {
-	since: string
-	limit?: number
+	since: string;
+	limit?: number;
 };
 type StreamsReorgsListEnvelope = {
-	reorgs: StreamsReorg[]
-	next_since: string | null
+	reorgs: StreamsReorg[];
+	next_since: string | null;
 };
 /** A filter that matches a single value or any value in a list. */
 type StreamsFilterValue = string | readonly string[];
@@ -589,11 +670,11 @@ type StreamsFilterValue = string | readonly string[];
 * map OR together server-side.
 */
 type StreamsLabelledFilter = {
-	types?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	types?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 };
 /** A map of label → filter group. Labels are yours; the server echoes them. */
 type StreamsFilterMap = Record<string, StreamsLabelledFilter>;
@@ -606,65 +687,65 @@ type StreamsEventForFilter<
 	F,
 	D extends boolean = false
 > = F extends {
-	types: readonly (infer T extends StreamsEventType)[]
+	types: readonly (infer T extends StreamsEventType)[];
 } ? D extends true ? Extract<IndexEvent, {
-	event_type: T
+	event_type: T;
 }> : Extract<StreamsEvent, {
-	event_type: T
+	event_type: T;
 }> : D extends true ? IndexEvent : StreamsEvent;
 type StreamsEventsListParams = {
-	cursor?: string | null
-	fromHeight?: number
-	toHeight?: number
-	types?: readonly StreamsEventType[]
+	cursor?: string | null;
+	fromHeight?: number;
+	toHeight?: number;
+	types?: readonly StreamsEventType[];
 	/** Event types to exclude (applied after `types`). */
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/**
 	* Labelled filter groups. The groups OR together in one scan and each
 	* returned event carries the labels it matched (`event.matched`) — two
 	* unrelated concerns share one page, one cursor, one checkpoint.
 	*/
-	filters?: StreamsFilterMap
-	limit?: number
+	filters?: StreamsFilterMap;
+	limit?: number;
 };
 type StreamsEventsStreamParams = {
-	fromCursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	fromCursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
-	filters?: StreamsFilterMap
-	batchSize?: number
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+	filters?: StreamsFilterMap;
+	batchSize?: number;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 };
 type StreamsEventsSubscribeParams = {
 	/** Resume strictly after this cursor; omit to live-tail from the tip. */
-	fromCursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	fromCursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
-	filters?: StreamsFilterMap
+	filters?: StreamsFilterMap;
 	/** Abort to unsubscribe (the returned function does the same). */
-	signal?: AbortSignal
+	signal?: AbortSignal;
 	/** Called for each pushed event, in order. */
-	onEvent: (event: StreamsEvent) => void | Promise<void>
+	onEvent: (event: StreamsEvent) => void | Promise<void>;
 	/** Called on a connection error; the subscription auto-reconnects from the
 	*  last delivered cursor unless the signal has aborted. */
-	onError?: (err: unknown) => void
+	onError?: (err: unknown) => void;
 };
 /**
 * The checkpoint the SDK computes for a batch. Persist `cursor` inside the same
@@ -691,14 +772,14 @@ type ConsumerBatchContext<
 	TReorg = unknown
 > = {
 	/** Checkpoint to commit alongside your rows. */
-	cursor: string | null
+	cursor: string | null;
 	/** Highest canonical block the sweep has reached. `null` before the first
 	*  row of a fresh consume. */
-	height: number | null
+	height: number | null;
 	/** Chain tip as of this page's read. */
-	tipHeight: number
+	tipHeight: number;
 	/** `tipHeight - height`, floored at 0. `null` until `height` is known. */
-	blocksBehind: number | null
+	blocksBehind: number | null;
 	/**
 	* The full tip for this page — `StreamsTip` or `IndexTip` depending on the
 	* surface. Exposed here so a handler never needs the `envelope` parameter,
@@ -706,12 +787,12 @@ type ConsumerBatchContext<
 	* `finalizedOnly` mistake becomes reachable (`return envelope.next_cursor`
 	* jumps the cursor past events that were filtered out and never delivered).
 	*/
-	tip: TTip
+	tip: TTip;
 	/**
 	* Reorgs reported alongside this page; empty when none. Rollback still
 	* belongs in `onReorg` — this is for observability inside a batch.
 	*/
-	reorgs: readonly TReorg[]
+	reorgs: readonly TReorg[];
 };
 /** @deprecated Use {@link ConsumerBatchContext} — the Index and Streams loops
 *  share one shape now. Kept as an alias so existing annotations compile. */
@@ -721,20 +802,20 @@ type StreamsBatchContext = ConsumerBatchContext;
 * inside the same transaction as your rollback so the two commit atomically.
 */
 type StreamsReorgContext = {
-	cursor: string
+	cursor: string;
 };
 type StreamsEventsConsumeParams<
 	TTx = never,
 	D extends boolean = false,
 	F extends StreamsFilterMap = Record<never, never>
 > = {
-	fromCursor?: string | null
+	fromCursor?: string | null;
 	/**
 	* Deliver events pre-decoded as the flat, `event_type`-discriminated rows
 	* Index serves (`IndexEvent`), so Streams consumption reads identically
 	* to Index consumption — no guard+decode pairs in your handler.
 	*/
-	decoded?: D
+	decoded?: D;
 	/**
 	* Destination adapter that owns the checkpoint + rollback transaction
 	* (e.g. `kyselySink` from `@secondlayer/sdk/sinks/kysely`). With a sink:
@@ -743,29 +824,29 @@ type StreamsEventsConsumeParams<
 	* transaction), reorg rollback is automatic, and `onBatch`'s return value
 	* is ignored.
 	*/
-	sink?: ConsumerSink<TTx>
+	sink?: ConsumerSink<TTx>;
 	/** Fires once per page, before `onBatch` and before any early return. */
-	onProgress?: (ctx: ConsumerBatchContext) => void
-	mode?: "tail" | "bounded"
+	onProgress?: (ctx: ConsumerBatchContext) => void;
+	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[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	finalizedOnly?: boolean;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/**
 	* Labelled filter groups. The groups OR together in ONE server-side scan,
 	* so two unrelated concerns share one page, one cursor, and one checkpoint
 	* instead of two consume loops. Pair with `on` to handle each label.
 	*/
-	filters?: F
+	filters?: F;
 	/**
 	* One handler per label in `filters`. Every label must be handled, so
 	* adding a label is a compile error until its handler exists.
@@ -776,8 +857,8 @@ type StreamsEventsConsumeParams<
 	* labels do not interleave within a page — add `onBatch` when you need
 	* strict global order across labels.
 	*/
-	on?: { [K in keyof F] : (events: StreamsEventForFilter<F[K], D>[], ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | Promise<void> }
-	batchSize?: number
+	on?: { [K in keyof F] : (events: StreamsEventForFilter<F[K], D>[], ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | Promise<void> };
+	batchSize?: number;
 	/**
 	* Apply a page of canonical events. Persist `ctx.cursor` in the same
 	* transaction as your writes. Returning a cursor overrides `ctx.cursor` as
@@ -786,7 +867,7 @@ type StreamsEventsConsumeParams<
 	* Optional only when `on` handles the page instead; a consume call with
 	* neither throws.
 	*/
-	onBatch?: (events: D extends true ? IndexEvent[] : StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
+	onBatch?: (events: D extends true ? IndexEvent[] : StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext & WithSinkTx<TTx>) => 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
@@ -794,127 +875,137 @@ type StreamsEventsConsumeParams<
 	* 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
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void;
 	/** Page-fetch retries after the first failure (429/5xx/network only —
 	*  4xx and handler throws always propagate). Default 3; `0` disables. */
-	retryCount?: number
+	retryCount?: number;
 	/** Base retry delay in ms; the n-th retry waits `retryDelay * n`. A server
 	*  `Retry-After` overrides it. Default 1000. */
-	retryDelay?: number
+	retryDelay?: number;
 	/** Void observer, called before each retry sleep (metrics/logging). */
 	onError?: (err: unknown, ctx: {
-		attempt: number
-		retriesLeft: number
-		delayMs: number
-	}) => void
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+		attempt: number;
+		retriesLeft: number;
+		delayMs: number;
+	}) => void;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 };
 /**
 * One yielded page from {@link StreamsClient.consume} — the
 * `GET /v1/streams/events` envelope verbatim, with `next_cursor` renamed to
 * `cursor` (the checkpoint to persist and resume from).
 */
-type StreamsBatch = {
+type StreamsBatch<TEvent = StreamsEvent> = {
 	/** Canonical events of this page, in cursor order. */
-	events: StreamsEvent[]
+	events: TEvent[];
 	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
-	cursor: string | null
-	tip: StreamsTip
+	cursor: string | null;
+	tip: StreamsTip;
 	/** Chain reorgs reported alongside this page; empty when none. */
-	reorgs: StreamsReorg[]
+	reorgs: StreamsReorg[];
 };
 type StreamsConsumeParams = {
 	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
-	cursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	cursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
+	/** Labelled OR-groups — same semantics as `events.consume`; each returned
+	*  event echoes the labels it matched. */
+	filters?: StreamsFilterMap;
 	/** Events per page (the `limit` query param). Default 100. */
-	batchSize?: number
+	batchSize?: number;
 	/** Poll interval while caught up at the tip, in ms. Default 2000. */
-	intervalMs?: number
+	intervalMs?: number;
 	/** Abort to end the iteration. */
-	signal?: AbortSignal
+	signal?: AbortSignal;
 };
 type StreamsEventsConsumeResult = {
-	cursor: string | null
-	pages: number
-	emptyPolls: number
+	cursor: string | null;
+	pages: number;
+	emptyPolls: number;
 };
 type StreamsEventsReplayParams = {
 	/** Start point: `"genesis"` (default) or a `<block>:<index>` cursor. */
-	from?: "genesis" | string
+	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
+	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
+	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
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void;
+	mode?: "tail" | "bounded";
+	batchSize?: number;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
+	/** Narrow the LIVE TAIL after the dump phase. The dump files themselves are
+	*  always all-type (block-partitioned parquet) — filter those in your own
+	*  tooling while processing each file. */
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	/** Labelled OR-groups for the live tail, like `consume`. */
+	filters?: StreamsFilterMap;
 };
 type FetchLike2 = (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
+	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
+	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
+	latest_finalized_cursor: string | null;
 	coverage: {
-		from_block: number
-		to_block: number
-	}
-	files: StreamsDumpFile[]
+		from_block: number;
+		to_block: number;
+	};
+	files: StreamsDumpFile[];
 	/** ed25519 signature over the manifest's canonical bytes. Absent on legacy
 	*  unsigned manifests. Verified by `list()` when `verifyDumpsManifest` is on. */
-	signature?: string
+	signature?: string;
 	/** Short id of the signing public key. */
-	key_id?: string
+	key_id?: string;
 };
 type StreamsDumps = {
 	/** Fetch and parse the latest dumps manifest. */
-	list(): Promise<StreamsDumpsManifest>
+	list(): Promise<StreamsDumpsManifest>;
 	/** Absolute URL for a manifest file. */
-	fileUrl(file: StreamsDumpFile): string
+	fileUrl(file: StreamsDumpFile): string;
 	/** Download a parquet file and verify its sha256 against the manifest. */
-	download(file: StreamsDumpFile): Promise<Uint8Array>
+	download(file: StreamsDumpFile): Promise<Uint8Array>;
 };
 type StreamsClient = {
 	/**
@@ -931,10 +1022,19 @@ type StreamsClient = {
 	* rewound automatically — use `events.consume` with `onReorg` for managed
 	* rollback semantics.
 	*/
-	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>
+	/** Narrowing overload: a literal `types` array narrows every batch's
+	*  event union to exactly those members. */
+	consume<const T extends readonly StreamsEventType[]>(params: StreamsConsumeParams & {
+		types: T;
+	}): AsyncIterableIterator<StreamsBatch<StreamsEventOfTypes<T>>>;
+	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>;
 	events: {
-		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
-		byTxId(txId: string): Promise<StreamsEventsListEnvelope>
+		/** Narrowing overload, matching `consume`. */
+		list<const T extends readonly StreamsEventType[]>(params: StreamsEventsListParams & {
+			types: T;
+		}): Promise<StreamsEventsEnvelope<StreamsEventOfTypes<T>>>;
+		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>;
+		byTxId(txId: string): Promise<StreamsEventsListEnvelope>;
 		/**
 		* Pull pages from Streams and call `onBatch` after each page.
 		*
@@ -949,8 +1049,8 @@ type StreamsClient = {
 			TTx = never,
 			D extends boolean = false
 		>(params: StreamsEventsConsumeParams<TTx, D, F> & {
-			sink?: ConsumerSink<TTx>
-		}): Promise<StreamsEventsConsumeResult>
+			sink?: ConsumerSink<TTx>;
+		}): 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
@@ -958,7 +1058,7 @@ type StreamsClient = {
 		* (exclusive input → no gap or duplicate at the seam). Requires
 		* `dumpsBaseUrl`.
 		*/
-		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>
+		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>;
 		/**
 		* Follow Streams as an async iterator.
 		*
@@ -966,39 +1066,43 @@ type StreamsClient = {
 		* indefinitely by default and stops when its `AbortSignal`, `maxPages`, or
 		* `maxEmptyPolls` stops it.
 		*/
-		stream(params?: StreamsEventsStreamParams): AsyncIterable<StreamsEvent>
+		/** Narrowing overload, matching `consume`. */
+		stream<const T extends readonly StreamsEventType[]>(params: StreamsEventsStreamParams & {
+			types: T;
+		}): AsyncIterable<StreamsEventOfTypes<T>>;
+		stream(params?: StreamsEventsStreamParams): AsyncIterable<StreamsEvent>;
 		/**
 		* Subscribe to the real-time SSE push surface. Calls `onEvent` for each new
 		* canonical event as the server pushes it (chain cadence, not poll-bounded),
 		* and verifies each frame's inline ed25519 signature when the client was
 		* created with `verify`. Returns an unsubscribe function.
 		*/
-		subscribe(params: StreamsEventsSubscribeParams): () => void
-	}
+		subscribe(params: StreamsEventsSubscribeParams): () => void;
+	};
 	blocks: {
-		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>
-	}
+		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>;
+	};
 	reorgs: {
-		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>
-	}
+		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>;
+	};
 	/** Bulk parquet dumps. Requires `dumpsBaseUrl` on the client. */
-	dumps: StreamsDumps
-	canonical(height: number): Promise<StreamsCanonicalBlock>
-	tip(): Promise<StreamsTip>
+	dumps: StreamsDumps;
+	canonical(height: number): Promise<StreamsCanonicalBlock>;
+	tip(): Promise<StreamsTip>;
 	/** Your own Streams consumption (events today + this month) and tier limits. */
-	usage(): Promise<StreamsUsage>
+	usage(): Promise<StreamsUsage>;
 };
 type StreamsUsage = {
-	product: "streams"
-	tier: string
+	product: "streams";
+	tier: string;
 	limits: {
-		rate_limit_per_second: number | null
-		retention_days: number | null
-	}
+		rate_limit_per_second: number | null;
+		retention_days: number | null;
+	};
 	usage: {
-		events_today: number
-		events_this_month: number
-	}
+		events_today: number;
+		events_this_month: number;
+	};
 };
 type Sleep = (ms: number, signal?: AbortSignal) => Promise<void>;
 /** Options shared by both consume loops' page-fetch retry. Vocabulary matches
@@ -1006,36 +1110,36 @@ type Sleep = (ms: number, signal?: AbortSignal) => Promise<void>;
 *  language across the family, not a third. */
 type PageRetryOptions = {
 	/** Retries after the first failure. Default 3; `0` disables. */
-	retryCount?: number
+	retryCount?: number;
 	/** Base delay in ms; the n-th retry waits `retryDelay * n` (matches the
 	*  stacks transport). A server `Retry-After` overrides it. Default 1000. */
-	retryDelay?: number
+	retryDelay?: number;
 	/** Void observer, called before each retry sleep (metrics/logging). The
 	*  retry policy owns the decision; this cannot change it. */
 	onError?: (err: unknown, ctx: {
-		attempt: number
-		retriesLeft: number
-		delayMs: number
-	}) => void
+		attempt: number;
+		retriesLeft: number;
+		delayMs: number;
+	}) => void;
 };
 /** Minimum shape a consumed Index row must expose. */
 type IndexFeedItem = {
-	cursor: string
-	block_height: number
+	cursor: string;
+	block_height: number;
 };
 /** Minimum envelope shape of a consumable Index feed page. */
 type IndexFeedEnvelope = {
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** One page fetch. `fromHeight` is only set on the first page of a fresh
 *  consume (no cursor yet) — cursor and from_height are mutually exclusive
 *  on the API. */
 type IndexFeedFetcher<TEnvelope extends IndexFeedEnvelope> = (params: {
-	cursor: string | null
-	fromHeight?: number
-	limit: number
+	cursor: string | null;
+	fromHeight?: number;
+	limit: number;
 }) => Promise<TEnvelope>;
 /** Consumer options shared by `index.events.consume` and
 *  `index.contractCalls.consume`. Same contract as the Streams consumer:
@@ -1048,18 +1152,18 @@ type IndexConsumeOptions<
 > = {
 	/** Resume from a committed checkpoint. Without it (and without
 	*  `fromHeight`) the API serves only the recent default window. */
-	fromCursor?: string | null
+	fromCursor?: string | null;
 	/** Start a fresh sweep at this height (e.g. `0` for genesis backfill).
 	*  Ignored once a cursor exists (including a sink's committed cursor). */
-	fromHeight?: number
+	fromHeight?: number;
 	/** `tail` (default) keeps polling at the tip; `bounded` returns on the
 	*  first empty page. */
-	mode?: "tail" | "bounded"
+	mode?: "tail" | "bounded";
 	/** Emit only rows at or below the tip's `finalized_height`; the
 	*  unfinalized tail is re-read each poll until it settles. Finalized data
 	*  never reorgs, so `onReorg` is skipped entirely. */
-	finalizedOnly?: boolean
-	batchSize?: number
+	finalizedOnly?: boolean;
+	batchSize?: number;
 	/**
 	* Destination adapter that owns the checkpoint + rollback transaction
 	* (e.g. `kyselySink` from `@secondlayer/sdk/sinks/kysely`). With a sink:
@@ -1068,29 +1172,29 @@ type IndexConsumeOptions<
 	* transaction — a throw aborts both), reorg rollback is automatic (no
 	* `onReorg` needed), and `onBatch`'s return value is ignored.
 	*/
-	sink?: ConsumerSink<TTx>
+	sink?: ConsumerSink<TTx>;
 	/** Fires once per page, before `onBatch` and before any early return —
 	*  an empty page still proves the loop is alive. Feed it to
 	*  `consumerHealth().record`. */
-	onProgress?: (ctx: ConsumerBatchContext) => void
-	onBatch: (items: TItem[], envelope: TEnvelope, ctx: ConsumerBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
+	onProgress?: (ctx: ConsumerBatchContext) => void;
+	onBatch: (items: TItem[], envelope: TEnvelope, ctx: ConsumerBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>;
 	onReorg?: (reorg: IndexReorg, ctx: {
-		cursor: string
-	}) => Promise<void> | void
-	sleep?: Sleep
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+		cursor: string;
+	}) => Promise<void> | void;
+	sleep?: Sleep;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 	/** Page-fetch retries after the first failure (429/5xx/network only —
 	*  4xx and handler throws always propagate). Default 3; `0` disables. */
-	retryCount?: number
+	retryCount?: number;
 	/** Base retry delay in ms; the n-th retry waits `retryDelay * n`. A server
 	*  `Retry-After` overrides it. Default 1000. */
-	retryDelay?: number
+	retryDelay?: number;
 	/** Void observer, called before each retry sleep. Cannot change the retry
 	*  decision — the policy owns it. */
-	onError?: PageRetryOptions["onError"]
+	onError?: PageRetryOptions["onError"];
 };
 /**
 * Checkpointed pull loop over a cursor-paginated Index feed — the Index port
@@ -1107,21 +1211,21 @@ declare function consumeIndexFeed<
 	TEnvelope extends IndexFeedEnvelope,
 	TTx = never
 >(opts: IndexConsumeOptions<TItem, TEnvelope, TTx> & {
-	fetchPage: IndexFeedFetcher<TEnvelope>
-	itemsOf: (envelope: TEnvelope) => TItem[]
+	fetchPage: IndexFeedFetcher<TEnvelope>;
+	itemsOf: (envelope: TEnvelope) => TItem[];
 }): Promise<{
-	cursor: string | null
-	pages: number
-	emptyPolls: number
+	cursor: string | null;
+	pages: number;
+	emptyPolls: number;
 }>;
 import { SbtcEventTopic as SbtcEventTopic2 } from "@secondlayer/stacks/sbtc";
 type IndexTip = {
-	block_height: number
+	block_height: number;
 	/** Highest height treated as immutable (past the burn-confirmation
 	*  finality boundary). Rows at or below it never reorg — `finalizedOnly`
 	*  consumers gate on this, since Index rows carry no per-event flag. */
-	finalized_height: number
-	lag_seconds: number
+	finalized_height: number;
+	lag_seconds: number;
 };
 /**
 * A chain reorg overlapping a returned page's height range. Height-keyed feeds
@@ -1134,54 +1238,54 @@ type IndexTip = {
 * inclusive. Empty when the page spans no reorg.
 */
 type IndexReorg = {
-	id: string
-	detected_at: string
-	fork_point_height: number
-	old_index_block_hash: string | null
-	new_index_block_hash: string | null
+	id: string;
+	detected_at: string;
+	fork_point_height: number;
+	old_index_block_hash: string | null;
+	new_index_block_hash: string | null;
 	/** Orphaned cursor span `<block_height>:<tx_index>`, inclusive. */
 	orphaned_range: {
-		from: string
-		to: string
-	}
+		from: string;
+		to: string;
+	};
 	/**
 	* First position of the new canonical chain at the fork, `fork:0`
 	* (INCLUSIVE). Not an exclusive resume token — resuming a `(bh,ei) > cursor`
 	* read directly from it would skip `fork:0`. To re-read the new run, rewind
 	* to the foot of `fork_point_height` (`Cursor.atHeight`), not to this value.
 	*/
-	new_canonical_tip: string
+	new_canonical_tip: string;
 };
 type IndexUsage = {
-	product: "index"
-	tier: string
+	product: "index";
+	tier: string;
 	limits: {
-		rate_limit_per_second: number | null
-	}
+		rate_limit_per_second: number | null;
+	};
 	usage: {
-		decoded_events_today: number
-		decoded_events_this_month: number
-	}
+		decoded_events_today: number;
+		decoded_events_this_month: number;
+	};
 };
 type FtTransfer = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_transfer"
-	contract_id: string
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_transfer";
+	contract_id: string;
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type FtTransfersEnvelope<TRow = FtTransfer> = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** Transfer columns that survive any projection — the consume contract
 *  (`cursor`, `block_height`) plus the `event_type` discriminant. */
@@ -1195,40 +1299,40 @@ type FtTransfersListParams = {
 	* one a compile error rather than `undefined` at runtime. Omitting
 	* `block_time` also lets the server skip the blocks join.
 	*/
-	fields?: readonly (keyof FtTransfer & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	contractId?: string
-	assetIdentifier?: string
-	sender?: string
-	recipient?: string
-	fromHeight?: number
-	toHeight?: number
+	fields?: readonly (keyof FtTransfer & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	contractId?: string;
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type FtTransfersWalkParams = Omit<FtTransfersListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type NftTransfer = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_transfer"
-	contract_id: string
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: string
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_transfer";
+	contract_id: string;
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: string;
 };
 type NftTransfersEnvelope<TRow = NftTransfer> = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** See {@link FtTransferAlwaysFields}. */
 type NftTransferAlwaysFields = "cursor" | "block_height" | "event_type";
@@ -1236,110 +1340,110 @@ type NftTransferAlwaysFields = "cursor" | "block_height" | "event_type";
 type NftTransferFields<F extends keyof NftTransfer & string> = Pick<NftTransfer, (F | NftTransferAlwaysFields) & keyof NftTransfer>;
 type NftTransfersListParams = {
 	/** Columns to return (see {@link FtTransfersListParams.fields}). */
-	fields?: readonly (keyof NftTransfer & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	contractId?: string
-	assetIdentifier?: string
-	sender?: string
-	recipient?: string
-	fromHeight?: number
-	toHeight?: number
+	fields?: readonly (keyof NftTransfer & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	contractId?: string;
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type NftTransfersWalkParams = Omit<NftTransfersListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type IndexEventBase = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	contract_id: string | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	contract_id: string | null;
 	/** Submitting-transaction context, present only when `txContext: true` was
 	*  requested. `tx_sender` is the real tx sender — distinct from a transfer's
 	*  asset `sender`, and the only place a `print` event's sender is available.
 	*  Lets a consumer build per-event tx context without a `/v1/index/transactions`
 	*  call per event. */
-	tx_sender?: string | null
-	tx_type?: string | null
-	tx_status?: string | null
-	tx_contract_id?: string | null
-	tx_function_name?: string | null
+	tx_sender?: string | null;
+	tx_type?: string | null;
+	tx_status?: string | null;
+	tx_contract_id?: string | null;
+	tx_function_name?: string | null;
 };
 type IndexFtTransfer = IndexEventBase & {
-	event_type: "ft_transfer"
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	event_type: "ft_transfer";
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type IndexNftTransfer = IndexEventBase & {
-	event_type: "nft_transfer"
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: string
+	event_type: "nft_transfer";
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: string;
 };
 type IndexStxTransfer = IndexEventBase & {
-	event_type: "stx_transfer"
-	sender: string
-	recipient: string
-	amount: string
-	memo: string | null
+	event_type: "stx_transfer";
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo: string | null;
 };
 type IndexStxMint = IndexEventBase & {
-	event_type: "stx_mint"
-	recipient: string
-	amount: string
+	event_type: "stx_mint";
+	recipient: string;
+	amount: string;
 };
 type IndexStxBurn = IndexEventBase & {
-	event_type: "stx_burn"
-	sender: string
-	amount: string
+	event_type: "stx_burn";
+	sender: string;
+	amount: string;
 };
 type IndexStxLock = IndexEventBase & {
-	event_type: "stx_lock"
-	sender: string
-	amount: string
+	event_type: "stx_lock";
+	sender: string;
+	amount: string;
 	payload: {
-		unlock_height: string | null
-	}
+		unlock_height: string | null;
+	};
 };
 type IndexFtMint = IndexEventBase & {
-	event_type: "ft_mint"
-	asset_identifier: string
-	recipient: string
-	amount: string
+	event_type: "ft_mint";
+	asset_identifier: string;
+	recipient: string;
+	amount: string;
 };
 type IndexFtBurn = IndexEventBase & {
-	event_type: "ft_burn"
-	asset_identifier: string
-	sender: string
-	amount: string
+	event_type: "ft_burn";
+	asset_identifier: string;
+	sender: string;
+	amount: string;
 };
 type IndexNftMint = IndexEventBase & {
-	event_type: "nft_mint"
-	asset_identifier: string
-	recipient: string
-	value: string
+	event_type: "nft_mint";
+	asset_identifier: string;
+	recipient: string;
+	value: string;
 };
 type IndexNftBurn = IndexEventBase & {
-	event_type: "nft_burn"
-	asset_identifier: string
-	sender: string
-	value: string
+	event_type: "nft_burn";
+	asset_identifier: string;
+	sender: string;
+	value: string;
 };
 type IndexPrint = IndexEventBase & {
-	event_type: "print"
+	event_type: "print";
 	payload: {
-		topic: string | null
-		value: unknown
-		raw_value: string | null
-	}
+		topic: string | null;
+		value: unknown;
+		raw_value: string | null;
+	};
 };
 /** Decoded chain event, discriminated by `event_type`. */
 type IndexEvent = IndexFtTransfer | IndexNftTransfer | IndexStxTransfer | IndexStxMint | IndexStxBurn | IndexStxLock | IndexFtMint | IndexFtBurn | IndexNftMint | IndexNftBurn | IndexPrint;
@@ -1356,39 +1460,39 @@ type EventsEnvelope<
 	T extends IndexEventType = IndexEventType,
 	TRow = IndexEventOf<T>
 > = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** The single decoded-event member matching one `event_type` literal.
 *  `IndexEventOf<"ft_transfer">` is `IndexFtTransfer`. */
 type IndexEventOf<T extends IndexEventType> = Extract<IndexEvent, {
-	event_type: T
+	event_type: T;
 }>;
 type EventsListParams<T extends IndexEventType = IndexEventType> = {
 	/** Required. One of the decoded event types. Passing a literal narrows the
 	*  rows every surface hands back to that event's own shape. */
-	eventType: T
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	eventType: T;
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** One id, or several to scope the sweep to a set of contracts (max 20).
 	*  Mutually exclusive with `trait`. */
-	contractId?: string | readonly string[]
-	assetIdentifier?: string
-	sender?: string
-	recipient?: string
-	fromHeight?: number
-	toHeight?: number
+	contractId?: string | readonly string[];
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+	fromHeight?: number;
+	toHeight?: number;
 	/** Restrict to contracts conforming to a trait/standard (e.g. "sip-010").
 	*  Mutually exclusive with contractId; contract-keyed event types only. */
-	trait?: string
+	trait?: string;
 	/** Join the submitting transaction into each event — populates `tx_sender`,
 	*  `tx_type`, `tx_status`, `tx_contract_id`, `tx_function_name`. Off by default.
 	*  Avoids a `/v1/index/transactions` call per event; for `print` events it's
 	*  the only source of the submitting sender. */
-	txContext?: boolean
+	txContext?: boolean;
 	/**
 	* Return only these columns. The server projects the SELECT, so an
 	* unrequested field is physically absent — and the returned row type
@@ -1403,188 +1507,188 @@ type EventsListParams<T extends IndexEventType = IndexEventType> = {
 	* not per field. What it buys is wire bytes, plus skipping the `blocks`
 	* join when `block_time` is omitted.
 	*/
-	fields?: readonly (keyof IndexEventOf<T> & string)[]
+	fields?: readonly (keyof IndexEventOf<T> & string)[];
 };
 type EventsWalkParams<T extends IndexEventType = IndexEventType> = Omit<EventsListParams<T>, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type EventsConsumeParams<
 	T extends IndexEventType = IndexEventType,
 	TTx = never
 > = Omit<EventsListParams<T>, "cursor" | "fromCursor" | "limit" | "fields"> & IndexConsumeOptions<IndexEventOf<T>, EventsEnvelope<T>, TTx>;
 type IndexContractCall = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	contract_id: string
-	function_name: string
-	sender: string
-	status: string
-	args: unknown[]
-	result: unknown
-	result_hex: string | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	contract_id: string;
+	function_name: string;
+	sender: string;
+	status: string;
+	args: unknown[];
+	result: unknown;
+	result_hex: string | null;
 };
 type ContractCallsEnvelope = {
-	contract_calls: IndexContractCall[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	contract_calls: IndexContractCall[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 type ContractCallsListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** One id, or several to scope the sweep to a set of contracts (max 20).
 	*  Mutually exclusive with `trait`. */
-	contractId?: string | readonly string[]
-	functionName?: string
-	sender?: string
-	fromHeight?: number
-	toHeight?: number
+	contractId?: string | readonly string[];
+	functionName?: string;
+	sender?: string;
+	fromHeight?: number;
+	toHeight?: number;
 	/** Restrict to contracts conforming to a trait/standard (e.g. "sip-010").
 	*  Mutually exclusive with contractId. */
-	trait?: string
+	trait?: string;
 };
 type ContractCallsWalkParams = Omit<ContractCallsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type ContractCallsConsumeParams<TTx = never> = Omit<ContractCallsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexContractCall, ContractCallsEnvelope, TTx>;
 /** One canonical block in the sync map. Lean by design — block + parent hash
 *  for chain linkage, burn anchor for Bitcoin confirmations. Use `blocks` for
 *  the full block resource. */
 type IndexCanonicalBlock = {
-	cursor: string
-	block_height: number
-	block_hash: string
-	parent_hash: string
-	burn_block_height: number
-	burn_block_hash: string | null
+	cursor: string;
+	block_height: number;
+	block_hash: string;
+	parent_hash: string;
+	burn_block_height: number;
+	burn_block_hash: string | null;
 };
 type CanonicalEnvelope = {
-	canonical: IndexCanonicalBlock[]
-	next_cursor: string | null
-	tip: IndexTip
+	canonical: IndexCanonicalBlock[];
+	next_cursor: string | null;
+	tip: IndexTip;
 };
 type CanonicalListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type CanonicalWalkParams = Omit<CanonicalListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** A block resource. Metadata is intentionally thin — only chain-linkage and
 *  burn-anchor fields are persisted (no miner / tx_count / signer). */
 type IndexBlock = {
-	cursor: string
-	block_height: number
-	block_hash: string
-	parent_hash: string
-	burn_block_height: number
-	burn_block_hash: string | null
-	block_time: string | null
-	canonical: boolean
+	cursor: string;
+	block_height: number;
+	block_hash: string;
+	parent_hash: string;
+	burn_block_height: number;
+	burn_block_hash: string | null;
+	block_time: string | null;
+	canonical: boolean;
 };
 type BlocksEnvelope = {
-	blocks: IndexBlock[]
-	next_cursor: string | null
-	tip: IndexTip
+	blocks: IndexBlock[];
+	next_cursor: string | null;
+	tip: IndexTip;
 };
 type BlockEnvelope = {
-	block: IndexBlock
-	tip: IndexTip
+	block: IndexBlock;
+	tip: IndexTip;
 };
 type BlocksListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type BlocksWalkParams = Omit<BlocksListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type IndexPostCondition = {
-	type: "stx"
-	principal: string
-	condition_code: number
-	condition_code_name: string | null
-	amount: string
+	type: "stx";
+	principal: string;
+	condition_code: number;
+	condition_code_name: string | null;
+	amount: string;
 } | {
-	type: "ft"
-	principal: string
-	asset_identifier: string
-	condition_code: number
-	condition_code_name: string | null
-	amount: string
+	type: "ft";
+	principal: string;
+	asset_identifier: string;
+	condition_code: number;
+	condition_code_name: string | null;
+	amount: string;
 } | {
-	type: "nft"
-	principal: string
-	asset_identifier: string
-	asset_value: unknown
-	condition_code: number
-	condition_code_name: string | null
+	type: "nft";
+	principal: string;
+	asset_identifier: string;
+	asset_value: unknown;
+	condition_code: number;
+	condition_code_name: string | null;
 };
 /** Full transaction document: columnar fields plus `raw_tx`-decoded enrichment.
 *  Payload sub-objects are present only for the matching `tx_type`; enrichment
 *  fields are null when `raw_tx` isn't decodable (e.g. burnchain ops). */
 type IndexTransaction = {
-	cursor: string
-	tx_id: string
-	block_height: number
-	block_time?: string | null
-	tx_index: number
-	tx_type: string
-	sender: string
-	status: string
-	fee: string | null
-	nonce: string | null
-	sponsored: boolean | null
-	anchor_mode: string | null
-	post_condition_mode: string | null
-	post_conditions: IndexPostCondition[]
+	cursor: string;
+	tx_id: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_index: number;
+	tx_type: string;
+	sender: string;
+	status: string;
+	fee: string | null;
+	nonce: string | null;
+	sponsored: boolean | null;
+	anchor_mode: string | null;
+	post_condition_mode: string | null;
+	post_conditions: IndexPostCondition[];
 	contract_call?: {
-		contract_id: string
-		function_name: string
-		function_args: unknown[]
+		contract_id: string;
+		function_name: string;
+		function_args: unknown[];
 		/** Raw hex-encoded ClarityValues; decode(function_args_hex[i]) === function_args[i]. */
-		function_args_hex: string[]
-		result: unknown
-		result_hex: string | null
-	}
+		function_args_hex: string[];
+		result: unknown;
+		result_hex: string | null;
+	};
 	token_transfer?: {
-		recipient: string
-		amount: string
-		memo: string
-	}
+		recipient: string;
+		amount: string;
+		memo: string;
+	};
 	smart_contract?: {
-		contract_id: string | null
-		clarity_version: number | null
-	}
+		contract_id: string | null;
+		clarity_version: number | null;
+	};
 	coinbase?: {
-		alt_recipient: string | null
-	}
+		alt_recipient: string | null;
+	};
 	tenure_change?: {
-		cause: number
-	}
+		cause: number;
+	};
 };
 type TransactionsEnvelope<TRow = IndexTransaction> = {
-	transactions: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	transactions: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 type TransactionEnvelope = {
-	transaction: IndexTransaction
-	tip: IndexTip
+	transaction: IndexTransaction;
+	tip: IndexTip;
 };
 /** Transaction columns that survive any projection. */
 type TransactionAlwaysFields = "cursor" | "block_height" | "tx_id";
@@ -1596,123 +1700,123 @@ type TransactionsListParams = {
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexTransaction & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	type?: string
-	sender?: string
-	contractId?: string
-	fromHeight?: number
-	toHeight?: number
+	fields?: readonly (keyof IndexTransaction & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	type?: string;
+	sender?: string;
+	contractId?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type TransactionsWalkParams = Omit<TransactionsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** A decoded PoX-4 stacking action (one per stacking contract call). */
 type IndexStackingAction = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	burn_block_height: number
-	tx_id: string
-	tx_index: number
-	function_name: string
-	caller: string
-	stacker: string | null
-	delegate_to: string | null
-	amount_ustx: string | null
-	lock_period: number | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	burn_block_height: number;
+	tx_id: string;
+	tx_index: number;
+	function_name: string;
+	caller: string;
+	stacker: string | null;
+	delegate_to: string | null;
+	amount_ustx: string | null;
+	lock_period: number | null;
 	pox_addr: {
-		version: number | null
-		hashbytes: string | null
-		btc: string | null
-	}
-	start_cycle: number | null
-	end_cycle: number | null
-	reward_cycle: number | null
-	signer_key: string | null
-	result_ok: boolean
+		version: number | null;
+		hashbytes: string | null;
+		btc: string | null;
+	};
+	start_cycle: number | null;
+	end_cycle: number | null;
+	reward_cycle: number | null;
+	signer_key: string | null;
+	result_ok: boolean;
 };
 type StackingEnvelope = {
-	stacking: IndexStackingAction[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	stacking: IndexStackingAction[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 	/** Present only when the PoX-4 decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 type StackingListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	functionName?: string
-	stacker?: string
-	caller?: string
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	functionName?: string;
+	stacker?: string;
+	caller?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type StackingWalkParams = Omit<StackingListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** A pending (unconfirmed) transaction. Like a transaction document but
 *  pre-chain — no block_height/tx_index/result/events — with `received_at` and
 *  a sequence cursor instead of a block position. */
 type IndexMempoolTransaction = {
-	cursor: string
-	tx_id: string
-	tx_type: string
-	sender: string
-	received_at?: string | null
-	fee: string | null
-	nonce: string | null
-	sponsored: boolean | null
-	anchor_mode: string | null
-	post_condition_mode: string | null
-	post_conditions: IndexPostCondition[]
+	cursor: string;
+	tx_id: string;
+	tx_type: string;
+	sender: string;
+	received_at?: string | null;
+	fee: string | null;
+	nonce: string | null;
+	sponsored: boolean | null;
+	anchor_mode: string | null;
+	post_condition_mode: string | null;
+	post_conditions: IndexPostCondition[];
 	contract_call?: {
-		contract_id: string
-		function_name: string
-		function_args: unknown[]
-	}
+		contract_id: string;
+		function_name: string;
+		function_args: unknown[];
+	};
 	token_transfer?: {
-		recipient: string
-		amount: string
-		memo: string
-	}
+		recipient: string;
+		amount: string;
+		memo: string;
+	};
 	smart_contract?: {
-		clarity_version: number | null
-	}
+		clarity_version: number | null;
+	};
 	coinbase?: {
-		alt_recipient: string | null
-	}
+		alt_recipient: string | null;
+	};
 	tenure_change?: {
-		cause: number
-	}
+		cause: number;
+	};
 };
 type MempoolEnvelope = {
-	mempool: IndexMempoolTransaction[]
-	next_cursor: string | null
-	tip: IndexTip
+	mempool: IndexMempoolTransaction[];
+	next_cursor: string | null;
+	tip: IndexTip;
 };
 type MempoolTransactionEnvelope = {
-	transaction: IndexMempoolTransaction
-	tip: IndexTip
+	transaction: IndexMempoolTransaction;
+	tip: IndexTip;
 };
 type MempoolListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	sender?: string
-	type?: string
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	sender?: string;
+	type?: string;
 	/** Filter to pending calls to a single contract (e.g. `SP….contract`). */
-	contractId?: string
+	contractId?: string;
 };
 type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /**
 * Empirical per-topic print payload schema for a contract, inferred from
@@ -1720,194 +1824,194 @@ type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
 * when the contract has more print events than the windows examined.
 */
 type PrintSchemaResponse = {
-	contract_id: string
-	topics: InferredTopicSchema[]
-	sampled: boolean
-	total_events: number
+	contract_id: string;
+	topics: InferredTopicSchema[];
+	sampled: boolean;
+	total_events: number;
 	/** True when the count hit the server-side cap (total_events is the cap). */
-	total_events_capped: boolean
+	total_events_capped: boolean;
 	sample: {
-		size: number
-		newest_height: number | null
-		oldest_height: number | null
-	}
-	tip: IndexTip
+		size: number;
+		newest_height: number | null;
+		oldest_height: number | null;
+	};
+	tip: IndexTip;
 };
 type SbtcWithdrawalStatus = "REQUESTED" | "ACCEPTED" | "REJECTED";
 /** A completed sBTC peg-in, keyed by `bitcoin_txid` (deposits carry no
 *  `request_id`). One terminal `completed-deposit` event per deposit. */
 type IndexSbtcDeposit = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	amount: string | null
-	sender: string | null
-	bitcoin_txid: string | null
-	output_index: number | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	amount: string | null;
+	sender: string | null;
+	bitcoin_txid: string | null;
+	output_index: number | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
 };
 /** A deposit fetched by Bitcoin txid — always terminal, hence `status`. */
 type IndexSbtcDepositDetail = IndexSbtcDeposit & {
-	status: "COMPLETED"
+	status: "COMPLETED";
 };
 /** A peg-out collapsed to one row per `request_id`, with lifecycle `status`
 *  derived from the latest accept/reject. */
 type IndexSbtcWithdrawal = {
-	cursor: string
-	request_id: number
-	status: SbtcWithdrawalStatus
-	amount: string | null
-	sender: string | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
-	sweep_txid: string | null
+	cursor: string;
+	request_id: number;
+	status: SbtcWithdrawalStatus;
+	amount: string | null;
+	sender: string | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
+	sweep_txid: string | null;
 	/** BTC L1 settlement of the committed sweep: true once confirmed, false while
 	*  pending, null when there is no sweep yet (REQUESTED). */
-	settlement_confirmed: boolean | null
+	settlement_confirmed: boolean | null;
 	/** BTC confirmations on the sweep tx, null when no settlement row yet. */
-	btc_confirmations: number | null
+	btc_confirmations: number | null;
 	/** Confirming BTC block height, null while unconfirmed / no sweep. */
-	btc_block_height: number | null
+	btc_block_height: number | null;
 	/** When the sweep crossed the confirmation threshold (ISO), null otherwise. */
-	confirmed_at: string | null
-	requested_at?: string | null
-	resolved_at?: string | null
+	confirmed_at: string | null;
+	requested_at?: string | null;
+	resolved_at?: string | null;
 };
 /** One phase of a withdrawal's lifecycle (the on-Stacks event that drove it). */
 type IndexSbtcWithdrawalPhase = {
-	block_height: number
-	block_time: string | null
-	tx_id: string
+	block_height: number;
+	block_time: string | null;
+	tx_id: string;
 };
 /** A single peg-out's full assembled lifecycle, fetched by `request_id`.
 *  `finalized` is true once terminal and past the reorg margin. */
 type IndexSbtcWithdrawalDetail = {
-	request_id: number
-	status: SbtcWithdrawalStatus
-	amount: string | null
-	sender: string | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
-	requested: IndexSbtcWithdrawalPhase
+	request_id: number;
+	status: SbtcWithdrawalStatus;
+	amount: string | null;
+	sender: string | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
+	requested: IndexSbtcWithdrawalPhase;
 	accepted: (IndexSbtcWithdrawalPhase & {
-		sweep_txid: string | null
-		signer_bitmap: string | null
-	}) | null
-	rejected: IndexSbtcWithdrawalPhase | null
+		sweep_txid: string | null;
+		signer_bitmap: string | null;
+	}) | null;
+	rejected: IndexSbtcWithdrawalPhase | null;
 	settlement: {
-		sweep_txid: string | null
-		btc_confirmations: number | null
-		settlement_confirmed: boolean | null
+		sweep_txid: string | null;
+		btc_confirmations: number | null;
+		settlement_confirmed: boolean | null;
 		/** Confirming Bitcoin block height; null until the sweep confirms. */
-		btc_block_height: number | null
+		btc_block_height: number | null;
 		/** ISO timestamp the sweep first crossed the confirmation threshold. */
-		confirmed_at: string | null
-	}
-	finalized: boolean
+		confirmed_at: string | null;
+	};
+	finalized: boolean;
 };
 /** A raw decoded sBTC protocol-state event — the full `sbtc_events` row, one
 *  per event across all topics. */
 type IndexSbtcEvent = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	topic: SbtcEventTopic
-	request_id: number | null
-	amount: string | null
-	sender: string | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
-	bitcoin_txid: string | null
-	output_index: number | null
-	sweep_txid: string | null
-	burn_hash: string | null
-	burn_height: number | null
-	signer_bitmap: string | null
-	max_fee: string | null
-	fee: string | null
-	governance_contract_type: number | null
-	governance_new_contract: string | null
-	signer_aggregate_pubkey: string | null
-	signer_threshold: number | null
-	signer_address: string | null
-	signer_keys_count: number | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	topic: SbtcEventTopic;
+	request_id: number | null;
+	amount: string | null;
+	sender: string | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
+	bitcoin_txid: string | null;
+	output_index: number | null;
+	sweep_txid: string | null;
+	burn_hash: string | null;
+	burn_height: number | null;
+	signer_bitmap: string | null;
+	max_fee: string | null;
+	fee: string | null;
+	governance_contract_type: number | null;
+	governance_new_contract: string | null;
+	signer_aggregate_pubkey: string | null;
+	signer_threshold: number | null;
+	signer_address: string | null;
+	signer_keys_count: number | null;
 };
 /** The peg "scoreboard" — a single all-time canonical aggregate. */
 type IndexSbtcSummary = {
-	total_deposits: number
-	total_withdrawals_requested: number
-	total_withdrawals_accepted: number
-	total_withdrawals_rejected: number
-	net_peg_flow_sats: string
-	total_locked_sats: string
-	sbtc_supply_sats: string | null
+	total_deposits: number;
+	total_withdrawals_requested: number;
+	total_withdrawals_accepted: number;
+	total_withdrawals_rejected: number;
+	net_peg_flow_sats: string;
+	total_locked_sats: string;
+	sbtc_supply_sats: string | null;
 };
 type SbtcDepositsEnvelope<TRow = IndexSbtcDeposit> = {
-	deposits: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	deposits: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 	/** Present only when the sBTC decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 type SbtcDepositEnvelope = {
-	deposit: IndexSbtcDepositDetail
-	tip: IndexTip
+	deposit: IndexSbtcDepositDetail;
+	tip: IndexTip;
 };
 type SbtcWithdrawalsEnvelope<TRow = IndexSbtcWithdrawal> = {
-	withdrawals: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-	notes?: string
+	withdrawals: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
+	notes?: string;
 };
 type SbtcWithdrawalEnvelope = {
-	withdrawal: IndexSbtcWithdrawalDetail
-	tip: IndexTip
+	withdrawal: IndexSbtcWithdrawalDetail;
+	tip: IndexTip;
 };
 type SbtcEventsEnvelope = {
-	events: IndexSbtcEvent[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-	notes?: string
+	events: IndexSbtcEvent[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
+	notes?: string;
 };
 type SbtcSummaryEnvelope = {
-	summary: IndexSbtcSummary
-	tip: IndexTip
-	notes?: string
+	summary: IndexSbtcSummary;
+	tip: IndexTip;
+	notes?: string;
 };
 type SbtcDepositsListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** Clamp to the finality boundary — only settled deposits past the reorg margin. */
-	confirmed?: boolean
-	sender?: string
-	bitcoinTxid?: string
-	fromHeight?: number
-	toHeight?: number
+	confirmed?: boolean;
+	sender?: string;
+	bitcoinTxid?: string;
+	fromHeight?: number;
+	toHeight?: number;
 	/**
 	* Columns to return. The server projects the row, so an unrequested column
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexSbtcDeposit & string)[]
+	fields?: readonly (keyof IndexSbtcDeposit & string)[];
 };
 /** Deposit columns that survive any projection — pagination needs them. */
 type SbtcDepositAlwaysFields = "cursor" | "block_height";
 /** A deposit row narrowed to the requested columns plus the always-present ones. */
 type SbtcDepositFields<F extends keyof IndexSbtcDeposit & string> = Pick<IndexSbtcDeposit, (F | SbtcDepositAlwaysFields) & keyof IndexSbtcDeposit>;
 type SbtcDepositsWalkParams = Omit<SbtcDepositsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** SbtcWithdrawal columns that survive any projection. */
 type SbtcWithdrawalAlwaysFields = "cursor" | "request_id";
@@ -1919,39 +2023,39 @@ type SbtcWithdrawalsListParams = {
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexSbtcWithdrawal & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	confirmed?: boolean
-	status?: SbtcWithdrawalStatus
-	sender?: string
-	requestId?: number
+	fields?: readonly (keyof IndexSbtcWithdrawal & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	confirmed?: boolean;
+	status?: SbtcWithdrawalStatus;
+	sender?: string;
+	requestId?: number;
 	/** Filter by BTC L1 settlement: true → only confirmed sweeps; false → not
 	*  yet confirmed (pending or no sweep). */
-	settlementConfirmed?: boolean
-	fromHeight?: number
-	toHeight?: number
+	settlementConfirmed?: boolean;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type SbtcWithdrawalsWalkParams = Omit<SbtcWithdrawalsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type SbtcEventsListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	confirmed?: boolean
-	topic?: SbtcEventTopic
-	sender?: string
-	requestId?: number
-	bitcoinTxid?: string
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	confirmed?: boolean;
+	topic?: SbtcEventTopic;
+	sender?: string;
+	requestId?: number;
+	bitcoinTxid?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type SbtcEventsWalkParams = Omit<SbtcEventsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type SbtcEventsConsumeParams<TTx = never> = Omit<SbtcEventsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexSbtcEvent, SbtcEventsEnvelope, TTx>;
 type SbtcDepositsConsumeParams<TTx = never> = Omit<SbtcDepositsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexSbtcDeposit, SbtcDepositsEnvelope, TTx>;
@@ -1962,98 +2066,98 @@ interface SbtcResource {
 		/** Narrowing overload: `fields` shrinks the row type to exactly the
 		*  requested columns plus {@link SbtcDepositAlwaysFields}. */
 		list<const F extends keyof IndexSbtcDeposit & string>(params: SbtcDepositsListParams & {
-			fields: readonly F[]
-		}): Promise<SbtcDepositsEnvelope<SbtcDepositFields<F>>>
-		list(params?: SbtcDepositsListParams): Promise<SbtcDepositsEnvelope>
-		walk(params?: SbtcDepositsWalkParams): AsyncIterable<IndexSbtcDeposit>
+			fields: readonly F[];
+		}): Promise<SbtcDepositsEnvelope<SbtcDepositFields<F>>>;
+		list(params?: SbtcDepositsListParams): Promise<SbtcDepositsEnvelope>;
+		walk(params?: SbtcDepositsWalkParams): AsyncIterable<IndexSbtcDeposit>;
 		/** Checkpointed sweep of completed deposits — append-only, so safe to
 		*  mirror. See {@link IndexConsumeOptions}. */
 		consume<TTx = never>(params: SbtcDepositsConsumeParams<TTx> & {
-			sink?: ConsumerSink<TTx>
+			sink?: ConsumerSink<TTx>;
 		}): Promise<{
-			cursor: string | null
-			pages: number
-			emptyPolls: number
-		}>
+			cursor: string | null;
+			pages: number;
+			emptyPolls: number;
+		}>;
 		/** Fetch a completed deposit by Bitcoin txid; 404 → null. */
-		get(bitcoinTxid: string): Promise<SbtcDepositEnvelope | null>
+		get(bitcoinTxid: string): Promise<SbtcDepositEnvelope | null>;
 	};
 	withdrawals: {
 		/** Narrowing overload: `fields` shrinks the row type to exactly the
 		*  requested columns plus {@link SbtcWithdrawalAlwaysFields}. */
 		list<const F extends keyof IndexSbtcWithdrawal & string>(params: SbtcWithdrawalsListParams & {
-			fields: readonly F[]
-		}): Promise<SbtcWithdrawalsEnvelope<SbtcWithdrawalFields<F>>>
-		list(params?: SbtcWithdrawalsListParams): Promise<SbtcWithdrawalsEnvelope>
-		walk(params?: SbtcWithdrawalsWalkParams): AsyncIterable<IndexSbtcWithdrawal>
+			fields: readonly F[];
+		}): Promise<SbtcWithdrawalsEnvelope<SbtcWithdrawalFields<F>>>;
+		list(params?: SbtcWithdrawalsListParams): Promise<SbtcWithdrawalsEnvelope>;
+		walk(params?: SbtcWithdrawalsWalkParams): AsyncIterable<IndexSbtcWithdrawal>;
 		/** Fetch a withdrawal's full lifecycle by request id; 404 → null. */
-		get(requestId: number): Promise<SbtcWithdrawalEnvelope | null>
+		get(requestId: number): Promise<SbtcWithdrawalEnvelope | null>;
 	};
 	events: {
-		list(params?: SbtcEventsListParams): Promise<SbtcEventsEnvelope>
-		walk(params?: SbtcEventsWalkParams): AsyncIterable<IndexSbtcEvent>
+		list(params?: SbtcEventsListParams): Promise<SbtcEventsEnvelope>;
+		walk(params?: SbtcEventsWalkParams): AsyncIterable<IndexSbtcEvent>;
 		/** Checkpointed sweep of the raw peg event log — append-only across all
 		*  six topics. See {@link IndexConsumeOptions}. */
 		consume<TTx = never>(params: SbtcEventsConsumeParams<TTx> & {
-			sink?: ConsumerSink<TTx>
+			sink?: ConsumerSink<TTx>;
 		}): Promise<{
-			cursor: string | null
-			pages: number
-			emptyPolls: number
-		}>
+			cursor: string | null;
+			pages: number;
+			emptyPolls: number;
+		}>;
 	};
 	/** The peg scoreboard — a single all-time aggregate (no pagination). */
 	summary(): Promise<SbtcSummaryEnvelope>;
 }
 /** Per-function action count within a reward cycle. */
 type IndexPoxFunctionCount = {
-	function_name: string
-	count: number
+	function_name: string;
+	count: number;
 };
 /** Aggregate stats for one PoX reward cycle — distinct from `index.stacking`
 *  (decoded per-call PoX-4 actions); this is the reward-cycle rollup. */
 type IndexPoxCycle = {
-	reward_cycle: number
+	reward_cycle: number;
 	/** Total ustx locked across all stack-* calls in this cycle (bigint-safe string). */
-	total_stacked_ustx: string
-	unique_stackers: number
-	unique_delegators: number
-	action_count: number
-	start_block_height: number
-	end_block_height: number
+	total_stacked_ustx: string;
+	unique_stackers: number;
+	unique_delegators: number;
+	action_count: number;
+	start_block_height: number;
+	end_block_height: number;
 	/** True when this is the latest reward cycle (still accumulating new actions). */
-	is_current: boolean
-	function_breakdown: IndexPoxFunctionCount[]
+	is_current: boolean;
+	function_breakdown: IndexPoxFunctionCount[];
 };
 type PoxCyclesEnvelope = {
-	cycles: IndexPoxCycle[]
+	cycles: IndexPoxCycle[];
 	/** The next `reward_cycle` to page from (cycles descend), or null at the end. */
-	next_cursor: number | null
-	tip: IndexTip
+	next_cursor: number | null;
+	tip: IndexTip;
 	/** Present only when the PoX-4 decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 type PoxCycleEnvelope = {
-	cycle: IndexPoxCycle
-	tip: IndexTip
-	notes?: string
+	cycle: IndexPoxCycle;
+	tip: IndexTip;
+	notes?: string;
 };
 type PoxCyclesListParams = {
 	/** A `reward_cycle` to page from; the page returns cycles below it (descending). */
-	cursor?: number | null
-	limit?: number
+	cursor?: number | null;
+	limit?: number;
 };
 type PoxCyclesWalkParams = Omit<PoxCyclesListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** `index.pox` — PoX reward-cycle aggregates. */
 interface PoxResource {
 	cycles: {
-		list(params?: PoxCyclesListParams): Promise<PoxCyclesEnvelope>
-		walk(params?: PoxCyclesWalkParams): AsyncIterable<IndexPoxCycle>
+		list(params?: PoxCyclesListParams): Promise<PoxCyclesEnvelope>;
+		walk(params?: PoxCyclesWalkParams): AsyncIterable<IndexPoxCycle>;
 		/** Fetch one reward cycle's aggregate by number; 404 → null. */
-		get(rewardCycle: number): Promise<PoxCycleEnvelope | null>
+		get(rewardCycle: number): Promise<PoxCycleEnvelope | null>;
 	};
 }
 /** The decoded `pox-5` boot-contract print topics (SIP-045 Bitcoin Staking) —
@@ -2064,37 +2168,37 @@ type IndexPox5EventTopic = Pox5EventTopic;
 *  `data` always carries the full decoded tuple, including nested shapes
 *  (`btc-lockup`, `bond-rewards`, `bond-periods`) that have no flat column. */
 type IndexPox5Event = {
-	cursor: string
-	block_height: number
-	block_time: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	topic: IndexPox5EventTopic
-	staker: string | null
-	signer: string | null
-	signer_manager: string | null
-	bond_index: number | null
+	cursor: string;
+	block_height: number;
+	block_time: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	topic: IndexPox5EventTopic;
+	staker: string | null;
+	signer: string | null;
+	signer_manager: string | null;
+	bond_index: number | null;
 	/** ustx, bigint-safe string. */
-	amount_ustx: string | null
+	amount_ustx: string | null;
 	/** sats, bigint-safe string. */
-	amount_sats: string | null
-	reward_cycle: number | null
-	first_reward_cycle: number | null
-	unlock_cycle: number | null
-	unlock_burn_height: number | null
-	is_l1_lock: boolean | null
-	signer_key: string | null
+	amount_sats: string | null;
+	reward_cycle: number | null;
+	first_reward_cycle: number | null;
+	unlock_cycle: number | null;
+	unlock_burn_height: number | null;
+	is_l1_lock: boolean | null;
+	signer_key: string | null;
 	/** The full decoded print tuple as JSON. */
-	data: unknown
+	data: unknown;
 };
 type Pox5EventsEnvelope<TRow = IndexPox5Event> = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 	/** Present only when the PoX-5 decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 /** Pox5Event columns that survive any projection. */
 type Pox5EventAlwaysFields = "cursor" | "block_height" | "topic";
@@ -2106,24 +2210,24 @@ type Pox5EventsListParams = {
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexPox5Event & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	fields?: readonly (keyof IndexPox5Event & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** Clamp to the finality boundary — only rows past the reorg margin. */
-	confirmed?: boolean
-	topic?: IndexPox5EventTopic
-	staker?: string
-	signer?: string
-	signerManager?: string
-	bondIndex?: number
-	rewardCycle?: number
-	fromHeight?: number
-	toHeight?: number
+	confirmed?: boolean;
+	topic?: IndexPox5EventTopic;
+	staker?: string;
+	signer?: string;
+	signerManager?: string;
+	bondIndex?: number;
+	rewardCycle?: number;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type Pox5EventsWalkParams = Omit<Pox5EventsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** `index.pox5` — decoded PoX-5 print events, the staking primitive from the
 *  epoch 4.0 hard fork onward (PoX-4's `index.stacking` stream ends there). */
@@ -2132,10 +2236,10 @@ interface Pox5Resource {
 		/** Narrowing overload: `fields` shrinks the row type to exactly the
 		*  requested columns plus {@link Pox5EventAlwaysFields}. */
 		list<const F extends keyof IndexPox5Event & string>(params: Pox5EventsListParams & {
-			fields: readonly F[]
-		}): Promise<Pox5EventsEnvelope<Pox5EventFields<F>>>
-		list(params?: Pox5EventsListParams): Promise<Pox5EventsEnvelope>
-		walk(params?: Pox5EventsWalkParams): AsyncIterable<IndexPox5Event>
+			fields: readonly F[];
+		}): Promise<Pox5EventsEnvelope<Pox5EventFields<F>>>;
+		list(params?: Pox5EventsListParams): Promise<Pox5EventsEnvelope>;
+		walk(params?: Pox5EventsWalkParams): AsyncIterable<IndexPox5Event>;
 	};
 }
 /**
@@ -2149,20 +2253,20 @@ interface FtTransfersResource {
 	/** Narrowing overload for the callable shorthand — same wire path as
 	*  `list`, so it must narrow identically. */
 	<const F extends keyof FtTransfer & string>(params: FtTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<FtTransfersEnvelope<FtTransferFields<F>>>;
 	(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
 	/** Narrowing overload: `fields` shrinks the row type to exactly the
 	*  requested columns plus {@link FtTransferAlwaysFields}. */
 	list<const F extends keyof FtTransfer & string>(params: FtTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<FtTransfersEnvelope<FtTransferFields<F>>>;
 	list(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
 	/** Narrowing overload, matching `list`: `walk` forwards `fields` to the
 	*  wire, so without this the yielded rows are stripped while the type
 	*  still promises every column. */
 	walk<const F extends keyof FtTransfer & string>(params: FtTransfersWalkParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): AsyncIterable<FtTransferFields<F>>;
 	walk(params?: FtTransfersWalkParams): AsyncIterable<FtTransfer>;
 }
@@ -2171,18 +2275,18 @@ interface NftTransfersResource {
 	/** Narrowing overload for the callable shorthand — same wire path as
 	*  `list`, so it must narrow identically. */
 	<const F extends keyof NftTransfer & string>(params: NftTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<NftTransfersEnvelope<NftTransferFields<F>>>;
 	(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
 	/** Narrowing overload: `fields` shrinks the row type to exactly the
 	*  requested columns plus {@link NftTransferAlwaysFields}. */
 	list<const F extends keyof NftTransfer & string>(params: NftTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<NftTransfersEnvelope<NftTransferFields<F>>>;
 	list(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
 	/** Narrowing overload, matching `list` (see {@link FtTransfersResource}). */
 	walk<const F extends keyof NftTransfer & string>(params: NftTransfersWalkParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): AsyncIterable<NftTransferFields<F>>;
 	walk(params?: NftTransfersWalkParams): AsyncIterable<NftTransfer>;
 }
@@ -2194,7 +2298,7 @@ interface IndexEventsResource {
 		T extends IndexEventType,
 		const F extends keyof IndexEventOf<T> & string
 	>(params: EventsListParams<T> & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<EventsEnvelope<T, IndexEventFields<T, F>>>;
 	<T extends IndexEventType>(params: EventsListParams<T>): Promise<EventsEnvelope<T>>;
 	/** Narrowing overload: `fields` shrinks the returned row type to exactly
@@ -2204,7 +2308,7 @@ interface IndexEventsResource {
 		T extends IndexEventType,
 		const F extends keyof IndexEventOf<T> & string
 	>(params: EventsListParams<T> & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<EventsEnvelope<T, IndexEventFields<T, F>>>;
 	list<T extends IndexEventType>(params: EventsListParams<T>): Promise<EventsEnvelope<T>>;
 	/** Narrowing overload, matching `list`: `walk` forwards `fields` to the
@@ -2214,33 +2318,33 @@ interface IndexEventsResource {
 		T extends IndexEventType,
 		const F extends keyof IndexEventOf<T> & string
 	>(params: EventsWalkParams<T> & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): AsyncIterable<IndexEventFields<T, F>>;
 	walk<T extends IndexEventType>(params: EventsWalkParams<T>): AsyncIterable<IndexEventOf<T>>;
 	consume<
 		T extends IndexEventType,
 		TTx = never
 	>(params: EventsConsumeParams<T, TTx> & {
-		sink?: ConsumerSink<TTx>
+		sink?: ConsumerSink<TTx>;
 	}): Promise<{
-		cursor: string | null
-		pages: number
-		emptyPolls: number
+		cursor: string | null;
+		pages: number;
+		emptyPolls: number;
 	}>;
 }
 /** Per-event-type filter vocabulary in the {@link IndexDiscovery} doc. */
 type IndexEventTypeFilters = {
-	columns?: string[]
-	allowed_filters?: string[]
-	equality_filters?: string[]
-	required_non_null?: string[]
+	columns?: string[];
+	allowed_filters?: string[];
+	equality_filters?: string[];
+	required_non_null?: string[];
 };
 /** The `GET /v1/index` discovery doc — live endpoint + filter vocabulary.
 *  Shape is intentionally open (the server may add fields); the agent-relevant
 *  parts are the per-type filter rules. */
 type IndexDiscovery = {
-	event_type_filters?: Record<string, IndexEventTypeFilters>
-	[key: string]: unknown
+	event_type_filters?: Record<string, IndexEventTypeFilters>;
+	[key: string]: unknown;
 };
 declare class Index extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
@@ -2266,27 +2370,27 @@ declare class Index extends BaseClient {
 	*  Callable: `index.events(params)` ≡ `index.events.list(params)`. */
 	readonly events: IndexEventsResource;
 	readonly contractCalls: {
-		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>
-		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>
+		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>;
+		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>;
 		consume: <TTx = never>(params: ContractCallsConsumeParams<TTx> & {
-			sink?: ConsumerSink<TTx>
+			sink?: ConsumerSink<TTx>;
 		}) => Promise<{
-			cursor: string | null
-			pages: number
-			emptyPolls: number
-		}>
+			cursor: string | null;
+			pages: number;
+			emptyPolls: number;
+		}>;
 	};
 	/** Canonical block-hash map — sync only the current canonical chain. */
 	readonly canonical: {
-		list: (params?: CanonicalListParams) => Promise<CanonicalEnvelope>
-		walk: (params?: CanonicalWalkParams) => AsyncIterable<IndexCanonicalBlock>
+		list: (params?: CanonicalListParams) => Promise<CanonicalEnvelope>;
+		walk: (params?: CanonicalWalkParams) => AsyncIterable<IndexCanonicalBlock>;
 	};
 	/** Canonical blocks: paginated `list`/`walk`, plus `get` by height or hash
 	*  (resolves to null on 404). */
 	readonly blocks: {
-		list: (params?: BlocksListParams) => Promise<BlocksEnvelope>
-		walk: (params?: BlocksWalkParams) => AsyncIterable<IndexBlock>
-		get: (ref: string | number) => Promise<BlockEnvelope | null>
+		list: (params?: BlocksListParams) => Promise<BlocksEnvelope>;
+		walk: (params?: BlocksWalkParams) => AsyncIterable<IndexBlock>;
+		get: (ref: string | number) => Promise<BlockEnvelope | null>;
 	};
 	/** Full transaction documents: paginated `list`/`walk`, plus `get` by tx_id
 	*  (resolves to null on 404). */
@@ -2297,26 +2401,26 @@ declare class Index extends BaseClient {
 		*  overloads. */
 		list: {
 			<const F extends keyof IndexTransaction & string>(params: TransactionsListParams & {
-				fields: readonly F[]
-			}): Promise<TransactionsEnvelope<TransactionFields<F>>>
-			(params?: TransactionsListParams): Promise<TransactionsEnvelope>
-		}
-		walk: (params?: TransactionsWalkParams) => AsyncIterable<IndexTransaction>
-		get: (txId: string) => Promise<TransactionEnvelope | null>
-		getProof: (txId: string) => Promise<TransactionProof | null>
+				fields: readonly F[];
+			}): Promise<TransactionsEnvelope<TransactionFields<F>>>;
+			(params?: TransactionsListParams): Promise<TransactionsEnvelope>;
+		};
+		walk: (params?: TransactionsWalkParams) => AsyncIterable<IndexTransaction>;
+		get: (txId: string) => Promise<TransactionEnvelope | null>;
+		getProof: (txId: string) => Promise<TransactionProof | null>;
 	};
 	/** Decoded PoX-4 stacking actions. Empty (with a `notes` hint) when the
 	*  platform's PoX-4 decoder is disabled. */
 	readonly stacking: {
-		list: (params?: StackingListParams) => Promise<StackingEnvelope>
-		walk: (params?: StackingWalkParams) => AsyncIterable<IndexStackingAction>
+		list: (params?: StackingListParams) => Promise<StackingEnvelope>;
+		walk: (params?: StackingWalkParams) => AsyncIterable<IndexStackingAction>;
 	};
 	/** Pending (unconfirmed) transactions: paginated `list`/`walk`, plus `get` by
 	*  tx_id (resolves to null when the tx has confirmed or dropped). */
 	readonly mempool: {
-		list: (params?: MempoolListParams) => Promise<MempoolEnvelope>
-		walk: (params?: MempoolWalkParams) => AsyncIterable<IndexMempoolTransaction>
-		get: (txId: string) => Promise<MempoolTransactionEnvelope | null>
+		list: (params?: MempoolListParams) => Promise<MempoolEnvelope>;
+		walk: (params?: MempoolWalkParams) => AsyncIterable<IndexMempoolTransaction>;
+		get: (txId: string) => Promise<MempoolTransactionEnvelope | null>;
 	};
 	/** Decoded sBTC peg surface — the only productized decoded sBTC peg feed on
 	*  Stacks. `deposits`/`withdrawals`/`events` paginate; `summary` is a scalar. */
@@ -2429,7 +2533,7 @@ declare class Projects extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
 	/** All projects owned by the account, newest-relevant first. */
 	list(): Promise<{
-		projects: Project[]
+		projects: Project[];
 	}>;
 	/** A single project by slug. */
 	get(slug: string): Promise<Project>;
@@ -2439,7 +2543,7 @@ declare class Projects extends BaseClient {
 	update(slug: string, patch: UpdateProjectParams): Promise<Project>;
 	/** Delete a project. The account's last remaining project cannot be deleted. */
 	delete(slug: string): Promise<{
-		ok: true
+		ok: true;
 	}>;
 	/** Team members and pending invitations for a project. */
 	team(slug: string): Promise<ProjectTeam>;
@@ -2449,7 +2553,7 @@ import { ChainTrigger, ChainTriggerType, CreateSubscriptionRequest as CreateSubs
 import { trigger } from "@secondlayer/shared/schemas/subscriptions";
 declare class Subscriptions extends BaseClient {
 	list(): Promise<{
-		data: SubscriptionSummary[]
+		data: SubscriptionSummary[];
 	}>;
 	get(id: string): Promise<SubscriptionDetail>;
 	create(input: CreateSubscriptionRequest): Promise<CreateSubscriptionResponse>;
@@ -2457,25 +2561,25 @@ declare class Subscriptions extends BaseClient {
 	pause(id: string): Promise<SubscriptionDetail>;
 	resume(id: string): Promise<SubscriptionDetail>;
 	delete(id: string): Promise<{
-		ok: true
+		ok: true;
 	}>;
 	rotateSecret(id: string): Promise<RotateSecretResponse>;
 	/** Send a one-off test webhook to the subscription's URL (built for its
 	*  format, SSRF-guarded). Logged as a delivery row, visible via recentDeliveries. */
 	test(id: string): Promise<SubscriptionTestResult>;
 	recentDeliveries(id: string): Promise<{
-		data: DeliveryRow[]
+		data: DeliveryRow[];
 	}>;
 	replay(id: string, range: {
-		fromBlock: number
-		toBlock: number
-		force?: string
+		fromBlock: number;
+		toBlock: number;
+		force?: string;
 	}): Promise<ReplayResult>;
 	dead(id: string): Promise<{
-		data: DeadRow[]
+		data: DeadRow[];
 	}>;
 	requeueDead(id: string, outboxId: string): Promise<{
-		ok: true
+		ok: true;
 	}>;
 }
 interface ContextAccount {
@@ -2513,8 +2617,8 @@ interface ContextSnapshot {
 	indexTip: IndexTip | null;
 	subgraphs: SubgraphSummary2[] | null;
 	subscriptions: {
-		count: number
-		byStatus: Record<string, number>
+		count: number;
+		byStatus: Record<string, number>;
 	} | null;
 	/** The account's projects (null when unreadable — e.g. a scoped key). */
 	projects: ContextProject[] | null;
@@ -2543,14 +2647,14 @@ declare class SecondLayer extends BaseClient {
 	* PAYMENT-BALANCE/SESSION) apply to every item.
 	*/
 	batch(requests: Array<{
-		path: string
-		params?: Record<string, string | number | boolean>
+		path: string;
+		params?: Record<string, string | number | boolean>;
 	}>): Promise<{
 		results: Array<{
-			path: string | null
-			status: number
-			body: unknown
-		}>
+			path: string | null;
+			status: number;
+			body: unknown;
+		}>;
 	}>;
 	context(): Promise<ContextSnapshot>;
 }
@@ -2569,18 +2673,18 @@ declare class SecondLayer extends BaseClient {
 * ```
 */
 declare function getSubgraph<T extends {
-	name: string
-	schema: Record<string, unknown>
+	name: string;
+	schema: Record<string, unknown>;
 }>(def: T, options?: Partial<SecondLayerOptions> | SecondLayer | Subgraphs): InferSubgraphClient2<T>;
 type CreateStreamsClientOptions = {
-	apiKey: string
-	baseUrl?: string
-	fetchImpl?: FetchLike2
+	apiKey: string;
+	baseUrl?: string;
+	fetchImpl?: FetchLike2;
 	/**
 	* 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
+	dumpsBaseUrl?: string;
 	/**
 	* Verify the ed25519 `X-Signature` on every REST response and per-frame SSE
 	* signature. Three states:
@@ -2599,8 +2703,8 @@ type CreateStreamsClientOptions = {
 	* rotated `X-Signature-KeyId` triggers one refresh) unless a PEM is pinned.
 	*/
 	verify?: boolean | {
-		publicKey: string
-	}
+		publicKey: string;
+	};
 	/**
 	* Verify the bulk dumps manifest's ed25519 signature in `client.dumps.list()`
 	* before trusting any file sha256 (default ON). Uses the same key source as
@@ -2608,7 +2712,7 @@ type CreateStreamsClientOptions = {
 	* `false` to opt out. A missing or invalid signature throws
 	* `StreamsSignatureError`.
 	*/
-	verifyDumpsManifest?: boolean
+	verifyDumpsManifest?: boolean;
 };
 declare function createStreamsClient(options: CreateStreamsClientOptions): StreamsClient;
 /**
@@ -2672,14 +2776,14 @@ declare class SecondLayerError extends Error {
 	*/
 	walk(fn?: (err: unknown) => boolean): unknown;
 	toJSON(): {
-		name: string
-		message: string
-		shortMessage: string
-		cause: string | undefined
-		code: string | undefined
-		docsUrl: string | undefined
-		retryable: boolean
-		retryAfterSeconds: number | undefined
+		name: string;
+		message: string;
+		shortMessage: string;
+		cause: string | undefined;
+		code: string | undefined;
+		docsUrl: string | undefined;
+		retryable: boolean;
+		retryAfterSeconds: number | undefined;
 	};
 }
 /**
@@ -2713,9 +2817,9 @@ declare class AuthError extends ApiError {
 *  with `retryAfterSeconds` parsed from the `Retry-After` header when sent. */
 declare class RateLimitError extends ApiError {
 	/** Raw `Retry-After` header value (seconds or HTTP-date). */
-	readonly retryAfter?: string;
+	readonly retryAfter?: string | undefined;
 	readonly status: 429;
-	constructor(message?: string, retryAfter?: string);
+	constructor(message?: string, retryAfter?: string | undefined);
 }
 /** Thrown on a 4xx the caller can fix (bad cursor, bad params). Never retried. */
 declare class ValidationError extends ApiError {
@@ -2746,8 +2850,7 @@ declare class VersionConflictError extends ApiError {
 * } catch (err) {
 *   if (err instanceof ByoBreakingChangeError) {
 *     console.log(err.details.plan.dropStatement);
-*     console.log(err.details.plan.statements.join(";
-"));
+*     console.log(err.details.plan.statements.join(";\n"));
 *   }
 * }
 * ```
@@ -2765,210 +2868,210 @@ declare class StreamsSignatureError extends SecondLayerError {
 	constructor(message?: string);
 }
 type FtTransferEvent = Extract<StreamsEvent, {
-	event_type: "ft_transfer"
+	event_type: "ft_transfer";
 }>;
 type DecodedFtTransferPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type DecodedFtTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_transfer"
-	decoded_payload: DecodedFtTransferPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_transfer";
+	decoded_payload: DecodedFtTransferPayload;
+	source_cursor: string;
 };
 declare function isFtTransfer(event: StreamsEvent): event is FtTransferEvent;
 declare function decodeFtTransfer(event: StreamsEvent): DecodedFtTransfer;
 type NftTransferEvent = Extract<StreamsEvent, {
-	event_type: "nft_transfer"
+	event_type: "nft_transfer";
 }>;
 type DecodedNftTransferPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	recipient: string
-	value: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	recipient: string;
+	value: string;
 };
 type DecodedNftTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_transfer"
-	decoded_payload: DecodedNftTransferPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_transfer";
+	decoded_payload: DecodedNftTransferPayload;
+	source_cursor: string;
 };
 declare function isNftTransfer(event: StreamsEvent): event is NftTransferEvent;
 declare function decodeNftTransfer(event: StreamsEvent): DecodedNftTransfer;
 type DecodedStxTransferPayload = {
-	sender: string
-	recipient: string
-	amount: string
-	memo: string | null
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo: string | null;
 };
 type DecodedStxTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_transfer"
-	decoded_payload: DecodedStxTransferPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_transfer";
+	decoded_payload: DecodedStxTransferPayload;
+	source_cursor: string;
 };
 type DecodedStxMintPayload = {
-	recipient: string
-	amount: string
+	recipient: string;
+	amount: string;
 };
 type DecodedStxMint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_mint"
-	decoded_payload: DecodedStxMintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_mint";
+	decoded_payload: DecodedStxMintPayload;
+	source_cursor: string;
 };
 type DecodedStxBurnPayload = {
-	sender: string
-	amount: string
+	sender: string;
+	amount: string;
 };
 type DecodedStxBurn = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_burn"
-	decoded_payload: DecodedStxBurnPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_burn";
+	decoded_payload: DecodedStxBurnPayload;
+	source_cursor: string;
 };
 declare function isStxTransfer(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_transfer"
+	event_type: "stx_transfer";
 };
 declare function decodeStxTransfer(event: StreamsEvent): DecodedStxTransfer;
 declare function isStxMint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_mint"
+	event_type: "stx_mint";
 };
 declare function decodeStxMint(event: StreamsEvent): DecodedStxMint;
 declare function isStxBurn(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_burn"
+	event_type: "stx_burn";
 };
 declare function decodeStxBurn(event: StreamsEvent): DecodedStxBurn;
 type DecodedStxLockPayload = {
-	sender: string
-	amount: string
+	sender: string;
+	amount: string;
 	payload: {
-		unlock_height: string | null
-	}
+		unlock_height: string | null;
+	};
 };
 type DecodedStxLock = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "stx_lock"
-	decoded_payload: DecodedStxLockPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "stx_lock";
+	decoded_payload: DecodedStxLockPayload;
+	source_cursor: string;
 };
 declare function isStxLock(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "stx_lock"
+	event_type: "stx_lock";
 };
 declare function decodeStxLock(event: StreamsEvent): DecodedStxLock;
 type DecodedFtMintPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	recipient: string;
+	amount: string;
 };
 type DecodedFtMint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_mint"
-	decoded_payload: DecodedFtMintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_mint";
+	decoded_payload: DecodedFtMintPayload;
+	source_cursor: string;
 };
 type DecodedFtBurnPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	amount: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	amount: string;
 };
 type DecodedFtBurn = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_burn"
-	decoded_payload: DecodedFtBurnPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_burn";
+	decoded_payload: DecodedFtBurnPayload;
+	source_cursor: string;
 };
 type DecodedNftMintPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	recipient: string
-	value: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	recipient: string;
+	value: string;
 };
 type DecodedNftMint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_mint"
-	decoded_payload: DecodedNftMintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_mint";
+	decoded_payload: DecodedNftMintPayload;
+	source_cursor: string;
 };
 type DecodedNftBurnPayload = {
-	asset_identifier: string
-	contract_id: string
-	token_name: string | null
-	sender: string
-	value: string
+	asset_identifier: string;
+	contract_id: string;
+	token_name: string | null;
+	sender: string;
+	value: string;
 };
 type DecodedNftBurn = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_burn"
-	decoded_payload: DecodedNftBurnPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_burn";
+	decoded_payload: DecodedNftBurnPayload;
+	source_cursor: string;
 };
 declare function isFtMint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "ft_mint"
+	event_type: "ft_mint";
 };
 declare function decodeFtMint(event: StreamsEvent): DecodedFtMint;
 declare function isFtBurn(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "ft_burn"
+	event_type: "ft_burn";
 };
 declare function decodeFtBurn(event: StreamsEvent): DecodedFtBurn;
 declare function isNftMint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "nft_mint"
+	event_type: "nft_mint";
 };
 declare function decodeNftMint(event: StreamsEvent): DecodedNftMint;
 declare function isNftBurn(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "nft_burn"
+	event_type: "nft_burn";
 };
 declare function decodeNftBurn(event: StreamsEvent): DecodedNftBurn;
 /** Decoded form of a Clarity `print` event:
@@ -2977,41 +3080,41 @@ declare function decodeNftBurn(event: StreamsEvent): DecodedNftBurn;
 *    `0x…` hex, tuples as objects)
 *  - `raw_value`: the canonical serialized hex, for byte-exact consumers */
 type DecodedPrintValue = {
-	topic: string | null
-	value: unknown
-	raw_value: string | null
+	topic: string | null;
+	value: unknown;
+	raw_value: string | null;
 };
 type DecodedPrintPayload = {
-	contract_id: string | null
-	payload: DecodedPrintValue
+	contract_id: string | null;
+	payload: DecodedPrintValue;
 };
 type DecodedPrint = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "print"
-	decoded_payload: DecodedPrintPayload
-	source_cursor: string
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "print";
+	decoded_payload: DecodedPrintPayload;
+	source_cursor: string;
 };
 declare function isPrint(event: StreamsEvent): event is StreamsEvent & {
-	event_type: "print"
+	event_type: "print";
 };
 declare function decodePrint(event: StreamsEvent): DecodedPrint;
 /** Superset of the columns the decoded_events table holds. Every decoded
 *  event's `decoded_payload` is assignable to this, so the indexer's writer
 *  can map columns generically instead of per-event-type. */
 type DecodedEventColumns = {
-	contract_id?: string | null
-	asset_identifier?: string | null
-	sender?: string | null
-	recipient?: string | null
-	amount?: string | null
-	value?: string | null
-	memo?: string | null
+	contract_id?: string | null;
+	asset_identifier?: string | null;
+	sender?: string | null;
+	recipient?: string | null;
+	amount?: string | null;
+	value?: string | null;
+	memo?: string | null;
 	/** JSONB overflow for non-flat types (e.g. print's decoded value). */
-	payload?: unknown
+	payload?: unknown;
 };
 /**
 * Helpers for Streams cursors. A cursor is the opaque `<block>:<index>` string
@@ -3036,12 +3139,12 @@ declare const Cursor: {
 	* type), larger than any real index, so nothing at `height - 1` survives the
 	* keyset and the next returned row is exactly `(height, 0)`.
 	*/
-	atHeight(height: number): string
+	atHeight(height: number): string;
 	/** Parse a `<block>:<index>` cursor. Throws `ValidationError` if malformed. */
 	parse(cursor: string): {
-		blockHeight: number
-		eventIndex: number
-	}
+		blockHeight: number;
+		eventIndex: number;
+	};
 };
 type DecodedEventRow = DecodedFtTransfer | DecodedNftTransfer | DecodedStxTransfer | DecodedStxMint | DecodedStxBurn | DecodedStxLock | DecodedFtMint | DecodedFtBurn | DecodedNftMint | DecodedNftBurn | DecodedPrint;
 import { X402TokenSymbol } from "@secondlayer/shared/x402";
@@ -3058,31 +3161,31 @@ import { StacksChain } from "@secondlayer/stacks/chains";
 *  - `buildSignedX402Payment` / `readX402Challenge` — primitives for custom transports.
 */
 type X402Accept = {
-	scheme: "exact"
-	network: string
-	asset: string
+	scheme: "exact";
+	network: string;
+	asset: string;
 	/** Atomic units. */
-	amount: string
-	payTo: string
-	maxTimeoutSeconds: number
+	amount: string;
+	payTo: string;
+	maxTimeoutSeconds: number;
 	extra: {
-		nonce: string
-	}
+		nonce: string;
+	};
 };
 type X402Challenge = {
-	x402Version: number
-	accepts: X402Accept[]
-	error?: string
+	x402Version: number;
+	accepts: X402Accept[];
+	error?: string;
 };
 /** Decoded `PAYMENT-RESPONSE` settlement receipt. */
 type X402Receipt = {
-	success: boolean
+	success: boolean;
 	/** Settlement tier: `optimistic` (served on broadcast-accept, reconciled
 	*  async) or `confirmed` (canonical). Absent on older deployments. */
-	state?: "optimistic" | "confirmed"
-	txid: string
-	payer: string
-	network: string
+	state?: "optimistic" | "confirmed";
+	txid: string;
+	payer: string;
+	network: string;
 };
 /** Bitcoin-native first — sBTC is the compelling micropay asset; USDCx the
 *  dollar peg; STX the fallback. Override via `preferAssets`. */
@@ -3097,56 +3200,56 @@ declare function readX402Challenge(res: Response): Promise<X402Challenge | null>
 /** Read the settlement receipt from a paid 200 response. */
 declare function readX402Receipt(res: Response): X402Receipt | null;
 type SelectOfferOptions = {
-	preferAssets?: X402TokenSymbol[]
-	maxAmountPerCall?: Partial<Record<X402TokenSymbol, bigint>>
+	preferAssets?: X402TokenSymbol[];
+	maxAmountPerCall?: Partial<Record<X402TokenSymbol, bigint>>;
 };
 /** Choose an `accepts[]` entry by preference order, skipping any that exceed the
 *  per-asset spend cap. Throws {@link X402SpendGuardError} if none qualify. */
 declare function selectOffer(challenge: X402Challenge, opts?: SelectOfferOptions): {
-	accept: X402Accept
-	symbol: X402TokenSymbol
+	accept: X402Accept;
+	symbol: X402TokenSymbol;
 };
 /** Fetch the payer account's next nonce from a Stacks node (`/v2/accounts`). */
 declare function resolveAccountNonce(address: string, nodeUrl?: string): Promise<number>;
 type BuildSignedX402PaymentOptions = {
-	challenge: X402Challenge
-	account: LocalAccount
+	challenge: X402Challenge;
+	account: LocalAccount;
 	/** The payer account's next nonce. */
-	accountNonce: bigint | number | string
+	accountNonce: bigint | number | string;
 	/** Preferred asset string (e.g. an sBTC/USDCx id). Defaults to the first offer. */
-	asset?: string
-	chain?: StacksChain
+	asset?: string;
+	chain?: StacksChain;
 };
 /** Build a signed, base64 `PAYMENT-SIGNATURE` header for one `accepts[]` entry. */
 declare function buildSignedX402Payment(opts: BuildSignedX402PaymentOptions): Promise<{
-	header: string
-	accept: X402Accept
+	header: string;
+	accept: X402Accept;
 }>;
 type WithX402Options = SelectOfferOptions & {
-	account: LocalAccount
+	account: LocalAccount;
 	/** Prepaid-credit token (PAYMENT-BALANCE) from a prior deposit — calls
 	*  debit the tab server-side instead of settling on-chain per call. */
-	balanceToken?: string
+	balanceToken?: string;
 	/** Autonomous treasury policy: when the tab's remaining balance (read from
 	*  X-BALANCE-REMAINING-USD) drops below `whenBelow`, deposit `usd` more in
 	*  the background (one on-chain payment) and adopt the fresh token. */
 	topUp?: {
-		usd: number
-		whenBelow: number
-	}
+		usd: number;
+		whenBelow: number;
+	};
 	/** Override the payer nonce; auto-resolved from `nodeUrl` when omitted. */
-	accountNonce?: bigint | number | string
+	accountNonce?: bigint | number | string;
 	/** Node for auto-nonce lookup. Defaults to {@link DEFAULT_NONCE_NODE_URL}. */
-	nodeUrl?: string
-	chain?: StacksChain
+	nodeUrl?: string;
+	chain?: StacksChain;
 	/** Fired just before the paid retry (the call then blocks on confirmed-tier
 	*  settle, or returns near-instantly on an optimistic surface). */
 	onSettling?: (info: {
-		asset: string
-		amount: string
-	}) => void
+		asset: string;
+		amount: string;
+	}) => void;
 	/** Abort the paid retry after this long. */
-	timeoutMs?: number
+	timeoutMs?: number;
 };
 type X402Fetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
 /**
@@ -3161,23 +3264,23 @@ type X402Fetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
 */
 declare function withX402(baseFetch: typeof fetch, opts: WithX402Options): X402Fetch;
 type X402ClientOptions = WithX402Options & {
-	baseUrl: string
+	baseUrl: string;
 	/** Override the underlying fetch (tests). */
-	fetch?: typeof fetch
+	fetch?: typeof fetch;
 };
 type X402Result<T = unknown> = {
-	data: T
+	data: T;
 	/** Settlement receipt, or null if the response carried none. */
-	payment: X402Receipt | null
-	response: Response
+	payment: X402Receipt | null;
+	response: Response;
 };
 type X402Client = {
 	get<T = unknown>(path: string, o?: {
-		query?: Record<string, string>
-	}): Promise<X402Result<T>>
+		query?: Record<string, string>;
+	}): Promise<X402Result<T>>;
 	post<T = unknown>(path: string, o?: {
-		body?: unknown
-	}): Promise<X402Result<T>>
+		body?: unknown;
+	}): Promise<X402Result<T>>;
 };
 /**
 * A small client over {@link withX402}: `.get/.post` against `baseUrl`, returning
@@ -3192,7 +3295,7 @@ declare function createX402Client(opts: X402ClientOptions): X402Client;
 type X402FetchFn = (extraHeaders: Record<string, string>) => Promise<Response>;
 type PayAndRetryOptions = Omit<WithX402Options, never> & {
 	/** Required here (use `withX402` for auto-nonce). */
-	accountNonce: bigint | number | string
+	accountNonce: bigint | number | string;
 };
 /**
 * Low-level: run a request via a caller-controlled fetch; if it 402s, pay and
@@ -3224,7 +3327,7 @@ interface ConsumerHealth {
 * should restart on. `blocks_behind` still ships in the body for dashboards.
 */
 declare function consumerHealth(options?: {
-	staleAfterMs?: number
+	staleAfterMs?: number;
 }): ConsumerHealth;
 /**
 * An `AbortSignal` wired to SIGTERM/SIGINT (redeploys arrive as SIGTERM).
@@ -3236,7 +3339,7 @@ declare function consumerHealth(options?: {
 * No-op (never fires) on runtimes without `process` signal handling.
 */
 declare function shutdownSignal(options?: {
-	signals?: readonly ("SIGTERM" | "SIGINT")[]
+	signals?: readonly ("SIGTERM" | "SIGINT")[];
 }): AbortSignal;
 import { ChainWebhookDelivery } from "@secondlayer/shared";
 import { StandardWebhooksHeaders } from "@secondlayer/shared/crypto/standard-webhooks";
@@ -3244,7 +3347,7 @@ import { StandardWebhooksHeaders as StandardWebhooksHeaders2, verify } from "@se
 import { ChainApplyDeliveryOf, ChainApplyEnvelope, ChainApplyEnvelopeOf, ChainEventEnvelope, ChainFtBurnData, ChainFtMintData, ChainFtTransferData, ChainNftBurnData, ChainNftMintData, ChainNftTransferData, ChainPrintEventData, ChainReorgOrphanedEntry, ChainReorgRollbackDelivery, ChainReorgRollbackEnvelope, ChainStxBurnData, ChainStxLockData, ChainStxMintData, ChainStxTransferData, ChainTestDelivery, ChainTxLevelEvent, ChainWebhookDelivery as ChainWebhookDelivery2, ChainWebhookEnvelope, SbtcDepositEvent, SbtcWithdrawalEvent, SbtcWithdrawalSweptConfirmedEvent } from "@secondlayer/shared";
 type HeaderLookup = (name: string) => string | null | undefined;
 type WebhookHeaderInput = HeaderLookup | StandardWebhooksHeaders | Record<string, string | string[] | undefined> | {
-	get: (name: string) => string | null
+	get: (name: string) => string | null;
 };
 /**
 * Verify a Secondlayer webhook delivery signature.