@secondlayer/subgraphs 0.5.0

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

@@ -0,0 +1,147 @@
+/** 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;
+}
+/** Table definition within a subgraph schema */
+interface SubgraphTable {
+	columns: Record<string, SubgraphColumn>;
+	/** Composite indexes (each entry is an array of column names) */
+	indexes?: string[][];
+	/** Unique key constraints (each entry is an array of column names). Required for upsert. */
+	uniqueKeys?: string[][];
+}
+/** Subgraph schema — maps table names to table definitions */
+type SubgraphSchema = Record<string, SubgraphTable>;
+/** Source filter for what blockchain data this subgraph processes */
+interface SubgraphSource {
+	/** Contract principal (e.g., SP000...::contract-name). Supports * wildcards. */
+	contract?: string;
+	/** Event name/topic to filter on */
+	event?: string;
+	/** Function name to filter on */
+	function?: string;
+	/** Transaction type filter (e.g., "stx_transfer", "contract_call") */
+	type?: string;
+	/** Minimum amount filter (for stx_transfer sources) */
+	minAmount?: bigint;
+}
+/** Context passed to subgraph handlers during event processing */
+interface SubgraphContext {
+	block: {
+		height: number
+		hash: string
+		timestamp: number
+		burnBlockHeight: number
+	};
+	tx: {
+		txId: string
+		sender: string
+		type: string
+		status: string
+	};
+	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;
+	findOne(table: string, where: Record<string, unknown>): Promise<Record<string, unknown> | null>;
+	findMany(table: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+}
+/** 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;
+	/** What blockchain data to process — one or more source filters */
+	sources: SubgraphSource[];
+	/** Tables in this subgraph */
+	schema: SubgraphSchema;
+	/** Keyed handler functions — keys match sourceKey() output, "*" is catch-all */
+	handlers: Record<string, SubgraphHandler>;
+}
+import { Kysely, Transaction } from "kysely";
+import { Database } from "@secondlayer/shared/db";
+type AnyDb = Kysely<Database> | Transaction<Database>;
+interface BlockMeta {
+	height: number;
+	hash: string;
+	timestamp: number;
+	burnBlockHeight: number;
+}
+interface TxMeta {
+	txId: string;
+	sender: string;
+	type: string;
+	status: string;
+}
+/**
+* Runtime context passed to subgraph handlers.
+* Batches writes and flushes them atomically at the end of a block.
+* Reads execute immediately against the DB (pre-flush state).
+*/
+declare class SubgraphContext2 {
+	readonly block: BlockMeta;
+	private _tx;
+	private readonly db;
+	private readonly pgSchemaName;
+	private readonly subgraphSchema;
+	private readonly ops;
+	constructor(db: AnyDb, pgSchemaName: string, subgraphSchema: SubgraphSchema, block: BlockMeta, tx: TxMeta);
+	get tx(): TxMeta;
+	/** Update the current transaction context (used by runner between events) */
+	setTx(tx: TxMeta): void;
+	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;
+	findOne(table: string, where: Record<string, unknown>): Promise<Record<string, unknown> | null>;
+	findMany(table: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+	/** Number of pending write operations */
+	get pendingOps(): number;
+	/**
+	* Execute all batched writes in a single transaction.
+	* Auto-populates _block_height, _tx_id, _created_at on inserts.
+	*/
+	flush(): Promise<number>;
+	/** Build SQL statements from write ops */
+	private buildStatements;
+	private validateTable;
+}
+interface MatchedTx {
+	tx: {
+		tx_id: string
+		type: string
+		sender: string
+		status: string
+		contract_id?: string | null
+		function_name?: string | null
+	};
+	events: {
+		id: string
+		tx_id: string
+		type: string
+		event_index: number
+		data: unknown
+	}[];
+	/** Which source produced this match — used for handler dispatch */
+	sourceKey: string;
+}
+interface RunResult {
+	processed: number;
+	errors: number;
+}
+/**\\n* Run a subgraph's keyed handlers against all matched transactions/events.\\n*\\n* Each MatchedTx carries a sourceKey from the matcher. The runner looks up\\n* the corresponding handler in subgraph.handlers, falling back to "*".\\n*\\n* Does NOT flush — caller is responsible for flushing ctx after run.\\n*/
+declare function runHandlers(subgraph: SubgraphDefinition, matched: MatchedTx[], ctx: SubgraphContext2, opts?: {
+	errorThreshold?: number
+}): Promise<RunResult>;
+export { runHandlers, RunResult };

package/dist/src/runtime/runner.js

@@ -0,0 +1,130 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/runtime/clarity.ts
+import { cvToJSON, deserializeCV } from "@secondlayer/stacks/clarity";
+function decodeClarityValue(hex) {
+  try {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const cv = deserializeCV(cleanHex);
+    return cvToJSON(cv);
+  } catch {
+    return hex;
+  }
+}
+function decodeEventData(data) {
+  if (typeof data === "string" && data.startsWith("0x") && data.length > 10) {
+    return decodeClarityValue(data);
+  }
+  if (Array.isArray(data)) {
+    return data.map(decodeEventData);
+  }
+  if (typeof data === "object" && data !== null) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(data)) {
+      decoded[key] = decodeEventData(value);
+    }
+    return decoded;
+  }
+  return data;
+}
+function decodeFunctionArgs(args) {
+  return args.map(decodeClarityValue);
+}
+
+// src/runtime/runner.ts
+import { logger } from "@secondlayer/shared/logger";
+import { getErrorMessage } from "@secondlayer/shared";
+var DEFAULT_ERROR_THRESHOLD = 50;
+function resolveHandler(handlers, key) {
+  return handlers[key] ?? handlers["*"] ?? null;
+}
+async function runHandlers(subgraph, matched, ctx, opts) {
+  let processed = 0;
+  let errors = 0;
+  const threshold = opts?.errorThreshold ?? DEFAULT_ERROR_THRESHOLD;
+  for (const { tx, events, sourceKey } of matched) {
+    const handler = resolveHandler(subgraph.handlers, sourceKey);
+    if (!handler) {
+      logger.warn("No handler found for source key", { subgraph: subgraph.name, sourceKey, txId: tx.tx_id });
+      continue;
+    }
+    ctx.setTx({
+      txId: tx.tx_id,
+      sender: tx.sender,
+      type: tx.type,
+      status: tx.status
+    });
+    if (events.length === 0) {
+      try {
+        const txPayload = {
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
+          }
+        };
+        await handler(txPayload, ctx);
+        processed++;
+      } catch (err) {
+        errors++;
+        logger.error("Subgraph handler error", {
+          subgraph: subgraph.name,
+          sourceKey,
+          txId: tx.tx_id,
+          error: getErrorMessage(err)
+        });
+      }
+      continue;
+    }
+    for (const event of events) {
+      if (errors >= threshold) {
+        logger.error("Subgraph error threshold reached, skipping remaining events", {
+          subgraph: subgraph.name,
+          errors,
+          threshold
+        });
+        return { processed, errors };
+      }
+      try {
+        const decoded = decodeEventData(event.data);
+        const eventPayload = {
+          ...decoded,
+          _eventId: event.id,
+          _eventType: event.type,
+          _eventIndex: event.event_index,
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
+          }
+        };
+        await handler(eventPayload, ctx);
+        processed++;
+      } catch (err) {
+        errors++;
+        logger.error("Subgraph handler error", {
+          subgraph: subgraph.name,
+          sourceKey,
+          txId: tx.tx_id,
+          eventId: event.id,
+          eventType: event.type,
+          error: getErrorMessage(err)
+        });
+      }
+    }
+  }
+  return { processed, errors };
+}
+export {
+  runHandlers
+};
+
+//# debugId=68B81C2CF799988B64756E2164756E21
+//# sourceMappingURL=runner.js.map

