@secondlayer/subgraphs 3.22.0 → 3.23.1

package/dist/src/index.d.ts

@@ -1,4 +1,91 @@
-import { AbiContract } from "@secondlayer/stacks/clarity";
+import { AbiContract as AbiContract2 } from "@secondlayer/stacks/clarity";
+import { UnwrapResponse } from "@secondlayer/stacks/actions";
+import { AbiContract, ExtractFunctionArgs, ExtractFunctionOutput, ExtractReadOnlyFunctions, ToCamelCase } from "@secondlayer/stacks/clarity";
+/**
+* How long a read stays valid.
+*
+* - `per-block` (default): pinned to the block being processed, cached under
+*   its `index_block_hash`. Sound for any read-only function — reindexing the
+*   same block always returns the same value, and a reorg-replaced block has a
+*   different id so it can't inherit the orphaned answer.
+* - `contract-constant`: the caller asserts the value cannot change for this
+*   contract and these args (SIP-010 `get-decimals`/`get-symbol`), so it is
+*   resolved ONCE instead of once per block. This is the mode that makes a
+*   backfill affordable — under `per-block` every block is a distinct key and
+*   therefore a distinct RPC. Declaring it on a value that does change pins the
+*   first answer forever, so it is opt-in and never inferred.
+*/
+type ChainReadCacheMode = "per-block" | "contract-constant";
+type ChainReadOptions = {
+	cache?: ChainReadCacheMode
+};
+/**
+* The chain-read surface, fully typed by an ABI.
+*
+* Shaped like `getContract` from `@secondlayer/stacks` — the same ABI in, the
+* same camelCased read methods out — minus `call`/`buildCall`: a handler
+* indexes the chain, it never writes to it.
+*
+* Reached through {@link readContractAt} rather than off `ctx.client`
+* directly: an ABI-generic method living on the context interface makes every
+* structural comparison of a subgraph definition instantiate it, which exceeds
+* TS's depth budget. At a call site the ABI is already concrete and it costs
+* nothing.
+*/
+interface ChainReadClient {
+	/**
+	* Read-only methods of a contract, evaluated against the exact block being
+	* processed.
+	*
+	* Every call is pinned to the block's `index_block_hash`, so a handler is a
+	* pure function of its block: reindexing a range produces byte-identical
+	* rows. Reading at the node's tip instead would make the same reindex
+	* return different values — that is the corruption this refuses to allow,
+	* so a block whose id was never persisted throws rather than falling back.
+	*
+	* Results are memoized in Postgres, so a value is fetched once per block
+	* rather than once per event (or once per contract with
+	* `cache: "contract-constant"`).
+	*/
+	contract<const C extends AbiContract>(contractId: string, abi: C, options?: ChainReadOptions): {
+		read: ChainReadMethods<C>
+	};
+}
+/**
+* The camelCased read methods of an ABI. Spelled out rather than reused from
+* `ContractInstance<C>["read"]`: that type is a conditional over the codegen
+* brand, and evaluating it wherever a subgraph definition is structurally
+* compared pushes TS past its instantiation depth.
+*/
+type ChainReadMethods<C extends AbiContract> = { [N in ExtractReadOnlyFunctions<C> as ToCamelCase<N>] : (args: ExtractFunctionArgs<C, N>) => Promise<UnwrapResponse<ExtractFunctionOutput<C, N>>> };
+/**
+* `ChainReadClient` with the ABI generic erased. Structurally cheap, so the
+* base `SubgraphContext` can carry it; `TypedSubgraphContext` uses the real
+* one and handlers get full inference.
+*/
+interface ErasedChainReadClient {
+	contract(contractId: string, abi: unknown, options?: ChainReadOptions): {
+		read: Record<string, (args?: Record<string, unknown>) => Promise<unknown>>
+	};
+}
+/**
+* Typed read methods for one contract, from a handler.
+*
+* ```ts
+* const token = readContractAt(ctx, contractId, SIP010_ABI, {
+*   cache: "contract-constant",
+* });
+* const decimals = await token.read.getDecimals({}); // bigint
+* ```
+*/
+declare function readContractAt<const C extends AbiContract>(ctx: {
+	client: ErasedChainReadClient
+}, contractId: string, abi: C, options?: ChainReadOptions): {
+	read: ChainReadMethods<C>
+};
+declare class ChainReadError extends Error {
+	name: string;
+}
 /** Supported column types for subgraph schemas */
 type ColumnType = "text" | "uint" | "int" | "principal" | "boolean" | "timestamp" | "jsonb";
 /** Column definition in a subgraph table */
