@secondlayer/sdk 6.22.0 → 6.23.1

package/dist/subgraphs/index.d.ts

@@ -310,1141 +310,1202 @@ interface TransactionProof {
 		reward_set: RewardSet
 	};
 }
-type IndexTip = {
-	block_height: number
-	lag_seconds: number
-};
-/**
-* A chain reorg overlapping a returned page's height range. Height-keyed feeds
-* (`/transactions`, `/contract-calls`, `/stacking`) populate this so a consumer
-* can reconcile: roll back the rows whose `block_height:tx_index` cursor falls in
-* `orphaned_range`, then re-fetch from `new_canonical_tip`. 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
-	/** Orphaned cursor span `<block_height>:<tx_index>`, inclusive. */
-	orphaned_range: {
-		from: string
-		to: string
-	}
-	/** New canonical tip cursor to resume from. */
-	new_canonical_tip: string
-};
-type IndexUsage = {
-	product: "index"
-	tier: string
-	limits: {
-		rate_limit_per_second: number | null
-	}
-	usage: {
-		decoded_events_today: number
-		decoded_events_this_month: number
-	}
-};
-type FtTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_transfer"
-	contract_id: string
-	asset_identifier: string
+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
+} | Record<string, unknown>;
+type StxTransferPayload = {
 	sender: string
 	recipient: string
 	amount: string
+	memo?: string
 };