package/dist/src/runtime/runner.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/runtime/clarity.ts", "../src/runtime/runner.ts"],
+  "sourcesContent": [
+    "import { cvToJSON, deserializeCV } from \"@secondlayer/stacks/clarity\";\n\n/**\n * Decode a hex-encoded Clarity value to a JS object.\n * Returns original value on failure.\n */\nexport function decodeClarityValue(hex: string): unknown {\n  try {\n    const cleanHex = hex.startsWith(\"0x\") ? hex.slice(2) : hex;\n    const cv = deserializeCV(cleanHex);\n    return cvToJSON(cv);\n  } catch {\n    return hex;\n  }\n}\n\n/**\n * Recursively decode all hex-encoded Clarity values in an object.\n * Any string starting with \"0x\" and longer than 10 chars is attempted.\n */\nexport function decodeEventData(data: unknown): unknown {\n  if (typeof data === \"string\" && data.startsWith(\"0x\") && data.length > 10) {\n    return decodeClarityValue(data);\n  }\n\n  if (Array.isArray(data)) {\n    return data.map(decodeEventData);\n  }\n\n  if (typeof data === \"object\" && data !== null) {\n    const decoded: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(data)) {\n      decoded[key] = decodeEventData(value);\n    }\n    return decoded;\n  }\n\n  return data;\n}\n\n/**\n * Decode function args array (hex-encoded Clarity values).\n */\nexport function decodeFunctionArgs(args: string[]): unknown[] {\n  return args.map(decodeClarityValue);\n}\n",
+    "import { logger } from \"@secondlayer/shared/logger\";\nimport { getErrorMessage } from \"@secondlayer/shared\";\nimport type { SubgraphDefinition } from \"../types.ts\";\nimport type { SubgraphContext } from \"./context.ts\";\nimport type { MatchedTx } from \"./source-matcher.ts\";\nimport { decodeEventData } from \"./clarity.ts\";\n\n/** Max consecutive handler errors before marking subgraph as error */\nconst DEFAULT_ERROR_THRESHOLD = 50;\n\nexport interface RunResult {\n  processed: number;\n  errors: number;\n}\n\n/**\n * Resolve the handler for a matched tx.\n * Looks up by sourceKey first, then falls back to \"*\" catch-all.\n */\nfunction resolveHandler(handlers: SubgraphDefinition[\"handlers\"], key: string) {\n  return handlers[key] ?? handlers[\"*\"] ?? null;\n}\n\n/**\n * Run a subgraph's keyed handlers against all matched transactions/events.\n *\n * Each MatchedTx carries a sourceKey from the matcher. The runner looks up\n * the corresponding handler in subgraph.handlers, falling back to \"*\".\n *\n * Does NOT flush — caller is responsible for flushing ctx after run.\n */\nexport async function runHandlers(\n  subgraph: SubgraphDefinition,\n  matched: MatchedTx[],\n  ctx: SubgraphContext,\n  opts?: { errorThreshold?: number },\n): Promise<RunResult> {\n  let processed = 0;\n  let errors = 0;\n  const threshold = opts?.errorThreshold ?? DEFAULT_ERROR_THRESHOLD;\n\n  for (const { tx, events, sourceKey } of matched) {\n    const handler = resolveHandler(subgraph.handlers, sourceKey);\n    if (!handler) {\n      logger.warn(\"No handler found for source key\", { subgraph: subgraph.name, sourceKey, txId: tx.tx_id });\n      continue;\n    }\n\n    ctx.setTx({\n      txId: tx.tx_id,\n      sender: tx.sender,\n      type: tx.type,\n      status: tx.status,\n    });\n\n    // If no events but tx matched, call handler with tx-level data\n    if (events.length === 0) {\n      try {\n        const txPayload: Record<string, unknown> = {\n          tx: {\n            txId: tx.tx_id,\n            sender: tx.sender,\n            type: tx.type,\n            status: tx.status,\n            contractId: tx.contract_id,\n            functionName: tx.function_name,\n          },\n        };\n        await handler(txPayload, ctx);\n        processed++;\n      } catch (err) {\n        errors++;\n        logger.error(\"Subgraph handler error\", {\n          subgraph: subgraph.name,\n          sourceKey,\n          txId: tx.tx_id,\n          error: getErrorMessage(err),\n        });\n      }\n      continue;\n    }\n\n    for (const event of events) {\n      if (errors >= threshold) {\n        logger.error(\"Subgraph error threshold reached, skipping remaining events\", {\n          subgraph: subgraph.name,\n          errors,\n          threshold,\n        });\n        return { processed, errors };\n      }\n\n      try {\n        const decoded = decodeEventData(event.data) as Record<string, unknown>;\n        const eventPayload: Record<string, unknown> = {\n          ...decoded,\n          _eventId: event.id,\n          _eventType: event.type,\n          _eventIndex: event.event_index,\n          tx: {\n            txId: tx.tx_id,\n            sender: tx.sender,\n            type: tx.type,\n            status: tx.status,\n            contractId: tx.contract_id,\n            functionName: tx.function_name,\n          },\n        };\n\n        await handler(eventPayload, ctx);\n        processed++;\n      } catch (err) {\n        errors++;\n        logger.error(\"Subgraph handler error\", {\n          subgraph: subgraph.name,\n          sourceKey,\n          txId: tx.tx_id,\n          eventId: event.id,\n          eventType: event.type,\n          error: getErrorMessage(err),\n        });\n      }\n    }\n  }\n\n  return { processed, errors };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "68B81C2CF799988B64756E2164756E21",
+  "names": []
+}

