@opendatalabs/vana-sdk 2.3.0 → 3.0.0

package/dist/utils/signatureCache.js

@@ -1,167 +0,0 @@
-import { getAddress, toHex } from "viem";
-import { sha256 } from "@noble/hashes/sha256";
-class SignatureCache {
-  static PREFIX = "vana_sig_";
-  static DEFAULT_TTL_HOURS = 2;
-  /**
-   * Get a cached signature if it exists and hasn't expired
-   *
-   * @param cache - Platform cache adapter instance
-   * @param walletAddress - Wallet address that created the signature
-   * @param messageHash - Hash of the message that was signed
-   * @returns The cached signature if valid, null if expired or not found
-   * @example
-   * ```typescript
-   * const messageHash = SignatureCache.hashMessage(typedData);
-   * const cached = SignatureCache.get(cache, '0x123...', messageHash);
-   * if (cached) {
-   *   console.log('Using cached signature:', cached);
-   * }
-   * ```
-   */
-  static get(cache, walletAddress, messageHash) {
-    const key = this.getCacheKey(walletAddress, messageHash);
-    try {
-      const stored = cache.get(key);
-      if (!stored) return null;
-      const cached = JSON.parse(stored);
-      if (Date.now() > cached.expires) {
-        cache.delete(key);
-        return null;
-      }
-      return cached.signature;
-    } catch {
-      try {
-        cache.delete(key);
-      } catch {
-      }
-      return null;
-    }
-  }
-  /**
-   * Store a signature in the cache with configurable TTL
-   *
-   * @param cache - Platform cache adapter instance
-   * @param walletAddress - Wallet address that created the signature
-   * @param messageHash - Hash of the message that was signed
-   * @param signature - The signature to cache
-   * @param ttlHours - Time to live in hours (default: 2)
-   * @example
-   * ```typescript
-   * const signature = await wallet.signTypedData(typedData);
-   * const messageHash = SignatureCache.hashMessage(typedData);
-   *
-   * // Cache for default 2 hours
-   * SignatureCache.set(cache, walletAddress, messageHash, signature);
-   *
-   * // Cache for 24 hours
-   * SignatureCache.set(cache, walletAddress, messageHash, signature, 24);
-   * ```
-   */
-  static set(cache, walletAddress, messageHash, signature, ttlHours = this.DEFAULT_TTL_HOURS) {
-    const key = this.getCacheKey(walletAddress, messageHash);
-    const cached = {
-      signature,
-      expires: Date.now() + ttlHours * 36e5
-      // Convert hours to milliseconds
-    };
-    try {
-      cache.set(key, JSON.stringify(cached));
-    } catch {
-    }
-  }
-  /**
-   * Clear all cached signatures (useful for testing or explicit cleanup)
-   *
-   * @param cache - Platform cache adapter instance
-   * @example
-   * ```typescript
-   * // Clear all signatures when user logs out
-   * SignatureCache.clear(cache);
-   *
-   * // Clear before running tests
-   * beforeEach(() => {
-   *   SignatureCache.clear(cache);
-   * });
-   * ```
-   */
-  static clear(cache) {
-    try {
-      cache.clear();
-    } catch {
-    }
-  }
-  static getCacheKey(walletAddress, messageHash) {
-    return `${this.PREFIX}${getAddress(walletAddress)}:${messageHash}`;
-  }
-  /**
-   * Generate a deterministic hash of a message object for cache key generation
-   *
-   * @remarks
-   * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.
-   * Uses SHA-256 for collision resistance and deterministic key generation.
-   * Handles BigInt serialization and sorts object keys for consistency.
-   *
-   * @param message - The message object to hash (typically EIP-712 typed data)
-   * @returns A hex string hash (SHA-256) suitable for cache keys
-   * @example
-   * ```typescript
-   * const typedData = {
-   *   domain: { name: 'Vana', version: '1' },
-   *   message: { nonce: 123n, grant: '...' }
-   * };
-   *
-   * const hash = SignatureCache.hashMessage(typedData);
-   * // Returns SHA-256 hash like: "a1b2c3d4e5f6..."
-   * ```
-   */
-  static hashMessage(message) {
-    const jsonString = JSON.stringify(message, this.deterministicReplacer);
-    const hashBytes = sha256(new TextEncoder().encode(jsonString));
-    return toHex(hashBytes);
-  }
-  /**
-   * Deterministic JSON replacer for consistent cache key generation.
-   *
-   * @remarks
-   * Handles BigInt serialization and sorts object keys to ensure
-   * identical objects always produce the same hash regardless of
-   * property order.
-   *
-   * @param _key - The object key being serialized (unused)
-   * @param value - The value to serialize
-   * @returns The serialized value with sorted keys for objects
-   *
-   * @internal
-   */
-  static deterministicReplacer(_key, value) {
-    if (typeof value === "bigint") {
-      return `__BIGINT__${value.toString()}`;
-    }
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      return Object.keys(value).sort().reduce(
-        (sorted, key) => {
-          sorted[key] = value[key];
-          return sorted;
-        },
-        {}
-      );
-    }
-    return value;
-  }
-}
-async function withSignatureCache(cache, walletAddress, typedData, signFn, ttlHours) {
-  const messageHash = SignatureCache.hashMessage(typedData);
-  const cached = SignatureCache.get(cache, walletAddress, messageHash);
-  if (cached) {
-    return cached;
-  }
-  const signature = await signFn();
-  SignatureCache.set(cache, walletAddress, messageHash, signature, ttlHours);
-  return signature;
-}
-export {
-  SignatureCache,
-  withSignatureCache
-};
-//# sourceMappingURL=signatureCache.js.map