-type FtTransfersEnvelope = {
-	events: FtTransfer[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-};
-type FtTransfersListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	contractId?: string
-	sender?: string
-	recipient?: string
-	fromHeight?: number
-	toHeight?: number
-};
-type FtTransfersWalkParams = Omit<FtTransfersListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
-};
-type NftTransfer = {
-	cursor: string
-	block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_transfer"
-	contract_id: string
-	asset_identifier: string
-	sender: string
+type StxMintPayload = {
 	recipient: string
-	value: string
-};
-type NftTransfersEnvelope = {
-	events: NftTransfer[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-};
-type NftTransfersListParams = {
-	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
-};
-type IndexEventBase = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	contract_id: string | null
+	amount: string
 };
-type IndexFtTransfer = IndexEventBase & {
-	event_type: "ft_transfer"
-	asset_identifier: string
+type StxBurnPayload = {
 	sender: string
-	recipient: string
 	amount: string
 };
-type IndexNftTransfer = IndexEventBase & {
-	event_type: "nft_transfer"
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: string
+type StxLockPayload = {
+	locked_address: string
+	locked_amount: string
+	unlock_height: string
 };
-type IndexStxTransfer = IndexEventBase & {
-	event_type: "stx_transfer"
+type FtTransferPayload = {
+	asset_identifier: string
 	sender: string
 	recipient: string
 	amount: string
-	memo: string | null
 };
-type IndexStxMint = IndexEventBase & {
-	event_type: "stx_mint"
+type FtMintPayload = {
+	asset_identifier: string
 	recipient: string
 	amount: string
 };
-type IndexStxBurn = IndexEventBase & {
-	event_type: "stx_burn"
-	sender: string
-	amount: string
-};
-type IndexStxLock = IndexEventBase & {
-	event_type: "stx_lock"
-	sender: string
-	amount: string
-	payload: {
-		unlock_height: string | null
-	}
-};
-type IndexFtMint = IndexEventBase & {
-	event_type: "ft_mint"
+type FtBurnPayload = {
 	asset_identifier: string
-	recipient: string
+	sender: string
 	amount: string
 };
-type IndexFtBurn = IndexEventBase & {
-	event_type: "ft_burn"
+type NftTransferPayload = {
 	asset_identifier: string
 	sender: string
-	amount: string
+	recipient: string
+	value: StreamsClarityValue
+	/** Canonical serialized hex of `value`, when the stream carries it. */
+	raw_value?: string
 };
-type IndexNftMint = IndexEventBase & {
-	event_type: "nft_mint"
+type NftMintPayload = {
 	asset_identifier: string
 	recipient: string
-	value: string
+	value: StreamsClarityValue
+	raw_value?: string
 };
-type IndexNftBurn = IndexEventBase & {
-	event_type: "nft_burn"
+type NftBurnPayload = {
 	asset_identifier: string
 	sender: string
-	value: string
-};
-type IndexPrint = IndexEventBase & {
-	event_type: "print"
-	payload: {
-		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;
-type IndexEventType = IndexEvent["event_type"];
-type EventsEnvelope = {
-	events: IndexEvent[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-};
-type EventsListParams = {
-	/** Required. One of the decoded event types. */
-	eventType: IndexEventType
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	contractId?: 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
+	value: StreamsClarityValue
+	raw_value?: string
 };
-type EventsWalkParams = Omit<EventsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+type PrintPayload = {
+	contract_id?: string | null
+	topic?: string
+	value?: unknown
+	raw_value?: string
 };
-type IndexContractCall = {
+type StreamsEventBase = {
+	/**
+	* Globally unique, monotonic position of this event (`<block>:<index>`). Use
+	* it as the primary key of your projection rows — replaying a batch then
+	* upserts cleanly. Don't synthesize your own id from `tx_id`/`event_index`.
+	*/
 	cursor: string
 	block_height: number
-	block_time?: string | null
+	block_hash: string
+	burn_block_height: number
 	tx_id: string
 	tx_index: number
-	contract_id: string
-	function_name: string
-	sender: string
-	status: string
-	args: unknown[]
-	result: unknown
-	result_hex: string | null
+	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
 };
-type ContractCallsEnvelope = {
-	contract_calls: IndexContractCall[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+type StreamsEventOf<
+	T extends StreamsEventType,
+	P
+> = StreamsEventBase & {
+	event_type: T
+	payload: P
 };
-type ContractCallsListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	contractId?: 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
-};
-type ContractCallsWalkParams = Omit<ContractCallsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
-};
-/** 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
+/** 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
-	parent_hash: string
 	burn_block_height: number
-	burn_block_hash: string | null
-};
-type CanonicalEnvelope = {
-	canonical: IndexCanonicalBlock[]
-	next_cursor: string | null
-	tip: IndexTip
-};
-type CanonicalListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	fromHeight?: number
-	toHeight?: number
-};
-type CanonicalWalkParams = Omit<CanonicalListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	/**
+	* Highest Stacks block past the burn-confirmation finality boundary.
+	* Optional for back-compat; the API always sets it.
+	*/
+	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 cursor (`<oldest_seekable_height>:0`); `null` = unlimited. */
+	oldest_cursor?: string | null
 };
-/** 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
+type StreamsCanonicalBlock = {
 	block_height: number
 	block_hash: string
-	parent_hash: string
 	burn_block_height: number
 	burn_block_hash: string | null
-	block_time: string | null
-	canonical: boolean
+	is_canonical: true
 };
-type BlocksEnvelope = {
-	blocks: IndexBlock[]
+type StreamsReorg = {
+	detected_at: string
+	fork_point_height: number
+	orphaned_range: {
+		from: string
+		to: string
+	}
+	new_canonical_tip: string
+};
+type StreamsEventsEnvelope = {
+	events: StreamsEvent[]
 	next_cursor: string | null
-	tip: IndexTip
+	tip: StreamsTip
+	reorgs: StreamsReorg[]
 };
-type BlockEnvelope = {
-	block: IndexBlock
-	tip: IndexTip
+type StreamsEventsListEnvelope = Omit<StreamsEventsEnvelope, "next_cursor">;
+type StreamsReorgsListParams = {
+	since: string
+	limit?: number
 };
-type BlocksListParams = {
+type StreamsReorgsListEnvelope = {
+	reorgs: StreamsReorg[]
+	next_since: string | null
+};
+/** A filter that matches a single value or any value in a list. */
+type StreamsFilterValue = string | readonly string[];
+type StreamsEventsListParams = {
 	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
 	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
+	limit?: number
 };
-type BlocksWalkParams = Omit<BlocksListParams, "limit"> & {
+type StreamsEventsStreamParams = {
+	fromCursor?: string | null
+	types?: readonly StreamsEventType[]
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
 	batchSize?: number
+	emptyBackoffMs?: number
+	maxPages?: number
+	maxEmptyPolls?: number
 	signal?: AbortSignal
 };
-type IndexPostCondition = {
-	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: "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[]
-	contract_call?: {
-		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
-	}
-	token_transfer?: {
-		recipient: string
-		amount: string
-		memo: string
-	}
-	smart_contract?: {
-		contract_id: string | null
-		clarity_version: number | null
-	}
-	coinbase?: {
-		alt_recipient: string | null
-	}
-	tenure_change?: {
-		cause: number
-	}
-};
-type TransactionsEnvelope = {
-	transactions: IndexTransaction[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-};
-type TransactionEnvelope = {
-	transaction: IndexTransaction
-	tip: IndexTip
-};
-type TransactionsListParams = {
-	cursor?: string | null
+type StreamsEventsSubscribeParams = {
+	/** Resume strictly after this cursor; omit to live-tail from the tip. */
 	fromCursor?: string | null
-	limit?: number
-	type?: string
-	sender?: string
-	contractId?: string
-	fromHeight?: number
-	toHeight?: number
-};
-type TransactionsWalkParams = Omit<TransactionsListParams, "limit"> & {
-	batchSize?: number
+	types?: readonly StreamsEventType[]
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
+	/** Abort to unsubscribe (the returned function does the same). */
 	signal?: AbortSignal
+	/** Called for each pushed event, in order. */
+	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
 };
-/** A decoded PoX-4 stacking action (one per stacking contract call). */
-type IndexStackingAction = {
+/**
+* The checkpoint the SDK computes for a batch. Persist `cursor` inside the same
+* transaction as your projection writes, then resume from it via `fromCursor`.
+* It is the position to advance to: `next_cursor` normally, or the last
+* finalized event when `finalizedOnly` is set.
+*/
+type StreamsBatchContext = {
+	cursor: string | null
+};
+/**
+* The checkpoint for a reorg rollback. Persist `cursor` (the rewind position)
+* inside the same transaction as your rollback so the two commit atomically.
+*/
+type StreamsReorgContext = {
 	cursor: string
-	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
 };
-type StackingEnvelope = {
-	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
+type StreamsEventsConsumeParams = {
+	fromCursor?: string | null
+	mode?: "tail" | "bounded"
+	/**
+	* Emit only finalized (immutable) events and never surface reorgs. The SDK
+	* checkpoints at the last finalized event and re-reads the unfinalized tail
+	* until it settles. Trades finality lag for zero reorg handling; `onReorg` is
+	* ignored.
+	*/
+	finalizedOnly?: boolean
+	types?: readonly StreamsEventType[]
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
+	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
+	* the resume point (advanced manual control); returning nothing uses it.
+	*/
+	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
+	/**
+	* Roll your projection back to `reorg.fork_point_height`, persisting
+	* `ctx.cursor` in the same transaction. Called once per *new* reorg
+	* (deduped in-memory, fork-ascending) before the SDK rewinds and re-reads the
+	* now-canonical events. Omit it to ignore reorgs (events stay canonical, but
+	* stale rows from an orphaned fork are left in place).
+	*/
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
+	emptyBackoffMs?: number
+	maxPages?: number
+	maxEmptyPolls?: number
+	signal?: AbortSignal
 };
-type StackingListParams = {
+/**
+* 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 = {
+	/** Canonical events of this page, in cursor order. */
+	events: StreamsEvent[]
+	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
+	cursor: string | null
+	tip: StreamsTip
+	/** Chain reorgs reported alongside this page; empty when none. */
+	reorgs: StreamsReorg[]
+};
+type StreamsConsumeParams = {
+	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
 	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	functionName?: string
-	stacker?: string
-	caller?: string
-	fromHeight?: number
-	toHeight?: number
+	types?: readonly StreamsEventType[]
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
+	/** Events per page (the `limit` query param). Default 100. */
+	batchSize?: number
+	/** Poll interval while caught up at the tip, in ms. Default 2000. */
+	intervalMs?: number
+	/** Abort to end the iteration. */
+	signal?: AbortSignal
 };
-type StackingWalkParams = Omit<StackingListParams, "limit"> & {
+type StreamsEventsConsumeResult = {
+	cursor: string | null
+	pages: number
+	emptyPolls: number
+};
+type StreamsEventsReplayParams = {
+	/** Start point: `"genesis"` (default) or a `<block>:<index>` cursor. */
+	from?: "genesis" | string
+	/**
+	* Called once per finalized dump file, in block order, before live tailing.
+	* Process the parquet with your own tooling (e.g. DuckDB) — the SDK does not
+	* decode parquet. Use `client.dumps.download(file)` to fetch + verify bytes.
+	*/
+	onDumpFile: (file: StreamsDumpFile) => Promise<void> | void
+	/** Called per live page after the dump phase, like `consume`. */
+	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined
+	mode?: "tail" | "bounded"
 	batchSize?: number
+	emptyBackoffMs?: number
+	maxPages?: number
+	maxEmptyPolls?: number
 	signal?: AbortSignal
 };
-/** 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[]
-	contract_call?: {
-		contract_id: string
-		function_name: string
-		function_args: unknown[]
+/** One bulk parquet file in the dumps manifest. `path` is the object key under
+*  the dumps base URL. */
+type StreamsDumpFile = {
+	path: string
+	from_block: number
+	to_block: number
+	min_cursor: string | null
+	max_cursor: string | null
+	row_count: number
+	byte_size: number
+	sha256: string
+	schema_version: number
+	created_at: string
+};
+type StreamsDumpsManifest = {
+	dataset: string
+	network: string
+	version: string
+	schema_version: number
+	generated_at: string
+	producer_version: string
+	finality_lag_blocks: number
+	/** Cursor at the end of the finalized bulk coverage — hand to live tailing. */
+	latest_finalized_cursor: string | null
+	coverage: {
+		from_block: number
+		to_block: number
 	}
-	token_transfer?: {
-		recipient: string
-		amount: string
-		memo: string
+	files: StreamsDumpFile[]
+	/** ed25519 signature over the manifest's canonical bytes. Absent on legacy
+	*  unsigned manifests. Verified by `list()` when `verifyDumpsManifest` is on. */
+	signature?: string
+	/** Short id of the signing public key. */
+	key_id?: string
+};
+type StreamsDumps = {
+	/** Fetch and parse the latest dumps manifest. */
+	list(): Promise<StreamsDumpsManifest>
+	/** Absolute URL for a manifest file. */
+	fileUrl(file: StreamsDumpFile): string
+	/** Download a parquet file and verify its sha256 against the manifest. */
+	download(file: StreamsDumpFile): Promise<Uint8Array>
+};
+type StreamsClient = {
+	/**
+	* Follow Streams as an async iterator of page batches.
+	*
+	* Yields one {@link StreamsBatch} per `GET /v1/streams/events` page — the
+	* existing envelope (`events`, `next_cursor` → `cursor`, `tip`, `reorgs`)
+	* with zero extra API calls. Batches are chosen over per-block groupings
+	* because the envelope is page-keyed, so every yield is exactly one fetch.
+	* Empty pages are skipped; at the tip the iterator re-polls every
+	* `intervalMs` (default 2000) until aborted via `signal`.
+	*
+	* Reorgs are surfaced on the batch (`batch.reorgs`) but the cursor is not
+	* rewound automatically — use `events.consume` with `onReorg` for managed
+	* rollback semantics.
+	*/
+	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>
+	events: {
+		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
+		byTxId(txId: string): Promise<StreamsEventsListEnvelope>
+		/**
+		* Pull pages from Streams and call `onBatch` after each page.
+		*
+		* Use `consume` for indexers and ETL jobs that own checkpointing. Return
+		* the checkpoint cursor from `onBatch`. Default `mode: "tail"` keeps
+		* polling when caught up; `mode: "bounded"` exits on the first empty page.
+		* The consumer also exits when `maxPages`, `maxEmptyPolls`, or `signal`
+		* stops it.
+		*/
+		consume(params: StreamsEventsConsumeParams): Promise<StreamsEventsConsumeResult>
+		/**
+		* Backfill from bulk dumps, then continue live from the dump→live seam in
+		* one call. Iterates finalized dump files (via `onDumpFile`) in block
+		* order, then tails live from the manifest's `latest_finalized_cursor`
+		* (exclusive input → no gap or duplicate at the seam). Requires
+		* `dumpsBaseUrl`.
+		*/
+		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>
+		/**
+		* Follow Streams as an async iterator.
+		*
+		* Use `stream` for live processors and watch-style apps. It tails
+		* indefinitely by default and stops when its `AbortSignal`, `maxPages`, or
+		* `maxEmptyPolls` stops it.
+		*/
+		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
 	}
-	smart_contract?: {
-		clarity_version: number | null
+	blocks: {
+		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>
 	}
-	coinbase?: {
-		alt_recipient: string | null
+	reorgs: {
+		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>
 	}
-	tenure_change?: {
-		cause: number
+	/** Bulk parquet dumps. Requires `dumpsBaseUrl` on the client. */
+	dumps: StreamsDumps
+	canonical(height: number): Promise<StreamsCanonicalBlock>
+	tip(): Promise<StreamsTip>
+	/** Your own Streams consumption (events today + this month) and tier limits. */
+	usage(): Promise<StreamsUsage>
+};
+type StreamsUsage = {
+	product: "streams"
+	tier: string
+	limits: {
+		rate_limit_per_second: number | null
+		retention_days: number | null
+	}
+	usage: {
+		events_today: number
+		events_this_month: number
 	}
 };
-type MempoolEnvelope = {
-	mempool: IndexMempoolTransaction[]
-	next_cursor: string | null
-	tip: IndexTip
+type Sleep = (ms: number, signal?: AbortSignal) => Promise<void>;
+/** Minimum shape a consumed Index row must expose. */
+type IndexFeedItem = {
+	cursor: string
+	block_height: number
 };
-type MempoolTransactionEnvelope = {
-	transaction: IndexMempoolTransaction
+/** Minimum envelope shape of a consumable Index feed page. */
+type IndexFeedEnvelope = {
+	next_cursor: string | null
 	tip: IndexTip
+	reorgs: IndexReorg[]
 };
-type MempoolListParams = {
-	cursor?: string | null
+/** Consumer options shared by `index.events.consume` and
+*  `index.contractCalls.consume`. Same contract as the Streams consumer:
+*  commit your writes inside `onBatch`, return the cursor you committed. */
+type IndexConsumeOptions<
+	TItem extends IndexFeedItem,
+	TEnvelope extends IndexFeedEnvelope
+> = {
+	/** Resume from a committed checkpoint. Without it (and without
+	*  `fromHeight`) the API serves only the recent default window. */
 	fromCursor?: string | null
-	limit?: number
-	sender?: string
-	type?: string
-	/** Filter to pending calls to a single contract (e.g. `SP….contract`). */
-	contractId?: string
-};
-type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
+	/** Start a fresh sweep at this height (e.g. `0` for genesis backfill).
+	*  Ignored once a cursor exists. */
+	fromHeight?: number
+	/** `tail` (default) keeps polling at the tip; `bounded` returns on the
+	*  first empty page. */
+	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
+	onBatch: (items: TItem[], envelope: TEnvelope, ctx: {
+		cursor: string | null
+	}) => 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
 };
+type IndexTip = {
+	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
+};
 /**
-* Empirical per-topic print payload schema for a contract, inferred from
-* sampled on-chain events. `topics` is sorted by count desc; `sampled` is true
-* when the contract has more print events than the windows examined.
+* A chain reorg overlapping a returned page's height range. Height-keyed feeds
+* (`/transactions`, `/contract-calls`, `/stacking`) populate this so a consumer
+* can reconcile: roll back the rows whose `block_height:tx_index` cursor falls in
+* `orphaned_range`, then re-fetch from `new_canonical_tip`. Empty when the page
+* spans no reorg.
 */
-type PrintSchemaResponse = {
-	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
-	sample: {
-		size: number
-		newest_height: number | null
-		oldest_height: number | null
+type IndexReorg = {
+	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
+	}
+	/** New canonical tip cursor to resume from. */
+	new_canonical_tip: string
+};
+type IndexUsage = {
+	product: "index"
+	tier: string
+	limits: {
+		rate_limit_per_second: number | null
+	}
+	usage: {
+		decoded_events_today: number
+		decoded_events_this_month: number
 	}
+};
+type FtTransfer = {
+	cursor: string
+	block_height: number
+	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 = {
+	events: FtTransfer[]
+	next_cursor: string | null
 	tip: IndexTip
+	reorgs: IndexReorg[]
 };
-/**
-* `index.ftTransfers` — callable shorthand for `.list()`, with `.list`/`.walk`
-* still available: `await sl.index.ftTransfers({ contractId })`.
-*
-* The API accepts `contract_id`/`sender`/`recipient` equality filters only —
-* no amount filtering and no asset-slug resolution on /v1/index/ft-transfers.
-*/
-interface FtTransfersResource {
-	(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
-	list(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
-	walk(params?: FtTransfersWalkParams): AsyncIterable<FtTransfer>;
-}
-/** `index.nftTransfers` — callable shorthand for `.list()` (see {@link FtTransfersResource}). */
-interface NftTransfersResource {
-	(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
-	list(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
-	walk(params?: NftTransfersWalkParams): AsyncIterable<NftTransfer>;
-}
-/** `index.events` — callable shorthand for `.list()`; `eventType` is required. */
-interface IndexEventsResource {
-	(params: EventsListParams): Promise<EventsEnvelope>;
-	list(params: EventsListParams): Promise<EventsEnvelope>;
-	walk(params: EventsWalkParams): AsyncIterable<IndexEvent>;
-}
-/** Per-event-type filter vocabulary in the {@link IndexDiscovery} doc. */
-type IndexEventTypeFilters = {
-	columns?: string[]
-	allowed_filters?: string[]
-	equality_filters?: string[]
-	required_non_null?: string[]
+type FtTransfersListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	contractId?: string
+	sender?: string
+	recipient?: string
+	fromHeight?: number
+	toHeight?: number
 };
-/** 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
+type FtTransfersWalkParams = Omit<FtTransfersListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
 };
-declare class Index extends BaseClient {
-	constructor(options?: Partial<SecondLayerOptions>);
-	/** Your own Index consumption (decoded events today + this month) and tier limits. */
-	usage(): Promise<IndexUsage>;
-	/**
-	* Index discovery doc — the live vocabulary: every endpoint, each event type's
-	* columns, allowed/equality filters, and required-non-null fields. Read this to
-	* learn what's queryable (and which types accept `trait`) instead of hardcoding.
-	*/
-	discover(): Promise<IndexDiscovery>;
-	/**
-	* Empirical per-topic print payload schema for a contract — what topics it
-	* emits and each field's observed Clarity/TS/column types. Anonymous read;
-	* 404 → null.
-	*/
-	printSchema(contractId: string): Promise<PrintSchemaResponse | null>;
-	/** Callable: `index.ftTransfers(params)` ≡ `index.ftTransfers.list(params)`. */
-	readonly ftTransfers: FtTransfersResource;
-	/** Callable: `index.nftTransfers(params)` ≡ `index.nftTransfers.list(params)`. */
-	readonly nftTransfers: NftTransfersResource;
-	/** Generic decoded events by `event_type` (the full /v1/index/events surface).
-	*  Callable: `index.events(params)` ≡ `index.events.list(params)`. */
-	readonly events: IndexEventsResource;
-	readonly contractCalls: {
-		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>
-		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>
-	};
-	/** Canonical block-hash map — sync only the current canonical chain. */
-	readonly canonical: {
-		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>
-	};
-	/** Full transaction documents: paginated `list`/`walk`, plus `get` by tx_id
-	*  (resolves to null on 404). */
-	readonly transactions: {
-		list: (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>
-	};
-	/** 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>
-	};
-	private listFtTransfers;
-	private listNftTransfers;
-	private walkFtTransfers;
-	private walkNftTransfers;
-	private listEvents;
-	private walkEvents;
-	private listContractCalls;
-	private walkContractCalls;
-	private listCanonical;
-	private walkCanonical;
-	private listBlocks;
-	private getBlock;
-	private walkBlocks;
-	private listTransactions;
-	private getTransaction;
-	/** Fetch the inclusion proof for a tx (raw tx + Nakamoto header + merkle path)
-	*  to verify client-side with `verifyTransactionProof`. 404 → null. A 503
-	*  (`PROOF_TX_SET_INCOMPLETE` / `PROOF_NODE_UNAVAILABLE`) surfaces as an
-	*  ApiError — the proof can't be assembled on this deployment right now. */
-	private getTransactionProof;
-	private walkTransactions;
-	private listStacking;
-	private walkStacking;
-	private listMempool;
-	private getMempoolTx;
-	private walkMempool;
-}
-/**
-* Typed client for project management (`/api/projects/*`).
-*
-* Projects are the account-scoped containers for work. Every method requires an
-* account-level (owner) API key or a dashboard session — scoped read keys are
-* rejected. Team mutations (invite/remove/role) are intentionally not exposed
-* here; only the read view ({@link Projects.team}) is.
-*/
-interface Project {
-	id: string;
-	name: string;
-	slug: string;
-	network: string;
-	nodeRpc: string | null;
-	settings: Record<string, unknown> | null;
-	createdAt: string;
-	updatedAt: string;
-}
-interface ProjectTeamMember {
-	id: string;
-	role: string;
-	email: string;
-	displayName: string | null;
-	avatarUrl: string | null;
-	createdAt: string;
-}
-interface ProjectInvitation {
-	id: string;
-	email: string;
-	role: string;
-	expiresAt: string;
-	createdAt: string;
-}
-interface ProjectTeam {
-	members: ProjectTeamMember[];
-	invitations: ProjectInvitation[];
-}
-interface CreateProjectParams {
-	name: string;
-	slug?: string;
-	network?: string;
-	nodeRpc?: string;
-}
-interface UpdateProjectParams {
-	name?: string;
-	/** Rename the project's URL slug. */
-	slug?: string;
-	network?: string;
-	nodeRpc?: string;
-	settings?: Record<string, unknown>;
-}
-declare class Projects extends BaseClient {
-	constructor(options?: Partial<SecondLayerOptions>);
-	/** All projects owned by the account, newest-relevant first. */
-	list(): Promise<{
-		projects: Project[]
-	}>;
-	/** A single project by slug. */
-	get(slug: string): Promise<Project>;
-	/** Create a project. The creator is added as the project owner. */
-	create(params: CreateProjectParams): Promise<Project>;
-	/** Update a project's name, slug (rename), network, RPC, or settings. */
-	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
-	}>;
-	/** Team members and pending invitations for a project. */
-	team(slug: string): Promise<ProjectTeam>;
-}
-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
-} | Record<string, unknown>;
-type StxTransferPayload = {
+type NftTransfer = {
+	cursor: string
+	block_height: number
+	tx_id: string
+	tx_index: number
+	event_index: number
+	event_type: "nft_transfer"
+	contract_id: string
+	asset_identifier: string
 	sender: string
 	recipient: string
-	amount: string
-	memo?: string
+	value: string
 };
-type StxMintPayload = {
-	recipient: string
-	amount: string
+type NftTransfersEnvelope = {
+	events: NftTransfer[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: IndexReorg[]
 };
-type StxBurnPayload = {
-	sender: string
-	amount: string
+type NftTransfersListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	contractId?: string
+	assetIdentifier?: string
+	sender?: string
+	recipient?: string
+	fromHeight?: number
+	toHeight?: number
 };
-type StxLockPayload = {
-	locked_address: string
-	locked_amount: string
-	unlock_height: string
+type NftTransfersWalkParams = Omit<NftTransfersListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
 };
-type FtTransferPayload = {
+type IndexEventBase = {
+	cursor: string
+	block_height: number
+	block_time?: string | null
+	tx_id: string
+	tx_index: number
+	event_index: number
+	contract_id: string | null
+};
+type IndexFtTransfer = IndexEventBase & {
+	event_type: "ft_transfer"
 	asset_identifier: string
 	sender: string
 	recipient: string
 	amount: string
 };
-type FtMintPayload = {
+type IndexNftTransfer = IndexEventBase & {
+	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
+};
+type IndexStxMint = IndexEventBase & {
+	event_type: "stx_mint"
 	recipient: string
 	amount: string
 };
-type FtBurnPayload = {
-	asset_identifier: string
+type IndexStxBurn = IndexEventBase & {
+	event_type: "stx_burn"
 	sender: string
 	amount: string
 };
-type NftTransferPayload = {
-	asset_identifier: string
+type IndexStxLock = IndexEventBase & {
+	event_type: "stx_lock"
 	sender: string
+	amount: string
+	payload: {
+		unlock_height: string | null
+	}
+};
+type IndexFtMint = IndexEventBase & {
+	event_type: "ft_mint"
+	asset_identifier: string
 	recipient: string
-	value: StreamsClarityValue
-	/** Canonical serialized hex of `value`, when the stream carries it. */
-	raw_value?: string
+	amount: string
 };
-type NftMintPayload = {
+type IndexFtBurn = IndexEventBase & {
+	event_type: "ft_burn"
+	asset_identifier: string
+	sender: string
+	amount: string
+};
+type IndexNftMint = IndexEventBase & {
+	event_type: "nft_mint"
 	asset_identifier: string
 	recipient: string
-	value: StreamsClarityValue
-	raw_value?: string
+	value: string
 };
-type NftBurnPayload = {
+type IndexNftBurn = IndexEventBase & {
+	event_type: "nft_burn"
 	asset_identifier: string
 	sender: string
-	value: StreamsClarityValue
-	raw_value?: string
+	value: string
 };
-type PrintPayload = {
-	contract_id?: string | null
-	topic?: string
-	value?: unknown
-	raw_value?: string
+type IndexPrint = IndexEventBase & {
+	event_type: "print"
+	payload: {
+		topic: string | null
+		value: unknown
+		raw_value: string | null
+	}
 };
-type StreamsEventBase = {
-	/**
-	* Globally unique, monotonic position of this event (`<block>:<index>`). Use
-	* it as the primary key of your projection rows — replaying a batch then
-	* upserts cleanly. Don't synthesize your own id from `tx_id`/`event_index`.
-	*/
+/** Decoded chain event, discriminated by `event_type`. */
+type IndexEvent = IndexFtTransfer | IndexNftTransfer | IndexStxTransfer | IndexStxMint | IndexStxBurn | IndexStxLock | IndexFtMint | IndexFtBurn | IndexNftMint | IndexNftBurn | IndexPrint;
+type IndexEventType = IndexEvent["event_type"];
+type EventsEnvelope = {
+	events: IndexEvent[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: IndexReorg[]
+};
+type EventsListParams = {
+	/** Required. One of the decoded event types. */
+	eventType: IndexEventType
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	contractId?: 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
+};
+type EventsWalkParams = Omit<EventsListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+type EventsConsumeParams = Omit<EventsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexEvent, EventsEnvelope>;
+type IndexContractCall = {
 	cursor: string
 	block_height: number
-	block_hash: string
-	burn_block_height: number
+	block_time?: string | null
 	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
+	contract_id: string
+	function_name: string
+	sender: string
+	status: string
+	args: unknown[]
+	result: unknown
+	result_hex: string | null
 };
-type StreamsEventOf<
-	T extends StreamsEventType,
-	P
-> = StreamsEventBase & {
-	event_type: T
-	payload: P
+type ContractCallsEnvelope = {
+	contract_calls: IndexContractCall[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: IndexReorg[]
 };
-/** 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 = {
+type ContractCallsListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	contractId?: 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
+};
+type ContractCallsWalkParams = Omit<ContractCallsListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+type ContractCallsConsumeParams = Omit<ContractCallsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexContractCall, ContractCallsEnvelope>;
+/** 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
-	/**
-	* Highest Stacks block past the burn-confirmation finality boundary.
-	* Optional for back-compat; the API always sets it.
-	*/
-	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 cursor (`<oldest_seekable_height>:0`); `null` = unlimited. */
-	oldest_cursor?: string | null
+	burn_block_hash: string | null
 };
-type StreamsCanonicalBlock = {
+type CanonicalEnvelope = {
+	canonical: IndexCanonicalBlock[]
+	next_cursor: string | null
+	tip: IndexTip
+};
+type CanonicalListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	fromHeight?: number
+	toHeight?: number
+};
+type CanonicalWalkParams = Omit<CanonicalListParams, "limit"> & {
+	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
-	is_canonical: true
-};
-type StreamsReorg = {
-	detected_at: string
-	fork_point_height: number
-	orphaned_range: {
-		from: string
-		to: string
-	}
-	new_canonical_tip: string
+	block_time: string | null
+	canonical: boolean
 };
-type StreamsEventsEnvelope = {
-	events: StreamsEvent[]
+type BlocksEnvelope = {
+	blocks: IndexBlock[]
 	next_cursor: string | null
-	tip: StreamsTip
-	reorgs: StreamsReorg[]
-};
-type StreamsEventsListEnvelope = Omit<StreamsEventsEnvelope, "next_cursor">;
-type StreamsReorgsListParams = {
-	since: string
-	limit?: number
+	tip: IndexTip
 };
-type StreamsReorgsListEnvelope = {
-	reorgs: StreamsReorg[]
-	next_since: string | null
+type BlockEnvelope = {
+	block: IndexBlock
+	tip: IndexTip
 };
-/** A filter that matches a single value or any value in a list. */
-type StreamsFilterValue = string | readonly string[];
-type StreamsEventsListParams = {
+type BlocksListParams = {
 	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
 	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
-	limit?: number
 };
-type StreamsEventsStreamParams = {
-	fromCursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+type BlocksWalkParams = Omit<BlocksListParams, "limit"> & {
 	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
-	/** Abort to unsubscribe (the returned function does the same). */
-	signal?: AbortSignal
-	/** Called for each pushed event, in order. */
-	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
-};
-/**
-* The checkpoint the SDK computes for a batch. Persist `cursor` inside the same
-* transaction as your projection writes, then resume from it via `fromCursor`.
-* It is the position to advance to: `next_cursor` normally, or the last
-* finalized event when `finalizedOnly` is set.
-*/
-type StreamsBatchContext = {
-	cursor: string | null
+type IndexPostCondition = {
+	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: "nft"
+	principal: string
+	asset_identifier: string
+	asset_value: unknown
+	condition_code: number
+	condition_code_name: string | null
 };
-/**
-* The checkpoint for a reorg rollback. Persist `cursor` (the rewind position)
-* inside the same transaction as your rollback so the two commit atomically.
-*/
-type StreamsReorgContext = {
+/** 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[]
+	contract_call?: {
+		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
+	}
+	token_transfer?: {
+		recipient: string
+		amount: string
+		memo: string
+	}
+	smart_contract?: {
+		contract_id: string | null
+		clarity_version: number | null
+	}
+	coinbase?: {
+		alt_recipient: string | null
+	}
+	tenure_change?: {
+		cause: number
+	}
 };
-type StreamsEventsConsumeParams = {
-	fromCursor?: string | null
-	mode?: "tail" | "bounded"
-	/**
-	* Emit only finalized (immutable) events and never surface reorgs. The SDK
-	* checkpoints at the last finalized event and re-reads the unfinalized tail
-	* until it settles. Trades finality lag for zero reorg handling; `onReorg` is
-	* ignored.
-	*/
-	finalizedOnly?: boolean
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
-	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
-	* the resume point (advanced manual control); returning nothing uses it.
-	*/
-	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
-	/**
-	* Roll your projection back to `reorg.fork_point_height`, persisting
-	* `ctx.cursor` in the same transaction. Called once per *new* reorg
-	* (deduped in-memory, fork-ascending) before the SDK rewinds and re-reads the
-	* now-canonical events. Omit it to ignore reorgs (events stay canonical, but
-	* stale rows from an orphaned fork are left in place).
-	*/
-	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+type TransactionsEnvelope = {
+	transactions: IndexTransaction[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: IndexReorg[]
 };
-/**
-* 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 = {
-	/** Canonical events of this page, in cursor order. */
-	events: StreamsEvent[]
-	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
-	cursor: string | null
-	tip: StreamsTip
-	/** Chain reorgs reported alongside this page; empty when none. */
-	reorgs: StreamsReorg[]
+type TransactionEnvelope = {
+	transaction: IndexTransaction
+	tip: IndexTip
 };
-type StreamsConsumeParams = {
-	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
+type TransactionsListParams = {
 	cursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
-	/** Events per page (the `limit` query param). Default 100. */
+	fromCursor?: string | null
+	limit?: number
+	type?: string
+	sender?: string
+	contractId?: string
+	fromHeight?: number
+	toHeight?: number
+};
+type TransactionsWalkParams = Omit<TransactionsListParams, "limit"> & {
 	batchSize?: number
-	/** Poll interval while caught up at the tip, in ms. Default 2000. */
-	intervalMs?: number
-	/** Abort to end the iteration. */
 	signal?: AbortSignal
 };
-type StreamsEventsConsumeResult = {
-	cursor: string | null
-	pages: number
-	emptyPolls: number
-};
-type StreamsEventsReplayParams = {
-	/** Start point: `"genesis"` (default) or a `<block>:<index>` cursor. */
-	from?: "genesis" | string
-	/**
-	* Called once per finalized dump file, in block order, before live tailing.
-	* Process the parquet with your own tooling (e.g. DuckDB) — the SDK does not
-	* decode parquet. Use `client.dumps.download(file)` to fetch + verify bytes.
-	*/
-	onDumpFile: (file: StreamsDumpFile) => Promise<void> | void
-	/** Called per live page after the dump phase, like `consume`. */
-	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined
-	mode?: "tail" | "bounded"
-	batchSize?: number
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+/** 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
+	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
 };
-/** One bulk parquet file in the dumps manifest. `path` is the object key under
-*  the dumps base URL. */
-type StreamsDumpFile = {
-	path: string
-	from_block: number
-	to_block: number
-	min_cursor: string | null
-	max_cursor: string | null
-	row_count: number
-	byte_size: number
-	sha256: string
-	schema_version: number
-	created_at: string
+type StackingEnvelope = {
+	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
 };
-type StreamsDumpsManifest = {
-	dataset: string
-	network: string
-	version: string
-	schema_version: number
-	generated_at: string
-	producer_version: string
-	finality_lag_blocks: number
-	/** Cursor at the end of the finalized bulk coverage — hand to live tailing. */
-	latest_finalized_cursor: string | null
-	coverage: {
-		from_block: number
-		to_block: number
-	}
-	files: StreamsDumpFile[]
-	/** ed25519 signature over the manifest's canonical bytes. Absent on legacy
-	*  unsigned manifests. Verified by `list()` when `verifyDumpsManifest` is on. */
-	signature?: string
-	/** Short id of the signing public key. */
-	key_id?: string
+type StackingListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	functionName?: string
+	stacker?: string
+	caller?: string
+	fromHeight?: number
+	toHeight?: number
 };
-type StreamsDumps = {
-	/** Fetch and parse the latest dumps manifest. */
-	list(): Promise<StreamsDumpsManifest>
-	/** Absolute URL for a manifest file. */
-	fileUrl(file: StreamsDumpFile): string
-	/** Download a parquet file and verify its sha256 against the manifest. */
-	download(file: StreamsDumpFile): Promise<Uint8Array>
+type StackingWalkParams = Omit<StackingListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
 };
-type StreamsClient = {
-	/**
-	* Follow Streams as an async iterator of page batches.
-	*
-	* Yields one {@link StreamsBatch} per `GET /v1/streams/events` page — the
-	* existing envelope (`events`, `next_cursor` → `cursor`, `tip`, `reorgs`)
-	* with zero extra API calls. Batches are chosen over per-block groupings
-	* because the envelope is page-keyed, so every yield is exactly one fetch.
-	* Empty pages are skipped; at the tip the iterator re-polls every
-	* `intervalMs` (default 2000) until aborted via `signal`.
-	*
-	* Reorgs are surfaced on the batch (`batch.reorgs`) but the cursor is not
-	* rewound automatically — use `events.consume` with `onReorg` for managed
-	* rollback semantics.
-	*/
-	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>
-	events: {
-		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
-		byTxId(txId: string): Promise<StreamsEventsListEnvelope>
-		/**
-		* Pull pages from Streams and call `onBatch` after each page.
-		*
-		* Use `consume` for indexers and ETL jobs that own checkpointing. Return
-		* the checkpoint cursor from `onBatch`. Default `mode: "tail"` keeps
-		* polling when caught up; `mode: "bounded"` exits on the first empty page.
-		* The consumer also exits when `maxPages`, `maxEmptyPolls`, or `signal`
-		* stops it.
-		*/
-		consume(params: StreamsEventsConsumeParams): Promise<StreamsEventsConsumeResult>
-		/**
-		* Backfill from bulk dumps, then continue live from the dump→live seam in
-		* one call. Iterates finalized dump files (via `onDumpFile`) in block
-		* order, then tails live from the manifest's `latest_finalized_cursor`
-		* (exclusive input → no gap or duplicate at the seam). Requires
-		* `dumpsBaseUrl`.
-		*/
-		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>
-		/**
-		* Follow Streams as an async iterator.
-		*
-		* Use `stream` for live processors and watch-style apps. It tails
-		* indefinitely by default and stops when its `AbortSignal`, `maxPages`, or
-		* `maxEmptyPolls` stops it.
-		*/
-		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
+/** 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[]
+	contract_call?: {
+		contract_id: string
+		function_name: string
+		function_args: unknown[]
 	}
-	blocks: {
-		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>
+	token_transfer?: {
+		recipient: string
+		amount: string
+		memo: string
 	}
-	reorgs: {
-		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>
+	smart_contract?: {
+		clarity_version: number | null
 	}
-	/** Bulk parquet dumps. Requires `dumpsBaseUrl` on the client. */
-	dumps: StreamsDumps
-	canonical(height: number): Promise<StreamsCanonicalBlock>
-	tip(): Promise<StreamsTip>
-	/** Your own Streams consumption (events today + this month) and tier limits. */
-	usage(): Promise<StreamsUsage>
-};
-type StreamsUsage = {
-	product: "streams"
-	tier: string
-	limits: {
-		rate_limit_per_second: number | null
-		retention_days: number | null
+	coinbase?: {
+		alt_recipient: string | null
 	}
-	usage: {
-		events_today: number
-		events_this_month: number
+	tenure_change?: {
+		cause: number
 	}
 };
+type MempoolEnvelope = {
+	mempool: IndexMempoolTransaction[]
+	next_cursor: string | null
+	tip: IndexTip
+};
+type MempoolTransactionEnvelope = {
+	transaction: IndexMempoolTransaction
+	tip: IndexTip
+};
+type MempoolListParams = {
+	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
+};
+type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+/**
+* Empirical per-topic print payload schema for a contract, inferred from
+* sampled on-chain events. `topics` is sorted by count desc; `sampled` is true
+* when the contract has more print events than the windows examined.
+*/
+type PrintSchemaResponse = {
+	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
+	sample: {
+		size: number
+		newest_height: number | null
+		oldest_height: number | null
+	}
+	tip: IndexTip
+};
+/**
+* `index.ftTransfers` — callable shorthand for `.list()`, with `.list`/`.walk`
+* still available: `await sl.index.ftTransfers({ contractId })`.
+*
+* The API accepts `contract_id`/`sender`/`recipient` equality filters only —
+* no amount filtering and no asset-slug resolution on /v1/index/ft-transfers.
+*/
+interface FtTransfersResource {
+	(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
+	list(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
+	walk(params?: FtTransfersWalkParams): AsyncIterable<FtTransfer>;
+}
+/** `index.nftTransfers` — callable shorthand for `.list()` (see {@link FtTransfersResource}). */
+interface NftTransfersResource {
+	(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
+	list(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
+	walk(params?: NftTransfersWalkParams): AsyncIterable<NftTransfer>;
+}
+/** `index.events` — callable shorthand for `.list()`; `eventType` is required. */
+interface IndexEventsResource {
+	(params: EventsListParams): Promise<EventsEnvelope>;
+	list(params: EventsListParams): Promise<EventsEnvelope>;
+	walk(params: EventsWalkParams): AsyncIterable<IndexEvent>;
+	consume(params: EventsConsumeParams): Promise<{
+		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[]
+};
+/** 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
+};
+declare class Index extends BaseClient {
+	constructor(options?: Partial<SecondLayerOptions>);
+	/** Your own Index consumption (decoded events today + this month) and tier limits. */
+	usage(): Promise<IndexUsage>;
+	/**
+	* Index discovery doc — the live vocabulary: every endpoint, each event type's
+	* columns, allowed/equality filters, and required-non-null fields. Read this to
+	* learn what's queryable (and which types accept `trait`) instead of hardcoding.
+	*/
+	discover(): Promise<IndexDiscovery>;
+	/**
+	* Empirical per-topic print payload schema for a contract — what topics it
+	* emits and each field's observed Clarity/TS/column types. Anonymous read;
+	* 404 → null.
+	*/
+	printSchema(contractId: string): Promise<PrintSchemaResponse | null>;
+	/** Callable: `index.ftTransfers(params)` ≡ `index.ftTransfers.list(params)`. */
+	readonly ftTransfers: FtTransfersResource;
+	/** Callable: `index.nftTransfers(params)` ≡ `index.nftTransfers.list(params)`. */
+	readonly nftTransfers: NftTransfersResource;
+	/** Generic decoded events by `event_type` (the full /v1/index/events surface).
+	*  Callable: `index.events(params)` ≡ `index.events.list(params)`. */
+	readonly events: IndexEventsResource;
+	readonly contractCalls: {
+		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>
+		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>
+		consume: (params: ContractCallsConsumeParams) => Promise<{
+			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>
+	};
+	/** 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>
+	};
+	/** Full transaction documents: paginated `list`/`walk`, plus `get` by tx_id
+	*  (resolves to null on 404). */
+	readonly transactions: {
+		list: (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>
+	};
+	/** 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>
+	};
+	private listFtTransfers;
+	private listNftTransfers;
+	private walkFtTransfers;
+	private walkNftTransfers;
+	private listEvents;
+	private walkEvents;
+	private listContractCalls;
+	private walkContractCalls;
+	private listCanonical;
+	private walkCanonical;
+	private listBlocks;
+	private getBlock;
+	private walkBlocks;
+	private listTransactions;
+	private getTransaction;
+	/** Fetch the inclusion proof for a tx (raw tx + Nakamoto header + merkle path)
+	*  to verify client-side with `verifyTransactionProof`. 404 → null. A 503
+	*  (`PROOF_TX_SET_INCOMPLETE` / `PROOF_NODE_UNAVAILABLE`) surfaces as an
+	*  ApiError — the proof can't be assembled on this deployment right now. */
+	private getTransactionProof;
+	private walkTransactions;
+	private listStacking;
+	private walkStacking;
+	private listMempool;
+	private getMempoolTx;
+	private walkMempool;
+}
+/**
+* Typed client for project management (`/api/projects/*`).
+*
+* Projects are the account-scoped containers for work. Every method requires an
+* account-level (owner) API key or a dashboard session — scoped read keys are
+* rejected. Team mutations (invite/remove/role) are intentionally not exposed
+* here; only the read view ({@link Projects.team}) is.
+*/
+interface Project {
+	id: string;
+	name: string;
+	slug: string;
+	network: string;
+	nodeRpc: string | null;
+	settings: Record<string, unknown> | null;
+	createdAt: string;
+	updatedAt: string;
+}
+interface ProjectTeamMember {
+	id: string;
+	role: string;
+	email: string;
+	displayName: string | null;
+	avatarUrl: string | null;
+	createdAt: string;
+}
+interface ProjectInvitation {
+	id: string;
+	email: string;
+	role: string;
+	expiresAt: string;
+	createdAt: string;
+}
+interface ProjectTeam {
+	members: ProjectTeamMember[];
+	invitations: ProjectInvitation[];
+}
+interface CreateProjectParams {
+	name: string;
+	slug?: string;
+	network?: string;
+	nodeRpc?: string;
+}
+interface UpdateProjectParams {
+	name?: string;
+	/** Rename the project's URL slug. */
+	slug?: string;
+	network?: string;
+	nodeRpc?: string;
+	settings?: Record<string, unknown>;
+}
+declare class Projects extends BaseClient {
+	constructor(options?: Partial<SecondLayerOptions>);
+	/** All projects owned by the account, newest-relevant first. */
+	list(): Promise<{
+		projects: Project[]
+	}>;
+	/** A single project by slug. */
+	get(slug: string): Promise<Project>;
+	/** Create a project. The creator is added as the project owner. */
+	create(params: CreateProjectParams): Promise<Project>;
+	/** Update a project's name, slug (rename), network, RPC, or settings. */
+	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
+	}>;
+	/** Team members and pending invitations for a project. */
+	team(slug: string): Promise<ProjectTeam>;
+}
 import { CreateSubscriptionRequest, CreateSubscriptionResponse, DeadRow, DeliveryRow, ReplayResult, RotateSecretResponse, SubscriptionDetail, SubscriptionSummary, SubscriptionTestResult, UpdateSubscriptionRequest } from "@secondlayer/shared/schemas/subscriptions";
 declare class Subscriptions extends BaseClient {
 	list(): Promise<{