package/dist/src/runtime/source-matcher.d.ts

@@ -0,0 +1,53 @@
+/** Source filter for what blockchain data this subgraph processes */
+interface SubgraphSource {
+	/** Contract principal (e.g., SP000...::contract-name). Supports * wildcards. */
+	contract?: string;
+	/** Event name/topic to filter on */
+	event?: string;
+	/** Function name to filter on */
+	function?: string;
+	/** Transaction type filter (e.g., "stx_transfer", "contract_call") */
+	type?: string;
+	/** Minimum amount filter (for stx_transfer sources) */
+	minAmount?: bigint;
+}
+interface MatchedTx {
+	tx: {
+		tx_id: string
+		type: string
+		sender: string
+		status: string
+		contract_id?: string | null
+		function_name?: string | null
+	};
+	events: {
+		id: string
+		tx_id: string
+		type: string
+		event_index: number
+		data: unknown
+	}[];
+	/** Which source produced this match — used for handler dispatch */
+	sourceKey: string;
+}
+type TxRecord = {
+	tx_id: string
+	type: string
+	sender: string
+	status: string
+	contract_id?: string | null
+	function_name?: string | null
+};
+type EventRecord = {
+	id: string
+	tx_id: string
+	type: string
+	event_index: number
+	data: unknown
+};
+/**
+* Match all sources against a block's transactions and events.
+* Deduplicates by (txId, sourceKey) — each handler key fires at most once per tx.
+*/
+declare function matchSources(sources: SubgraphSource[], transactions: TxRecord[], events: EventRecord[]): MatchedTx[];
+export { matchSources, MatchedTx };