package/dist/utils/signatureCache.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/signatureCache.ts"],"sourcesContent":["/**\n * Provides signature caching to improve UX by avoiding repeated wallet prompts.\n *\n * @remarks\n * This module implements a secure signature cache that stores signed messages\n * temporarily to avoid repeatedly prompting users for the same signature.\n * It uses platform-appropriate storage (sessionStorage in browser, memory in Node.js)\n * and includes automatic expiration and cleanup.\n *\n * @category Utilities\n * @module utils/signatureCache\n */\n\nimport type { Hash } from \"viem\";\nimport { getAddress, toHex } from \"viem\";\nimport type { VanaCacheAdapter } from \"../platform/interface\";\nimport { sha256 } from \"@noble/hashes/sha256\";\n\n/**\n * Represents a cached signature with expiration metadata.\n *\n * @internal\n */\ninterface CachedSignature {\n  /** The cached signature hash */\n  signature: Hash;\n  /** Unix timestamp when this cache entry expires */\n  expires: number;\n}\n\n/**\n * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.\n *\n * @remarks\n * This cache significantly improves UX by avoiding repeated wallet signature prompts\n * for identical operations. It's particularly useful for operations that may be\n * retried or called multiple times with the same parameters.\n *\n * Features:\n * - Platform-appropriate storage (sessionStorage in browser, memory in Node.js)\n * - Configurable TTL (default 2 hours)\n * - Automatic cleanup of expired entries\n * - Cache keys based on wallet address + message hash\n *\n * @example\n * ```typescript\n * // Check cache before requesting signature\n * const cached = SignatureCache.get(cache, walletAddress, messageHash);\n * if (cached) {\n *   return cached;\n * }\n *\n * // Request signature and cache it\n * const signature = await wallet.signTypedData(typedData);\n * SignatureCache.set(cache, walletAddress, messageHash, signature);\n * ```\n * @category Utilities\n */\nexport class SignatureCache {\n  private static readonly PREFIX = \"vana_sig_\";\n  private static readonly DEFAULT_TTL_HOURS = 2;\n\n  /**\n   * Get a cached signature if it exists and hasn't expired\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @returns The cached signature if valid, null if expired or not found\n   * @example\n   * ```typescript\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   * const cached = SignatureCache.get(cache, '0x123...', messageHash);\n   * if (cached) {\n   *   console.log('Using cached signature:', cached);\n   * }\n   * ```\n   */\n  static get(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n  ): Hash | null {\n    const key = this.getCacheKey(walletAddress, messageHash);\n\n    try {\n      const stored = cache.get(key);\n      if (!stored) return null;\n\n      const cached: CachedSignature = JSON.parse(stored);\n\n      // Check if expired\n      if (Date.now() > cached.expires) {\n        cache.delete(key);\n        return null;\n      }\n\n      return cached.signature;\n    } catch {\n      // Invalid JSON or storage error, clean up\n      try {\n        cache.delete(key);\n      } catch {\n        // Ignore cache cleanup errors\n      }\n      return null;\n    }\n  }\n\n  /**\n   * Store a signature in the cache with configurable TTL\n   *\n   * @param cache - Platform cache adapter instance\n   * @param walletAddress - Wallet address that created the signature\n   * @param messageHash - Hash of the message that was signed\n   * @param signature - The signature to cache\n   * @param ttlHours - Time to live in hours (default: 2)\n   * @example\n   * ```typescript\n   * const signature = await wallet.signTypedData(typedData);\n   * const messageHash = SignatureCache.hashMessage(typedData);\n   *\n   * // Cache for default 2 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature);\n   *\n   * // Cache for 24 hours\n   * SignatureCache.set(cache, walletAddress, messageHash, signature, 24);\n   * ```\n   */\n  static set(\n    cache: VanaCacheAdapter,\n    walletAddress: string,\n    messageHash: string,\n    signature: Hash,\n    ttlHours: number = this.DEFAULT_TTL_HOURS,\n  ): void {\n    const key = this.getCacheKey(walletAddress, messageHash);\n    const cached: CachedSignature = {\n      signature,\n      expires: Date.now() + ttlHours * 3600000, // Convert hours to milliseconds\n    };\n\n    try {\n      cache.set(key, JSON.stringify(cached));\n    } catch {\n      // Storage quota exceeded or other error, ignore silently\n      // Better to continue without caching than to fail\n    }\n  }\n\n  /**\n   * Clear all cached signatures (useful for testing or explicit cleanup)\n   *\n   * @param cache - Platform cache adapter instance\n   * @example\n   * ```typescript\n   * // Clear all signatures when user logs out\n   * SignatureCache.clear(cache);\n   *\n   * // Clear before running tests\n   * beforeEach(() => {\n   *   SignatureCache.clear(cache);\n   * });\n   * ```\n   */\n  static clear(cache: VanaCacheAdapter): void {\n    try {\n      cache.clear();\n    } catch {\n      // Ignore storage errors\n    }\n  }\n\n  private static getCacheKey(\n    walletAddress: string,\n    messageHash: string,\n  ): string {\n    return `${this.PREFIX}${getAddress(walletAddress)}:${messageHash}`;\n  }\n\n  /**\n   * Generate a deterministic hash of a message object for cache key generation\n   *\n   * @remarks\n   * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.\n   * Uses SHA-256 for collision resistance and deterministic key generation.\n   * Handles BigInt serialization and sorts object keys for consistency.\n   *\n   * @param message - The message object to hash (typically EIP-712 typed data)\n   * @returns A hex string hash (SHA-256) suitable for cache keys\n   * @example\n   * ```typescript\n   * const typedData = {\n   *   domain: { name: 'Vana', version: '1' },\n   *   message: { nonce: 123n, grant: '...' }\n   * };\n   *\n   * const hash = SignatureCache.hashMessage(typedData);\n   * // Returns SHA-256 hash like: \"a1b2c3d4e5f6...\"\n   * ```\n   */\n  static hashMessage(message: object): string {\n    // Deterministically stringify the object with sorted keys\n    const jsonString = JSON.stringify(message, this.deterministicReplacer);\n\n    // Use SHA-256 for cryptographic hashing\n    const hashBytes = sha256(new TextEncoder().encode(jsonString));\n    return toHex(hashBytes);\n  }\n\n  /**\n   * Deterministic JSON replacer for consistent cache key generation.\n   *\n   * @remarks\n   * Handles BigInt serialization and sorts object keys to ensure\n   * identical objects always produce the same hash regardless of\n   * property order.\n   *\n   * @param _key - The object key being serialized (unused)\n   * @param value - The value to serialize\n   * @returns The serialized value with sorted keys for objects\n   *\n   * @internal\n   */\n  private static deterministicReplacer(_key: string, value: unknown): unknown {\n    if (typeof value === \"bigint\") {\n      return `__BIGINT__${value.toString()}`;\n    }\n    // Sort object keys for deterministic serialization\n    if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n      return Object.keys(value as Record<string, unknown>)\n        .sort()\n        .reduce(\n          (sorted, key) => {\n            sorted[key] = (value as Record<string, unknown>)[key];\n            return sorted;\n          },\n          {} as Record<string, unknown>,\n        );\n    }\n    return value;\n  }\n}\n\n/**\n * Wraps signature operations with caching to avoid repeated prompts.\n *\n * @remarks\n * This helper function checks the cache before requesting a signature\n * and stores new signatures for future use. It significantly improves\n * UX for operations that may be retried or called multiple times.\n *\n * @param cache - The cache adapter to use for storage.\n *   Obtain from platform adapter.\n * @param walletAddress - The wallet address signing the message.\n *   Obtain from wallet connection.\n * @param typedData - The EIP-712 typed data being signed.\n *   Typically permission or grant data.\n * @param signFn - Async function that performs the actual signing.\n *   Usually calls wallet.signTypedData().\n * @param ttlHours - Cache TTL in hours.\n *   Defaults to 2 hours.\n * @returns The signature (cached or newly generated)\n *\n * @example\n * ```typescript\n * const signature = await withSignatureCache(\n *   platformAdapter.cache,\n *   walletAddress,\n *   typedData,\n *   async () => wallet.signTypedData(typedData),\n *   24 // Cache for 24 hours\n * );\n * ```\n *\n * @category Utilities\n */\nexport async function withSignatureCache(\n  cache: VanaCacheAdapter,\n  walletAddress: string,\n  typedData: Record<string, unknown>,\n  signFn: () => Promise<Hash>,\n  ttlHours?: number,\n): Promise<Hash> {\n  // Create a hash of the typed data for the cache key\n  const messageHash = SignatureCache.hashMessage(typedData);\n\n  // Try to get from cache first\n  const cached = SignatureCache.get(cache, walletAddress, messageHash);\n  if (cached) {\n    return cached;\n  }\n\n  // Not in cache, sign and store\n  const signature = await signFn();\n  SignatureCache.set(cache, walletAddress, messageHash, signature, ttlHours);\n\n  return signature;\n}\n"],"mappings":"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","names":[]}

