@secondlayer/subgraphs 0.8.1 → 0.9.0

package/dist/src/index.js

@@ -1,20 +1,6 @@
 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/validate.ts
 import { z } from "zod/v4";
 var SubgraphNameSchema = z.string().min(1).max(63).regex(/^[a-z][a-z0-9-]*$/, "Must start with lowercase letter, contain only lowercase alphanumeric and hyphens");
@@ -40,18 +26,43 @@ var SubgraphTableSchema = z.object({
   uniqueKeys: z.array(z.array(z.string())).optional()
 });
 var SubgraphSchemaSchema = z.record(z.string(), SubgraphTableSchema).refine((s) => Object.keys(s).length > 0, "Schema must have at least one table");
-var SubgraphSourceSchema = z.object({
-  contract: z.string().optional(),
-  event: z.string().optional(),
-  function: z.string().optional(),
-  type: z.string().optional(),
-  minAmount: z.bigint().optional()
-}).refine((s) => s.contract || s.type, "Source must specify at least 'contract' or 'type'");
+var VALID_FILTER_TYPES = [
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "contract_call",
+  "contract_deploy",
+  "print_event"
+];
+var SubgraphFilterSchema = z.object({
+  type: z.enum(VALID_FILTER_TYPES),
+  sender: z.string().optional(),
+  recipient: z.string().optional(),
+  minAmount: z.bigint().optional(),
+  maxAmount: z.bigint().optional(),
+  assetIdentifier: z.string().optional(),
+  contractId: z.string().optional(),
+  functionName: z.string().optional(),
+  caller: z.string().optional(),
+  deployer: z.string().optional(),
+  contractName: z.string().optional(),
+  topic: z.string().optional(),
+  lockedAddress: z.string().optional(),
+  abi: z.record(z.string(), z.any()).optional()
+}).passthrough();
 var SubgraphDefinitionSchema = z.object({
   name: SubgraphNameSchema,
   version: z.string().optional(),
   description: z.string().optional(),
-  sources: z.array(SubgraphSourceSchema).min(1, "Must have at least one source"),
+  startBlock: z.number().int().nonnegative().optional(),
+  sources: z.record(z.string(), SubgraphFilterSchema).refine((s) => Object.keys(s).length > 0, "Must have at least one source"),
   schema: SubgraphSchemaSchema,
   handlers: z.record(z.string(), z.any())
 });
