@secondlayer/subgraphs 4.4.1 → 5.0.1

package/dist/src/runtime/reindex.d.ts

@@ -1,539 +0,0 @@
-import { AbiContract as AbiContract2 } from "@secondlayer/stacks/clarity";
-import { AssetIdentifier } from "@secondlayer/stacks/filters";
-/**
-* How long a read stays valid.
-*
-* - `per-block` (default): pinned to the block being processed, cached under
-*   its `index_block_hash`. Sound for any read-only function — reindexing the
-*   same block always returns the same value, and a reorg-replaced block has a
-*   different id so it can't inherit the orphaned answer.
-* - `contract-constant`: the caller asserts the value cannot change for this
-*   contract and these args (SIP-010 `get-decimals`/`get-symbol`), so it is
-*   resolved ONCE instead of once per block. This is the mode that makes a
-*   backfill affordable — under `per-block` every block is a distinct key and
-*   therefore a distinct RPC. Declaring it on a value that does change pins the
-*   first answer forever, so it is opt-in and never inferred.
-*/
-type ChainReadCacheMode = "per-block" | "contract-constant";
-type ChainReadOptions = {
-	cache?: ChainReadCacheMode
-};
-/**
-* `ChainReadClient` with the ABI generic erased. Structurally cheap, so the
-* base `SubgraphContext` can carry it; `TypedSubgraphContext` uses the real
-* one and handlers get full inference.
-*/
-interface ErasedChainReadClient {
-	contract(contractId: string, abi: unknown, options?: ChainReadOptions): {
-		read: Record<string, (args?: Record<string, unknown>) => Promise<unknown>>
-	};
-}
-/** Supported column types for subgraph schemas */
-type ColumnType = "text" | "uint" | "int" | "principal" | "boolean" | "timestamp" | "jsonb";
-/** Column definition in a subgraph table */
-interface SubgraphColumn {
-	type: ColumnType;
-	nullable?: boolean;
-	indexed?: boolean;
-	search?: boolean;
-	default?: string | number | boolean;
-}
-/**
-* A foreign-key relation to another table in the same subgraph. Drives DDL FK
-* constraints and ORM codegen (`@relation` in Prisma, `relations()` in Drizzle)
-* so generated clients get typed joins. The referenced columns must form a
-* `uniqueKeys` entry on the target table.
-*/
-interface SubgraphRelation {
-	/** Relation field name on this table's generated model (e.g. "pool"). */
-	name: string;
-	/** Target table name in this subgraph. */
-	references: string;
-	/** Local column(s) holding the foreign key. */
-	fields: string[];
-	/** Target column(s) the fields point at (a uniqueKeys entry on the target). */
-	referencedColumns: string[];
-}
-/**
-* Table definition within a subgraph schema.
-*
-* The array fields are `readonly` so a schema literal can be hoisted out of
-* the `defineSubgraph()` call with `as const` (or {@link defineSchema}) and
-* still typecheck — `as const` produces `readonly [readonly ["holder"]]`,
-* which a mutable `string[][]` rejects. Without that, extracting a helper
-* that takes `ctx` meant losing the entire typed surface, which is why the
-* shipped starter reached for `ctx: any`.
-*/
-interface SubgraphTable {
-	columns: Record<string, SubgraphColumn>;
-	/** Composite indexes (each entry is an array of column names) */
-	indexes?: readonly (readonly string[])[];
-	/** Unique key constraints (each entry is an array of column names). Required for upsert. */
-	uniqueKeys?: readonly (readonly string[])[];
-	/** Foreign-key relations to other tables (for typed ORM joins). */
-	relations?: readonly SubgraphRelation[];
-}
-/** Subgraph schema — maps table names to table definitions */
-type SubgraphSchema = Record<string, SubgraphTable>;
-/** STX event filters */
-interface StxTransferFilter {
-	type: "stx_transfer";
-	sender?: string;
-	recipient?: string;
-	minAmount?: bigint;
-	maxAmount?: bigint;
-}
-interface StxMintFilter {
-	type: "stx_mint";
-	recipient?: string;
-	minAmount?: bigint;
-}
-interface StxBurnFilter {
-	type: "stx_burn";
-	sender?: string;
-	minAmount?: bigint;
-}
-interface StxLockFilter {
-	type: "stx_lock";
-	lockedAddress?: string;
-	minAmount?: bigint;
-}
-/**
-* Restrict a source to contracts conforming to a trait/standard (e.g. "sip-010")
-* instead of a fixed contract — resolved from the contract registry at match time,
-* as-of each processed block. Lets a source index "all SIP-010 tokens" etc.
-*/
-type TraitScope = {
-	trait?: string
-};
-/**
-* Scope a source to a DYNAMIC address set discovered from another source's
-* events, instead of a fixed contract list.
-*
-* The standard shape it unlocks: a router plus pools created after you
-* deploy. `contractId` arrays cover a set you know at authoring time; a
-* factory covers the set that grows. It is deliberately NOT tied to contract
-* deployment — the address can come from any field of any event, so it also
-* covers launchpad-minted tokens, DAO extension allowlists, and registry
-* entries.
-*
-* ```ts
-* sources: {
-*   registry: {
-*     type: "print_event",
-*     contractId: REGISTRY,
-*     topic: "pool-created",
-*     prints: { "pool-created": { pool: "principal" } },
-*   },
-*   swaps: {
-*     type: "print_event",
-*     topic: "swap",
-*     // every pool the registry has ever announced, including new ones
-*     factory: { from: "registry", field: "data.pool" },
-*   },
-* }
-* ```
-*
-* Two guarantees the runtime provides:
-* - **Same-block ordering** — a contract discovered in block N receives its
-*   own block-N events. Discovery runs before matching, within the block.
-* - **Reorg-scoped** — the discovered set is stamped with the block that
-*   revealed it and rolled back with everything else on a fork, so an address
-*   announced on an orphaned chain does not linger forever.
-*/
-interface FactoryScope {
-	factory?: {
-		/** Source name whose events reveal the addresses. */
-		from: string
-		/** Dotted path to the address on that source's payload
-		*  (e.g. `"data.pool"`, `"contractId"`, `"data.token.id"`). */
-		field: string
-	};
-}
-/** FT event filters */
-interface FtTransferFilter extends TraitScope {
-	type: "ft_transfer";
-	assetIdentifier?: AssetIdentifier;
-	sender?: string;
-	recipient?: string;
-	minAmount?: bigint;
-}
-interface FtMintFilter extends TraitScope {
-	type: "ft_mint";
-	assetIdentifier?: AssetIdentifier;
-	recipient?: string;
-	minAmount?: bigint;
-}
-interface FtBurnFilter extends TraitScope {
-	type: "ft_burn";
-	assetIdentifier?: AssetIdentifier;
-	sender?: string;
-	minAmount?: bigint;
-}
-/** NFT event filters */
-interface NftTransferFilter extends TraitScope {
-	type: "nft_transfer";
-	assetIdentifier?: AssetIdentifier;
-	sender?: string;
-	recipient?: string;
-}
-interface NftMintFilter extends TraitScope {
-	type: "nft_mint";
-	assetIdentifier?: AssetIdentifier;
-	recipient?: string;
-}
-interface NftBurnFilter extends TraitScope {
-	type: "nft_burn";
-	assetIdentifier?: AssetIdentifier;
-	sender?: string;
-}
-/** Contract event filters */
-interface ContractCallFilter extends TraitScope, FactoryScope {
-	type: "contract_call";
-	/**
-	* One contract id, or a SET of them (max 20) — the standard DeFi shape is
-	* a router plus N pools, which used to cost N near-identical sources and
-	* handlers, or the `"*"` catch-all that erases per-source typing. Payload
-	* types are identical per `type`, so one handler serves the set and
-	* `event.contractId` disambiguates.
-	*
-	* Supports `*` wildcards (e.g. `"SP1ABC….pool-*"`). Mutually exclusive
-	* with `trait`, which resolves its own set per block.
-	*/
-	contractId?: string | readonly string[];
-	functionName?: string;
-	caller?: string;
-	/**
-	* Contract ABI (pass it `as const`) used to type `event.input` — the named,
-	* decoded function arguments. Dev-provided; serialized into the deployed
-	* definition and used at runtime to decode args by name. Omit to keep
-	* `event.args` as a positional `unknown[]`.
-	*
-	* Deploy validation requires `abi` whenever `functionName` is set
-	* (`normalizeAbi()` from `@secondlayer/stacks/clarity`).
-	*/
-	abi?: AbiContract2;
-}
-interface ContractDeployFilter {
-	type: "contract_deploy";
-	deployer?: string;
-	contractName?: string;
-}
-interface NestedContractCallFilter extends TraitScope, FactoryScope {
-	type: "nested_contract_call";
-	contractId?: string | readonly string[];
-	functionName?: string;
-	caller?: string;
-	sender?: string;
-}
-interface VarSetFilter extends TraitScope, FactoryScope {
-	type: "var_set";
-	contractId?: string | readonly string[];
-	varName?: string;
-}
-interface MapWriteFilter extends TraitScope, FactoryScope {
-	type: "map_set" | "map_insert" | "map_delete";
-	contractId?: string | readonly string[];
-	map?: string;
-}
-/**
-* One declared field of a print payload.
-*
-* A bare {@link ColumnType} is a required scalar (`amount: "uint"`). The
-* composite forms exist because real print payloads are not flat: BNS-V2
-* emits `name` as a NESTED tuple, and a `prints` vocabulary that could only
-* say `"jsonb"` is why a handler reading flat `data.name` type-checked,
-* deployed, and then decoded to null on every event.
-*
-* - `{ type: F, optional: true }` — the KEY becomes optional on `event.data`
-*   (mirrors `always_present: false` in the inferred schema).
-* - `{ tuple: { … } }` — a nested tuple, typed all the way down.
-* - `{ list: F }` — a list of `F`.
-*/
-type PrintField = ColumnType | {
-	type: PrintField
-	optional: true
-} | {
-	tuple: Record<string, PrintField>
-} | {
-	list: PrintField
-};
-/**
-* Per-topic field schema for a print_event source. When declared, the handler's
-* `event` is a discriminated union keyed by `topic` and `event.data` is typed
-* per topic. Nested tuples, lists, and optional fields — see {@link PrintField}.
-*
-* Also opts the source into RUNTIME validation: a payload that does not match
-* is skipped and logged rather than written as nulls.
-*/
-type PrintEventPrints = Record<string, Record<string, PrintField>>;
-/**
-* One column in a static identity map. Literals only — the bundler never
-* executes user code, so `{ from: "tokenX" }` is valid and `from("tokenX")`
-* is not.
-*/
-type MaterializeColumn = {
-	from: string
-} | {
-	fromTx: "sender" | "txId"
-} | {
-	fromBlock: "height" | "hash" | "timestamp"
-};
-/** Static insert from a source event — replaces a 1:1 handler. */
-interface MaterializeSpec {
-	table: string;
-	/** Keys = schema column names (snake). */
-	columns: Record<string, MaterializeColumn>;
-}
-type PrintEventFields = FactoryScope & {
-	type: "print_event"
-	topic?: string
-	/** Identity map: insert without a handler function. XOR with handlers[name]. */
-	materialize?: MaterializeSpec
-};
-/**
-* Pinned to one or more contract ids with no trait — `prints` is required so
-* `event.data` is typed and empty-table handlers cannot typecheck.
-*/
-type PinnedPrintEventFilter = PrintEventFields & {
-	contractId: string | readonly string[]
-	trait?: undefined
-	prints: PrintEventPrints
-};
-/**
-* Trait-scoped print source (optionally narrowed by contractId). No single
-* schema — `prints` stays optional.
-*/
-type TraitPrintEventFilter = PrintEventFields & {
-	contractId?: string | readonly string[]
-	trait: string
-	prints?: PrintEventPrints
-};
-/**
-* Unpinned / factory-only print source (no contractId). `prints` optional.
-*/
-type UnpinnedPrintEventFilter = PrintEventFields & {
-	contractId?: undefined
-	trait?: string
-	prints?: PrintEventPrints
-};
-/**
-* Print-event filter. Pinned sources (contractId set, no trait) require
-* `prints`; trait and unpinned sources may omit it.
-*/
-type PrintEventFilter = PinnedPrintEventFilter | TraitPrintEventFilter | UnpinnedPrintEventFilter;
-/** All subgraph filter types — discriminated on `type` */
-type SubgraphFilter = StxTransferFilter | StxMintFilter | StxBurnFilter | StxLockFilter | FtTransferFilter | FtMintFilter | FtBurnFilter | NftTransferFilter | NftMintFilter | NftBurnFilter | ContractCallFilter | ContractDeployFilter | PrintEventFilter | NestedContractCallFilter | VarSetFilter | MapWriteFilter;
-/** Transaction metadata available in handlers */
-interface TxMeta {
-	txId: string;
-	sender: string;
-	type: string;
-	status: string;
-	contractId?: string | null;
-	functionName?: string | null;
-}
-/** Scalar types that can appear as row values */
-type RowValue = string | number | bigint | boolean | null | undefined | Record<string, unknown> | unknown[];
-/** Value or computed function that receives existing row */
-type ComputedValue = RowValue | ((existing: Record<string, unknown> | null) => unknown);
-/** Context passed to subgraph handlers during event processing */
-interface SubgraphContext {
-	block: {
-		height: number
-		hash: string
-		timestamp: number
-		burnBlockHeight: number
-		/** Nakamoto StacksBlockId, when the block row carries one. */
-		indexBlockHash?: string | null
-	};
-	tx: TxMeta;
-	/**
-	* Read-only contract calls pinned to this block. Cached, so the same
-	* (contract, function, args) is fetched once per block rather than once
-	* per event.
-	*
-	* Erased here on purpose: this interface is compared structurally wherever
-	* a subgraph definition is passed around, and carrying an ABI-generic
-	* method pushes those comparisons past TS's instantiation depth. Handlers
-	* receive `TypedSubgraphContext`, which exposes the fully typed version.
-	*/
-	client: ErasedChainReadClient;
-	insert(table: string, row: Record<string, unknown>): void;
-	update(table: string, where: Record<string, unknown>, set: Record<string, unknown>): void;
-	upsert(table: string, key: Record<string, unknown>, row: Record<string, unknown>): void;
-	delete(table: string, where: Record<string, unknown>): void;
-	/**
-	* Atomic counter update — the blessed accumulator primitive. Applies
-	* `col = COALESCE(col, 0) + delta` per column (insert-or-add); deltas may
-	* be negative. Requires a uniqueKeys constraint matching `key`. Prefer
-	* this over patchOrInsert with functional updaters for running totals.
-	*/
-	increment(table: string, key: Record<string, unknown>, deltas: Record<string, bigint | number>): void;
-	/** Partial update — sets only specified fields, preserves others */
-	patch(table: string, where: Record<string, unknown>, set: Record<string, unknown>): void;
-	/** Find-then-merge-or-insert. Values can be functions: (existing) => newValue */
-	patchOrInsert(table: string, key: Record<string, unknown>, row: Record<string, ComputedValue>): Promise<void>;
-	findOne(table: string, where: Record<string, unknown>): Promise<Record<string, unknown> | null>;
-	findMany(table: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
-	/** Format a bigint amount with decimal places */
-	formatUnits(value: bigint, decimals: number): string;
-	/** Count rows matching filter */
-	count(table: string, where?: Record<string, unknown>): Promise<number>;
-	/** Sum a numeric column */
-	sum(table: string, column: string, where?: Record<string, unknown>): Promise<bigint>;
-	/** Min of a numeric column */
-	min(table: string, column: string, where?: Record<string, unknown>): Promise<bigint | null>;
-	/** Max of a numeric column */
-	max(table: string, column: string, where?: Record<string, unknown>): Promise<bigint | null>;
-	/** Count distinct values in a column */
-	countDistinct(table: string, column: string, where?: Record<string, unknown>): Promise<number>;
-}
-/** Handler function that processes events and writes to the subgraph */
-type SubgraphHandler = (event: Record<string, unknown>, ctx: SubgraphContext) => Promise<void> | void;
-/** Complete subgraph definition */
-interface SubgraphDefinition {
-	/** Unique subgraph name (lowercase, alphanumeric + hyphens) */
-	name: string;
-	/** Semantic version */
-	version?: string;
-	/** Human description */
-	description?: string;
-	/** Block height to start indexing from (default: 1) */
-	startBlock?: number;
-	/** 'concurrent' = tip-first: live at tip now, history backfills behind.
-	*  Requires order-tolerant handlers. Default 'blocking'. */
-	backfillMode?: "blocking" | "concurrent";
-	/** Named source filters — keys become handler keys */
-	sources: Record<string, SubgraphFilter>;
-	/** Tables in this subgraph */
-	schema: SubgraphSchema;
-	/** Handler functions — keys must match source names (or "*" for catch-all) */
-	handlers: Record<string, SubgraphHandler>;
-}
-import { Block, Event, Transaction } from "@secondlayer/shared/db";
-/** A runtime event row. `clock: "vm"` marks an opt-in `vm_events` row whose
-*  `event_index` is `ordinal` — a second ordinal that never sorts or
-*  dedupes against classic `events.event_index`. */
-type RuntimeEvent = Event & {
-	clock?: "vm"
-};
-interface BlockData {
-	block: Block;
-	txs: Transaction[];
-	/** Classic `events` rows (Streams 1.0 clock). */
-	events: Event[];
-	/** Opt-in `vm_events` rows on their own clock. Absent/empty on `"*"`
-	*  nodes and on archives collected without `storage`/`contract_calls`. */
-	vmEvents?: RuntimeEvent[];
-}
-/**
-* Where the subgraph runtime reads canonical chain data. Today it taps the
-* indexer Postgres directly (`PostgresBlockSource`); the re-point adds a
-* `PublicApiBlockSource` that consumes the Streams clock + Index data over
-* HTTP. `matchSources` / handlers / flush / outbox are unchanged — only the
-* loader + tip swap behind this seam.
-*/
-interface BlockSource {
-	/** Highest canonical block height available to process. */
-	getTip(): Promise<number>;
-	/** Canonical block data for [fromHeight, toHeight], keyed by height. */
-	loadBlockRange(fromHeight: number, toHeight: number): Promise<Map<number, BlockData>>;
-	/** Sparse-scan probe: lowest height in (afterHeight, untilHeight] holding
-	*  an event this source's subgraph could match, or null when the rest of
-	*  the range is empty. Optional — only event-scoped sources support it. */
-	nextDataHeight?(afterHeight: number, untilHeight: number): Promise<number | null>;
-}
-type ReindexBatchConfig = {
-	defaultBatchSize: number
-	minBatchSize: number
-	maxBatchSize: number
-};
-type ReindexBatchEnv = {
-	SUBGRAPH_REINDEX_BATCH_SIZE?: string
-	SUBGRAPH_REINDEX_MIN_BATCH_SIZE?: string
-	SUBGRAPH_REINDEX_MAX_BATCH_SIZE?: string
-};
-type ReindexResumeRow = {
-	last_processed_block: number | string
-	reindex_from_block: number | string | null
-	reindex_to_block: number | string | null
-};
-declare function initialReindexProgressBlock(fromBlock: number): number;
-declare function resolveReindexResumeBlock(row: ReindexResumeRow): number | null;
-declare function resolveReindexBatchConfig(env?: ReindexBatchEnv): ReindexBatchConfig;
-interface ReindexOptions {
-	/**
-	* Floor on the walk's first block — NOT a caller-supplied range. When set
-	* (e.g. an op row carrying a `from_block`), it raises the walk start and
-	* can never lower it. There is deliberately no `toBlock` counterpart:
-	* a reindex always runs to chain tip. See {@link resolveBlockRange}.
-	*/
-	startBlockFloor?: number;
-	schemaName?: string;
-	/** Op row to receive processed_events on each progress flush. */
-	operationId?: string;
-	signal?: AbortSignal;
-}
-/**
-* Resolve the reindex walk range. Always the whole subgraph:
-* `[def.startBlock, chain tip]`. Chain tip reads from `index_progress` —
-* lives in the source DB.
-*
-* Reindex drops the schema unconditionally, so the walk range is also the
-* ONLY data that survives. A narrower walk therefore does not "reindex a
-* range" — it silently destroys every row outside it while leaving the
-* subgraph reporting `active` at chain tip (f079: a single-block
-* `--from-block N --to-block N` emptied sbtc-flows, and the first recovery
-* attempt rebuilt only 21% of its history). Ranged, additive work is
-* `backfillSubgraph`'s job.
-*
-* `startBlockFloor` is a plan-policy floor, not a range: it can only raise
-* the start block, never lower it, and never bounds the end.
-*/
-declare function resolveBlockRange(source: BlockSource, def: SubgraphDefinition, opts?: ReindexOptions): Promise<{
-	fromBlock: number
-	toBlock: number
-}>;
-/**
-* Reindex a subgraph by dropping its tables, recreating them, and reprocessing
-* all historical blocks through the handler pipeline.
-*
-* Always whole-subgraph: `[start_block, chain tip]`. There is no ranged
-* reindex — the drop cannot be scoped to a range without re-running delta
-* handlers (`ctx.increment` / `ctx.update` / `ctx.patchOrInsert`) over rows
-* that were never removed, which is the exact double-count hazard `backfill`
-* already refuses. Use `backfillSubgraph` for ranged, additive work.
-*
-* Supports cancellation via AbortSignal — on shutdown abort, status stays
-* "reindexing" for auto-resume; on user cancel, status resets to "active".
-*/
-declare function reindexSubgraph(def: SubgraphDefinition, opts?: ReindexOptions): Promise<{
-	processed: number
-}>;
-/**
-* Resume a previously interrupted reindex. Skips schema drop (already done)
-* and continues from last_processed_block + 1.
-*/
-declare function resumeReindex(def: SubgraphDefinition, opts: {
-	schemaName: string
-	operationId?: string
-	signal?: AbortSignal
-}): Promise<{
-	processed: number
-}>;
-/**
-* Backfill a subgraph by re-processing a block range WITHOUT dropping the schema.
-* Uses upserts so existing data is updated, not duplicated. Safe to run while
-* the subgraph is actively syncing.
-*/
-declare function backfillSubgraph(def: SubgraphDefinition, opts: {
-	fromBlock: number
-	toBlock: number
-	schemaName?: string
-	operationId?: string
-	signal?: AbortSignal
-}): Promise<{
-	processed: number
-}>;
-export { resumeReindex, resolveReindexResumeBlock, resolveReindexBatchConfig, resolveBlockRange, reindexSubgraph, initialReindexProgressBlock, backfillSubgraph, ReindexOptions };