@secondlayer/subgraphs 3.15.2 → 3.17.0

package/dist/src/index.d.ts

@@ -434,11 +434,17 @@ type IsOptionalColumn<C> = C extends {
 	default: string | number | boolean
 } ? true : false;
 /**
+* Like `InferColumnType` but for WRITE inputs: numeric (`uint`/`int`) columns
+* also accept a plain `number` (the runtime coerces to bigint). Reads stay
+* strict `bigint` via `InferColumnType`, so handlers still get exact types back.
+*/
+type WriteColumnType<C extends SubgraphColumn> = C["type"] extends "uint" | "int" ? C["nullable"] extends true ? bigint | number | null : bigint | number : InferColumnType<C>;
+/**
 * Row shape accepted by `ctx.insert`. System columns (`_id`, `_blockHeight`,
 * `_txId`, `_createdAt`) are omitted — the runtime adds them. Nullable and
 * defaulted columns are optional; all others required.
 */
-type WriteRow<T extends SubgraphTable> = { [K in keyof T["columns"] as IsOptionalColumn<T["columns"][K]> extends true ? never : K] : InferColumnType<T["columns"][K]> } & { [K in keyof T["columns"] as IsOptionalColumn<T["columns"][K]> extends true ? K : never]? : InferColumnType<T["columns"][K]> };
+type WriteRow<T extends SubgraphTable> = { [K in keyof T["columns"] as IsOptionalColumn<T["columns"][K]> extends true ? never : K] : WriteColumnType<T["columns"][K]> } & { [K in keyof T["columns"] as IsOptionalColumn<T["columns"][K]> extends true ? K : never]? : WriteColumnType<T["columns"][K]> };
 /** Computed-or-value row for `patchOrInsert` — each field may be a function of the existing row. */
 type PatchRow<T extends SubgraphTable> = { [K in keyof WriteRow<T>]? : WriteRow<T>[K] | ((existing: InferTableRow<T> | null) => unknown) };
 type TableName<S extends SubgraphSchema> = keyof S & string;
@@ -466,10 +472,20 @@ interface TypedSubgraphContext<S extends SubgraphSchema> {
 	tx: TxMeta;
 	insert<T extends TableName<S>>(table: T, row: WriteRow<S[T]>): void;
 	update<T extends TableName<S>>(table: T, where: RowWhere<S, T>, set: Partial<WriteRow<S[T]>>): void;
-	upsert<T extends TableName<S>>(table: T, key: Partial<WriteRow<S[T]>>, row: WriteRow<S[T]>): void;
+	upsert<
+		T extends TableName<S>,
+		K extends Partial<WriteRow<S[T]>>
+	>(table: T, key: K, row: Omit<WriteRow<S[T]>, keyof K> & Partial<WriteRow<S[T]>>): void;
 	delete<T extends TableName<S>>(table: T, where: RowWhere<S, T>): void;
 	patch<T extends TableName<S>>(table: T, where: RowWhere<S, T>, set: Partial<WriteRow<S[T]>>): void;
 	patchOrInsert<T extends TableName<S>>(table: T, key: Partial<WriteRow<S[T]>>, row: PatchRow<S[T]> & Record<string, ComputedValue>): Promise<void>;
+	/**
+	* Atomic accumulator — `INSERT … ON CONFLICT (key) DO UPDATE SET col =
+	* COALESCE(col,0) + delta`. Deltas commute, so it's the reorg-safe primitive
+	* for running totals (per-cycle aggregates, balances). Requires a `uniqueKeys`
+	* constraint matching `key`; deltas may be `number` or `bigint`.
+	*/
+	increment<T extends TableName<S>>(table: T, key: Partial<WriteRow<S[T]>>, deltas: Partial<Record<ColumnName<S, T>, bigint | number>>): void;
 	findOne<T extends TableName<S>>(table: T, where: RowWhere<S, T>): Promise<InferTableRow<S[T]> | null>;
 	findMany<T extends TableName<S>>(table: T, where: RowWhere<S, T>): Promise<InferTableRow<S[T]>[]>;
 	formatUnits(value: bigint, decimals: number): string;

package/dist/src/index.js

@@ -1433,7 +1433,9 @@ import { sql as sql3 } from "kysely";
 
 // src/runtime/block-source.ts
 import { getSourceDb } from "@secondlayer/shared/db";
-import { IndexHttpClient } from "@secondlayer/shared/index-http";
+import {
+  IndexHttpClient
+} from "@secondlayer/shared/index-http";
 import { logger as logger3 } from "@secondlayer/shared/logger";
 
 // src/runtime/batch-loader.ts
@@ -1512,6 +1514,22 @@ function reconstructTransaction(t) {
     created_at: new Date(0)
   };
 }