@@ -61,6 +72,7 @@ function validateSubgraphDefinition(def) {
 
 // src/runtime/context.ts
 import { logger } from "@secondlayer/shared/logger";
+import { formatUnits } from "@secondlayer/stacks/utils";
 import { sql } from "kysely";
 function validateColumnName(name) {
   if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
@@ -128,6 +140,20 @@ class SubgraphContext {
     this.validateTable(table);
     this.ops.push({ kind: "delete", table, data: where });
   }
+  patch(table, where, set) {
+    this.update(table, where, set);
+  }
+  async patchOrInsert(table, key, row) {
+    const existing = await this.findOne(table, key);
+    const resolved = {};
+    for (const [k, v] of Object.entries(row)) {
+      resolved[k] = typeof v === "function" ? v(existing) : v;
+    }
+    this.upsert(table, key, resolved);
+  }
+  formatUnits(value, decimals) {
+    return formatUnits(value, decimals);
+  }
   async findOne(table, where) {
     this.validateTable(table);
     const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
@@ -145,6 +171,47 @@ class SubgraphContext {
     const { rows } = await sql.raw(query).execute(this.db);
     return rows.map((r) => this.coerceRow(table, r));
   }
+  async count(table, where) {
+    this.validateTable(table);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
+    const { rows } = await sql.raw(`SELECT COUNT(*)::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
+    return Number(rows[0]?.count ?? 0);
+  }
+  async sum(table, column, where) {
+    this.validateTable(table);
+    validateColumnName(column);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
+    const { rows } = await sql.raw(`SELECT COALESCE(SUM("${column}"), 0) AS total FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
+    return BigInt(rows[0]?.total?.toString() ?? "0");
+  }
+  async min(table, column, where) {
+    this.validateTable(table);
+    validateColumnName(column);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
+    const { rows } = await sql.raw(`SELECT MIN("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
+    const val = rows[0]?.val;
+    return val != null ? BigInt(val.toString()) : null;
+  }
+  async max(table, column, where) {
+    this.validateTable(table);
+    validateColumnName(column);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
+    const { rows } = await sql.raw(`SELECT MAX("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
+    const val = rows[0]?.val;
+    return val != null ? BigInt(val.toString()) : null;
+  }
+  async countDistinct(table, column, where) {
+    this.validateTable(table);
+    validateColumnName(column);
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
+    const { rows } = await sql.raw(`SELECT COUNT(DISTINCT "${column}")::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
+    return Number(rows[0]?.count ?? 0);
+  }
   coerceRow(table, row) {
     const tableDef = this.subgraphSchema[table];
     if (!tableDef)
@@ -285,12 +352,12 @@ function buildWhereClause(where) {
 }
 
 // src/runtime/clarity.ts
-import { cvToJSON, deserializeCV } from "@secondlayer/stacks/clarity";
+import { cvToValue, 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);
+    return cvToValue(cv);
   } catch {
     return hex;
   }
@@ -319,19 +386,177 @@ function decodeFunctionArgs(args) {
 import { getErrorMessage } from "@secondlayer/shared";
 import { logger as logger2 } from "@secondlayer/shared/logger";
 var DEFAULT_ERROR_THRESHOLD = 50;
-function resolveHandler(handlers, key) {
-  return handlers[key] ?? handlers["*"] ?? null;
+function camelCase(str) {
+  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function camelizeKeys(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(camelizeKeys);
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    result[camelCase(k)] = camelizeKeys(v);
+  }
+  return result;
+}
+function buildEventPayload(filter, tx, event) {
+  const txMeta = {
+    txId: tx.tx_id,
+    sender: tx.sender,
+    type: tx.type,
+    status: tx.status,
+    contractId: tx.contract_id ?? null,
+    functionName: tx.function_name ?? null
+  };
+  if (!event) {
+    switch (filter.type) {
+      case "contract_call":
+        return {
+          contractId: tx.contract_id ?? "",
+          functionName: tx.function_name ?? "",
+          caller: tx.sender,
+          args: {},
+          result: null,
+          tx: txMeta
+        };
+      case "contract_deploy":
+        return {
+          contractId: tx.contract_id ?? "",
+          deployer: tx.sender,
+          tx: txMeta
+        };
+      default:
+        return { tx: txMeta };
+    }
+  }
+  const decoded = decodeEventData(event.data);
+  switch (filter.type) {
+    case "ft_transfer":
+      return {
+        sender: decoded.sender,
+        recipient: decoded.recipient,
+        amount: decoded.amount,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "ft_mint":
+      return {
+        recipient: decoded.recipient,
+        amount: decoded.amount,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "ft_burn":
+      return {
+        sender: decoded.sender,
+        amount: decoded.amount,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "nft_transfer":
+      return {
+        sender: decoded.sender,
+        recipient: decoded.recipient,
+        tokenId: decoded.value,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "nft_mint":
+      return {
+        recipient: decoded.recipient,
+        tokenId: decoded.value,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "nft_burn":
+      return {
+        sender: decoded.sender,
+        tokenId: decoded.value,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "stx_transfer":
+      return {
+        sender: decoded.sender,
+        recipient: decoded.recipient,
+        amount: decoded.amount,
+        memo: decoded.memo ?? "",
+        tx: txMeta
+      };
+    case "stx_mint":
+      return {
+        recipient: decoded.recipient,
+        amount: decoded.amount,
+        tx: txMeta
+      };
+    case "stx_burn":
+      return {
+        sender: decoded.sender,
+        amount: decoded.amount,
+        tx: txMeta
+      };
+    case "stx_lock":
+      return {
+        lockedAddress: decoded.locked_address,
+        lockedAmount: decoded.locked_amount,
+        unlockHeight: decoded.unlock_height,
+        tx: txMeta
+      };
+    case "print_event": {
+      const topic = decoded.topic ?? "";
+      const rawValue = decoded.value;
+      const data = rawValue && typeof rawValue === "object" ? camelizeKeys(rawValue) : rawValue;
+      return {
+        contractId: decoded.contract_identifier ?? tx.contract_id ?? "",
+        topic,
+        data: data ?? {},
+        tx: txMeta
+      };
+    }
+    case "contract_call":
+      return {
+        ...decoded,
+        _eventType: event.type,
+        contractId: tx.contract_id ?? "",
+        functionName: tx.function_name ?? "",
+        caller: tx.sender,
+        args: {},
+        result: null,
+        tx: txMeta
+      };
+    case "contract_deploy":
+      return {
+        contractId: tx.contract_id ?? "",
+        deployer: tx.sender,
+        tx: txMeta
+      };
+    default:
+      return {
+        ...decoded,
+        _eventType: event.type,
+        tx: txMeta
+      };
+  }
 }
 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);
+  const filterLookup = new Map;
+  if (!Array.isArray(subgraph.sources)) {
+    for (const [name, filter] of Object.entries(subgraph.sources)) {
+      filterLookup.set(name, filter);
+    }
+  }
+  for (const { tx, events, sourceName } of matched) {
+    const handler = subgraph.handlers[sourceName] ?? subgraph.handlers["*"] ?? null;
     if (!handler) {
-      logger2.warn("No handler found for source key", {
+      logger2.warn("No handler found for source", {
         subgraph: subgraph.name,
-        sourceKey: sourceKey2,
+        sourceName,
         txId: tx.tx_id
       });
       continue;
@@ -340,11 +565,14 @@ async function runHandlers(subgraph, matched, ctx, opts) {
       txId: tx.tx_id,
       sender: tx.sender,
       type: tx.type,
-      status: tx.status
+      status: tx.status,
+      contractId: tx.contract_id ?? null,
+      functionName: tx.function_name ?? null
     });
+    const filter = filterLookup.get(sourceName);
     if (events.length === 0) {
       try {
-        const txPayload = {
+        const payload = filter ? buildEventPayload(filter, tx, null) : {
           tx: {
             txId: tx.tx_id,
             sender: tx.sender,
@@ -354,13 +582,13 @@ async function runHandlers(subgraph, matched, ctx, opts) {
             functionName: tx.function_name
           }
         };
-        await handler(txPayload, ctx);
+        await handler(payload, ctx);
         processed++;
       } catch (err) {
         errors++;
         logger2.error("Subgraph handler error", {
           subgraph: subgraph.name,
-          sourceKey: sourceKey2,
+          sourceName,
           txId: tx.tx_id,
           error: getErrorMessage(err)
         });
@@ -377,28 +605,30 @@ async function runHandlers(subgraph, matched, ctx, opts) {
         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);
+        const payload = filter ? buildEventPayload(filter, tx, event) : (() => {
+          const decoded = decodeEventData(event.data);
+          return {
+            ...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(payload, ctx);
         processed++;
       } catch (err) {
         errors++;
         logger2.error("Subgraph handler error", {
           subgraph: subgraph.name,
-          sourceKey: sourceKey2,
+          sourceName,
           txId: tx.tx_id,
           eventId: event.id,
           eventType: event.type,
@@ -423,62 +653,186 @@ function matchPattern(value, pattern) {
   }
   return re.test(value);
 }
-function matchSource(source, transactions, eventsByTx) {
+function matchFilter(filter, 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) => {
+  switch (filter.type) {
+    case "stx_transfer":
+    case "stx_mint":
+    case "stx_burn":
+    case "stx_lock": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => e.type === eventType);
+        if (matched.length === 0)
+          continue;
+        const filtered = matched.filter((e) => {
           const data = e.data;
-          const rawAmount = data?.amount;
-          if (rawAmount === undefined)
+          if (!data)
             return false;
-          const amount = BigInt(rawAmount);
-          return amount >= source.minAmount;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if ("lockedAddress" in filter && filter.lockedAddress) {
+            if (!matchPattern(data.locked_address, filter.lockedAddress))
+              return false;
+          }
+          if ("minAmount" in filter && filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? data.locked_amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          if ("maxAmount" in filter && filter.maxAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount > filter.maxAmount)
+              return false;
+          }
+          return true;
         });
-        if (amountEvents.length === 0)
-          continue;
-        matchedEvents = amountEvents;
+        if (filtered.length > 0) {
+          results.push({ tx, events: filtered });
+        }
       }
-      results.push({ tx, events: matchedEvents, sourceKey: key });
-      continue;
+      break;
     }
-    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;
+    case "ft_transfer":
+    case "ft_mint":
+    case "ft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if (filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
       }
-      const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-      let matchedEvents = txEvents;
-      if (!txContractMatch) {
-        matchedEvents = txEvents.filter((e) => {
+      break;
+    }
+    case "nft_transfer":
+    case "nft_mint":
+    case "nft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
           const data = e.data;
-          const contractIdentifier = data?.contract_identifier;
-          return contractIdentifier && matchPattern(contractIdentifier, source.contract);
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          return true;
         });
-        if (matchedEvents.length === 0)
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+    case "contract_call": {
+      for (const tx of transactions) {
+        if (tx.type !== "contract_call")
+          continue;
+        if (filter.contractId) {
+          if (!tx.contract_id || !matchPattern(tx.contract_id, filter.contractId))
+            continue;
+        }
+        if (filter.functionName) {
+          if (!tx.function_name || !matchPattern(tx.function_name, filter.functionName))
+            continue;
+        }
+        if (filter.caller) {
+          if (!matchPattern(tx.sender, filter.caller))
+            continue;
+        }
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
+      }
+      break;
+    }
+    case "contract_deploy": {
+      for (const tx of transactions) {
+        if (tx.type !== "smart_contract")
           continue;
+        if (filter.deployer) {
+          if (!matchPattern(tx.sender, filter.deployer))
+            continue;
+        }
+        if (filter.contractName) {
+          const name = tx.contract_id?.split(".")[1] ?? "";
+          if (!matchPattern(name, filter.contractName))
+            continue;
+        }
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
       }
-      if (source.event) {
-        matchedEvents = matchedEvents.filter((e) => {
-          if (matchPattern(e.type, source.event))
-            return true;
+      break;
+    }
+    case "print_event": {
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== "smart_contract_event")
+            return false;
           const data = e.data;
-          const topic = data?.topic;
-          return topic ? matchPattern(topic, source.event) : false;
+          if (!data)
+            return false;
+          if (data.topic !== "print")
+            return false;
+          if (filter.contractId) {
+            const contractId = data.contract_identifier;
+            if (!contractId || !matchPattern(contractId, filter.contractId))
+              return false;
+          }
+          return true;
         });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
       }
-      if (txContractMatch || matchedEvents.length > 0) {
-        results.push({ tx, events: matchedEvents, sourceKey: key });
-      }
+      break;
     }
   }
   return results;
@@ -492,13 +846,13 @@ function matchSources(sources, transactions, events) {
   }
   const seen = new Set;
   const results = [];
-  for (const source of sources) {
-    const matches = matchSource(source, transactions, eventsByTx);
+  for (const [sourceName, filter] of Object.entries(sources)) {
+    const matches = matchFilter(filter, transactions, eventsByTx);
     for (const match of matches) {
-      const dedupeKey = `${match.tx.tx_id}:${match.sourceKey}`;
+      const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
       if (!seen.has(dedupeKey)) {
         seen.add(dedupeKey);
-        results.push(match);
+        results.push({ ...match, sourceName });
       }
     }
   }
@@ -1175,6 +1529,7 @@ async function backfillSubgraph(def, opts) {
     throw err;
   }
 }
+
 // src/define.ts
 function defineSubgraph(def) {
   return def;
@@ -1351,7 +1706,6 @@ function getDefault(type) {
 }
 export {
   validateSubgraphDefinition,
-  sourceKey,
   resumeReindex,
   reindexSubgraph,
   pgSchemaName,
@@ -1362,5 +1716,5 @@ export {
   backfillSubgraph
 };
 
-//# debugId=4B7B76347D5AD39564756E2164756E21
+//# debugId=9F5F23B13281C9C864756E2164756E21
 //# sourceMappingURL=index.js.map