@opendatalabs/vana-sdk 0.1.0-alpha.7e4db82 → 0.1.0-alpha.7ee7635

package/dist/utils/signatureCache.d.ts

@@ -0,0 +1,134 @@
+import { Hash } from 'viem';
+import { VanaCacheAdapter } from '../platform/interface.js';
+
+/**
+ * Simple signature cache using platform cache adapter to avoid repeated signing of identical messages.
+ *
+ * @remarks
+ * This cache significantly improves UX by avoiding repeated wallet signature prompts
+ * for identical operations. It's particularly useful for operations that may be
+ * retried or called multiple times with the same parameters.
+ *
+ * Features:
+ * - Platform-appropriate storage (sessionStorage in browser, memory in Node.js)
+ * - Configurable TTL (default 2 hours)
+ * - Automatic cleanup of expired entries
+ * - Cache keys based on wallet address + message hash
+ *
+ * @example
+ * ```typescript
+ * // Check cache before requesting signature
+ * const cached = SignatureCache.get(cache, walletAddress, messageHash);
+ * if (cached) {
+ *   return cached;
+ * }
+ *
+ * // Request signature and cache it
+ * const signature = await wallet.signTypedData(typedData);
+ * SignatureCache.set(cache, walletAddress, messageHash, signature);
+ * ```
+ * @category Utilities
+ */
+declare class SignatureCache {
+    private static readonly PREFIX;
+    private static readonly DEFAULT_TTL_HOURS;
+    /**
+     * 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: VanaCacheAdapter, walletAddress: string, messageHash: string): Hash | 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: VanaCacheAdapter, walletAddress: string, messageHash: string, signature: Hash, ttlHours?: number): void;
+    /**
+     * 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: VanaCacheAdapter): void;
+    private static getCacheKey;
+    /**
+     * 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: object): string;
+    /**
+     * Deterministic JSON replacer that handles BigInt values and sorts object keys
+     * This ensures consistent cache key generation for EIP-712 typed data
+     *
+     * @param _key - The object key being serialized (unused)
+     * @param value - The value to serialize
+     * @returns The serialized value with sorted keys for objects
+     */
+    private static deterministicReplacer;
+}
+/**
+ * Wrapper function to cache signature operations
+ *
+ * @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)
+ * @returns The signature (cached or newly generated)
+ */
+declare function withSignatureCache(cache: VanaCacheAdapter, walletAddress: string, typedData: Record<string, unknown>, signFn: () => Promise<Hash>, ttlHours?: number): Promise<Hash>;
+
+export { SignatureCache, withSignatureCache };

package/dist/utils/signatureCache.js

@@ -0,0 +1,165 @@
+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 { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex } from "@noble/hashes/utils";
+class SignatureCache {
+  /**
+   * 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 bytesToHex(hashBytes);
+  }
+  /**
+   * Deterministic JSON replacer that handles BigInt values and sorts object keys
+   * This ensures consistent cache key generation for EIP-712 typed data
+   *
+   * @param _key - The object key being serialized (unused)
+   * @param value - The value to serialize
+   * @returns The serialized value with sorted keys for objects
+   */
+  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;
+  }
+}
+__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);
+  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

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

package/dist/utils/signatureFormatter.cjs

@@ -0,0 +1,45 @@
+"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);
+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)) {
+    return signature;
+  }
+  if (v < 27) {
+    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, "0");
+    return `0x${cleanSig.slice(0, 128)}${adjustedV}`;
+  }
+  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

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

package/dist/utils/signatureFormatter.d.cts

@@ -0,0 +1,39 @@
+import { 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
+ */
+declare function formatSignatureForContract(signature: Hash): Hash;
+
+export { formatSignatureForContract };

package/dist/utils/signatureFormatter.d.ts

@@ -0,0 +1,39 @@
+import { 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
+ */
+declare function formatSignatureForContract(signature: Hash): Hash;
+
+export { formatSignatureForContract };

package/dist/utils/signatureFormatter.js

@@ -0,0 +1,21 @@
+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)) {
+    return signature;
+  }
+  if (v < 27) {
+    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, "0");
+    return `0x${cleanSig.slice(0, 128)}${adjustedV}`;
+  }
+  return signature;
+}
+export {
+  formatSignatureForContract
+};
+//# sourceMappingURL=signatureFormatter.js.map

package/dist/utils/signatureFormatter.js.map

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

package/dist/utils/transactionHelpers.cjs

@@ -0,0 +1,54 @@
+"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 transactionHelpers_exports = {};
+__export(transactionHelpers_exports, {
+  tx: () => tx,
+  txLiteral: () => txLiteral
+});
+module.exports = __toCommonJS(transactionHelpers_exports);
+function tx(input) {
+  return {
+    hash: input.hash,
+    from: input.from,
+    contract: input.contract,
+    fn: input.fn,
+    ...input.chainId !== void 0 && { chainId: input.chainId },
+    ...input.value !== void 0 && { value: input.value },
+    ...input.nonce !== void 0 && { nonce: input.nonce },
+    ...input.to !== void 0 && { to: input.to }
+  };
+}
+function txLiteral(input) {
+  return {
+    hash: input.hash,
+    from: input.from,
+    contract: input.contract,
+    fn: input.fn,
+    ...input.chainId !== void 0 && { chainId: input.chainId },
+    ...input.value !== void 0 && { value: input.value },
+    ...input.nonce !== void 0 && { nonce: input.nonce },
+    ...input.to !== void 0 && { to: input.to }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tx,
+  txLiteral
+});
+//# sourceMappingURL=transactionHelpers.cjs.map