+function reconstructTxFromEventRow(e) {
+  return {
+    tx_id: e.tx_id,
+    block_height: e.block_height,
+    tx_index: e.tx_index ?? 0,
+    type: e.tx_type ?? "",
+    sender: e.tx_sender ?? "",
+    status: e.tx_status ?? "success",
+    contract_id: e.tx_contract_id ?? null,
+    function_name: e.tx_function_name ?? null,
+    function_args: [],
+    raw_result: null,
+    raw_tx: "",
+    created_at: new Date(0)
+  };
+}
 function reconstructEvent(e) {
   const base = {
     id: `${e.tx_id}#${e.event_index}`,
@@ -1637,6 +1655,17 @@ function sourceFilters(subgraph) {
   const sources = subgraph.sources;
   return Array.isArray(sources) ? sources : Object.values(sources);
 }
+function needsTransactionData(subgraph) {
+  return sourceFilters(subgraph).some((f) => TX_SOURCE_TYPES.has(f.type));
+}
+function synthesizeTxsFromEvents(events) {
+  const byId = new Map;
+  for (const e of events) {
+    if (!byId.has(e.tx_id))
+      byId.set(e.tx_id, reconstructTxFromEventRow(e));
+  }
+  return [...byId.values()];
+}
 function indexEventTypesForFilterTypes(filterTypes) {
   if (filterTypes.some((t) => TX_SOURCE_TYPES.has(t))) {
     return ALL_INDEX_EVENT_TYPES;
@@ -1670,10 +1699,12 @@ class PublicApiBlockSource {
   http;
   eventTypes;
   probeTargets;
-  constructor(http, eventTypes, probeTargets) {
+  needsTransactions;
+  constructor(http, eventTypes, probeTargets, needsTransactions = true) {
     this.http = http;
     this.eventTypes = eventTypes;
     this.probeTargets = probeTargets;
+    this.needsTransactions = needsTransactions;
   }
   async nextDataHeight(afterHeight, untilHeight) {
     if (!this.probeTargets?.length)
@@ -1686,10 +1717,11 @@ class PublicApiBlockSource {
     return this.http.getIndexTip();
   }
   async loadBlockRange(fromHeight, toHeight) {
-    const [blocks, txs, eventLists] = await Promise.all([
+    const withTx = !this.needsTransactions;
+    const [blocks, txRows, eventLists] = await Promise.all([
       this.http.walkBlocks(fromHeight, toHeight),
-      this.http.walkTransactions(fromHeight, toHeight),
-      Promise.all(this.eventTypes.map((t) => this.http.walkEvents(t, fromHeight, toHeight)))
+      this.needsTransactions ? this.http.walkTransactions(fromHeight, toHeight) : Promise.resolve([]),
+      Promise.all(this.eventTypes.map((t) => this.http.walkEvents(t, fromHeight, toHeight, withTx)))
     ]);
     const map = new Map;
     for (const b of blocks) {
@@ -1699,8 +1731,9 @@ class PublicApiBlockSource {
         events: []
       });
     }
+    const txs = this.needsTransactions ? txRows.map(reconstructTransaction) : synthesizeTxsFromEvents(eventLists.flat());
     for (const t of txs) {
-      map.get(t.block_height)?.txs.push(reconstructTransaction(t));
+      map.get(t.block_height)?.txs.push(t);
     }
     for (const list of eventLists) {
       for (const e of list) {
@@ -1765,7 +1798,7 @@ function buildHttpClient() {
 }
 function resolveBlockSource(subgraph) {
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph && isStreamsIndexEligible(subgraph)) {
-    return new FallbackBlockSource(new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph), canSparseScan(subgraph) ? sparseProbeTargets(subgraph) : undefined), postgresBlockSource);
+    return new FallbackBlockSource(new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph), canSparseScan(subgraph) ? sparseProbeTargets(subgraph) : undefined, needsTransactionData(subgraph)), postgresBlockSource);
   }
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph) {
     logger3.debug("Subgraph not streams-index eligible, using DB tap", {
@@ -4037,5 +4070,5 @@ export {
   ByoBreakingChangeError
 };
 
-//# debugId=D13A7E4F60723ACE64756E2164756E21
+//# debugId=F6E8980AB9FF4A2864756E2164756E21
 //# sourceMappingURL=index.js.map