@secondlayer/subgraphs 0.5.0

package/dist/src/service.js

@@ -0,0 +1,780 @@
+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/context.ts
+import { sql } from "kysely";
+import { logger } from "@secondlayer/shared/logger";
+function validateColumnName(name) {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
+    throw new Error(`Invalid column name: ${name}`);
+  }
+}
+
+class SubgraphContext {
+  block;
+  _tx;
+  db;
+  pgSchemaName;
+  subgraphSchema;
+  ops = [];
+  constructor(db, pgSchemaName, subgraphSchema, block, tx) {
+    this.db = db;
+    this.pgSchemaName = pgSchemaName;
+    this.subgraphSchema = subgraphSchema;
+    this.block = block;
+    this._tx = tx;
+  }
+  get tx() {
+    return this._tx;
+  }
+  setTx(tx) {
+    this._tx = tx;
+  }
+  insert(table, row) {
+    this.validateTable(table);
+    this.ops.push({ kind: "insert", table, data: row });
+  }
+  update(table, where, set) {
+    this.validateTable(table);
+    this.ops.push({ kind: "update", table, data: where, set });
+  }
+  upsert(table, key, row) {
+    this.validateTable(table);
+    const tableDef = this.subgraphSchema[table];
+    const keyColumns = Object.keys(key);
+    const hasUniqueConstraint = tableDef.uniqueKeys?.some((uk) => uk.length === keyColumns.length && uk.every((c) => keyColumns.includes(c)));
+    if (hasUniqueConstraint) {
+      this.ops.push({ kind: "insert", table, data: { ...key, ...row, _upsert_keys: keyColumns } });
+    } else {
+      logger.warn("upsert called without matching uniqueKeys constraint, using fallback", {
+        table,
+        keys: keyColumns
+      });
+      this.ops.push({ kind: "insert", table, data: { ...key, ...row, _upsert_fallback_keys: keyColumns, _upsert_fallback_set: row } });
+    }
+  }
+  delete(table, where) {
+    this.validateTable(table);
+    this.ops.push({ kind: "delete", table, data: where });
+  }
+  async findOne(table, where) {
+    this.validateTable(table);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const { clause } = buildWhereClause(where);
+    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause} LIMIT 1`;
+    const { rows } = await sql.raw(query).execute(this.db);
+    return rows[0] ?? null;
+  }
+  async findMany(table, where) {
+    this.validateTable(table);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const { clause } = buildWhereClause(where);
+    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause}`;
+    const { rows } = await sql.raw(query).execute(this.db);
+    return rows;
+  }
+  get pendingOps() {
+    return this.ops.length;
+  }
+  async flush() {
+    if (this.ops.length === 0)
+      return 0;
+    const opsToFlush = [...this.ops];
+    this.ops.length = 0;
+    const statements = this.buildStatements(opsToFlush);
+    if ("isTransaction" in this.db) {
+      for (const stmt of statements) {
+        await sql.raw(stmt).execute(this.db);
+      }
+    } else {
+      await this.db.transaction().execute(async (tx) => {
+        for (const stmt of statements) {
+          await sql.raw(stmt).execute(tx);
+        }
+      });
+    }
+    return opsToFlush.length;
+  }
+  buildStatements(ops) {
+    const statements = [];
+    for (const op of ops) {
+      const qualifiedTable = `"${this.pgSchemaName}"."${op.table}"`;
+      switch (op.kind) {
+        case "insert": {
+          const upsertKeys = op.data._upsert_keys;
+          const fallbackKeys = op.data._upsert_fallback_keys;
+          const fallbackSet = op.data._upsert_fallback_set;
+          const data = { ...op.data };
+          delete data._upsert_keys;
+          delete data._upsert_fallback_keys;
+          delete data._upsert_fallback_set;
+          data._block_height = this.block.height;
+          data._tx_id = this._tx.txId;
+          data._created_at = "NOW()";
+          const cols = Object.keys(data);
+          cols.forEach(validateColumnName);
+          const vals = cols.map((c) => data[c] === "NOW()" ? "NOW()" : escapeLiteral(data[c]));
+          let stmt = `INSERT INTO ${qualifiedTable} (${cols.map((c) => `"${c}"`).join(", ")}) VALUES (${vals.join(", ")})`;
+          if (upsertKeys && upsertKeys.length > 0) {
+            const updateCols = cols.filter((c) => !upsertKeys.includes(c) && !c.startsWith("_"));
+            if (updateCols.length > 0) {
+              const setClauses = updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`);
+              stmt += ` ON CONFLICT (${upsertKeys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
+            } else {
+              stmt += ` ON CONFLICT (${upsertKeys.map((k) => `"${k}"`).join(", ")}) DO NOTHING`;
+            }
+          } else if (fallbackKeys && fallbackSet) {}
+          statements.push(stmt);
+          break;
+        }
+        case "update": {
+          const setEntries = Object.entries(op.set);
+          setEntries.forEach(([k]) => validateColumnName(k));
+          const setClauses = setEntries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
+          const { clause } = buildWhereClause(op.data);
+          statements.push(`UPDATE ${qualifiedTable} SET ${setClauses.join(", ")} WHERE ${clause}`);
+          break;
+        }
+        case "delete": {
+          const { clause } = buildWhereClause(op.data);
+          statements.push(`DELETE FROM ${qualifiedTable} WHERE ${clause}`);
+          break;
+        }
+      }
+    }
+    return statements;
+  }
+  validateTable(table) {
+    if (!this.subgraphSchema[table]) {
+      throw new Error(`Table "${table}" not found in subgraph schema. Available: [${Object.keys(this.subgraphSchema).join(", ")}]`);
+    }
+  }
+}
+function escapeLiteral(value) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "object")
+    return `'${JSON.stringify(value).replace(/'/g, "''")}'::jsonb`;
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function buildWhereClause(where) {
+  const entries = Object.entries(where);
+  if (entries.length === 0)
+    return { clause: "TRUE", values: [] };
+  entries.forEach(([k]) => validateColumnName(k));
+  const parts = entries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
+  return { clause: parts.join(" AND "), values: [] };
+}
+
+// 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;
+}
+
+// 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 as logger2 } 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: sourceKey2 } of matched) {
+    const handler = resolveHandler(subgraph.handlers, sourceKey2);
+    if (!handler) {
+      logger2.warn("No handler found for source key", { subgraph: subgraph.name, sourceKey: sourceKey2, 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++;
+        logger2.error("Subgraph handler error", {
+          subgraph: subgraph.name,
+          sourceKey: sourceKey2,
+          txId: tx.tx_id,
+          error: getErrorMessage(err)
+        });
+      }
+      continue;
+    }
+    for (const event of events) {
+      if (errors >= threshold) {
+        logger2.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++;
+        logger2.error("Subgraph handler error", {
+          subgraph: subgraph.name,
+          sourceKey: sourceKey2,
+          txId: tx.tx_id,
+          eventId: event.id,
+          eventType: event.type,
+          error: getErrorMessage(err)
+        });
+      }
+    }
+  }
+  return { processed, errors };
+}
+
+// src/runtime/block-processor.ts
+import { sql as sql2 } from "kysely";
+import { getDb } from "@secondlayer/shared/db";
+import { logger as logger3 } from "@secondlayer/shared/logger";
+import { updateSubgraphStatus, recordSubgraphProcessed } from "@secondlayer/shared/db/queries/subgraphs";
+
+// src/schema/utils.ts
+import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
+
+// src/runtime/block-processor.ts
+async function processBlock(subgraph, subgraphName, blockHeight, opts) {
+  const db = getDb();
+  const blockStart = performance.now();
+  const result = {
+    blockHeight,
+    matched: 0,
+    processed: 0,
+    errors: 0,
+    skipped: false
+  };
+  const block = await db.selectFrom("blocks").selectAll().where("height", "=", blockHeight).executeTakeFirst();
+  if (!block) {
+    logger3.warn("Block not found for subgraph processing", { subgraph: subgraphName, blockHeight });
+    result.skipped = true;
+    return result;
+  }
+  if (!block.canonical) {
+    logger3.debug("Skipping non-canonical block", { subgraph: subgraphName, blockHeight });
+    result.skipped = true;
+    return result;
+  }
+  const txs = await db.selectFrom("transactions").selectAll().where("block_height", "=", blockHeight).execute();
+  const evts = await db.selectFrom("events").selectAll().where("block_height", "=", blockHeight).execute();
+  const matched = matchSources(subgraph.sources, txs, evts);
+  result.matched = matched.length;
+  if (matched.length === 0) {
+    if (!opts?.skipProgressUpdate) {
+      await updateSubgraphStatus(db, subgraphName, "active", blockHeight);
+    }
+    return result;
+  }
+  const subgraphRecord = await db.selectFrom("subgraphs").select("schema_name").where("name", "=", subgraphName).executeTakeFirst();
+  const schemaName = subgraphRecord?.schema_name ?? pgSchemaName(subgraphName);
+  const blockMeta = {
+    height: block.height,
+    hash: block.hash,
+    timestamp: block.timestamp,
+    burnBlockHeight: block.burn_block_height
+  };
+  const initialTx = {
+    txId: "",
+    sender: "",
+    type: "",
+    status: ""
+  };
+  let handlerMs = 0;
+  let flushMs = 0;
+  await db.transaction().execute(async (tx) => {
+    const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx);
+    const handlerStart = performance.now();
+    const runResult = await runHandlers(subgraph, matched, ctx);
+    handlerMs = performance.now() - handlerStart;
+    result.processed = runResult.processed;
+    result.errors = runResult.errors;
+    if (ctx.pendingOps > 0) {
+      const flushStart = performance.now();
+      await ctx.flush();
+      flushMs = performance.now() - flushStart;
+    }
+    if (!opts?.skipProgressUpdate) {
+      const status = runResult.errors > 0 && runResult.processed === 0 ? "error" : "active";
+      await updateSubgraphStatus(tx, subgraphName, status, blockHeight);
+    }
+    if (!opts?.skipProgressUpdate && (runResult.processed > 0 || runResult.errors > 0)) {
+      const lastError = runResult.errors > 0 ? `${runResult.errors} error(s) at block ${blockHeight}` : undefined;
+      await recordSubgraphProcessed(tx, subgraphName, runResult.processed, runResult.errors, lastError);
+    }
+  });
+  const totalMs = performance.now() - blockStart;
+  result.timing = {
+    totalMs: Math.round(totalMs),
+    handlerMs: Math.round(handlerMs),
+    flushMs: Math.round(flushMs)
+  };
+  if (blockHeight % 1000 === 0) {
+    try {
+      const tables = Object.keys(subgraph.schema);
+      for (const table of tables) {
+        const { rows } = await sql2.raw(`SELECT COUNT(*) as count FROM "${schemaName}"."${table}"`).execute(db);
+        const count = Number(rows[0].count);
+        if (count >= 1e7) {
+          logger3.warn("Subgraph table exceeds 10M rows", { subgraph: subgraphName, table, count });
+        }
+      }
+    } catch {}
+  }
+  return result;
+}
+
+// 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
+    };
+  }
+}
+
+// src/runtime/catchup.ts
+import { getDb as getDb2 } from "@secondlayer/shared/db";
+import { logger as logger4 } from "@secondlayer/shared/logger";
+import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
+var LOG_INTERVAL = 1000;
+var catchingUp = new Set;
+async function catchUpSubgraph(subgraph, subgraphName) {
+  if (catchingUp.has(subgraphName))
+    return 0;
+  catchingUp.add(subgraphName);
+  try {
+    const db = getDb2();
+    const subgraphRow = await getSubgraph(db, subgraphName);
+    if (!subgraphRow)
+      return 0;
+    const lastProcessedBlock = Number(subgraphRow.last_processed_block);
+    const progress = await db.selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
+    if (!progress)
+      return 0;
+    const chainTip = Number(progress.last_contiguous_block);
+    if (lastProcessedBlock >= chainTip)
+      return 0;
+    const startBlock = lastProcessedBlock + 1;
+    const totalBlocks = chainTip - lastProcessedBlock;
+    logger4.info("Subgraph catch-up starting", {
+      subgraph: subgraphName,
+      from: startBlock,
+      to: chainTip,
+      blocks: totalBlocks
+    });
+    const stats = new StatsAccumulator(subgraphName, subgraphRow.api_key_id, true);
+    let processed = 0;
+    for (let height = startBlock;height <= chainTip; height++) {
+      const result = await processBlock(subgraph, subgraphName, height);
+      processed++;
+      if (result.timing) {
+        stats.record(result.timing, result.processed);
+        if (stats.shouldFlush()) {
+          await stats.flush(db);
+        }
+      }
+      if (processed % LOG_INTERVAL === 0) {
+        logger4.info("Subgraph catch-up progress", {
+          subgraph: subgraphName,
+          processed,
+          total: totalBlocks,
+          currentBlock: height,
+          pct: Math.round(processed / totalBlocks * 100)
+        });
+      }
+    }
+    await stats.flush(db);
+    logger4.info("Subgraph catch-up complete", {
+      subgraph: subgraphName,
+      processed
+    });
+    return processed;
+  } finally {
+    catchingUp.delete(subgraphName);
+  }
+}
+
+// src/runtime/reorg.ts
+import { getDb as getDb3, getRawClient } from "@secondlayer/shared/db";
+import { listSubgraphs } from "@secondlayer/shared/db/queries/subgraphs";
+import { logger as logger5 } from "@secondlayer/shared/logger";
+import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
+async function handleSubgraphReorg(blockHeight, loadSubgraphDef) {
+  const db = getDb3();
+  const client = getRawClient();
+  const activeSubgraphs = (await listSubgraphs(db)).filter((v) => v.status === "active");
+  if (activeSubgraphs.length === 0)
+    return;
+  logger5.info("Propagating reorg to subgraphs", { blockHeight, subgraphCount: activeSubgraphs.length });
+  for (const sg of activeSubgraphs) {
+    try {
+      const schema = sg.definition?.schema;
+      if (!schema)
+        continue;
+      const schemaName = sg.schema_name ?? pgSchemaName(sg.name);
+      for (const tableName of Object.keys(schema)) {
+        await client.unsafe(`DELETE FROM "${schemaName}"."${tableName}" WHERE "_block_height" = $1`, [blockHeight]);
+      }
+      logger5.info("Subgraph reorg cleanup done", { subgraph: sg.name, blockHeight });
+      const def = await loadSubgraphDef(sg.handler_path);
+      await processBlock(def, sg.name, blockHeight);
+      logger5.info("Subgraph reorg reprocessed", { subgraph: sg.name, blockHeight });
+    } catch (err) {
+      logger5.error("Subgraph reorg handling failed", {
+        subgraph: sg.name,
+        blockHeight,
+        error: getErrorMessage2(err)
+      });
+    }
+  }
+}
+
+// src/runtime/processor.ts
+import { getDb as getDb4 } from "@secondlayer/shared/db";
+import { logger as logger6 } from "@secondlayer/shared/logger";
+import { getErrorMessage as getErrorMessage3 } from "@secondlayer/shared";
+import { listen } from "@secondlayer/shared/queue/listener";
+import { listSubgraphs as listSubgraphs2, updateSubgraphStatus as updateSubgraphStatus2 } from "@secondlayer/shared/db/queries/subgraphs";
+var CHANNEL_NEW_BLOCK = "streams:new_job";
+var DEFAULT_CONCURRENCY = 5;
+var POLL_INTERVAL_MS = 5000;
+function isHandlerNotFoundError(err) {
+  if (!(err instanceof Error))
+    return false;
+  const code = err.code;
+  if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND" || code === "ENOENT")
+    return true;
+  return err.message.includes("Cannot find module") || err.message.includes("ENOENT");
+}
+async function loadSubgraphDefinition(handlerPath) {
+  const mod = await import(handlerPath);
+  return mod.default ?? mod;
+}
+async function startSubgraphProcessor(opts) {
+  const concurrency = opts?.concurrency ?? DEFAULT_CONCURRENCY;
+  let running = true;
+  logger6.info("Starting subgraph processor", { concurrency });
+  const db = getDb4();
+  const activeSubgraphs = (await listSubgraphs2(db)).filter((v) => v.status === "active");
+  for (const sg of activeSubgraphs) {
+    try {
+      const def = await loadSubgraphDefinition(sg.handler_path);
+      await catchUpSubgraph(def, sg.name);
+    } catch (err) {
+      const msg = getErrorMessage3(err);
+      if (isHandlerNotFoundError(err)) {
+        await updateSubgraphStatus2(db, sg.name, "error");
+      }
+      logger6.error("Subgraph catch-up failed on startup", {
+        subgraph: sg.name,
+        error: msg
+      });
+    }
+  }
+  const stopListening = await listen(CHANNEL_NEW_BLOCK, async () => {
+    if (!running)
+      return;
+    const db2 = getDb4();
+    const subgraphs = (await listSubgraphs2(db2)).filter((v) => v.status === "active");
+    for (const sg of subgraphs) {
+      try {
+        const def = await loadSubgraphDefinition(sg.handler_path);
+        await catchUpSubgraph(def, sg.name);
+      } catch (err) {
+        const msg = getErrorMessage3(err);
+        if (isHandlerNotFoundError(err)) {
+          await updateSubgraphStatus2(db2, sg.name, "error");
+        }
+        logger6.error("Subgraph processing failed", {
+          subgraph: sg.name,
+          error: msg
+        });
+      }
+    }
+  });
+  const stopReorgListening = await listen("subgraph_reorg", async (payload) => {
+    if (!running)
+      return;
+    try {
+      const data = JSON.parse(payload ?? "{}");
+      const blockHeight = data.blockHeight;
+      if (typeof blockHeight === "number") {
+        await handleSubgraphReorg(blockHeight, loadSubgraphDefinition);
+      }
+    } catch (err) {
+      logger6.error("Subgraph reorg handling failed", {
+        error: getErrorMessage3(err)
+      });
+    }
+  });
+  const pollInterval = setInterval(async () => {
+    if (!running)
+      return;
+    const db2 = getDb4();
+    const subgraphs = (await listSubgraphs2(db2)).filter((v) => v.status === "active");
+    for (const sg of subgraphs) {
+      try {
+        const def = await loadSubgraphDefinition(sg.handler_path);
+        await catchUpSubgraph(def, sg.name);
+      } catch (err) {
+        logger6.error("Subgraph poll processing failed", {
+          subgraph: sg.name,
+          error: getErrorMessage3(err)
+        });
+      }
+    }
+  }, POLL_INTERVAL_MS);
+  logger6.info("Subgraph processor ready");
+  return async () => {
+    running = false;
+    clearInterval(pollInterval);
+    await stopListening();
+    await stopReorgListening();
+    logger6.info("Subgraph processor stopped");
+  };
+}
+
+// src/service.ts
+import { logger as logger7 } from "@secondlayer/shared/logger";
+var processor = await startSubgraphProcessor({
+  concurrency: parseInt(process.env.SUBGRAPH_CONCURRENCY ?? "5")
+});
+var shutdown = async () => {
+  logger7.info("Shutting down subgraph processor...");
+  await processor();
+  process.exit(0);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+//# debugId=FE37EBBC45186A0D64756E2164756E21
+//# sourceMappingURL=service.js.map