package/dist/utils/transactionHelpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/transactionHelpers.ts"],"sourcesContent":["/**\n * Helper functions for creating typed transaction POJOs\n */\n\nimport type { Hash, Address } from 'viem';\nimport type { TransactionResult } from '../types/operations';\nimport type { Contract, Fn } from '../generated/event-types';\n\n/**\n * Creates a strongly-typed TransactionResult POJO.\n * \n * @remarks\n * This helper ensures all required fields are present and typed correctly,\n * reducing boilerplate and preventing mistakes.\n * \n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n * \n * @example\n * ```typescript\n * return tx({\n *   hash,\n *   from: account.address,\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * ```\n */\nexport function tx<C extends Contract, F extends Fn<C>>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}\n\n/**\n * Creates a transaction result with literal type inference.\n * Use this when you need TypeScript to preserve exact string literals.\n * \n * @param input - Transaction details\n * @param input.hash - Transaction hash\n * @param input.from - Transaction sender address\n * @param input.contract - Contract name\n * @param input.fn - Function name\n * @param input.chainId - Optional chain ID\n * @param input.value - Optional transaction value\n * @param input.nonce - Optional nonce\n * @param input.to - Optional recipient address\n * @returns Typed TransactionResult\n * \n * @example\n * ```typescript\n * const transaction = txLiteral({\n *   hash: '0x...',\n *   from: '0x...',\n *   contract: \"DataPortabilityPermissions\",\n *   fn: \"revokePermission\",\n * });\n * // TypeScript knows exactly: DataPortabilityPermissions + revokePermission\n * ```\n */\nexport function txLiteral<\n  const C extends Contract,\n  const F extends Fn<C>\n>(input: {\n  hash: Hash;\n  from: Address;\n  contract: C;\n  fn: F;\n  chainId?: number;\n  value?: bigint;\n  nonce?: number;\n  to?: Address;\n}): TransactionResult<C, F> {\n  // Create a new plain object to ensure independence and true POJO behavior\n  return {\n    hash: input.hash,\n    from: input.from,\n    contract: input.contract,\n    fn: input.fn,\n    ...(input.chainId !== undefined && { chainId: input.chainId }),\n    ...(input.value !== undefined && { value: input.value }),\n    ...(input.nonce !== undefined && { nonce: input.nonce }),\n    ...(input.to !== undefined && { to: input.to }),\n  };\n}"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoCO,SAAS,GAAwC,OAS5B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;AA4BO,SAAS,UAGd,OAS0B;AAE1B,SAAO;AAAA,IACL,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,UAAU,MAAM;AAAA,IAChB,IAAI,MAAM;AAAA,IACV,GAAI,MAAM,YAAY,UAAa,EAAE,SAAS,MAAM,QAAQ;AAAA,IAC5D,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,UAAU,UAAa,EAAE,OAAO,MAAM,MAAM;AAAA,IACtD,GAAI,MAAM,OAAO,UAAa,EAAE,IAAI,MAAM,GAAG;AAAA,EAC/C;AACF;","names":[]}

package/dist/utils/transactionHelpers.d.cts

@@ -0,0 +1,86 @@
+import { Hash, Address } from 'viem';
+import { TransactionResult } from '../types/operations.cjs';
+import { Contract, Fn } from '../generated/event-types.cjs';
+import '../generated/server/server-exports.cjs';
+import '../generated/server/server.cjs';
+
+/**
+ * Helper functions for creating typed transaction POJOs
+ */
+
+/**
+ * Creates a strongly-typed TransactionResult POJO.
+ *
+ * @remarks
+ * This helper ensures all required fields are present and typed correctly,
+ * reducing boilerplate and preventing mistakes.
+ *
+ * @param input - Transaction details
+ * @param input.hash - Transaction hash
+ * @param input.from - Transaction sender address
+ * @param input.contract - Contract name
+ * @param input.fn - Function name
+ * @param input.chainId - Optional chain ID
+ * @param input.value - Optional transaction value
+ * @param input.nonce - Optional nonce
+ * @param input.to - Optional recipient address
+ * @returns Typed TransactionResult
+ *
+ * @example
+ * ```typescript
+ * return tx({
+ *   hash,
+ *   from: account.address,
+ *   contract: "DataPortabilityPermissions",
+ *   fn: "revokePermission",
+ * });
+ * ```
+ */
+declare function tx<C extends Contract, F extends Fn<C>>(input: {
+    hash: Hash;
+    from: Address;
+    contract: C;
+    fn: F;
+    chainId?: number;
+    value?: bigint;
+    nonce?: number;
+    to?: Address;
+}): TransactionResult<C, F>;
+/**
+ * Creates a transaction result with literal type inference.
+ * Use this when you need TypeScript to preserve exact string literals.
+ *
+ * @param input - Transaction details
+ * @param input.hash - Transaction hash
+ * @param input.from - Transaction sender address
+ * @param input.contract - Contract name
+ * @param input.fn - Function name
+ * @param input.chainId - Optional chain ID
+ * @param input.value - Optional transaction value
+ * @param input.nonce - Optional nonce
+ * @param input.to - Optional recipient address
+ * @returns Typed TransactionResult
+ *
+ * @example
+ * ```typescript
+ * const transaction = txLiteral({
+ *   hash: '0x...',
+ *   from: '0x...',
+ *   contract: "DataPortabilityPermissions",
+ *   fn: "revokePermission",
+ * });
+ * // TypeScript knows exactly: DataPortabilityPermissions + revokePermission
+ * ```
+ */
+declare function txLiteral<const C extends Contract, const F extends Fn<C>>(input: {
+    hash: Hash;
+    from: Address;
+    contract: C;
+    fn: F;
+    chainId?: number;
+    value?: bigint;
+    nonce?: number;
+    to?: Address;
+}): TransactionResult<C, F>;
+
+export { tx, txLiteral };