@opendatalabs/vana-sdk 0.1.0-alpha.a6b60fc → 0.1.0-alpha.a78ce5c

package/dist/utils/subgraphConsistency.cjs

@@ -0,0 +1,184 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var subgraphConsistency_exports = {};
+__export(subgraphConsistency_exports, {
+  StaleDataError: () => StaleDataError,
+  addMetaToQuery: () => addMetaToQuery,
+  calculateStaleness: () => calculateStaleness,
+  checkSubgraphConsistency: () => checkSubgraphConsistency,
+  fetchSubgraphMeta: () => fetchSubgraphMeta,
+  waitForSubgraphSync: () => waitForSubgraphSync
+});
+module.exports = __toCommonJS(subgraphConsistency_exports);
+var import_graphql = require("graphql");
+var import_subgraph = require("../generated/subgraph");
+var import_subgraphMetaCache = require("./subgraphMetaCache");
+class StaleDataError extends Error {
+  constructor(requiredBlock, currentBlock, message) {
+    super(
+      message ?? `Subgraph data is stale. Required block: ${requiredBlock}, Current block: ${currentBlock}`
+    );
+    this.requiredBlock = requiredBlock;
+    this.currentBlock = currentBlock;
+    this.name = "StaleDataError";
+  }
+}
+async function fetchSubgraphMeta(subgraphUrl, useCache = true) {
+  if (useCache) {
+    const cached = import_subgraphMetaCache.globalMetaCache.get(subgraphUrl);
+    if (cached) {
+      return cached;
+    }
+  }
+  const response = await fetch(subgraphUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: (0, import_graphql.print)(import_subgraph.GetSubgraphMetaDocument)
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch subgraph metadata: ${response.status} ${response.statusText}`
+    );
+  }
+  const result = await response.json();
+  if (result.errors) {
+    throw new Error(
+      `Subgraph query errors: ${result.errors.map((e) => e.message).join(", ")}`
+    );
+  }
+  if (!result.data?._meta) {
+    throw new Error("No metadata returned from subgraph");
+  }
+  const meta = result.data._meta;
+  const subgraphMeta = {
+    blockNumber: meta.block.number,
+    blockTimestamp: meta.block.timestamp ?? void 0,
+    blockHash: meta.block.hash ?? void 0,
+    deployment: meta.deployment,
+    hasIndexingErrors: meta.hasIndexingErrors
+  };
+  if (useCache) {
+    import_subgraphMetaCache.globalMetaCache.set(subgraphUrl, subgraphMeta);
+  }
+  return subgraphMeta;
+}
+async function checkSubgraphConsistency(subgraphUrl, options) {
+  if (options?.signal?.aborted) {
+    throw new Error("Operation aborted");
+  }
+  if (!options?.minBlock) {
+    return fetchSubgraphMeta(subgraphUrl);
+  }
+  const meta = await fetchSubgraphMeta(subgraphUrl);
+  if (meta.blockNumber < options.minBlock) {
+    if (options.waitForSync && options.waitForSync > 0) {
+      return waitForSubgraphSync(
+        subgraphUrl,
+        options.minBlock,
+        options.waitForSync,
+        2e3,
+        // pollInterval
+        options.signal
+      );
+    }
+    throw new StaleDataError(options.minBlock, meta.blockNumber);
+  }
+  return meta;
+}
+async function waitForSubgraphSync(subgraphUrl, targetBlock, maxWait, pollInterval = 2e3, signal) {
+  const startTime = Date.now();
+  if (signal?.aborted) {
+    throw new Error("Operation aborted");
+  }
+  const checkAbort = () => {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+  };
+  while (Date.now() - startTime < maxWait) {
+    checkAbort();
+    const meta = await fetchSubgraphMeta(subgraphUrl);
+    if (meta.blockNumber >= targetBlock) {
+      return meta;
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(resolve, pollInterval);
+      if (signal) {
+        const abortHandler = () => {
+          clearTimeout(timer);
+          reject(new Error("Operation aborted"));
+        };
+        if (signal.aborted) {
+          abortHandler();
+        } else {
+          signal.addEventListener("abort", abortHandler, { once: true });
+        }
+      }
+    });
+  }
+  checkAbort();
+  const finalMeta = await fetchSubgraphMeta(subgraphUrl);
+  if (finalMeta.blockNumber >= targetBlock) {
+    return finalMeta;
+  }
+  throw new StaleDataError(
+    targetBlock,
+    finalMeta.blockNumber,
+    `Subgraph did not sync to block ${targetBlock} within ${maxWait}ms. Current block: ${finalMeta.blockNumber}`
+  );
+}
+function calculateStaleness(meta, currentTimestamp) {
+  if (!meta.blockTimestamp) {
+    return void 0;
+  }
+  return Math.max(0, currentTimestamp - meta.blockTimestamp);
+}
+function addMetaToQuery(baseQuery) {
+  if (baseQuery.includes("_meta")) {
+    return baseQuery;
+  }
+  const queryMatch = baseQuery.match(/query\s+\w+[^{]*\{/);
+  if (!queryMatch) {
+    return baseQuery;
+  }
+  const insertPoint = queryMatch.index + queryMatch[0].length;
+  return baseQuery.slice(0, insertPoint) + `
+  _meta {
+    block {
+      number
+      timestamp
+    }
+    hasIndexingErrors
+  }
+  ` + baseQuery.slice(insertPoint);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StaleDataError,
+  addMetaToQuery,
+  calculateStaleness,
+  checkSubgraphConsistency,
+  fetchSubgraphMeta,
+  waitForSubgraphSync
+});
+//# sourceMappingURL=subgraphConsistency.cjs.map

package/dist/utils/subgraphConsistency.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/subgraphConsistency.ts"],"sourcesContent":["/**\n * @file Utilities for handling subgraph data consistency\n * @module vana-sdk/utils/subgraphConsistency\n */\n\nimport { print } from \"graphql\";\nimport type { ConsistencyOptions } from \"../types/options\";\nimport type { GetSubgraphMetaQuery } from \"../generated/subgraph\";\nimport { GetSubgraphMetaDocument } from \"../generated/subgraph\";\nimport { globalMetaCache } from \"./subgraphMetaCache\";\n\n/**\n * Error thrown when subgraph data is stale relative to consistency requirements\n */\nexport class StaleDataError extends Error {\n  constructor(\n    public readonly requiredBlock: number,\n    public readonly currentBlock: number,\n    message?: string,\n  ) {\n    super(\n      message ??\n        `Subgraph data is stale. Required block: ${requiredBlock}, Current block: ${currentBlock}`,\n    );\n    this.name = \"StaleDataError\";\n  }\n}\n\n/**\n * Subgraph metadata response structure\n */\nexport interface SubgraphMeta {\n  blockNumber: number;\n  blockTimestamp?: number;\n  blockHash?: string;\n  deployment: string;\n  hasIndexingErrors: boolean;\n}\n\n/**\n * Response structure from subgraph queries\n */\ninterface SubgraphResponse<T> {\n  data?: T;\n  errors?: Array<{ message: string }>;\n}\n\n/**\n * Fetches the current metadata from a subgraph\n *\n * @param subgraphUrl - The GraphQL endpoint URL\n * @returns Current block information and indexing status\n */\nexport async function fetchSubgraphMeta(\n  subgraphUrl: string,\n  useCache = true,\n): Promise<SubgraphMeta> {\n  // Check cache first\n  if (useCache) {\n    const cached = globalMetaCache.get(subgraphUrl);\n    if (cached) {\n      return cached;\n    }\n  }\n\n  const response = await fetch(subgraphUrl, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n    },\n    body: JSON.stringify({\n      query: print(GetSubgraphMetaDocument),\n    }),\n  });\n\n  if (!response.ok) {\n    throw new Error(\n      `Failed to fetch subgraph metadata: ${response.status} ${response.statusText}`,\n    );\n  }\n\n  const result =\n    (await response.json()) as SubgraphResponse<GetSubgraphMetaQuery>;\n\n  if (result.errors) {\n    throw new Error(\n      `Subgraph query errors: ${result.errors.map((e) => e.message).join(\", \")}`,\n    );\n  }\n\n  if (!result.data?._meta) {\n    throw new Error(\"No metadata returned from subgraph\");\n  }\n\n  const meta = result.data._meta;\n  const subgraphMeta: SubgraphMeta = {\n    blockNumber: meta.block.number,\n    blockTimestamp: meta.block.timestamp ?? undefined,\n    blockHash: meta.block.hash ?? undefined,\n    deployment: meta.deployment,\n    hasIndexingErrors: meta.hasIndexingErrors,\n  };\n\n  // Cache the result\n  if (useCache) {\n    globalMetaCache.set(subgraphUrl, subgraphMeta);\n  }\n\n  return subgraphMeta;\n}\n\n/**\n * Checks if subgraph meets consistency requirements\n *\n * @param subgraphUrl - The GraphQL endpoint URL\n * @param options - Consistency requirements\n * @returns The subgraph metadata if requirements are met\n * @throws {StaleDataError} If subgraph is behind required block\n */\nexport async function checkSubgraphConsistency(\n  subgraphUrl: string,\n  options?: ConsistencyOptions,\n): Promise<SubgraphMeta> {\n  // Check if already aborted\n  if (options?.signal?.aborted) {\n    throw new Error(\"Operation aborted\");\n  }\n\n  // If no consistency requirements, just return current metadata\n  if (!options?.minBlock) {\n    return fetchSubgraphMeta(subgraphUrl);\n  }\n\n  const meta = await fetchSubgraphMeta(subgraphUrl);\n\n  // Check if subgraph has reached required block\n  if (meta.blockNumber < options.minBlock) {\n    // If waitForSync is specified, poll until caught up\n    if (options.waitForSync && options.waitForSync > 0) {\n      return waitForSubgraphSync(\n        subgraphUrl,\n        options.minBlock,\n        options.waitForSync,\n        2000, // pollInterval\n        options.signal,\n      );\n    }\n\n    // Otherwise throw immediately\n    throw new StaleDataError(options.minBlock, meta.blockNumber);\n  }\n\n  return meta;\n}\n\n/**\n * Waits for subgraph to sync to a specific block\n *\n * @param subgraphUrl - The GraphQL endpoint URL\n * @param targetBlock - Block number to wait for\n * @param maxWait - Maximum milliseconds to wait\n * @param pollInterval - How often to check (default: 2000ms)\n * @returns The subgraph metadata when target is reached\n * @throws {StaleDataError} If timeout is reached before sync\n */\nexport async function waitForSubgraphSync(\n  subgraphUrl: string,\n  targetBlock: number,\n  maxWait: number,\n  pollInterval = 2000,\n  signal?: AbortSignal,\n): Promise<SubgraphMeta> {\n  const startTime = Date.now();\n\n  // Check if already aborted\n  if (signal?.aborted) {\n    throw new Error(\"Operation aborted\");\n  }\n\n  // Set up abort handling\n  const checkAbort = () => {\n    if (signal?.aborted) {\n      throw new Error(\"Operation aborted\");\n    }\n  };\n\n  while (Date.now() - startTime < maxWait) {\n    checkAbort();\n    const meta = await fetchSubgraphMeta(subgraphUrl);\n\n    // Check if we've reached the target\n    if (meta.blockNumber >= targetBlock) {\n      return meta;\n    }\n\n    // Wait before next check with abort support\n    await new Promise<void>((resolve, reject) => {\n      const timer = setTimeout(resolve, pollInterval);\n\n      if (signal) {\n        const abortHandler = () => {\n          clearTimeout(timer);\n          reject(new Error(\"Operation aborted\"));\n        };\n\n        if (signal.aborted) {\n          abortHandler();\n        } else {\n          signal.addEventListener(\"abort\", abortHandler, { once: true });\n        }\n      }\n    });\n  }\n\n  // Timeout reached, check one more time\n  checkAbort();\n  const finalMeta = await fetchSubgraphMeta(subgraphUrl);\n  if (finalMeta.blockNumber >= targetBlock) {\n    return finalMeta;\n  }\n\n  throw new StaleDataError(\n    targetBlock,\n    finalMeta.blockNumber,\n    `Subgraph did not sync to block ${targetBlock} within ${maxWait}ms. Current block: ${finalMeta.blockNumber}`,\n  );\n}\n\n/**\n * Calculates staleness in seconds based on block timestamps\n *\n * @param meta - Subgraph metadata\n * @param currentTimestamp - Current chain timestamp\n * @returns Seconds behind the chain, or undefined if timestamps unavailable\n */\nexport function calculateStaleness(\n  meta: SubgraphMeta,\n  currentTimestamp: number,\n): number | undefined {\n  if (!meta.blockTimestamp) {\n    return undefined;\n  }\n\n  return Math.max(0, currentTimestamp - meta.blockTimestamp);\n}\n\n/**\n * Builds a GraphQL query with _meta field included\n *\n * @param baseQuery - The original query string\n * @returns Query with _meta field added\n */\nexport function addMetaToQuery(baseQuery: string): string {\n  // Simple approach: inject _meta at the root level\n  // This is a basic implementation - could be enhanced with proper AST manipulation\n  if (baseQuery.includes(\"_meta\")) {\n    return baseQuery; // Already has meta\n  }\n\n  // Find the first { after query name and inject _meta\n  const queryMatch = baseQuery.match(/query\\s+\\w+[^{]*\\{/);\n  if (!queryMatch) {\n    return baseQuery; // Can't parse, return as-is\n  }\n\n  const insertPoint = queryMatch.index! + queryMatch[0].length;\n  return (\n    baseQuery.slice(0, insertPoint) +\n    `\n  _meta {\n    block {\n      number\n      timestamp\n    }\n    hasIndexingErrors\n  }\n  ` +\n    baseQuery.slice(insertPoint)\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/utils/subgraphConsistency.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @file Utilities for handling subgraph data consistency
+ * @module vana-sdk/utils/subgraphConsistency
+ */
+import type { ConsistencyOptions } from "../types/options";
+/**
+ * Error thrown when subgraph data is stale relative to consistency requirements
+ */
+export declare class StaleDataError extends Error {
+    readonly requiredBlock: number;
+    readonly currentBlock: number;
+    constructor(requiredBlock: number, currentBlock: number, message?: string);
+}
+/**
+ * Subgraph metadata response structure
+ */
+export interface SubgraphMeta {
+    blockNumber: number;
+    blockTimestamp?: number;
+    blockHash?: string;
+    deployment: string;
+    hasIndexingErrors: boolean;
+}
+/**
+ * Fetches the current metadata from a subgraph
+ *
+ * @param subgraphUrl - The GraphQL endpoint URL
+ * @returns Current block information and indexing status
+ */
+export declare function fetchSubgraphMeta(subgraphUrl: string, useCache?: boolean): Promise<SubgraphMeta>;
+/**
+ * Checks if subgraph meets consistency requirements
+ *
+ * @param subgraphUrl - The GraphQL endpoint URL
+ * @param options - Consistency requirements
+ * @returns The subgraph metadata if requirements are met
+ * @throws {StaleDataError} If subgraph is behind required block
+ */
+export declare function checkSubgraphConsistency(subgraphUrl: string, options?: ConsistencyOptions): Promise<SubgraphMeta>;
+/**
+ * Waits for subgraph to sync to a specific block
+ *
+ * @param subgraphUrl - The GraphQL endpoint URL
+ * @param targetBlock - Block number to wait for
+ * @param maxWait - Maximum milliseconds to wait
+ * @param pollInterval - How often to check (default: 2000ms)
+ * @returns The subgraph metadata when target is reached
+ * @throws {StaleDataError} If timeout is reached before sync
+ */
+export declare function waitForSubgraphSync(subgraphUrl: string, targetBlock: number, maxWait: number, pollInterval?: number, signal?: AbortSignal): Promise<SubgraphMeta>;
+/**
+ * Calculates staleness in seconds based on block timestamps
+ *
+ * @param meta - Subgraph metadata
+ * @param currentTimestamp - Current chain timestamp
+ * @returns Seconds behind the chain, or undefined if timestamps unavailable
+ */
+export declare function calculateStaleness(meta: SubgraphMeta, currentTimestamp: number): number | undefined;
+/**
+ * Builds a GraphQL query with _meta field included
+ *
+ * @param baseQuery - The original query string
+ * @returns Query with _meta field added
+ */
+export declare function addMetaToQuery(baseQuery: string): string;

package/dist/utils/subgraphConsistency.js

@@ -0,0 +1,155 @@
+import { print } from "graphql";
+import { GetSubgraphMetaDocument } from "../generated/subgraph";
+import { globalMetaCache } from "./subgraphMetaCache";
+class StaleDataError extends Error {
+  constructor(requiredBlock, currentBlock, message) {
+    super(
+      message ?? `Subgraph data is stale. Required block: ${requiredBlock}, Current block: ${currentBlock}`
+    );
+    this.requiredBlock = requiredBlock;
+    this.currentBlock = currentBlock;
+    this.name = "StaleDataError";
+  }
+}
+async function fetchSubgraphMeta(subgraphUrl, useCache = true) {
+  if (useCache) {
+    const cached = globalMetaCache.get(subgraphUrl);
+    if (cached) {
+      return cached;
+    }
+  }
+  const response = await fetch(subgraphUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      query: print(GetSubgraphMetaDocument)
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch subgraph metadata: ${response.status} ${response.statusText}`
+    );
+  }
+  const result = await response.json();
+  if (result.errors) {
+    throw new Error(
+      `Subgraph query errors: ${result.errors.map((e) => e.message).join(", ")}`
+    );
+  }
+  if (!result.data?._meta) {
+    throw new Error("No metadata returned from subgraph");
+  }
+  const meta = result.data._meta;
+  const subgraphMeta = {
+    blockNumber: meta.block.number,
+    blockTimestamp: meta.block.timestamp ?? void 0,
+    blockHash: meta.block.hash ?? void 0,
+    deployment: meta.deployment,
+    hasIndexingErrors: meta.hasIndexingErrors
+  };
+  if (useCache) {
+    globalMetaCache.set(subgraphUrl, subgraphMeta);
+  }
+  return subgraphMeta;
+}
+async function checkSubgraphConsistency(subgraphUrl, options) {
+  if (options?.signal?.aborted) {
+    throw new Error("Operation aborted");
+  }
+  if (!options?.minBlock) {
+    return fetchSubgraphMeta(subgraphUrl);
+  }
+  const meta = await fetchSubgraphMeta(subgraphUrl);
+  if (meta.blockNumber < options.minBlock) {
+    if (options.waitForSync && options.waitForSync > 0) {
+      return waitForSubgraphSync(
+        subgraphUrl,
+        options.minBlock,
+        options.waitForSync,
+        2e3,
+        // pollInterval
+        options.signal
+      );
+    }
+    throw new StaleDataError(options.minBlock, meta.blockNumber);
+  }
+  return meta;
+}
+async function waitForSubgraphSync(subgraphUrl, targetBlock, maxWait, pollInterval = 2e3, signal) {
+  const startTime = Date.now();
+  if (signal?.aborted) {
+    throw new Error("Operation aborted");
+  }
+  const checkAbort = () => {
+    if (signal?.aborted) {
+      throw new Error("Operation aborted");
+    }
+  };
+  while (Date.now() - startTime < maxWait) {
+    checkAbort();
+    const meta = await fetchSubgraphMeta(subgraphUrl);
+    if (meta.blockNumber >= targetBlock) {
+      return meta;
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(resolve, pollInterval);
+      if (signal) {
+        const abortHandler = () => {
+          clearTimeout(timer);
+          reject(new Error("Operation aborted"));
+        };
+        if (signal.aborted) {
+          abortHandler();
+        } else {
+          signal.addEventListener("abort", abortHandler, { once: true });
+        }
+      }
+    });
+  }
+  checkAbort();
+  const finalMeta = await fetchSubgraphMeta(subgraphUrl);
+  if (finalMeta.blockNumber >= targetBlock) {
+    return finalMeta;
+  }
+  throw new StaleDataError(
+    targetBlock,
+    finalMeta.blockNumber,
+    `Subgraph did not sync to block ${targetBlock} within ${maxWait}ms. Current block: ${finalMeta.blockNumber}`
+  );
+}
+function calculateStaleness(meta, currentTimestamp) {
+  if (!meta.blockTimestamp) {
+    return void 0;
+  }
+  return Math.max(0, currentTimestamp - meta.blockTimestamp);
+}
+function addMetaToQuery(baseQuery) {
+  if (baseQuery.includes("_meta")) {
+    return baseQuery;
+  }
+  const queryMatch = baseQuery.match(/query\s+\w+[^{]*\{/);
+  if (!queryMatch) {
+    return baseQuery;
+  }
+  const insertPoint = queryMatch.index + queryMatch[0].length;
+  return baseQuery.slice(0, insertPoint) + `
+  _meta {
+    block {
+      number
+      timestamp
+    }
+    hasIndexingErrors
+  }
+  ` + baseQuery.slice(insertPoint);
+}
+export {
+  StaleDataError,
+  addMetaToQuery,
+  calculateStaleness,
+  checkSubgraphConsistency,
+  fetchSubgraphMeta,
+  waitForSubgraphSync
+};
+//# sourceMappingURL=subgraphConsistency.js.map

package/dist/utils/subgraphConsistency.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/subgraphConsistency.ts"],"sourcesContent":["/**\n * @file Utilities for handling subgraph data consistency\n * @module vana-sdk/utils/subgraphConsistency\n */\n\nimport { print } from \"graphql\";\nimport type { ConsistencyOptions } from \"../types/options\";\nimport type { GetSubgraphMetaQuery } from \"../generated/subgraph\";\nimport { GetSubgraphMetaDocument } from \"../generated/subgraph\";\nimport { globalMetaCache } from \"./subgraphMetaCache\";\n\n/**\n * Error thrown when subgraph data is stale relative to consistency requirements\n */\nexport class StaleDataError extends Error {\n  constructor(\n    public readonly requiredBlock: number,\n    public readonly currentBlock: number,\n    message?: string,\n  ) {\n    super(\n      message ??\n        `Subgraph data is stale. Required block: ${requiredBlock}, Current block: ${currentBlock}`,\n    );\n    this.name = \"StaleDataError\";\n  }\n}\n\n/**\n * Subgraph metadata response structure\n */\nexport interface SubgraphMeta {\n  blockNumber: number;\n  blockTimestamp?: number;\n  blockHash?: string;\n  deployment: string;\n  hasIndexingErrors: boolean;\n}\n\n/**\n * Response structure from subgraph queries\n */\ninterface SubgraphResponse<T> {\n  data?: T;\n  errors?: Array<{ message: string }>;\n}\n\n/**\n * Fetches the current metadata from a subgraph\n *\n * @param subgraphUrl - The GraphQL endpoint URL\n * @returns Current block information and indexing status\n */\nexport async function fetchSubgraphMeta(\n  subgraphUrl: string,\n  useCache = true,\n): Promise<SubgraphMeta> {\n  // Check cache first\n  if (useCache) {\n    const cached = globalMetaCache.get(subgraphUrl);\n    if (cached) {\n      return cached;\n    }\n  }\n\n  const response = await fetch(subgraphUrl, {\n    method: \"POST\",\n    headers: {\n      \"Content-Type\": \"application/json\",\n    },\n    body: JSON.stringify({\n      query: print(GetSubgraphMetaDocument),\n    }),\n  });\n\n  if (!response.ok) {\n    throw new Error(\n      `Failed to fetch subgraph metadata: ${response.status} ${response.statusText}`,\n    );\n  }\n\n  const result =\n    (await response.json()) as SubgraphResponse<GetSubgraphMetaQuery>;\n\n  if (result.errors) {\n    throw new Error(\n      `Subgraph query errors: ${result.errors.map((e) => e.message).join(\", \")}`,\n    );\n  }\n\n  if (!result.data?._meta) {\n    throw new Error(\"No metadata returned from subgraph\");\n  }\n\n  const meta = result.data._meta;\n  const subgraphMeta: SubgraphMeta = {\n    blockNumber: meta.block.number,\n    blockTimestamp: meta.block.timestamp ?? undefined,\n    blockHash: meta.block.hash ?? undefined,\n    deployment: meta.deployment,\n    hasIndexingErrors: meta.hasIndexingErrors,\n  };\n\n  // Cache the result\n  if (useCache) {\n    globalMetaCache.set(subgraphUrl, subgraphMeta);\n  }\n\n  return subgraphMeta;\n}\n\n/**\n * Checks if subgraph meets consistency requirements\n *\n * @param subgraphUrl - The GraphQL endpoint URL\n * @param options - Consistency requirements\n * @returns The subgraph metadata if requirements are met\n * @throws {StaleDataError} If subgraph is behind required block\n */\nexport async function checkSubgraphConsistency(\n  subgraphUrl: string,\n  options?: ConsistencyOptions,\n): Promise<SubgraphMeta> {\n  // Check if already aborted\n  if (options?.signal?.aborted) {\n    throw new Error(\"Operation aborted\");\n  }\n\n  // If no consistency requirements, just return current metadata\n  if (!options?.minBlock) {\n    return fetchSubgraphMeta(subgraphUrl);\n  }\n\n  const meta = await fetchSubgraphMeta(subgraphUrl);\n\n  // Check if subgraph has reached required block\n  if (meta.blockNumber < options.minBlock) {\n    // If waitForSync is specified, poll until caught up\n    if (options.waitForSync && options.waitForSync > 0) {\n      return waitForSubgraphSync(\n        subgraphUrl,\n        options.minBlock,\n        options.waitForSync,\n        2000, // pollInterval\n        options.signal,\n      );\n    }\n\n    // Otherwise throw immediately\n    throw new StaleDataError(options.minBlock, meta.blockNumber);\n  }\n\n  return meta;\n}\n\n/**\n * Waits for subgraph to sync to a specific block\n *\n * @param subgraphUrl - The GraphQL endpoint URL\n * @param targetBlock - Block number to wait for\n * @param maxWait - Maximum milliseconds to wait\n * @param pollInterval - How often to check (default: 2000ms)\n * @returns The subgraph metadata when target is reached\n * @throws {StaleDataError} If timeout is reached before sync\n */\nexport async function waitForSubgraphSync(\n  subgraphUrl: string,\n  targetBlock: number,\n  maxWait: number,\n  pollInterval = 2000,\n  signal?: AbortSignal,\n): Promise<SubgraphMeta> {\n  const startTime = Date.now();\n\n  // Check if already aborted\n  if (signal?.aborted) {\n    throw new Error(\"Operation aborted\");\n  }\n\n  // Set up abort handling\n  const checkAbort = () => {\n    if (signal?.aborted) {\n      throw new Error(\"Operation aborted\");\n    }\n  };\n\n  while (Date.now() - startTime < maxWait) {\n    checkAbort();\n    const meta = await fetchSubgraphMeta(subgraphUrl);\n\n    // Check if we've reached the target\n    if (meta.blockNumber >= targetBlock) {\n      return meta;\n    }\n\n    // Wait before next check with abort support\n    await new Promise<void>((resolve, reject) => {\n      const timer = setTimeout(resolve, pollInterval);\n\n      if (signal) {\n        const abortHandler = () => {\n          clearTimeout(timer);\n          reject(new Error(\"Operation aborted\"));\n        };\n\n        if (signal.aborted) {\n          abortHandler();\n        } else {\n          signal.addEventListener(\"abort\", abortHandler, { once: true });\n        }\n      }\n    });\n  }\n\n  // Timeout reached, check one more time\n  checkAbort();\n  const finalMeta = await fetchSubgraphMeta(subgraphUrl);\n  if (finalMeta.blockNumber >= targetBlock) {\n    return finalMeta;\n  }\n\n  throw new StaleDataError(\n    targetBlock,\n    finalMeta.blockNumber,\n    `Subgraph did not sync to block ${targetBlock} within ${maxWait}ms. Current block: ${finalMeta.blockNumber}`,\n  );\n}\n\n/**\n * Calculates staleness in seconds based on block timestamps\n *\n * @param meta - Subgraph metadata\n * @param currentTimestamp - Current chain timestamp\n * @returns Seconds behind the chain, or undefined if timestamps unavailable\n */\nexport function calculateStaleness(\n  meta: SubgraphMeta,\n  currentTimestamp: number,\n): number | undefined {\n  if (!meta.blockTimestamp) {\n    return undefined;\n  }\n\n  return Math.max(0, currentTimestamp - meta.blockTimestamp);\n}\n\n/**\n * Builds a GraphQL query with _meta field included\n *\n * @param baseQuery - The original query string\n * @returns Query with _meta field added\n */\nexport function addMetaToQuery(baseQuery: string): string {\n  // Simple approach: inject _meta at the root level\n  // This is a basic implementation - could be enhanced with proper AST manipulation\n  if (baseQuery.includes(\"_meta\")) {\n    return baseQuery; // Already has meta\n  }\n\n  // Find the first { after query name and inject _meta\n  const queryMatch = baseQuery.match(/query\\s+\\w+[^{]*\\{/);\n  if (!queryMatch) {\n    return baseQuery; // Can't parse, return as-is\n  }\n\n  const insertPoint = queryMatch.index! + queryMatch[0].length;\n  return (\n    baseQuery.slice(0, insertPoint) +\n    `\n  _meta {\n    block {\n      number\n      timestamp\n    }\n    hasIndexingErrors\n  }\n  ` +\n    baseQuery.slice(insertPoint)\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/utils/subgraphMetaCache.cjs

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var subgraphMetaCache_exports = {};
+__export(subgraphMetaCache_exports, {
+  SubgraphMetaCache: () => SubgraphMetaCache,
+  globalMetaCache: () => globalMetaCache
+});
+module.exports = __toCommonJS(subgraphMetaCache_exports);
+class SubgraphMetaCache {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  ttl;
+  /**
+   * Create a new metadata cache
+   *
+   * @param ttl - Time to live in milliseconds (default: 2000ms)
+   * @param maxSize - Maximum cache entries (default: 10)
+   */
+  constructor(ttl = 2e3, maxSize = 10) {
+    this.ttl = ttl;
+    this.maxSize = maxSize;
+  }
+  /**
+   * Get cached metadata if fresh
+   *
+   * @param url - Subgraph URL as cache key
+   * @returns Cached metadata or undefined if stale/missing
+   */
+  get(url) {
+    const entry = this.cache.get(url);
+    if (!entry) {
+      return void 0;
+    }
+    if (Date.now() - entry.timestamp > this.ttl) {
+      this.cache.delete(url);
+      return void 0;
+    }
+    this.cache.delete(url);
+    this.cache.set(url, entry);
+    return entry.meta;
+  }
+  /**
+   * Store metadata in cache
+   *
+   * @param url - Subgraph URL as cache key
+   * @param meta - Metadata to cache
+   */
+  set(url, meta) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(url)) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(url, {
+      meta,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   *
+   * @returns Cache size and TTL info
+   */
+  stats() {
+    return {
+      size: this.cache.size,
+      ttl: this.ttl,
+      maxSize: this.maxSize
+    };
+  }
+}
+const globalMetaCache = new SubgraphMetaCache();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SubgraphMetaCache,
+  globalMetaCache
+});
+//# sourceMappingURL=subgraphMetaCache.cjs.map

package/dist/utils/subgraphMetaCache.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/subgraphMetaCache.ts"],"sourcesContent":["/**\n * @file Simple cache for subgraph metadata to reduce redundant queries\n * @module vana-sdk/utils/subgraphMetaCache\n */\n\nimport type { SubgraphMeta } from \"./subgraphConsistency\";\n\ninterface CacheEntry {\n  meta: SubgraphMeta;\n  timestamp: number;\n}\n\n/**\n * Simple LRU cache for subgraph metadata\n *\n * @remarks\n * Reduces redundant _meta queries when multiple SDK methods are called\n * in quick succession. Uses a very short TTL to avoid masking staleness.\n */\nexport class SubgraphMetaCache {\n  private cache = new Map<string, CacheEntry>();\n  private readonly maxSize: number;\n  private readonly ttl: number;\n\n  /**\n   * Create a new metadata cache\n   *\n   * @param ttl - Time to live in milliseconds (default: 2000ms)\n   * @param maxSize - Maximum cache entries (default: 10)\n   */\n  constructor(ttl = 2000, maxSize = 10) {\n    this.ttl = ttl;\n    this.maxSize = maxSize;\n  }\n\n  /**\n   * Get cached metadata if fresh\n   *\n   * @param url - Subgraph URL as cache key\n   * @returns Cached metadata or undefined if stale/missing\n   */\n  get(url: string): SubgraphMeta | undefined {\n    const entry = this.cache.get(url);\n\n    if (!entry) {\n      return undefined;\n    }\n\n    // Check if still fresh\n    if (Date.now() - entry.timestamp > this.ttl) {\n      // Expired, remove it\n      this.cache.delete(url);\n      return undefined;\n    }\n\n    // Move to end (LRU)\n    this.cache.delete(url);\n    this.cache.set(url, entry);\n\n    return entry.meta;\n  }\n\n  /**\n   * Store metadata in cache\n   *\n   * @param url - Subgraph URL as cache key\n   * @param meta - Metadata to cache\n   */\n  set(url: string, meta: SubgraphMeta): void {\n    // Remove oldest if at capacity\n    if (this.cache.size >= this.maxSize && !this.cache.has(url)) {\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey) {\n        this.cache.delete(firstKey);\n      }\n    }\n\n    this.cache.set(url, {\n      meta,\n      timestamp: Date.now(),\n    });\n  }\n\n  /**\n   * Clear all cached entries\n   */\n  clear(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get cache statistics\n   *\n   * @returns Cache size and TTL info\n   */\n  stats(): { size: number; ttl: number; maxSize: number } {\n    return {\n      size: this.cache.size,\n      ttl: this.ttl,\n      maxSize: this.maxSize,\n    };\n  }\n}\n\n/**\n * Global cache instance (optional, can be configured per SDK instance)\n */\nexport const globalMetaCache = new SubgraphMetaCache();\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBO,MAAM,kBAAkB;AAAA,EACrB,QAAQ,oBAAI,IAAwB;AAAA,EAC3B;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQjB,YAAY,MAAM,KAAM,UAAU,IAAI;AACpC,SAAK,MAAM;AACX,SAAK,UAAU;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAI,KAAuC;AACzC,UAAM,QAAQ,KAAK,MAAM,IAAI,GAAG;AAEhC,QAAI,CAAC,OAAO;AACV,aAAO;AAAA,IACT;AAGA,QAAI,KAAK,IAAI,IAAI,MAAM,YAAY,KAAK,KAAK;AAE3C,WAAK,MAAM,OAAO,GAAG;AACrB,aAAO;AAAA,IACT;AAGA,SAAK,MAAM,OAAO,GAAG;AACrB,SAAK,MAAM,IAAI,KAAK,KAAK;AAEzB,WAAO,MAAM;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAI,KAAa,MAA0B;AAEzC,QAAI,KAAK,MAAM,QAAQ,KAAK,WAAW,CAAC,KAAK,MAAM,IAAI,GAAG,GAAG;AAC3D,YAAM,WAAW,KAAK,MAAM,KAAK,EAAE,KAAK,EAAE;AAC1C,UAAI,UAAU;AACZ,aAAK,MAAM,OAAO,QAAQ;AAAA,MAC5B;AAAA,IACF;AAEA,SAAK,MAAM,IAAI,KAAK;AAAA,MAClB;AAAA,MACA,WAAW,KAAK,IAAI;AAAA,IACtB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AACZ,SAAK,MAAM,MAAM;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,QAAwD;AACtD,WAAO;AAAA,MACL,MAAM,KAAK,MAAM;AAAA,MACjB,KAAK,KAAK;AAAA,MACV,SAAS,KAAK;AAAA,IAChB;AAAA,EACF;AACF;AAKO,MAAM,kBAAkB,IAAI,kBAAkB;","names":[]}

package/dist/utils/subgraphMetaCache.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @file Simple cache for subgraph metadata to reduce redundant queries
+ * @module vana-sdk/utils/subgraphMetaCache
+ */
+import type { SubgraphMeta } from "./subgraphConsistency";
+/**
+ * Simple LRU cache for subgraph metadata
+ *
+ * @remarks
+ * Reduces redundant _meta queries when multiple SDK methods are called
+ * in quick succession. Uses a very short TTL to avoid masking staleness.
+ */
+export declare class SubgraphMetaCache {
+    private cache;
+    private readonly maxSize;
+    private readonly ttl;
+    /**
+     * Create a new metadata cache
+     *
+     * @param ttl - Time to live in milliseconds (default: 2000ms)
+     * @param maxSize - Maximum cache entries (default: 10)
+     */
+    constructor(ttl?: number, maxSize?: number);
+    /**
+     * Get cached metadata if fresh
+     *
+     * @param url - Subgraph URL as cache key
+     * @returns Cached metadata or undefined if stale/missing
+     */
+    get(url: string): SubgraphMeta | undefined;
+    /**
+     * Store metadata in cache
+     *
+     * @param url - Subgraph URL as cache key
+     * @param meta - Metadata to cache
+     */
+    set(url: string, meta: SubgraphMeta): void;
+    /**
+     * Clear all cached entries
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     *
+     * @returns Cache size and TTL info
+     */
+    stats(): {
+        size: number;
+        ttl: number;
+        maxSize: number;
+    };
+}
+/**
+ * Global cache instance (optional, can be configured per SDK instance)
+ */
+export declare const globalMetaCache: SubgraphMetaCache;