@secondlayer/subgraphs 0.8.1 → 0.9.1

package/dist/src/service.js

@@ -1,22 +1,9 @@
 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 { 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)) {
@@ -84,6 +71,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}"`;
@@ -101,6 +102,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)
@@ -241,12 +283,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;
   }
@@ -275,19 +317,210 @@ 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 decodeFunctionArgs2(args) {
+  if (!Array.isArray(args))
+    return [];
+  return args.map((arg) => {
+    if (typeof arg === "string")
+      return decodeClarityValue(arg);
+    return arg;
+  });
+}
+function decodeRawResult(raw) {
+  if (typeof raw === "string" && raw.length > 2) {
+    return decodeClarityValue(raw);
+  }
+  return null;
+}
+function safeBigInt(val) {
+  if (typeof val === "bigint")
+    return val;
+  if (typeof val === "number")
+    return BigInt(val);
+  if (typeof val === "string") {
+    try {
+      return BigInt(val);
+    } catch {
+      return 0n;
+    }
+  }
+  return 0n;
+}
+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
+  };
+  const decodedArgs = decodeFunctionArgs2(tx.function_args);
+  const decodedResult = decodeRawResult(tx.raw_result);
+  if (!event) {
+    switch (filter.type) {
+      case "contract_call":
+        return {
+          contractId: tx.contract_id ?? "",
+          functionName: tx.function_name ?? "",
+          caller: tx.sender,
+          args: decodedArgs,
+          result: decodedResult,
+          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: safeBigInt(decoded.amount),
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "ft_mint":
+      return {
+        recipient: decoded.recipient,
+        amount: safeBigInt(decoded.amount),
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "ft_burn":
+      return {
+        sender: decoded.sender,
+        amount: safeBigInt(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: safeBigInt(decoded.amount),
+        memo: decoded.memo ?? "",
+        tx: txMeta
+      };
+    case "stx_mint":
+      return {
+        recipient: decoded.recipient,
+        amount: safeBigInt(decoded.amount),
+        tx: txMeta
+      };
+    case "stx_burn":
+      return {
+        sender: decoded.sender,
+        amount: safeBigInt(decoded.amount),
+        tx: txMeta
+      };
+    case "stx_lock":
+      return {
+        lockedAddress: decoded.locked_address,
+        lockedAmount: safeBigInt(decoded.locked_amount),
+        unlockHeight: safeBigInt(decoded.unlock_height),
+        tx: txMeta
+      };
+    case "print_event": {
+      const rawValue = decoded.value;
+      const clarityObj = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue) ? rawValue : null;
+      const topic = clarityObj?.topic ? String(clarityObj.topic) : decoded.topic ?? "";
+      const { topic: _, ...rest } = clarityObj ?? {};
+      const data = Object.keys(rest).length > 0 ? camelizeKeys(rest) : rawValue && typeof rawValue !== "object" ? 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: decodedArgs,
+        result: decodedResult,
+        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;
@@ -296,11 +529,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,
@@ -310,13 +546,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)
         });
@@ -333,28 +569,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,
@@ -379,62 +617,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;
@@ -448,13 +810,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 });
       }
     }
   }
@@ -766,7 +1128,8 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     let processed = 0;
     let batchSize = DEFAULT_BATCH_SIZE;
     let currentHeight = startBlock;
-    let nextBatchPromise = loadBlockRange(db, currentHeight, Math.min(currentHeight + batchSize - 1, chainTip));
+    let nextBatchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+    let nextBatchPromise = loadBlockRange(db, currentHeight, nextBatchEnd);
     while (currentHeight <= chainTip) {
       const currentRow = await getSubgraph(db, subgraphName);
       if (!currentRow || currentRow.status !== "active") {
@@ -777,11 +1140,11 @@ async function catchUpSubgraph(subgraph, subgraphName) {
         break;
       }
       const batch = await nextBatchPromise;
-      const batchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+      const batchEnd = nextBatchEnd;
       const nextStart = batchEnd + 1;
       if (nextStart <= chainTip) {
-        const nextEnd = Math.min(nextStart + batchSize - 1, chainTip);
-        nextBatchPromise = loadBlockRange(db, nextStart, nextEnd);
+        nextBatchEnd = Math.min(nextStart + batchSize - 1, chainTip);
+        nextBatchPromise = loadBlockRange(db, nextStart, nextBatchEnd);
       }
       const batchFailedBlocks = [];
       for (let height = currentHeight;height <= batchEnd; height++) {
@@ -1014,5 +1377,5 @@ var shutdown = async () => {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 
-//# debugId=1DD34E9C0E67AAF764756E2164756E21
+//# debugId=8F216EE232BD89E464756E2164756E21
 //# sourceMappingURL=service.js.map