@secondlayer/subgraphs 4.4.1 → 5.0.1

package/dist/src/runtime/block-processor.d.ts

@@ -1,559 +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>;
-}
-type TxRecord = {
-	tx_id: string
-	type: string
-	sender: string
-	status: string
-	/** Position within the block — the runner sorts dispatch into chain order. */
-	tx_index?: number
-	contract_id?: string | null
-	function_name?: string | null
-	function_args?: unknown | null
-	raw_result?: string | null
-};
-type EventRecord = {
-	id: string
-	tx_id: string
-	type: string
-	/** Classic `event_index`, or `ordinal` when `clock === "vm"`. */
-	event_index: number
-	data: unknown
-	/** Set on opt-in `vm_events` rows. Two clocks never sort or dedupe together. */
-	clock?: "vm"
-};
-import { Database as Database2 } from "@secondlayer/shared/db";
-import { Kysely as Kysely2, Transaction } from "kysely";
-/** Drop a subgraph's cached route — call on redeploy/delete (conn may
-*  change). Also evicts any warm sandbox subprocess for this subgraph
-*  (f071 Stage A `host.ts`) on the same edge: a redeploy can change
-*  `handler_code`/`version` together, and a stale warm
-*  subprocess must not survive past this invalidation any more than the
-*  cached route does. A no-op today since nothing sets `sandbox_workers`,
-*  but keeps the pool's documented invalidation contract honest for when it
-*  is. */
-declare function invalidateSubgraphRoute(subgraphName: string): void;
-/**
-* Resolve each distinct trait used by a subgraph's sources to its conforming
-* contract-id set, as of `blockHeight`, from the contract registry. Empty map
-* when no source is trait-scoped (the common case → no DB work).
-*/
-/**
-* Resolve each factory-scoped source's address set for this block.
-*
-* Two parts, and the ORDER is the guarantee:
-* 1. addresses persisted by earlier blocks (`block_height <= blockHeight`,
-*    so a reindex sees exactly what the live walk saw), then
-* 2. addresses revealed by THIS block's events — computed before matching,
-*    so a contract discovered in block N receives its own block-N events.
-*    Without this pass the first event from every discovered contract is
-*    silently lost.
-*/
-/**
-* Exported as a test seam. Both guarantees this function carries — a contract
-* discovered in block N receiving its OWN block-N events, and the persisted set
-* being height-stamped so a reorg can roll it back — were asserted only by
-* comment until now.
-*/
-declare function resolveFactoryContracts(subgraph: SubgraphDefinition, blockHeight: number, schemaName: string, db: Kysely2<Database2>, txs: TxRecord[], evts: EventRecord[], vmEvts?: EventRecord[]): Promise<{
-	resolved: Map<string, ReadonlySet<string>>
-	discovered: Array<{
-		sourceName: string
-		address: string
-	}>
-}>;
-interface ProcessBlockTiming {
-	totalMs: number;
-	handlerMs: number;
-	flushMs: number;
-}
-interface ProcessBlockResult {
-	blockHeight: number;
-	matched: number;
-	processed: number;
-	errors: number;
-	skipped: boolean;
-	timing?: ProcessBlockTiming;
-}
-/**
-* Process a single block through a single subgraph's pipeline.
-*
-* Flow:
-* 1. Load block + txs + events from DB
-* 2. Run source matcher
-* 3. Run handlers with SubgraphContext
-* 4. Flush context (commit writes atomically)
-* 5. Update subgraph.last_processed_block
-*/
-interface PreloadedBlockData {
-	block: import("@secondlayer/shared/db").Block;
-	txs: import("@secondlayer/shared/db").Transaction[];
-	events: import("@secondlayer/shared/db").Event[];
-	/** Opt-in `vm_events` rows on the vm clock; see `BlockData.vmEvents`. */
-	vmEvents?: import("./batch-loader.ts").RuntimeEvent[];
-}
-interface ProcessBlockOptions {
-	/** Skip updating last_processed_block in DB (reindex batches this externally). */
-	skipProgressUpdate?: boolean;
-	/** Pre-loaded block data — skips DB reads when provided (used by batch catch-up). */
-	preloaded?: PreloadedBlockData;
-	/**
-	* Crash-safe sequential processing. Two checkpoint scopes:
-	* - `{ status }` (reindex): a written block commits
-	*   `subgraphs.last_processed_block = blockHeight` in the SAME transaction
-	*   as its writes; replays skip at/below the cursor. Only for strictly
-	*   ascending walks over the subgraph's own cursor.
-	* - `{ operationId }` (backfill): same guarantee against the OPERATION's
-	*   own `cursor_block` — backfills legitimately revisit heights below the
-	*   live cursor, so they must never checkpoint (or read) the subgraph
-	*   cursor. The advance is a CONDITIONAL monotonic UPDATE: concurrent
-	*   writers serialize on it, and the loser's whole block tx rolls back
-	*   (surfaced as `skipped`, never an error/gap).
-	* Either way: a crash can never leave committed deltas ahead of the
-	* relevant checkpoint.
-	*/
-	atomicProgress?: {
-		status: string
-	} | {
-		operationId: string
-	};
-	/**
-	* Reorg rewind (f069): set exclusively by `reorg.ts`'s fork-block
-	* reprocess. Bypasses the live-path replay guard (a fork block's height
-	* is, by construction, at or below the current cursor — the guard would
-	* otherwise skip it) and writes the checkpoint via
-	* `rewindLiveProgress` (unconditional — a rewind's whole point is
-	* moving the cursor *backward*, which the live path's conditional
-	* advance would refuse). Safe only because the reorg path holds a
-	* transaction-scoped advisory lock across its whole
-	* delete+reprocess+rewind sequence, so nothing else can interleave a
-	* forward write. Never set this outside `reorg.ts`.
-	*/
-	reorgRewind?: true;
-	/** The subgraph row's uuid. Required to record a gap row when a block
-	*  processes with handler errors — `subgraph_gaps.subgraph_id` is NOT NULL.
-	*  Absent on paths that pass `skipProgressUpdate` (they record gaps
-	*  themselves, see reindex.ts). */
-	subgraphId?: string;
-}
-/** Default per-block retry schedule before a failure counts as persistent. */
-declare const BLOCK_RETRY_DELAYS_MS: number[];
-/**
-* processBlock with bounded retries. Throws the last error once the schedule
-* is exhausted — callers decide whether that halts the walk (strict paths) or
-* records a gap (backfill). Never advances any cursor on failure.
-*/
-declare function processBlockWithRetry(subgraph: SubgraphDefinition, subgraphName: string, blockHeight: number, opts?: ProcessBlockOptions, retryDelaysMs?: number[]): Promise<ProcessBlockResult>;
-declare function processBlock(subgraph: SubgraphDefinition, subgraphName: string, blockHeight: number, opts?: ProcessBlockOptions): Promise<ProcessBlockResult>;
-export { resolveFactoryContracts, processBlockWithRetry, processBlock, invalidateSubgraphRoute, ProcessBlockTiming, ProcessBlockResult, ProcessBlockOptions, PreloadedBlockData, BLOCK_RETRY_DELAYS_MS };