package/dist/utils/signatureFormatter.cjs

@@ -1,42 +0,0 @@
-"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 signatureFormatter_exports = {};
-__export(signatureFormatter_exports, {
-  formatSignatureForContract: () => formatSignatureForContract
-});
-module.exports = __toCommonJS(signatureFormatter_exports);
-var import_viem = require("viem");
-const V_OFFSET_FOR_ETHEREUM = 27;
-function formatSignatureForContract(signature) {
-  const sigBytes = (0, import_viem.fromHex)(signature, "bytes");
-  if (sigBytes.length !== 65) {
-    return signature;
-  }
-  const v = sigBytes[64];
-  if (v < 27) {
-    sigBytes[64] = v + V_OFFSET_FOR_ETHEREUM;
-    return (0, import_viem.toHex)(sigBytes);
-  }
-  return signature;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  formatSignatureForContract
-});
-//# sourceMappingURL=signatureFormatter.cjs.map

package/dist/utils/signatureFormatter.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import { type Hash, fromHex, toHex } from \"viem\";\n\nconst V_OFFSET_FOR_ETHEREUM = 27;\n\n/**\n * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.\n *\n * @remarks\n * This function ensures signature compatibility with Ethereum smart contracts by adjusting\n * the v-value component of ECDSA signatures. Some wallet implementations and signing methods\n * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts\n * expect v-values in the range [27, 28] for proper signature verification.\n *\n * The function automatically detects signatures with low v-values and applies the standard\n * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless\n * transactions and EIP-712 signature verification in smart contracts.\n *\n * **Technical Details:**\n * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total\n * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)\n * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]\n *\n * @param signature - The ECDSA signature hash to format (65 bytes as hex string)\n * @returns The formatted signature with correct v-value for Ethereum contract verification\n * @example\n * ```typescript\n * // Signature with v-value that needs adjustment\n * const rawSignature = \"0x1234...5600\"; // v = 0 (last byte)\n * const formatted = formatSignatureForContract(rawSignature);\n * // Result: \"0x1234...561b\" // v = 27 (0x1b)\n *\n * // Already properly formatted signature remains unchanged\n * const goodSignature = \"0x1234...561b\"; // v = 27\n * const unchanged = formatSignatureForContract(goodSignature);\n * // Result: \"0x1234...561b\" (no change needed)\n * ```\n * @category Cryptography\n */\nexport function formatSignatureForContract(signature: Hash): Hash {\n  // Convert to bytes for safer manipulation\n  const sigBytes = fromHex(signature, \"bytes\");\n\n  if (sigBytes.length !== 65) {\n    return signature;\n  }\n\n  // Extract v value (last byte)\n  const v = sigBytes[64];\n\n  if (v < 27) {\n    // Adjust v value\n    sigBytes[64] = v + V_OFFSET_FOR_ETHEREUM;\n    // Convert back to hex\n    return toHex(sigBytes);\n  }\n\n  return signature;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA0C;AAE1C,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAEhE,QAAM,eAAW,qBAAQ,WAAW,OAAO;AAE3C,MAAI,SAAS,WAAW,IAAI;AAC1B,WAAO;AAAA,EACT;AAGA,QAAM,IAAI,SAAS,EAAE;AAErB,MAAI,IAAI,IAAI;AAEV,aAAS,EAAE,IAAI,IAAI;AAEnB,eAAO,mBAAM,QAAQ;AAAA,EACvB;AAEA,SAAO;AACT;","names":[]}