@@ -216,7 +303,7 @@ interface ContractCallFilter extends TraitScope, FactoryScope {
 	* definition and used at runtime to decode args by name. Omit to keep
 	* `event.args` as a positional `unknown[]`.
 	*/
-	abi?: AbiContract;
+	abi?: AbiContract2;
 }
 interface ContractDeployFilter {
 	type: "contract_deploy";
@@ -287,8 +374,21 @@ interface SubgraphContext {
 		hash: string
 		timestamp: number
 		burnBlockHeight: number
+		/** Nakamoto StacksBlockId, when the block row carries one. */
+		indexBlockHash?: string | null
 	};
 	tx: TxMeta;
+	/**
+	* Read-only contract calls pinned to this block. Cached, so the same
+	* (contract, function, args) is fetched once per block rather than once
+	* per event.
+	*
+	* Erased here on purpose: this interface is compared structurally wherever
+	* a subgraph definition is passed around, and carrying an ABI-generic
+	* method pushes those comparisons past TS's instantiation depth. Handlers
+	* receive `TypedSubgraphContext`, which exposes the fully typed version.
+	*/
+	client: ErasedChainReadClient;
 	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;
@@ -397,7 +497,7 @@ declare function backfillSubgraph(def: SubgraphDefinition, opts: {
 }): Promise<{
 	processed: number
 }>;
-import { AbiContract as AbiContract2, ExtractFunctionArgs, ExtractFunctionNames } from "@secondlayer/stacks/clarity";
+import { AbiContract as AbiContract3, ExtractFunctionArgs as ExtractFunctionArgs2, ExtractFunctionNames } from "@secondlayer/stacks/clarity";
 /** Maps a ColumnType string literal to its TypeScript equivalent */
 type ColumnToTS<T extends string> = T extends "uint" | "int" ? bigint : T extends "text" | "principal" | "timestamp" ? string : T extends "boolean" ? boolean : T extends "jsonb" ? Record<string, unknown> : unknown;
 /** Infer TS type for a single column definition, respecting nullable */
@@ -574,8 +674,17 @@ interface TypedSubgraphContext<S extends SubgraphSchema> {
 		hash: string
 		timestamp: number
 		burnBlockHeight: number
+		/** Nakamoto StacksBlockId, when the block row carries one. */
+		indexBlockHash?: string | null
 	};
 	tx: TxMeta;
+	/**
+	* Read-only contract calls pinned to this block. Erased here for the same
+	* reason as on `SubgraphContext`: an ABI-generic method on a structurally
+	* compared interface exceeds TS's instantiation budget. Wrap it with
+	* `readContractAt(ctx, id, abi)` for full ABI typing at the call site.
+	*/
+	client: ErasedChainReadClient;
 	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<
@@ -690,10 +799,10 @@ interface ContractDeployPayload {
 * present for back-compat. Without an `abi`, the payload is {@link ContractCallEvent}.
 */
 type ContractCallPayload<F> = F extends {
-	abi: infer A extends AbiContract2
+	abi: infer A extends AbiContract3
 	functionName: infer N extends string
 } ? N extends ExtractFunctionNames<A> ? ContractCallEvent & {
-	input: ExtractFunctionArgs<A, N>
+	input: ExtractFunctionArgs2<A, N>
 } : ContractCallEvent : ContractCallEvent;
 /**
 * Print event typed per topic. When a `print_event` source declares a `prints`
@@ -963,10 +1072,10 @@ declare function generateIndexSchema(target: IndexCodegenTarget, opts?: IndexCod
 /** Index tables available to codegen, for help text and validation. */
 declare const INDEX_CODEGEN_TABLES: readonly string[];
 import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
-import { Database } from "@secondlayer/shared/db";
+import { Database as Database2 } from "@secondlayer/shared/db";
 import { ByoBreakingChangeDetails } from "@secondlayer/shared/errors";
-import { Kysely } from "kysely";
-type AnyDb = Kysely<Database>;
+import { Kysely as Kysely2 } from "kysely";
+type AnyDb = Kysely2<Database2>;
 interface TableDiff {
 	/** Tables added to the schema */
 	addedTables: string[];
@@ -1100,4 +1209,4 @@ type SparseProbeTarget = {
 declare function canSparseScan(subgraph: SubgraphDefinition): boolean;
 /** Probe targets for a subgraph's filters: decoded type + contract scope when\\n*  the filter pins one (assetIdentifier "SP….contract::asset" or contractId). */
 declare function sparseProbeTargets(subgraph: SubgraphDefinition): SparseProbeTarget[];
-export { validateSubgraphDefinition, validatePrintPayload, sparseProbeTargets, resumeReindex, renderDeployPlan, reindexSubgraph, pgSchemaName, inferPrintTopics, hasBreakingChanges, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, filterFieldsByType, diffSchema, deploySchema, defineSubgraph, defineSchema, canSparseScan, camelizeDataKey, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, SparseProbeTarget, RowValue, ReindexOptions, PrismaGenOptions, PrintValidationResult, PrintSample, PrintFieldToTS, PrintField, PrintEventPayload, PrintEventFor, PrintEventFilter, PrintDataOf, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferredTopicSchema, InferredPrintField, InferTableRow, InferSubgraphClient, InferContext, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, FactoryScope, EventForFilter, DrizzleGenOptions, DeployPlan, DeployDiff, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, ByoMigrationPlan, ByoBreakingChangeError, AnyEvent, AggregateSpec, AggregateResult };
+export { validateSubgraphDefinition, validatePrintPayload, sparseProbeTargets, resumeReindex, renderDeployPlan, reindexSubgraph, readContractAt, pgSchemaName, inferPrintTopics, hasBreakingChanges, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, filterFieldsByType, diffSchema, deploySchema, defineSubgraph, defineSchema, canSparseScan, camelizeDataKey, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, SparseProbeTarget, RowValue, ReindexOptions, PrismaGenOptions, PrintValidationResult, PrintSample, PrintFieldToTS, PrintField, PrintEventPayload, PrintEventFor, PrintEventFilter, PrintDataOf, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferredTopicSchema, InferredPrintField, InferTableRow, InferSubgraphClient, InferContext, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, FactoryScope, EventForFilter, ErasedChainReadClient, DrizzleGenOptions, DeployPlan, DeployDiff, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, ChainReadOptions, ChainReadMethods, ChainReadError, ChainReadClient, ChainReadCacheMode, ByoMigrationPlan, ByoBreakingChangeError, AnyEvent, AggregateSpec, AggregateResult };

package/dist/src/index.js

@@ -360,6 +360,139 @@ function generateSubgraphSQL(def, schemaNameOverride) {
   return { statements, hash };
 }
 
+// src/runtime/chain-read.ts
+import { getSourceDb } from "@secondlayer/shared/db";
+import { http, createPublicClient } from "@secondlayer/stacks";
+import {
+  ContractResponseError,
+  buildFunctionArgs,
+  isResponseOutput,
+  readContract
+} from "@secondlayer/stacks/actions";
+import {
+  clarityValueToJSUntyped,
+  deserializeCV,
+  normalizeAbi,
+  serializeCV,
+  toCamelCase
+} from "@secondlayer/stacks/clarity";
+function readContractAt(ctx, contractId, abi, options) {
+  return ctx.client.contract(contractId, abi, options);
+}
+
+class ChainReadError extends Error {
+  name = "ChainReadError";
+}
+function nodeClient(rpcUrl) {
+  return createPublicClient({
+    transport: http(rpcUrl, { retryCount: 0, timeout: 1e4 })
+  });
+}
+
+class ConcurrencyGate {
+  limit;
+  active = 0;
+  queue = [];
+  constructor(limit) {
+    this.limit = limit;
+  }
+  async run(fn) {
+    if (this.active >= this.limit) {
+      await new Promise((resolve) => this.queue.push(resolve));
+    }
+    this.active++;
+    try {
+      return await fn();
+    } finally {
+      this.active--;
+      this.queue.shift()?.();
+    }
+  }
+}
+var DEFAULT_MAX_CONCURRENT_READS = 4;
+function maxConcurrentReads() {
+  const raw = process.env.SUBGRAPH_CHAIN_READ_CONCURRENCY;
+  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CONCURRENT_READS;
+}
+var gate = new ConcurrencyGate(maxConcurrentReads());
+function hashArgs(args) {
+  const serialized = args.map((arg) => serializeCV(arg)).join(",");
+  return Bun.hash(serialized).toString(16);
+}
+function findFunction(abi, name) {
+  const fn = abi.functions.find((f) => f.name === name);
+  if (!fn) {
+    throw new ChainReadError(`No function "${name}" in the supplied ABI.`);
+  }
+  if (fn.access !== "read-only") {
+    throw new ChainReadError(`"${name}" is ${fn.access}, not read-only — a handler cannot call it.`);
+  }
+  return fn;
+}
+function createChainReadClient(ctx) {
+  const readValue = async (contractId, abi, functionName, args, options) => {
+    const rpcUrl = ctx.rpcUrl ?? process.env.STACKS_NODE_RPC_URL;
+    if (!rpcUrl) {
+      throw new ChainReadError("ctx.client needs a Stacks node: set STACKS_NODE_RPC_URL on the subgraph processor.");
+    }
+    const constant = options.cache === "contract-constant";
+    if (!constant && !ctx.indexBlockHash) {
+      throw new ChainReadError(`Block ${ctx.blockHeight} has no index_block_hash, so a read cannot be pinned to it. Reading at the node's tip would make this handler non-deterministic (the same reindex would produce different rows). Re-ingest the block, or pass cache: "contract-constant" if the value genuinely cannot change.`);
+    }
+    const fn = findFunction(abi, functionName);
+    const clarityArgs = buildFunctionArgs(fn, args);
+    const db = ctx.db ?? getSourceDb();
+    const argsHash = hashArgs(clarityArgs);
+    const pinnedTo = constant ? null : ctx.indexBlockHash;
+    const cached = await db.selectFrom("chain_read_cache").select("result_hex").where("contract_id", "=", contractId).where("function_name", "=", fn.name).where("args_hash", "=", argsHash).where((eb) => pinnedTo === null ? eb("index_block_hash", "is", null) : eb("index_block_hash", "=", pinnedTo)).executeTakeFirst();
+    const resultHex = cached?.result_hex ?? await gate.run(async () => {
+      const value2 = await readContract(nodeClient(rpcUrl), {
+        contract: contractId,
+        functionName: fn.name,
+        args: clarityArgs,
+        tip: ctx.indexBlockHash ?? undefined
+      });
+      return serializeCV(value2);
+    });
+    if (!cached) {
+      await db.insertInto("chain_read_cache").values({
+        contract_id: contractId,
+        function_name: fn.name,
+        args_hash: argsHash,
+        index_block_hash: pinnedTo,
+        block_height: constant ? null : ctx.blockHeight,
+        result_hex: resultHex
+      }).onConflict((oc) => oc.doNothing()).execute();
+    }
+    const value = deserializeCV(resultHex);
+    const js = clarityValueToJSUntyped(fn.outputs, value);
+    if (isResponseOutput(fn.outputs)) {
+      const response = js;
+      if ("ok" in response)
+        return response.ok;
+      throw new ContractResponseError(`${contractId}::${fn.name} returned an err response.`, response.err);
+    }
+    return js;
+  };
+  return {
+    contract(contractId, rawAbi, options = {}) {
+      const abi = normalizeAbi(rawAbi);
+      const camelToKebab = new Map;
+      for (const fn of abi.functions) {
+        camelToKebab.set(toCamelCase(fn.name), fn.name);
+      }
+      const read = new Proxy({}, {
+        get(_target, prop) {
+          const fnName = camelToKebab.get(prop) ?? prop;
+          return (args = {}) => readValue(contractId, abi, fnName, args, options);
+        }
+      });
+      return { read };
+    }
+  };
+}
+
 // src/runtime/context.ts
 var JOURNAL_RETENTION_BLOCKS = 300;
 var journalEnsured = new Set;
@@ -378,6 +511,7 @@ class SubgraphContext {
   ops = [];
   byo;
   journal;
+  _client;
   constructor(db, pgSchemaName2, subgraphSchema, block, tx, byo = false, journal = false) {
     this.db = db;
     this.pgSchemaName = pgSchemaName2;
@@ -387,6 +521,13 @@ class SubgraphContext {
     this.byo = byo;
     this.journal = journal;
   }
+  get client() {
+    this._client ??= createChainReadClient({
+      blockHeight: this.block.height,
+      indexBlockHash: this.block.indexBlockHash
+    });
+    return this._client;
+  }
   get tx() {
     return this._tx;
   }
@@ -948,11 +1089,11 @@ function buildWhereClause(where) {
 }
 
 // src/runtime/clarity.ts
-import { cvToValue, deserializeCV } from "@secondlayer/stacks/clarity";
+import { cvToValue, deserializeCV as deserializeCV2 } from "@secondlayer/stacks/clarity";
 function decodeClarityValue(hex) {
   try {
     const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-    const cv = deserializeCV(cleanHex);
+    const cv = deserializeCV2(cleanHex);
     return cvToValue(cv);
   } catch {
     return hex;
@@ -983,8 +1124,8 @@ import { getErrorMessage } from "@secondlayer/shared";
 import { logger as logger2 } from "@secondlayer/shared/logger";
 import {
   clarityValueToJS,
-  deserializeCV as deserializeCV2,
-  toCamelCase
+  deserializeCV as deserializeCV3,
+  toCamelCase as toCamelCase2
 } from "@secondlayer/stacks/clarity";
 
 // src/runtime/print-validate.ts
@@ -1147,7 +1288,7 @@ function buildContractCallInput(filter, tx) {
       return;
     try {
       const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-      input[toCamelCase(arg.name)] = decodeArg(arg.type, deserializeCV2(clean));
+      input[toCamelCase2(arg.name)] = decodeArg(arg.type, deserializeCV3(clean));
     } catch {}
   });
   return input;
@@ -1701,7 +1842,7 @@ import { logger as logger5 } from "@secondlayer/shared/logger";
 import { sql as sql3 } from "kysely";
 
 // src/runtime/block-source.ts
-import { getSourceDb } from "@secondlayer/shared/db";
+import { getSourceDb as getSourceDb2 } from "@secondlayer/shared/db";
 import {
   IndexHttpClient
 } from "@secondlayer/shared/index-http";
@@ -1762,6 +1903,7 @@ function reconstructBlock(b) {
     parent_hash: b.parent_hash,
     burn_block_height: b.burn_block_height,
     burn_block_hash: b.burn_block_hash,
+    index_block_hash: b.index_block_hash ?? null,
     timestamp: isoToUnixSeconds(b.block_time),
     canonical: true,
     created_at: new Date(0)
@@ -1896,11 +2038,11 @@ function sparseProbeTargets(subgraph) {
 
 class PostgresBlockSource {
   async getTip() {
-    const progress = await getSourceDb().selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
+    const progress = await getSourceDb2().selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
     return progress ? Number(progress.highest_seen_block) : 0;
   }
   loadBlockRange(fromHeight, toHeight) {
-    return loadBlockRange(getSourceDb(), fromHeight, toHeight);
+    return loadBlockRange(getSourceDb2(), fromHeight, toHeight);
   }
 }
 var EVENT_FILTER_TO_INDEX_TYPE = {
@@ -1969,8 +2111,8 @@ class PublicApiBlockSource {
   eventTypes;
   probeTargets;
   needsTransactions;
-  constructor(http, eventTypes, probeTargets, needsTransactions = true) {
-    this.http = http;
+  constructor(http2, eventTypes, probeTargets, needsTransactions = true) {
+    this.http = http2;
     this.eventTypes = eventTypes;
     this.probeTargets = probeTargets;
     this.needsTransactions = needsTransactions;
@@ -2482,7 +2624,8 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     height: block.height,
     hash: block.hash,
     timestamp: block.timestamp,
-    burnBlockHeight: block.burn_block_height
+    burnBlockHeight: block.burn_block_height,
+    indexBlockHash: block.index_block_hash
   };
   const initialTx = {
     txId: "",
@@ -3260,7 +3403,7 @@ function defineSchema(schema) {
 }
 // src/print-schema.ts
 import {
-  deserializeCV as deserializeCV3
+  deserializeCV as deserializeCV4
 } from "@secondlayer/stacks/clarity";
 function camelizeDataKey(str) {
   return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
@@ -3528,7 +3671,7 @@ function inferPrintTopics(samples) {
     let decoded = 0;
     for (const p of picked) {
       try {
-        const cv = deserializeCV3(p.rawHex);
+        const cv = deserializeCV4(p.rawHex);
         decoded++;
         if (cv.type === "tuple")
           tuples.push(cv);
@@ -4527,6 +4670,7 @@ export {
   resumeReindex,
   renderDeployPlan,
   reindexSubgraph,
+  readContractAt,
   pgSchemaName,
   inferPrintTopics,
   hasBreakingChanges,
@@ -4544,8 +4688,9 @@ export {
   camelizeDataKey,
   backfillSubgraph,
   INDEX_CODEGEN_TABLES,
+  ChainReadError,
   ByoBreakingChangeError
 };
 
-//# debugId=8BECEC189376FB2B64756E2164756E21
+//# debugId=A7D0F6BE4A80734464756E2164756E21
 //# sourceMappingURL=index.js.map