package/dist/src/runtime/source-matcher.js

@@ -0,0 +1,111 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/types.ts
+function sourceKey(source) {
+  if (source.contract) {
+    if (source.function)
+      return `${source.contract}::${source.function}`;
+    if (source.event)
+      return `${source.contract}::${source.event}`;
+    return source.contract;
+  }
+  if (source.type)
+    return source.type;
+  return "*";
+}
+
+// src/runtime/source-matcher.ts
+function matchPattern(value, pattern) {
+  if (!pattern.includes("*"))
+    return value === pattern;
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${regex}$`).test(value);
+}
+function matchSource(source, transactions, eventsByTx) {
+  const results = [];
+  const key = sourceKey(source);
+  for (const tx of transactions) {
+    if (source.type) {
+      if (!matchPattern(tx.type, source.type))
+        continue;
+      const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+      let matchedEvents = txEvents;
+      if (source.minAmount !== undefined) {
+        const amountEvents = matchedEvents.filter((e) => {
+          const data = e.data;
+          const rawAmount = data?.amount;
+          if (rawAmount === undefined)
+            return false;
+          const amount = BigInt(rawAmount);
+          return amount >= source.minAmount;
+        });
+        if (amountEvents.length === 0)
+          continue;
+        matchedEvents = amountEvents;
+      }
+      results.push({ tx, events: matchedEvents, sourceKey: key });
+      continue;
+    }
+    if (source.contract) {
+      const txContractMatch = tx.contract_id && matchPattern(tx.contract_id, source.contract);
+      if (source.function && tx.function_name) {
+        if (!matchPattern(tx.function_name, source.function))
+          continue;
+      } else if (source.function && !tx.function_name) {
+        continue;
+      }
+      const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+      let matchedEvents = txEvents;
+      if (!txContractMatch) {
+        matchedEvents = txEvents.filter((e) => {
+          const data = e.data;
+          const contractIdentifier = data?.contract_identifier;
+          return contractIdentifier && matchPattern(contractIdentifier, source.contract);
+        });
+        if (matchedEvents.length === 0)
+          continue;
+      }
+      if (source.event) {
+        matchedEvents = matchedEvents.filter((e) => {
+          if (matchPattern(e.type, source.event))
+            return true;
+          const data = e.data;
+          const topic = data?.topic;
+          return topic ? matchPattern(topic, source.event) : false;
+        });
+      }
+      if (txContractMatch || matchedEvents.length > 0) {
+        results.push({ tx, events: matchedEvents, sourceKey: key });
+      }
+    }
+  }
+  return results;
+}
+function matchSources(sources, transactions, events) {
+  const eventsByTx = new Map;
+  for (const event of events) {
+    const list = eventsByTx.get(event.tx_id) ?? [];
+    list.push(event);
+    eventsByTx.set(event.tx_id, list);
+  }
+  const seen = new Set;
+  const results = [];
+  for (const source of sources) {
+    const matches = matchSource(source, transactions, eventsByTx);
+    for (const match of matches) {
+      const dedupeKey = `${match.tx.tx_id}:${match.sourceKey}`;
+      if (!seen.has(dedupeKey)) {
+        seen.add(dedupeKey);
+        results.push(match);
+      }
+    }
+  }
+  return results;
+}
+export {
+  matchSources
+};
+
+//# debugId=A86478F2FF92B95F64756E2164756E21
+//# sourceMappingURL=source-matcher.js.map

package/dist/src/runtime/source-matcher.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/types.ts", "../src/runtime/source-matcher.ts"],
+  "sourcesContent": [
+    "/** Supported column types for subgraph schemas */\nexport type ColumnType =\n  | \"text\"\n  | \"uint\"\n  | \"int\"\n  | \"principal\"\n  | \"boolean\"\n  | \"timestamp\"\n  | \"jsonb\";\n\n/** Column definition in a subgraph table */\nexport interface SubgraphColumn {\n  type: ColumnType;\n  nullable?: boolean;\n  indexed?: boolean;\n  search?: boolean;\n  default?: string | number | boolean;\n}\n\n/** Table definition within a subgraph schema */\nexport interface SubgraphTable {\n  columns: Record<string, SubgraphColumn>;\n  /** Composite indexes (each entry is an array of column names) */\n  indexes?: string[][];\n  /** Unique key constraints (each entry is an array of column names). Required for upsert. */\n  uniqueKeys?: string[][];\n}\n\n/** Subgraph schema — maps table names to table definitions */\nexport type SubgraphSchema = Record<string, SubgraphTable>;\n\n/** Source filter for what blockchain data this subgraph processes */\nexport interface SubgraphSource {\n  /** Contract principal (e.g., SP000...::contract-name). Supports * wildcards. */\n  contract?: string;\n  /** Event name/topic to filter on */\n  event?: string;\n  /** Function name to filter on */\n  function?: string;\n  /** Transaction type filter (e.g., \"stx_transfer\", \"contract_call\") */\n  type?: string;\n  /** Minimum amount filter (for stx_transfer sources) */\n  minAmount?: bigint;\n}\n\n/** Context passed to subgraph handlers during event processing */\nexport interface SubgraphContext {\n  block: { height: number; hash: string; timestamp: number; burnBlockHeight: number };\n  tx: { txId: string; sender: string; type: string; status: string };\n  insert(table: string, row: Record<string, unknown>): void;\n  update(table: string, where: Record<string, unknown>, set: Record<string, unknown>): void;\n  upsert(table: string, key: Record<string, unknown>, row: Record<string, unknown>): void;\n  delete(table: string, where: Record<string, unknown>): void;\n  findOne(table: string, where: Record<string, unknown>): Promise<Record<string, unknown> | null>;\n  findMany(table: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;\n}\n\n/** Handler function that processes events and writes to the subgraph */\nexport type SubgraphHandler = (\n  event: Record<string, unknown>,\n  ctx: SubgraphContext,\n) => Promise<void> | void;\n\n/**\n * Derive the source key used to look up handlers.\n * - { contract: \"SP123.market\", function: \"list\" } → \"SP123.market::list\"\n * - { contract: \"SP123.market\", event: \"sale\" } → \"SP123.market::sale\"\n * - { contract: \"SP123.market\" } → \"SP123.market\"\n * - { type: \"stx_transfer\" } → \"stx_transfer\"\n */\nexport function sourceKey(source: SubgraphSource): string {\n  if (source.contract) {\n    if (source.function) return `${source.contract}::${source.function}`;\n    if (source.event) return `${source.contract}::${source.event}`;\n    return source.contract;\n  }\n  if (source.type) return source.type;\n  return \"*\";\n}\n\n/** Complete subgraph definition */\nexport interface SubgraphDefinition {\n  /** Unique subgraph name (lowercase, alphanumeric + hyphens) */\n  name: string;\n  /** Semantic version */\n  version?: string;\n  /** Human description */\n  description?: string;\n  /** What blockchain data to process — one or more source filters */\n  sources: SubgraphSource[];\n  /** Tables in this subgraph */\n  schema: SubgraphSchema;\n  /** Keyed handler functions — keys match sourceKey() output, \"*\" is catch-all */\n  handlers: Record<string, SubgraphHandler>;\n}\n",
+    "import { type SubgraphSource, sourceKey } from \"../types.ts\";\n\nexport interface MatchedTx {\n  tx: { tx_id: string; type: string; sender: string; status: string; contract_id?: string | null; function_name?: string | null };\n  events: { id: string; tx_id: string; type: string; event_index: number; data: unknown }[];\n  /** Which source produced this match — used for handler dispatch */\n  sourceKey: string;\n}\n\n/**\n * Check if a string matches a pattern with `*` wildcard support.\n */\nfunction matchPattern(value: string, pattern: string): boolean {\n  if (!pattern.includes(\"*\")) return value === pattern;\n  const regex = pattern\n    .replace(/[.+^${}()|[\\]\\\\]/g, \"\\\\$&\")\n    .replace(/\\*/g, \".*\");\n  return new RegExp(`^${regex}$`).test(value);\n}\n\ntype TxRecord = { tx_id: string; type: string; sender: string; status: string; contract_id?: string | null; function_name?: string | null };\ntype EventRecord = { id: string; tx_id: string; type: string; event_index: number; data: unknown };\n\n/**\n * Match a single source against transactions and events.\n */\nfunction matchSource(\n  source: SubgraphSource,\n  transactions: TxRecord[],\n  eventsByTx: Map<string, EventRecord[]>,\n): MatchedTx[] {\n  const results: MatchedTx[] = [];\n  const key = sourceKey(source);\n\n  for (const tx of transactions) {\n    // Type-based matching (e.g., token_transfer → matches tx.type)\n    if (source.type) {\n      if (!matchPattern(tx.type, source.type)) continue;\n\n      const txEvents = eventsByTx.get(tx.tx_id) ?? [];\n\n      // Collect all events for this tx (type-based sources match the whole tx)\n      let matchedEvents = txEvents;\n\n      // minAmount filter — check events with an amount field\n      if (source.minAmount !== undefined) {\n        const amountEvents = matchedEvents.filter((e) => {\n          const data = e.data as Record<string, unknown> | null;\n          const rawAmount = data?.amount as string | number | undefined;\n          if (rawAmount === undefined) return false;\n          const amount = BigInt(rawAmount);\n          return amount >= source.minAmount!;\n        });\n        if (amountEvents.length === 0) continue;\n        matchedEvents = amountEvents;\n      }\n\n      results.push({ tx, events: matchedEvents, sourceKey: key });\n      continue;\n    }\n\n    // Contract-based matching\n    if (source.contract) {\n      const txContractMatch = tx.contract_id && matchPattern(tx.contract_id, source.contract);\n\n      // Function filter\n      if (source.function && tx.function_name) {\n        if (!matchPattern(tx.function_name, source.function)) continue;\n      } else if (source.function && !tx.function_name) {\n        continue;\n      }\n\n      const txEvents = eventsByTx.get(tx.tx_id) ?? [];\n      let matchedEvents = txEvents;\n\n      if (!txContractMatch) {\n        // Check if any events match the contract\n        matchedEvents = txEvents.filter((e) => {\n          const data = e.data as Record<string, unknown> | null;\n          const contractIdentifier = data?.contract_identifier as string | undefined;\n          return contractIdentifier && matchPattern(contractIdentifier, source.contract!);\n        });\n        if (matchedEvents.length === 0) continue;\n      }\n\n      // Event type / topic filter\n      if (source.event) {\n        matchedEvents = matchedEvents.filter((e) => {\n          if (matchPattern(e.type, source.event!)) return true;\n          const data = e.data as Record<string, unknown> | null;\n          const topic = data?.topic as string | undefined;\n          return topic ? matchPattern(topic, source.event!) : false;\n        });\n      }\n\n      if (txContractMatch || matchedEvents.length > 0) {\n        results.push({ tx, events: matchedEvents, sourceKey: key });\n      }\n    }\n  }\n\n  return results;\n}\n\n/**\n * Match all sources against a block's transactions and events.\n * Deduplicates by (txId, sourceKey) — each handler key fires at most once per tx.\n */\nexport function matchSources(\n  sources: SubgraphSource[],\n  transactions: TxRecord[],\n  events: EventRecord[],\n): MatchedTx[] {\n  // Index events by txId\n  const eventsByTx = new Map<string, EventRecord[]>();\n  for (const event of events) {\n    const list = eventsByTx.get(event.tx_id) ?? [];\n    list.push(event);\n    eventsByTx.set(event.tx_id, list);\n  }\n\n  const seen = new Set<string>();\n  const results: MatchedTx[] = [];\n\n  for (const source of sources) {\n    const matches = matchSource(source, transactions, eventsByTx);\n    for (const match of matches) {\n      const dedupeKey = `${match.tx.tx_id}:${match.sourceKey}`;\n      if (!seen.has(dedupeKey)) {\n        seen.add(dedupeKey);\n        results.push(match);\n      }\n    }\n  }\n\n  return results;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "A86478F2FF92B95F64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,24 @@
+interface ProcessBlockTiming {
+	totalMs: number;
+	handlerMs: number;
+	flushMs: number;
+}
+import { Kysely } from "kysely";
+import { Database } from "@secondlayer/shared/db";
+/**
+* Accumulates per-block timing stats and flushes to DB periodically.
+* One instance per subgraph during catchup/reindex/live processing.
+*/
+declare class StatsAccumulator {
+	private subgraphName;
+	private apiKeyId;
+	private isCatchup;
+	private current;
+	private lastFlush;
+	constructor(subgraphName: string, apiKeyId: string | null, isCatchup: boolean);
+	record(timing: ProcessBlockTiming, opsCount: number): void;
+	shouldFlush(): boolean;
+	flush(db: Kysely<Database>): Promise<void>;
+	private newEntry;
+}
+export { StatsAccumulator };

package/dist/src/runtime/stats.js

@@ -0,0 +1,75 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/runtime/stats.ts
+var FLUSH_INTERVAL_BLOCKS = 100;
+var FLUSH_INTERVAL_MS = 60000;
+
+class StatsAccumulator {
+  subgraphName;
+  apiKeyId;
+  isCatchup;
+  current;
+  lastFlush = Date.now();
+  constructor(subgraphName, apiKeyId, isCatchup) {
+    this.subgraphName = subgraphName;
+    this.apiKeyId = apiKeyId;
+    this.isCatchup = isCatchup;
+    this.current = this.newEntry();
+  }
+  record(timing, opsCount) {
+    this.current.blocksProcessed++;
+    this.current.totalTimeMs += timing.totalMs;
+    this.current.handlerTimeMs += timing.handlerMs;
+    this.current.flushTimeMs += timing.flushMs;
+    this.current.maxBlockTimeMs = Math.max(this.current.maxBlockTimeMs, timing.totalMs);
+    this.current.maxHandlerTimeMs = Math.max(this.current.maxHandlerTimeMs, timing.handlerMs);
+    this.current.totalOps += opsCount;
+  }
+  shouldFlush() {
+    return this.current.blocksProcessed >= FLUSH_INTERVAL_BLOCKS || Date.now() - this.lastFlush >= FLUSH_INTERVAL_MS;
+  }
+  async flush(db) {
+    if (this.current.blocksProcessed === 0)
+      return;
+    const entry = this.current;
+    this.current = this.newEntry();
+    this.lastFlush = Date.now();
+    const avgOpsPerBlock = entry.blocksProcessed > 0 ? entry.totalOps / entry.blocksProcessed : 0;
+    await db.insertInto("subgraph_processing_stats").values({
+      subgraph_name: entry.subgraphName,
+      api_key_id: entry.apiKeyId,
+      bucket_start: entry.bucketStart,
+      bucket_end: new Date,
+      blocks_processed: entry.blocksProcessed,
+      total_time_ms: Math.round(entry.totalTimeMs),
+      handler_time_ms: Math.round(entry.handlerTimeMs),
+      flush_time_ms: Math.round(entry.flushTimeMs),
+      max_block_time_ms: Math.round(entry.maxBlockTimeMs),
+      max_handler_time_ms: Math.round(entry.maxHandlerTimeMs),
+      avg_ops_per_block: parseFloat(avgOpsPerBlock.toFixed(2)),
+      is_catchup: entry.isCatchup
+    }).execute();
+  }
+  newEntry() {
+    return {
+      subgraphName: this.subgraphName,
+      apiKeyId: this.apiKeyId,
+      bucketStart: new Date,
+      blocksProcessed: 0,
+      totalTimeMs: 0,
+      handlerTimeMs: 0,
+      flushTimeMs: 0,
+      maxBlockTimeMs: 0,
+      maxHandlerTimeMs: 0,
+      totalOps: 0,
+      isCatchup: this.isCatchup
+    };
+  }
+}
+export {
+  StatsAccumulator
+};
+
+//# debugId=2992B5CA15D3B67064756E2164756E21
+//# sourceMappingURL=stats.js.map

package/dist/src/runtime/stats.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/runtime/stats.ts"],
+  "sourcesContent": [
+    "import type { Kysely } from \"kysely\";\nimport type { Database } from \"@secondlayer/shared/db\";\nimport type { ProcessBlockTiming } from \"./block-processor.ts\";\n\ninterface StatsEntry {\n  subgraphName: string;\n  apiKeyId: string | null;\n  bucketStart: Date;\n  blocksProcessed: number;\n  totalTimeMs: number;\n  handlerTimeMs: number;\n  flushTimeMs: number;\n  maxBlockTimeMs: number;\n  maxHandlerTimeMs: number;\n  totalOps: number;\n  isCatchup: boolean;\n}\n\nconst FLUSH_INTERVAL_BLOCKS = 100;\nconst FLUSH_INTERVAL_MS = 60_000;\n\n/**\n * Accumulates per-block timing stats and flushes to DB periodically.\n * One instance per subgraph during catchup/reindex/live processing.\n */\nexport class StatsAccumulator {\n  private current: StatsEntry;\n  private lastFlush = Date.now();\n\n  constructor(\n    private subgraphName: string,\n    private apiKeyId: string | null,\n    private isCatchup: boolean,\n  ) {\n    this.current = this.newEntry();\n  }\n\n  record(timing: ProcessBlockTiming, opsCount: number): void {\n    this.current.blocksProcessed++;\n    this.current.totalTimeMs += timing.totalMs;\n    this.current.handlerTimeMs += timing.handlerMs;\n    this.current.flushTimeMs += timing.flushMs;\n    this.current.maxBlockTimeMs = Math.max(this.current.maxBlockTimeMs, timing.totalMs);\n    this.current.maxHandlerTimeMs = Math.max(this.current.maxHandlerTimeMs, timing.handlerMs);\n    this.current.totalOps += opsCount;\n  }\n\n  shouldFlush(): boolean {\n    return (\n      this.current.blocksProcessed >= FLUSH_INTERVAL_BLOCKS ||\n      Date.now() - this.lastFlush >= FLUSH_INTERVAL_MS\n    );\n  }\n\n  async flush(db: Kysely<Database>): Promise<void> {\n    if (this.current.blocksProcessed === 0) return;\n\n    const entry = this.current;\n    this.current = this.newEntry();\n    this.lastFlush = Date.now();\n\n    const avgOpsPerBlock = entry.blocksProcessed > 0\n      ? entry.totalOps / entry.blocksProcessed\n      : 0;\n\n    await db\n      .insertInto(\"subgraph_processing_stats\")\n      .values({\n        subgraph_name: entry.subgraphName,\n        api_key_id: entry.apiKeyId,\n        bucket_start: entry.bucketStart,\n        bucket_end: new Date(),\n        blocks_processed: entry.blocksProcessed,\n        total_time_ms: Math.round(entry.totalTimeMs),\n        handler_time_ms: Math.round(entry.handlerTimeMs),\n        flush_time_ms: Math.round(entry.flushTimeMs),\n        max_block_time_ms: Math.round(entry.maxBlockTimeMs),\n        max_handler_time_ms: Math.round(entry.maxHandlerTimeMs),\n        avg_ops_per_block: parseFloat(avgOpsPerBlock.toFixed(2)),\n        is_catchup: entry.isCatchup,\n      })\n      .execute();\n  }\n\n  private newEntry(): StatsEntry {\n    return {\n      subgraphName: this.subgraphName,\n      apiKeyId: this.apiKeyId,\n      bucketStart: new Date(),\n      blocksProcessed: 0,\n      totalTimeMs: 0,\n      handlerTimeMs: 0,\n      flushTimeMs: 0,\n      maxBlockTimeMs: 0,\n      maxHandlerTimeMs: 0,\n      totalOps: 0,\n      isCatchup: this.isCatchup,\n    };\n  }\n}\n"
+  ],
+  "mappings": ";;;;AAkBA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAAA;AAMnB,MAAM,iBAAiB;AAAA,EAKlB;AAAA,EACA;AAAA,EACA;AAAA,EANF;AAAA,EACA,YAAY,KAAK,IAAI;AAAA,EAE7B,WAAW,CACD,cACA,UACA,WACR;AAAA,IAHQ;AAAA,IACA;AAAA,IACA;AAAA,IAER,KAAK,UAAU,KAAK,SAAS;AAAA;AAAA,EAG/B,MAAM,CAAC,QAA4B,UAAwB;AAAA,IACzD,KAAK,QAAQ;AAAA,IACb,KAAK,QAAQ,eAAe,OAAO;AAAA,IACnC,KAAK,QAAQ,iBAAiB,OAAO;AAAA,IACrC,KAAK,QAAQ,eAAe,OAAO;AAAA,IACnC,KAAK,QAAQ,iBAAiB,KAAK,IAAI,KAAK,QAAQ,gBAAgB,OAAO,OAAO;AAAA,IAClF,KAAK,QAAQ,mBAAmB,KAAK,IAAI,KAAK,QAAQ,kBAAkB,OAAO,SAAS;AAAA,IACxF,KAAK,QAAQ,YAAY;AAAA;AAAA,EAG3B,WAAW,GAAY;AAAA,IACrB,OACE,KAAK,QAAQ,mBAAmB,yBAChC,KAAK,IAAI,IAAI,KAAK,aAAa;AAAA;AAAA,OAI7B,MAAK,CAAC,IAAqC;AAAA,IAC/C,IAAI,KAAK,QAAQ,oBAAoB;AAAA,MAAG;AAAA,IAExC,MAAM,QAAQ,KAAK;AAAA,IACnB,KAAK,UAAU,KAAK,SAAS;AAAA,IAC7B,KAAK,YAAY,KAAK,IAAI;AAAA,IAE1B,MAAM,iBAAiB,MAAM,kBAAkB,IAC3C,MAAM,WAAW,MAAM,kBACvB;AAAA,IAEJ,MAAM,GACH,WAAW,2BAA2B,EACtC,OAAO;AAAA,MACN,eAAe,MAAM;AAAA,MACrB,YAAY,MAAM;AAAA,MAClB,cAAc,MAAM;AAAA,MACpB,YAAY,IAAI;AAAA,MAChB,kBAAkB,MAAM;AAAA,MACxB,eAAe,KAAK,MAAM,MAAM,WAAW;AAAA,MAC3C,iBAAiB,KAAK,MAAM,MAAM,aAAa;AAAA,MAC/C,eAAe,KAAK,MAAM,MAAM,WAAW;AAAA,MAC3C,mBAAmB,KAAK,MAAM,MAAM,cAAc;AAAA,MAClD,qBAAqB,KAAK,MAAM,MAAM,gBAAgB;AAAA,MACtD,mBAAmB,WAAW,eAAe,QAAQ,CAAC,CAAC;AAAA,MACvD,YAAY,MAAM;AAAA,IACpB,CAAC,EACA,QAAQ;AAAA;AAAA,EAGL,QAAQ,GAAe;AAAA,IAC7B,OAAO;AAAA,MACL,cAAc,KAAK;AAAA,MACnB,UAAU,KAAK;AAAA,MACf,aAAa,IAAI;AAAA,MACjB,iBAAiB;AAAA,MACjB,aAAa;AAAA,MACb,eAAe;AAAA,MACf,aAAa;AAAA,MACb,gBAAgB;AAAA,MAChB,kBAAkB;AAAA,MAClB,UAAU;AAAA,MACV,WAAW,KAAK;AAAA,IAClB;AAAA;AAEJ;",
+  "debugId": "2992B5CA15D3B67064756E2164756E21",
+  "names": []
+}