@opendatalabs/vana-sdk 0.1.0-alpha.d7fc764 → 0.1.0-alpha.dba79a3

package/dist/utils/signatureCache.cjs

@@ -24,7 +24,6 @@ __export(signatureCache_exports, {
 module.exports = __toCommonJS(signatureCache_exports);
 var import_viem = require("viem");
 var import_sha256 = require("@noble/hashes/sha256");
-var import_utils = require("@noble/hashes/utils");
 class SignatureCache {
   static PREFIX = "vana_sig_";
   static DEFAULT_TTL_HOURS = 2;
@@ -143,15 +142,21 @@ class SignatureCache {
   static hashMessage(message) {
     const jsonString = JSON.stringify(message, this.deterministicReplacer);
     const hashBytes = (0, import_sha256.sha256)(new TextEncoder().encode(jsonString));
-    return (0, import_utils.bytesToHex)(hashBytes);
+    return (0, import_viem.toHex)(hashBytes);
   }
   /**
-   * Deterministic JSON replacer that handles BigInt values and sorts object keys
-   * This ensures consistent cache key generation for EIP-712 typed data
+   * 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") {

package/dist/utils/signatureCache.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/signatureCache.ts"],"sourcesContent":["import { Hash, getAddress } from \"viem\";\nimport type { VanaCacheAdapter } from \"../platform/interface\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { bytesToHex } from \"@noble/hashes/utils\";\n\ninterface CachedSignature {\n  signature: Hash;\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 bytesToHex(hashBytes);\n  }\n\n  /**\n   * Deterministic JSON replacer that handles BigInt values and sorts object keys\n   * This ensures consistent cache key generation for EIP-712 typed data\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  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 * Wrapper function to cache signature operations\n *\n * @param cache - The cache adapter to use for storage\n * @param walletAddress - The wallet address signing the message\n * @param typedData - The EIP-712 typed data being signed\n * @param signFn - Function that performs the actual signing\n * @param ttlHours - Cache TTL in hours (default 2)\n * @returns The signature (cached or newly generated)\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":[]}
+{"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/signatureCache.d.ts

@@ -1,6 +1,17 @@
-import { Hash } from 'viem';
-import { VanaCacheAdapter } from '../platform/interface.js';
-
+/**
+ * Provides signature caching to improve UX by avoiding repeated wallet prompts.
+ *
+ * @remarks
+ * This module implements a secure signature cache that stores signed messages
+ * temporarily to avoid repeatedly prompting users for the same signature.
+ * It uses platform-appropriate storage (sessionStorage in browser, memory in Node.js)
+ * and includes automatic expiration and cleanup.
+ *
+ * @category Utilities
+ * @module utils/signatureCache
+ */
+import type { Hash } from "viem";
+import type { VanaCacheAdapter } from "../platform/interface";
 /**
  * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.
  *
@@ -29,7 +40,7 @@ import { VanaCacheAdapter } from '../platform/interface.js';
  * ```
  * @category Utilities
  */
-declare class SignatureCache {
+export declare class SignatureCache {
     private static readonly PREFIX;
     private static readonly DEFAULT_TTL_HOURS;
     /**
@@ -110,25 +121,52 @@ declare class SignatureCache {
      */
     static hashMessage(message: object): string;
     /**
-     * Deterministic JSON replacer that handles BigInt values and sorts object keys
-     * This ensures consistent cache key generation for EIP-712 typed data
+     * 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
      */
     private static deterministicReplacer;
 }
 /**
- * Wrapper function to cache signature operations
+ * Wraps signature operations with caching to avoid repeated prompts.
  *
- * @param cache - The cache adapter to use for storage
- * @param walletAddress - The wallet address signing the message
- * @param typedData - The EIP-712 typed data being signed
- * @param signFn - Function that performs the actual signing
- * @param ttlHours - Cache TTL in hours (default 2)
+ * @remarks
+ * This helper function checks the cache before requesting a signature
+ * and stores new signatures for future use. It significantly improves
+ * UX for operations that may be retried or called multiple times.
+ *
+ * @param cache - The cache adapter to use for storage.
+ *   Obtain from platform adapter.
+ * @param walletAddress - The wallet address signing the message.
+ *   Obtain from wallet connection.
+ * @param typedData - The EIP-712 typed data being signed.
+ *   Typically permission or grant data.
+ * @param signFn - Async function that performs the actual signing.
+ *   Usually calls wallet.signTypedData().
+ * @param ttlHours - Cache TTL in hours.
+ *   Defaults to 2 hours.
  * @returns The signature (cached or newly generated)
+ *
+ * @example
+ * ```typescript
+ * const signature = await withSignatureCache(
+ *   platformAdapter.cache,
+ *   walletAddress,
+ *   typedData,
+ *   async () => wallet.signTypedData(typedData),
+ *   24 // Cache for 24 hours
+ * );
+ * ```
+ *
+ * @category Utilities
  */
-declare function withSignatureCache(cache: VanaCacheAdapter, walletAddress: string, typedData: Record<string, unknown>, signFn: () => Promise<Hash>, ttlHours?: number): Promise<Hash>;
-
-export { SignatureCache, withSignatureCache };
+export declare function withSignatureCache(cache: VanaCacheAdapter, walletAddress: string, typedData: Record<string, unknown>, signFn: () => Promise<Hash>, ttlHours?: number): Promise<Hash>;

package/dist/utils/signatureCache.js

@@ -1,10 +1,8 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { getAddress } from "viem";
+import { getAddress, toHex } from "viem";
 import { sha256 } from "@noble/hashes/sha256";
-import { bytesToHex } from "@noble/hashes/utils";
 class SignatureCache {
+  static PREFIX = "vana_sig_";
+  static DEFAULT_TTL_HOURS = 2;
   /**
    * Get a cached signature if it exists and hasn't expired
    *
@@ -120,15 +118,21 @@ class SignatureCache {
   static hashMessage(message) {
     const jsonString = JSON.stringify(message, this.deterministicReplacer);
     const hashBytes = sha256(new TextEncoder().encode(jsonString));
-    return bytesToHex(hashBytes);
+    return toHex(hashBytes);
   }
   /**
-   * Deterministic JSON replacer that handles BigInt values and sorts object keys
-   * This ensures consistent cache key generation for EIP-712 typed data
+   * 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") {
@@ -146,8 +150,6 @@ class SignatureCache {
     return value;
   }
 }
-__publicField(SignatureCache, "PREFIX", "vana_sig_");
-__publicField(SignatureCache, "DEFAULT_TTL_HOURS", 2);
 async function withSignatureCache(cache, walletAddress, typedData, signFn, ttlHours) {
   const messageHash = SignatureCache.hashMessage(typedData);
   const cached = SignatureCache.get(cache, walletAddress, messageHash);

package/dist/utils/signatureCache.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/signatureCache.ts"],"sourcesContent":["import { Hash, getAddress } from \"viem\";\nimport type { VanaCacheAdapter } from \"../platform/interface\";\nimport { sha256 } from \"@noble/hashes/sha256\";\nimport { bytesToHex } from \"@noble/hashes/utils\";\n\ninterface CachedSignature {\n  signature: Hash;\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 bytesToHex(hashBytes);\n  }\n\n  /**\n   * Deterministic JSON replacer that handles BigInt values and sorts object keys\n   * This ensures consistent cache key generation for EIP-712 typed data\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  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 * Wrapper function to cache signature operations\n *\n * @param cache - The cache adapter to use for storage\n * @param walletAddress - The wallet address signing the message\n * @param typedData - The EIP-712 typed data being signed\n * @param signFn - Function that performs the actual signing\n * @param ttlHours - Cache TTL in hours (default 2)\n * @returns The signature (cached or newly generated)\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":[]}
+{"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

@@ -21,20 +21,17 @@ __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 cleanSig = signature.startsWith("0x") ? signature.slice(2) : signature;
-  if (cleanSig.length !== 130) {
-    return signature;
-  }
-  const vHex = cleanSig.slice(128, 130);
-  const v = parseInt(vHex, 16);
-  if (isNaN(v)) {
+  const sigBytes = (0, import_viem.fromHex)(signature, "bytes");
+  if (sigBytes.length !== 65) {
     return signature;
   }
+  const v = sigBytes[64];
   if (v < 27) {
-    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, "0");
-    return `0x${cleanSig.slice(0, 128)}${adjustedV}`;
+    sigBytes[64] = v + V_OFFSET_FOR_ETHEREUM;
+    return (0, import_viem.toHex)(sigBytes);
   }
   return signature;
 }

package/dist/utils/signatureFormatter.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import type { Hash } 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  const cleanSig = signature.startsWith(\"0x\") ? signature.slice(2) : signature;\n\n  if (cleanSig.length !== 130) {\n    return signature;\n  }\n\n  const vHex = cleanSig.slice(128, 130);\n  const v = parseInt(vHex, 16);\n\n  if (isNaN(v)) {\n    return signature;\n  }\n\n  if (v < 27) {\n    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, \"0\");\n    return `0x${cleanSig.slice(0, 128)}${adjustedV}` as Hash;\n  }\n\n  return signature;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAChE,QAAM,WAAW,UAAU,WAAW,IAAI,IAAI,UAAU,MAAM,CAAC,IAAI;AAEnE,MAAI,SAAS,WAAW,KAAK;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,SAAS,MAAM,KAAK,GAAG;AACpC,QAAM,IAAI,SAAS,MAAM,EAAE;AAE3B,MAAI,MAAM,CAAC,GAAG;AACZ,WAAO;AAAA,EACT;AAEA,MAAI,IAAI,IAAI;AACV,UAAM,aAAa,IAAI,uBAAuB,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1E,WAAO,KAAK,SAAS,MAAM,GAAG,GAAG,CAAC,GAAG,SAAS;AAAA,EAChD;AAEA,SAAO;AACT;","names":[]}
+{"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,5 +1,4 @@
-import { Hash } from 'viem';
-
+import { type Hash } from "viem";
 /**
  * Formats a signature for Ethereum smart contract compatibility by adjusting the v-value.
  *
@@ -34,6 +33,4 @@ import { Hash } from 'viem';
  * ```
  * @category Cryptography
  */
-declare function formatSignatureForContract(signature: Hash): Hash;
-
-export { formatSignatureForContract };
+export declare function formatSignatureForContract(signature: Hash): Hash;

package/dist/utils/signatureFormatter.js

@@ -1,17 +1,14 @@
+import { fromHex, toHex } from "viem";
 const V_OFFSET_FOR_ETHEREUM = 27;
 function formatSignatureForContract(signature) {
-  const cleanSig = signature.startsWith("0x") ? signature.slice(2) : signature;
-  if (cleanSig.length !== 130) {
-    return signature;
-  }
-  const vHex = cleanSig.slice(128, 130);
-  const v = parseInt(vHex, 16);
-  if (isNaN(v)) {
+  const sigBytes = fromHex(signature, "bytes");
+  if (sigBytes.length !== 65) {
     return signature;
   }
+  const v = sigBytes[64];
   if (v < 27) {
-    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, "0");
-    return `0x${cleanSig.slice(0, 128)}${adjustedV}`;
+    sigBytes[64] = v + V_OFFSET_FOR_ETHEREUM;
+    return toHex(sigBytes);
   }
   return signature;
 }

package/dist/utils/signatureFormatter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/signatureFormatter.ts"],"sourcesContent":["import type { Hash } 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  const cleanSig = signature.startsWith(\"0x\") ? signature.slice(2) : signature;\n\n  if (cleanSig.length !== 130) {\n    return signature;\n  }\n\n  const vHex = cleanSig.slice(128, 130);\n  const v = parseInt(vHex, 16);\n\n  if (isNaN(v)) {\n    return signature;\n  }\n\n  if (v < 27) {\n    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, \"0\");\n    return `0x${cleanSig.slice(0, 128)}${adjustedV}` as Hash;\n  }\n\n  return signature;\n}\n"],"mappings":"AAEA,MAAM,wBAAwB;AAoCvB,SAAS,2BAA2B,WAAuB;AAChE,QAAM,WAAW,UAAU,WAAW,IAAI,IAAI,UAAU,MAAM,CAAC,IAAI;AAEnE,MAAI,SAAS,WAAW,KAAK;AAC3B,WAAO;AAAA,EACT;AAEA,QAAM,OAAO,SAAS,MAAM,KAAK,GAAG;AACpC,QAAM,IAAI,SAAS,MAAM,EAAE;AAE3B,MAAI,MAAM,CAAC,GAAG;AACZ,WAAO;AAAA,EACT;AAEA,MAAI,IAAI,IAAI;AACV,UAAM,aAAa,IAAI,uBAAuB,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC1E,WAAO,KAAK,SAAS,MAAM,GAAG,GAAG,CAAC,GAAG,SAAS;AAAA,EAChD;AAEA,SAAO;AACT;","names":[]}
+{"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

@@ -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":[]}