package/dist/utils/signatureFormatter.d.ts

@@ -1,36 +0,0 @@
-import { type Hash } from "viem";
-/**
- * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.
- *
- * @remarks
- * This function ensures signature compatibility with Ethereum smart contracts by adjusting
- * the v-value component of ECDSA signatures. Some wallet implementations and signing methods
- * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts
- * expect v-values in the range [27, 28] for proper signature verification.
- *
- * The function automatically detects signatures with low v-values and applies the standard
- * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless
- * transactions and EIP-712 signature verification in smart contracts.
- *
- * **Technical Details:**
- * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total
- * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)
- * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]
- *
- * @param signature - The ECDSA signature hash to format (65 bytes as hex string)
- * @returns The formatted signature with correct v-value for Ethereum contract verification
- * @example
- * ```typescript
- * // Signature with v-value that needs adjustment
- * const rawSignature = "0x1234...5600"; // v = 0 (last byte)
- * const formatted = formatSignatureForContract(rawSignature);
- * // Result: "0x1234...561b" // v = 27 (0x1b)
- *
- * // Already properly formatted signature remains unchanged
- * const goodSignature = "0x1234...561b"; // v = 27
- * const unchanged = formatSignatureForContract(goodSignature);
- * // Result: "0x1234...561b" (no change needed)
- * ```
- * @category Cryptography
- */
-export declare function formatSignatureForContract(signature: Hash): Hash;

package/dist/utils/signatureFormatter.js

@@ -1,18 +0,0 @@
-import { fromHex, toHex } from "viem";
-const V_OFFSET_FOR_ETHEREUM = 27;
-function formatSignatureForContract(signature) {
-  const sigBytes = fromHex(signature, "bytes");
-  if (sigBytes.length !== 65) {
-    return signature;
-  }
-  const v = sigBytes[64];
-  if (v < 27) {
-    sigBytes[64] = v + V_OFFSET_FOR_ETHEREUM;
-    return toHex(sigBytes);
-  }
-  return signature;
-}
-export {
-  formatSignatureForContract
-};
-//# sourceMappingURL=signatureFormatter.js.map

package/dist/utils/signatureFormatter.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import { type Hash, fromHex, toHex } from \"viem\";\n\nconst V_OFFSET_FOR_ETHEREUM = 27;\n\n/**\n * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.\n *\n * @remarks\n * This function ensures signature compatibility with Ethereum smart contracts by adjusting\n * the v-value component of ECDSA signatures. Some wallet implementations and signing methods\n * produce signatures with v-values in the range [0, 1], while Ethereum smart contracts\n * expect v-values in the range [27, 28] for proper signature verification.\n *\n * The function automatically detects signatures with low v-values and applies the standard\n * Ethereum offset (+27) to ensure compatibility. This is particularly important for gasless\n * transactions and EIP-712 signature verification in smart contracts.\n *\n * **Technical Details:**\n * - Ethereum signatures consist of r (32 bytes) + s (32 bytes) + v (1 byte) = 65 bytes total\n * - Valid v-values for Ethereum are 27 or 28 (or 0/1 + chain-specific offset for EIP-155)\n * - This function handles the common case where v ∈ [0, 1] needs adjustment to [27, 28]\n *\n * @param signature - The ECDSA signature hash to format (65 bytes as hex string)\n * @returns The formatted signature with correct v-value for Ethereum contract verification\n * @example\n * ```typescript\n * // Signature with v-value that needs adjustment\n * const rawSignature = \"0x1234...5600\"; // v = 0 (last byte)\n * const formatted = formatSignatureForContract(rawSignature);\n * // Result: \"0x1234...561b\" // v = 27 (0x1b)\n *\n * // Already properly formatted signature remains unchanged\n * const goodSignature = \"0x1234...561b\"; // v = 27\n * const unchanged = formatSignatureForContract(goodSignature);\n * // Result: \"0x1234...561b\" (no change needed)\n * ```\n * @category Cryptography\n */\nexport function formatSignatureForContract(signature: Hash): Hash {\n  // Convert to bytes for safer manipulation\n  const sigBytes = fromHex(signature, \"bytes\");\n\n  if (sigBytes.length !== 65) {\n    return signature;\n  }\n\n  // Extract v value (last byte)\n  const v = sigBytes[64];\n\n  if (v < 27) {\n    // Adjust v value\n    sigBytes[64] = v + V_OFFSET_FOR_ETHEREUM;\n    // Convert back to hex\n    return toHex(sigBytes);\n  }\n\n  return signature;\n}\n"],"mappings":"AAAA,SAAoB,SAAS,aAAa;AAE1C,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAEhE,QAAM,WAAW,QAAQ,WAAW,OAAO;AAE3C,MAAI,SAAS,WAAW,IAAI;AAC1B,WAAO;AAAA,EACT;AAGA,QAAM,IAAI,SAAS,EAAE;AAErB,MAAI,IAAI,IAAI;AAEV,aAAS,EAAE,IAAI,IAAI;AAEnB,WAAO,MAAM,QAAQ;AAAA,EACvB;AAEA,SAAO;AACT;","names":[]}

package/dist/utils/subgraphConsistency.cjs

@@ -1,184 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,65 +0,0 @@
-/**
- * @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;