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

package/dist/utils/encryption.d.ts

@@ -1,6 +1,3 @@
-import { WalletClient } from 'viem';
-import { VanaPlatformAdapter } from '../platform/interface.js';
-
 /**
  * Canonical Vana Protocol Encryption Functions
  *
@@ -11,11 +8,12 @@ import { VanaPlatformAdapter } from '../platform/interface.js';
  * This module uses the platform adapter pattern to provide consistent
  * encryption functionality across Node.js and browser environments.
  */
-
+import type { WalletClient } from "viem";
+import type { VanaPlatformAdapter } from "../platform/interface";
 /**
  * Default encryption seed message used throughout Vana protocol
  */
-declare const DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
+export declare const DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
 /**
  * Generate an encryption key by signing the canonical Vana encryption seed
  *
@@ -36,7 +34,7 @@ declare const DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption
  * const customKey = await generateEncryptionKey(walletClient, platformAdapter, 'my-custom-seed');
  * ```
  */
-declare function generateEncryptionKey(wallet: WalletClient, platformAdapter: VanaPlatformAdapter, seed?: string): Promise<string>;
+export declare function generateEncryptionKey(wallet: WalletClient, platformAdapter: VanaPlatformAdapter, seed?: string): Promise<string>;
 /**
  * Encrypts data using a wallet's public key for secure sharing with specific recipients.
  *
@@ -77,7 +75,7 @@ declare function generateEncryptionKey(wallet: WalletClient, platformAdapter: Va
  * );
  * ```
  */
-declare function encryptWithWalletPublicKey(data: string | Blob, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
+export declare function encryptWithWalletPublicKey(data: string | Blob, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
 /**
  * Decrypts data that was encrypted with the corresponding public key.
  *
@@ -126,7 +124,7 @@ declare function encryptWithWalletPublicKey(data: string | Blob, publicKey: stri
  * }
  * ```
  */
-declare function decryptWithWalletPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
+export declare function decryptWithWalletPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
 /**
  * Encrypt a file key with a DLP's public key using platform-appropriate cryptography
  *
@@ -135,14 +133,14 @@ declare function decryptWithWalletPrivateKey(encryptedData: string, privateKey:
  * @param platformAdapter - The platform adapter for crypto operations
  * @returns The encrypted key that can be stored on-chain
  */
-declare function encryptFileKey(fileKey: string, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
+export declare function encryptFileKey(fileKey: string, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
 /**
  * Generate encryption parameters for secure file storage
  *
  * @param platformAdapter - The platform adapter for crypto operations
  * @returns An object containing the initialization vector and encryption key
  */
-declare function getEncryptionParameters(platformAdapter: VanaPlatformAdapter): Promise<{
+export declare function getEncryptionParameters(platformAdapter: VanaPlatformAdapter): Promise<{
     iv: string;
     key: string;
 }>;
@@ -154,7 +152,7 @@ declare function getEncryptionParameters(platformAdapter: VanaPlatformAdapter):
  * @param platformAdapter - The platform adapter for crypto operations
  * @returns The decrypted data
  */
-declare function decryptWithPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
+export declare function decryptWithPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
 /**
  * Encrypts data using a signed key generated from the user's wallet signature.
  *
@@ -193,14 +191,14 @@ declare function decryptWithPrivateKey(encryptedData: string, privateKey: string
  * );
  * ```
  */
-declare function encryptBlobWithSignedKey(data: string | Blob, key: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;
+export declare function encryptBlobWithSignedKey(data: string | Blob, key: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;
 /**
  * Generate a new key pair for asymmetric encryption
  *
  * @param platformAdapter - The platform adapter for crypto operations
  * @returns Promise resolving to public and private key pair
  */
-declare function generateEncryptionKeyPair(platformAdapter: VanaPlatformAdapter): Promise<{
+export declare function generateEncryptionKeyPair(platformAdapter: VanaPlatformAdapter): Promise<{
     publicKey: string;
     privateKey: string;
 }>;
@@ -214,7 +212,7 @@ declare function generateEncryptionKeyPair(platformAdapter: VanaPlatformAdapter)
  * @param options.passphrase - Optional passphrase to protect the private key
  * @returns Promise resolving to public and private key pair
  */
-declare function generatePGPKeyPair(platformAdapter: VanaPlatformAdapter, options?: {
+export declare function generatePGPKeyPair(platformAdapter: VanaPlatformAdapter, options?: {
     name?: string;
     email?: string;
     passphrase?: string;
@@ -270,6 +268,4 @@ declare function generatePGPKeyPair(platformAdapter: VanaPlatformAdapter, option
  * );
  * ```
  */
-declare function decryptBlobWithSignedKey(encryptedData: string | Blob, key: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;
-
-export { DEFAULT_ENCRYPTION_SEED, decryptBlobWithSignedKey, decryptWithPrivateKey, decryptWithWalletPrivateKey, encryptBlobWithSignedKey, encryptFileKey, encryptWithWalletPublicKey, generateEncryptionKey, generateEncryptionKeyPair, generatePGPKeyPair, getEncryptionParameters };
+export declare function decryptBlobWithSignedKey(encryptedData: string | Blob, key: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;

package/dist/utils/encryption.js

@@ -4,7 +4,7 @@ async function generateEncryptionKey(wallet, platformAdapter, seed = DEFAULT_ENC
   if (!wallet.account) {
     throw new Error("Wallet account is required for encryption key generation");
   }
-  const account = wallet.account;
+  const { account } = wallet;
   const messageData = { message: seed };
   return await withSignatureCache(
     platformAdapter.cache,
@@ -26,7 +26,9 @@ async function encryptWithWalletPublicKey(data, publicKey, platformAdapter) {
       publicKey
     );
   } catch (error) {
-    throw new Error(`Failed to encrypt with wallet public key: ${error}`);
+    throw new Error(
+      `Failed to encrypt with wallet public key: ${String(error)}`
+    );
   }
 }
 async function decryptWithWalletPrivateKey(encryptedData, privateKey, platformAdapter) {
@@ -36,7 +38,9 @@ async function decryptWithWalletPrivateKey(encryptedData, privateKey, platformAd
       privateKey
     );
   } catch (error) {
-    throw new Error(`Failed to decrypt with wallet private key: ${error}`);
+    throw new Error(
+      `Failed to decrypt with wallet private key: ${String(error)}`
+    );
   }
 }
 async function encryptFileKey(fileKey, publicKey, platformAdapter) {
@@ -46,7 +50,7 @@ async function encryptFileKey(fileKey, publicKey, platformAdapter) {
       publicKey
     );
   } catch (error) {
-    throw new Error(`Failed to encrypt file key: ${error}`);
+    throw new Error(`Failed to encrypt file key: ${String(error)}`);
   }
 }
 async function getEncryptionParameters(platformAdapter) {
@@ -57,7 +61,9 @@ async function getEncryptionParameters(platformAdapter) {
       key: keyPair.privateKey.substring(0, 32)
     };
   } catch (error) {
-    throw new Error(`Failed to generate encryption parameters: ${error}`);
+    throw new Error(
+      `Failed to generate encryption parameters: ${String(error)}`
+    );
   }
 }
 async function decryptWithPrivateKey(encryptedData, privateKey, platformAdapter) {
@@ -67,7 +73,7 @@ async function decryptWithPrivateKey(encryptedData, privateKey, platformAdapter)
       privateKey
     );
   } catch (error) {
-    throw new Error(`Failed to decrypt with private key: ${error}`);
+    throw new Error(`Failed to decrypt with private key: ${String(error)}`);
   }
 }
 async function encryptBlobWithSignedKey(data, key, platformAdapter) {
@@ -86,21 +92,21 @@ async function encryptBlobWithSignedKey(data, key, platformAdapter) {
       type: "application/octet-stream"
     });
   } catch (error) {
-    throw new Error(`Failed to encrypt data: ${error}`);
+    throw new Error(`Failed to encrypt data: ${String(error)}`);
   }
 }
 async function generateEncryptionKeyPair(platformAdapter) {
   try {
     return await platformAdapter.crypto.generateKeyPair();
   } catch (error) {
-    throw new Error(`Failed to generate encryption key pair: ${error}`);
+    throw new Error(`Failed to generate encryption key pair: ${String(error)}`);
   }
 }
 async function generatePGPKeyPair(platformAdapter, options) {
   try {
     return await platformAdapter.pgp.generateKeyPair(options);
   } catch (error) {
-    throw new Error(`Failed to generate PGP key pair: ${error}`);
+    throw new Error(`Failed to generate PGP key pair: ${String(error)}`);
   }
 }
 async function decryptBlobWithSignedKey(encryptedData, key, platformAdapter) {
@@ -117,7 +123,7 @@ async function decryptBlobWithSignedKey(encryptedData, key, platformAdapter) {
     );
     return new Blob([decryptedArrayBuffer], { type: "text/plain" });
   } catch (error) {
-    throw new Error(`Failed to decrypt data: ${error}`);
+    throw new Error(`Failed to decrypt data: ${String(error)}`);
   }
 }
 export {

package/dist/utils/encryption.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/encryption.ts"],"sourcesContent":["/**\n * Canonical Vana Protocol Encryption Functions\n *\n * These functions define the standard way user data is encrypted/decrypted in Vana.\n * All applications should use these canonical functions to ensure compatibility\n * with existing encrypted data on the Vana network.\n *\n * This module uses the platform adapter pattern to provide consistent\n * encryption functionality across Node.js and browser environments.\n */\n\nimport type { WalletClient } from \"viem\";\nimport type { VanaPlatformAdapter } from \"../platform/interface\";\nimport { withSignatureCache } from \"./signatureCache\";\n\n/**\n * Default encryption seed message used throughout Vana protocol\n */\nexport const DEFAULT_ENCRYPTION_SEED =\n  \"Please sign to retrieve your encryption key\";\n\n/**\n * Generate an encryption key by signing the canonical Vana encryption seed\n *\n * This is the standard protocol function for creating encryption keys in Vana.\n * The signature serves as a symmetric encryption key for user data.\n *\n * @param wallet The user's wallet client for signing\n * @param platformAdapter Platform adapter for cache operations\n * @param seed Optional custom encryption seed (defaults to Vana standard)\n * @returns The signature that serves as the encryption key\n * @throws {Error} When wallet account is required but not provided\n * @example\n * ```typescript\n * const encryptionKey = await generateEncryptionKey(walletClient, platformAdapter);\n * console.log('Generated encryption key:', encryptionKey);\n *\n * // Use with custom seed\n * const customKey = await generateEncryptionKey(walletClient, platformAdapter, 'my-custom-seed');\n * ```\n */\nexport async function generateEncryptionKey(\n  wallet: WalletClient,\n  platformAdapter: VanaPlatformAdapter,\n  seed: string = DEFAULT_ENCRYPTION_SEED,\n): Promise<string> {\n  if (!wallet.account) {\n    throw new Error(\"Wallet account is required for encryption key generation\");\n  }\n\n  // Store account reference to satisfy TypeScript\n  const account = wallet.account;\n\n  // Use signature cache for encryption key generation\n  // Create a simple message object for cache key generation\n  const messageData = { message: seed };\n\n  return await withSignatureCache(\n    platformAdapter.cache,\n    account.address,\n    messageData,\n    async () => {\n      // Sign the encryption seed to generate a deterministic encryption key\n      return await wallet.signMessage({\n        account: account,\n        message: seed,\n      });\n    },\n  );\n}\n\n/**\n * Encrypts data using a wallet's public key for secure sharing with specific recipients.\n *\n * @remarks\n * This function implements asymmetric encryption using the recipient's public key,\n * enabling secure data sharing where only the holder of the corresponding private key\n * can decrypt the data. It automatically handles different data types and uses\n * platform-appropriate cryptographic libraries for maximum compatibility.\n *\n * This is commonly used when granting permissions to applications or servers,\n * where the data needs to be encrypted for a specific recipient's public key.\n *\n * @param data - The data to encrypt (string or Blob)\n * @param publicKey - The recipient's public key in hexadecimal format\n * @param platformAdapter - The platform adapter providing cryptographic operations\n * @returns Promise resolving to the encrypted data as a string\n * @throws {Error} When encryption fails due to invalid key or data format\n * @example\n * ```typescript\n * // Encrypt data for a specific application's public key\n * const appPublicKey = \"0x04a1b2c3...\"; // Application's public key\n * const sensitiveData = \"User's private information\";\n *\n * const encrypted = await encryptWithWalletPublicKey(\n *   sensitiveData,\n *   appPublicKey,\n *   platformAdapter\n * );\n *\n * console.log('Encrypted for app:', encrypted);\n *\n * // Encrypt file data for server processing\n * const fileBlob = new File(['{\"name\":\"John\",\"age\":30}'], 'profile.json');\n * const encryptedFile = await encryptWithWalletPublicKey(\n *   fileBlob,\n *   serverPublicKey,\n *   platformAdapter\n * );\n * ```\n */\nexport async function encryptWithWalletPublicKey(\n  data: string | Blob,\n  publicKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    const dataString = data instanceof Blob ? await data.text() : data;\n    return await platformAdapter.crypto.encryptWithWalletPublicKey(\n      dataString,\n      publicKey,\n    );\n  } catch (error) {\n    throw new Error(`Failed to encrypt with wallet public key: ${error}`);\n  }\n}\n\n/**\n * Decrypts data that was encrypted with the corresponding public key.\n *\n * @remarks\n * This function performs asymmetric decryption using the recipient's private key\n * to decrypt data that was encrypted with the corresponding public key. It's the\n * counterpart to `encryptWithWalletPublicKey` and is typically used by applications\n * or servers to decrypt data that was shared with them by users.\n *\n * The function automatically handles platform-specific cryptographic operations\n * and provides consistent behavior across browser and Node.js environments.\n *\n * @param encryptedData - The encrypted data string to decrypt\n * @param privateKey - The private key corresponding to the public key used for encryption\n * @param platformAdapter - The platform adapter providing cryptographic operations\n * @returns Promise resolving to the decrypted data as a string\n * @throws {Error} When decryption fails due to invalid key, corrupted data, or key mismatch\n * @example\n * ```typescript\n * // Decrypt data received from a user (server-side)\n * const encryptedUserData = \"encrypted_string_from_user\";\n * const serverPrivateKey = process.env.SERVER_PRIVATE_KEY;\n *\n * const decrypted = await decryptWithWalletPrivateKey(\n *   encryptedUserData,\n *   serverPrivateKey,\n *   platformAdapter\n * );\n *\n * const userData = JSON.parse(decrypted);\n * console.log('User data:', userData);\n *\n * // Handle decryption errors gracefully\n * try {\n *   const result = await decryptWithWalletPrivateKey(\n *     encryptedData,\n *     privateKey,\n *     platformAdapter\n *   );\n * } catch (error) {\n *   if (error.message.includes('invalid key')) {\n *     console.error('Key mismatch - data not encrypted for this recipient');\n *   } else {\n *     console.error('Decryption failed:', error.message);\n *   }\n * }\n * ```\n */\nexport async function decryptWithWalletPrivateKey(\n  encryptedData: string,\n  privateKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    return await platformAdapter.crypto.decryptWithWalletPrivateKey(\n      encryptedData,\n      privateKey,\n    );\n  } catch (error) {\n    throw new Error(`Failed to decrypt with wallet private key: ${error}`);\n  }\n}\n\n/**\n * Encrypt a file key with a DLP's public key using platform-appropriate cryptography\n *\n * @param fileKey The symmetric key used to encrypt the file\n * @param publicKey The DLP's public key\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns The encrypted key that can be stored on-chain\n */\nexport async function encryptFileKey(\n  fileKey: string,\n  publicKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    return await platformAdapter.crypto.encryptWithPublicKey(\n      fileKey,\n      publicKey,\n    );\n  } catch (error) {\n    throw new Error(`Failed to encrypt file key: ${error}`);\n  }\n}\n\n/**\n * Generate encryption parameters for secure file storage\n *\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns An object containing the initialization vector and encryption key\n */\nexport async function getEncryptionParameters(\n  platformAdapter: VanaPlatformAdapter,\n): Promise<{\n  iv: string;\n  key: string;\n}> {\n  try {\n    // Generate a new key pair for encryption parameters\n    const keyPair = await platformAdapter.crypto.generateKeyPair();\n\n    // Use parts of the generated keys as IV and key\n    // In production, this would use proper key derivation\n    return {\n      iv: keyPair.publicKey.substring(0, 16),\n      key: keyPair.privateKey.substring(0, 32),\n    };\n  } catch (error) {\n    throw new Error(`Failed to generate encryption parameters: ${error}`);\n  }\n}\n\n/**\n * Decrypt data that was encrypted with the DLP's public key using platform-appropriate cryptography\n *\n * @param encryptedData The encrypted data\n * @param privateKey The private key corresponding to the public key used for encryption\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns The decrypted data\n */\nexport async function decryptWithPrivateKey(\n  encryptedData: string,\n  privateKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    return await platformAdapter.crypto.decryptWithPrivateKey(\n      encryptedData,\n      privateKey,\n    );\n  } catch (error) {\n    throw new Error(`Failed to decrypt with private key: ${error}`);\n  }\n}\n\n/**\n * Encrypts data using a signed key generated from the user's wallet signature.\n *\n * @remarks\n * This is a pure cryptographic primitive that encrypts data using the Vana protocol's\n * standard encryption method. The key parameter must be a signature generated by the\n * `generateEncryptionKey` utility - this ensures deterministic key generation from the\n * user's wallet, enabling the same key to be regenerated for decryption.\n *\n * This function uses password-based encryption with the signature as the password,\n * providing symmetric encryption that can be decrypted with the same signature.\n *\n * @param data The data to encrypt (string or Blob)\n * @param key The signed key from `generateEncryptionKey` - MUST be a wallet signature\n * @param platformAdapter The platform adapter for crypto operations\n * @returns The encrypted data as Blob\n * @throws {Error} When encryption fails\n *\n * @example\n * ```typescript\n * // Generate the encryption key from wallet signature\n * const encryptionKey = await generateEncryptionKey(walletClient);\n *\n * // Encrypt data with the signed key\n * const encryptedBlob = await encryptBlobWithSignedKey(\n *   \"My sensitive data\",\n *   encryptionKey,\n *   platformAdapter\n * );\n *\n * // Later, decrypt with the same key\n * const decryptedBlob = await decryptBlobWithSignedKey(\n *   encryptedBlob,\n *   encryptionKey,\n *   platformAdapter\n * );\n * ```\n */\nexport async function encryptBlobWithSignedKey(\n  data: string | Blob,\n  key: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<Blob> {\n  try {\n    // Convert data to binary for encryption\n    const dataBuffer =\n      data instanceof Blob\n        ? await data.arrayBuffer()\n        : new TextEncoder().encode(data);\n    const dataArray = new Uint8Array(dataBuffer);\n\n    // Use platform adapter's password-based encryption\n    const encrypted = await platformAdapter.crypto.encryptWithPassword(\n      dataArray,\n      key,\n    );\n\n    // Convert Uint8Array<ArrayBufferLike> to ArrayBuffer to satisfy BlobPart type\n    const encryptedArrayBuffer = encrypted.buffer.slice(\n      encrypted.byteOffset,\n      encrypted.byteOffset + encrypted.byteLength,\n    ) as ArrayBuffer;\n\n    return new Blob([encryptedArrayBuffer], {\n      type: \"application/octet-stream\",\n    });\n  } catch (error) {\n    throw new Error(`Failed to encrypt data: ${error}`);\n  }\n}\n\n/**\n * Generate a new key pair for asymmetric encryption\n *\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns Promise resolving to public and private key pair\n */\nexport async function generateEncryptionKeyPair(\n  platformAdapter: VanaPlatformAdapter,\n): Promise<{\n  publicKey: string;\n  privateKey: string;\n}> {\n  try {\n    return await platformAdapter.crypto.generateKeyPair();\n  } catch (error) {\n    throw new Error(`Failed to generate encryption key pair: ${error}`);\n  }\n}\n\n/**\n * Generate a new PGP key pair with platform-appropriate configuration\n *\n * @param platformAdapter - The platform adapter for crypto operations\n * @param options - Key generation options\n * @param options.name - The name for the PGP key\n * @param options.email - The email for the PGP key\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Promise resolving to public and private key pair\n */\nexport async function generatePGPKeyPair(\n  platformAdapter: VanaPlatformAdapter,\n  options?: {\n    name?: string;\n    email?: string;\n    passphrase?: string;\n  },\n): Promise<{ publicKey: string; privateKey: string }> {\n  try {\n    return await platformAdapter.pgp.generateKeyPair(options);\n  } catch (error) {\n    throw new Error(`Failed to generate PGP key pair: ${error}`);\n  }\n}\n\n/**\n * Decrypts data using a signed key generated from the user's wallet signature.\n *\n * @remarks\n * This is a pure cryptographic primitive for decrypting data that was encrypted using\n * `encryptBlobWithSignedKey`. It is network-agnostic and only handles decryption - it does\n * not fetch data from any URL or make network requests. To decrypt a file from a URL, you\n * must first fetch the encrypted blob using one of the fetch utilities, then pass it to\n * this function.\n *\n * The key parameter must be the same signature that was used for encryption, typically\n * generated by the `generateEncryptionKey` utility. This ensures that only the user who\n * encrypted the data (or someone with the same wallet signature) can decrypt it.\n *\n * @param encryptedData The encrypted data to decrypt (string or Blob)\n * @param key The signed key from `generateEncryptionKey` - MUST be the same wallet signature used for encryption\n * @param platformAdapter The platform adapter for crypto operations\n * @returns Promise resolving to the decrypted blob\n * @throws {Error} When decryption fails due to wrong key or corrupted data\n *\n * @example\n * ```typescript\n * // Generate the same encryption key used for encryption\n * const encryptionKey = await generateEncryptionKey(walletClient);\n *\n * // Fetch and decrypt using the high-level API\n * const file = await vana.data.getUserFiles({ owner: \"0x...\" })[0];\n * const decryptedBlob = await vana.data.decryptFile(file);\n *\n * // Or use the low-level primitives directly\n * const encryptedBlob = await vana.data.fetch(file.url);\n * const decryptedBlob = await decryptBlobWithSignedKey(\n *   encryptedBlob,\n *   encryptionKey,\n *   platformAdapter\n * );\n *\n * // With IPFS gateway fallback\n * const encryptedBlob = await vana.data.fetchFromIPFS(file.url, {\n *   gateways: ['https://my-gateway.com/ipfs/', 'https://ipfs.io/ipfs/']\n * });\n * const decryptedBlob = await decryptBlobWithSignedKey(\n *   encryptedBlob,\n *   encryptionKey,\n *   platformAdapter\n * );\n * ```\n */\nexport async function decryptBlobWithSignedKey(\n  encryptedData: string | Blob,\n  key: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<Blob> {\n  try {\n    // Convert encrypted data to proper format\n    const encryptedBuffer =\n      encryptedData instanceof Blob\n        ? await encryptedData.arrayBuffer()\n        : new TextEncoder().encode(encryptedData);\n    const encryptedArray = new Uint8Array(encryptedBuffer);\n\n    // Use platform adapter's password-based decryption\n    const decrypted = await platformAdapter.crypto.decryptWithPassword(\n      encryptedArray,\n      key,\n    );\n\n    // Convert Uint8Array<ArrayBufferLike> to ArrayBuffer to satisfy BlobPart type\n    const decryptedArrayBuffer = decrypted.buffer.slice(\n      decrypted.byteOffset,\n      decrypted.byteOffset + decrypted.byteLength,\n    ) as ArrayBuffer;\n\n    // Convert decrypted data back to Blob\n    return new Blob([decryptedArrayBuffer], { type: \"text/plain\" });\n  } catch (error) {\n    throw new Error(`Failed to decrypt data: ${error}`);\n  }\n}\n"],"mappings":"AAaA,SAAS,0BAA0B;AAK5B,MAAM,0BACX;AAsBF,eAAsB,sBACpB,QACA,iBACA,OAAe,yBACE;AACjB,MAAI,CAAC,OAAO,SAAS;AACnB,UAAM,IAAI,MAAM,0DAA0D;AAAA,EAC5E;AAGA,QAAM,UAAU,OAAO;AAIvB,QAAM,cAAc,EAAE,SAAS,KAAK;AAEpC,SAAO,MAAM;AAAA,IACX,gBAAgB;AAAA,IAChB,QAAQ;AAAA,IACR;AAAA,IACA,YAAY;AAEV,aAAO,MAAM,OAAO,YAAY;AAAA,QAC9B;AAAA,QACA,SAAS;AAAA,MACX,CAAC;AAAA,IACH;AAAA,EACF;AACF;AA0CA,eAAsB,2BACpB,MACA,WACA,iBACiB;AACjB,MAAI;AACF,UAAM,aAAa,gBAAgB,OAAO,MAAM,KAAK,KAAK,IAAI;AAC9D,WAAO,MAAM,gBAAgB,OAAO;AAAA,MAClC;AAAA,MACA;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,6CAA6C,KAAK,EAAE;AAAA,EACtE;AACF;AAkDA,eAAsB,4BACpB,eACA,YACA,iBACiB;AACjB,MAAI;AACF,WAAO,MAAM,gBAAgB,OAAO;AAAA,MAClC;AAAA,MACA;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,8CAA8C,KAAK,EAAE;AAAA,EACvE;AACF;AAUA,eAAsB,eACpB,SACA,WACA,iBACiB;AACjB,MAAI;AACF,WAAO,MAAM,gBAAgB,OAAO;AAAA,MAClC;AAAA,MACA;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,+BAA+B,KAAK,EAAE;AAAA,EACxD;AACF;AAQA,eAAsB,wBACpB,iBAIC;AACD,MAAI;AAEF,UAAM,UAAU,MAAM,gBAAgB,OAAO,gBAAgB;AAI7D,WAAO;AAAA,MACL,IAAI,QAAQ,UAAU,UAAU,GAAG,EAAE;AAAA,MACrC,KAAK,QAAQ,WAAW,UAAU,GAAG,EAAE;AAAA,IACzC;AAAA,EACF,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,6CAA6C,KAAK,EAAE;AAAA,EACtE;AACF;AAUA,eAAsB,sBACpB,eACA,YACA,iBACiB;AACjB,MAAI;AACF,WAAO,MAAM,gBAAgB,OAAO;AAAA,MAClC;AAAA,MACA;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,uCAAuC,KAAK,EAAE;AAAA,EAChE;AACF;AAwCA,eAAsB,yBACpB,MACA,KACA,iBACe;AACf,MAAI;AAEF,UAAM,aACJ,gBAAgB,OACZ,MAAM,KAAK,YAAY,IACvB,IAAI,YAAY,EAAE,OAAO,IAAI;AACnC,UAAM,YAAY,IAAI,WAAW,UAAU;AAG3C,UAAM,YAAY,MAAM,gBAAgB,OAAO;AAAA,MAC7C;AAAA,MACA;AAAA,IACF;AAGA,UAAM,uBAAuB,UAAU,OAAO;AAAA,MAC5C,UAAU;AAAA,MACV,UAAU,aAAa,UAAU;AAAA,IACnC;AAEA,WAAO,IAAI,KAAK,CAAC,oBAAoB,GAAG;AAAA,MACtC,MAAM;AAAA,IACR,CAAC;AAAA,EACH,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,2BAA2B,KAAK,EAAE;AAAA,EACpD;AACF;AAQA,eAAsB,0BACpB,iBAIC;AACD,MAAI;AACF,WAAO,MAAM,gBAAgB,OAAO,gBAAgB;AAAA,EACtD,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,2CAA2C,KAAK,EAAE;AAAA,EACpE;AACF;AAYA,eAAsB,mBACpB,iBACA,SAKoD;AACpD,MAAI;AACF,WAAO,MAAM,gBAAgB,IAAI,gBAAgB,OAAO;AAAA,EAC1D,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,oCAAoC,KAAK,EAAE;AAAA,EAC7D;AACF;AAkDA,eAAsB,yBACpB,eACA,KACA,iBACe;AACf,MAAI;AAEF,UAAM,kBACJ,yBAAyB,OACrB,MAAM,cAAc,YAAY,IAChC,IAAI,YAAY,EAAE,OAAO,aAAa;AAC5C,UAAM,iBAAiB,IAAI,WAAW,eAAe;AAGrD,UAAM,YAAY,MAAM,gBAAgB,OAAO;AAAA,MAC7C;AAAA,MACA;AAAA,IACF;AAGA,UAAM,uBAAuB,UAAU,OAAO;AAAA,MAC5C,UAAU;AAAA,MACV,UAAU,aAAa,UAAU;AAAA,IACnC;AAGA,WAAO,IAAI,KAAK,CAAC,oBAAoB,GAAG,EAAE,MAAM,aAAa,CAAC;AAAA,EAChE,SAAS,OAAO;AACd,UAAM,IAAI,MAAM,2BAA2B,KAAK,EAAE;AAAA,EACpD;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/encryption.ts"],"sourcesContent":["/**\n * Canonical Vana Protocol Encryption Functions\n *\n * These functions define the standard way user data is encrypted/decrypted in Vana.\n * All applications should use these canonical functions to ensure compatibility\n * with existing encrypted data on the Vana network.\n *\n * This module uses the platform adapter pattern to provide consistent\n * encryption functionality across Node.js and browser environments.\n */\n\nimport type { WalletClient } from \"viem\";\nimport type { VanaPlatformAdapter } from \"../platform/interface\";\nimport { withSignatureCache } from \"./signatureCache\";\n\n/**\n * Default encryption seed message used throughout Vana protocol\n */\nexport const DEFAULT_ENCRYPTION_SEED =\n  \"Please sign to retrieve your encryption key\";\n\n/**\n * Generate an encryption key by signing the canonical Vana encryption seed\n *\n * This is the standard protocol function for creating encryption keys in Vana.\n * The signature serves as a symmetric encryption key for user data.\n *\n * @param wallet The user's wallet client for signing\n * @param platformAdapter Platform adapter for cache operations\n * @param seed Optional custom encryption seed (defaults to Vana standard)\n * @returns The signature that serves as the encryption key\n * @throws {Error} When wallet account is required but not provided\n * @example\n * ```typescript\n * const encryptionKey = await generateEncryptionKey(walletClient, platformAdapter);\n * console.log('Generated encryption key:', encryptionKey);\n *\n * // Use with custom seed\n * const customKey = await generateEncryptionKey(walletClient, platformAdapter, 'my-custom-seed');\n * ```\n */\nexport async function generateEncryptionKey(\n  wallet: WalletClient,\n  platformAdapter: VanaPlatformAdapter,\n  seed: string = DEFAULT_ENCRYPTION_SEED,\n): Promise<string> {\n  if (!wallet.account) {\n    throw new Error(\"Wallet account is required for encryption key generation\");\n  }\n\n  // Store account reference to satisfy TypeScript\n  const { account } = wallet;\n\n  // Use signature cache for encryption key generation\n  // Create a simple message object for cache key generation\n  const messageData = { message: seed };\n\n  return await withSignatureCache(\n    platformAdapter.cache,\n    account.address,\n    messageData,\n    async () => {\n      // Sign the encryption seed to generate a deterministic encryption key\n      return await wallet.signMessage({\n        account,\n        message: seed,\n      });\n    },\n  );\n}\n\n/**\n * Encrypts data using a wallet's public key for secure sharing with specific recipients.\n *\n * @remarks\n * This function implements asymmetric encryption using the recipient's public key,\n * enabling secure data sharing where only the holder of the corresponding private key\n * can decrypt the data. It automatically handles different data types and uses\n * platform-appropriate cryptographic libraries for maximum compatibility.\n *\n * This is commonly used when granting permissions to applications or servers,\n * where the data needs to be encrypted for a specific recipient's public key.\n *\n * @param data - The data to encrypt (string or Blob)\n * @param publicKey - The recipient's public key in hexadecimal format\n * @param platformAdapter - The platform adapter providing cryptographic operations\n * @returns Promise resolving to the encrypted data as a string\n * @throws {Error} When encryption fails due to invalid key or data format\n * @example\n * ```typescript\n * // Encrypt data for a specific application's public key\n * const appPublicKey = \"0x04a1b2c3...\"; // Application's public key\n * const sensitiveData = \"User's private information\";\n *\n * const encrypted = await encryptWithWalletPublicKey(\n *   sensitiveData,\n *   appPublicKey,\n *   platformAdapter\n * );\n *\n * console.log('Encrypted for app:', encrypted);\n *\n * // Encrypt file data for server processing\n * const fileBlob = new File(['{\"name\":\"John\",\"age\":30}'], 'profile.json');\n * const encryptedFile = await encryptWithWalletPublicKey(\n *   fileBlob,\n *   serverPublicKey,\n *   platformAdapter\n * );\n * ```\n */\nexport async function encryptWithWalletPublicKey(\n  data: string | Blob,\n  publicKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    const dataString = data instanceof Blob ? await data.text() : data;\n    return await platformAdapter.crypto.encryptWithWalletPublicKey(\n      dataString,\n      publicKey,\n    );\n  } catch (error) {\n    throw new Error(\n      `Failed to encrypt with wallet public key: ${String(error)}`,\n    );\n  }\n}\n\n/**\n * Decrypts data that was encrypted with the corresponding public key.\n *\n * @remarks\n * This function performs asymmetric decryption using the recipient's private key\n * to decrypt data that was encrypted with the corresponding public key. It's the\n * counterpart to `encryptWithWalletPublicKey` and is typically used by applications\n * or servers to decrypt data that was shared with them by users.\n *\n * The function automatically handles platform-specific cryptographic operations\n * and provides consistent behavior across browser and Node.js environments.\n *\n * @param encryptedData - The encrypted data string to decrypt\n * @param privateKey - The private key corresponding to the public key used for encryption\n * @param platformAdapter - The platform adapter providing cryptographic operations\n * @returns Promise resolving to the decrypted data as a string\n * @throws {Error} When decryption fails due to invalid key, corrupted data, or key mismatch\n * @example\n * ```typescript\n * // Decrypt data received from a user (server-side)\n * const encryptedUserData = \"encrypted_string_from_user\";\n * const serverPrivateKey = process.env.SERVER_PRIVATE_KEY;\n *\n * const decrypted = await decryptWithWalletPrivateKey(\n *   encryptedUserData,\n *   serverPrivateKey,\n *   platformAdapter\n * );\n *\n * const userData = JSON.parse(decrypted);\n * console.log('User data:', userData);\n *\n * // Handle decryption errors gracefully\n * try {\n *   const result = await decryptWithWalletPrivateKey(\n *     encryptedData,\n *     privateKey,\n *     platformAdapter\n *   );\n * } catch (error) {\n *   if (error.message.includes('invalid key')) {\n *     console.error('Key mismatch - data not encrypted for this recipient');\n *   } else {\n *     console.error('Decryption failed:', error.message);\n *   }\n * }\n * ```\n */\nexport async function decryptWithWalletPrivateKey(\n  encryptedData: string,\n  privateKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    return await platformAdapter.crypto.decryptWithWalletPrivateKey(\n      encryptedData,\n      privateKey,\n    );\n  } catch (error) {\n    throw new Error(\n      `Failed to decrypt with wallet private key: ${String(error)}`,\n    );\n  }\n}\n\n/**\n * Encrypt a file key with a DLP's public key using platform-appropriate cryptography\n *\n * @param fileKey The symmetric key used to encrypt the file\n * @param publicKey The DLP's public key\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns The encrypted key that can be stored on-chain\n */\nexport async function encryptFileKey(\n  fileKey: string,\n  publicKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    return await platformAdapter.crypto.encryptWithPublicKey(\n      fileKey,\n      publicKey,\n    );\n  } catch (error) {\n    throw new Error(`Failed to encrypt file key: ${String(error)}`);\n  }\n}\n\n/**\n * Generate encryption parameters for secure file storage\n *\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns An object containing the initialization vector and encryption key\n */\nexport async function getEncryptionParameters(\n  platformAdapter: VanaPlatformAdapter,\n): Promise<{\n  iv: string;\n  key: string;\n}> {\n  try {\n    // Generate a new key pair for encryption parameters\n    const keyPair = await platformAdapter.crypto.generateKeyPair();\n\n    // Use parts of the generated keys as IV and key\n    // In production, this would use proper key derivation\n    return {\n      iv: keyPair.publicKey.substring(0, 16),\n      key: keyPair.privateKey.substring(0, 32),\n    };\n  } catch (error) {\n    throw new Error(\n      `Failed to generate encryption parameters: ${String(error)}`,\n    );\n  }\n}\n\n/**\n * Decrypt data that was encrypted with the DLP's public key using platform-appropriate cryptography\n *\n * @param encryptedData The encrypted data\n * @param privateKey The private key corresponding to the public key used for encryption\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns The decrypted data\n */\nexport async function decryptWithPrivateKey(\n  encryptedData: string,\n  privateKey: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<string> {\n  try {\n    return await platformAdapter.crypto.decryptWithPrivateKey(\n      encryptedData,\n      privateKey,\n    );\n  } catch (error) {\n    throw new Error(`Failed to decrypt with private key: ${String(error)}`);\n  }\n}\n\n/**\n * Encrypts data using a signed key generated from the user's wallet signature.\n *\n * @remarks\n * This is a pure cryptographic primitive that encrypts data using the Vana protocol's\n * standard encryption method. The key parameter must be a signature generated by the\n * `generateEncryptionKey` utility - this ensures deterministic key generation from the\n * user's wallet, enabling the same key to be regenerated for decryption.\n *\n * This function uses password-based encryption with the signature as the password,\n * providing symmetric encryption that can be decrypted with the same signature.\n *\n * @param data The data to encrypt (string or Blob)\n * @param key The signed key from `generateEncryptionKey` - MUST be a wallet signature\n * @param platformAdapter The platform adapter for crypto operations\n * @returns The encrypted data as Blob\n * @throws {Error} When encryption fails\n *\n * @example\n * ```typescript\n * // Generate the encryption key from wallet signature\n * const encryptionKey = await generateEncryptionKey(walletClient);\n *\n * // Encrypt data with the signed key\n * const encryptedBlob = await encryptBlobWithSignedKey(\n *   \"My sensitive data\",\n *   encryptionKey,\n *   platformAdapter\n * );\n *\n * // Later, decrypt with the same key\n * const decryptedBlob = await decryptBlobWithSignedKey(\n *   encryptedBlob,\n *   encryptionKey,\n *   platformAdapter\n * );\n * ```\n */\nexport async function encryptBlobWithSignedKey(\n  data: string | Blob,\n  key: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<Blob> {\n  try {\n    // Convert data to binary for encryption\n    const dataBuffer =\n      data instanceof Blob\n        ? await data.arrayBuffer()\n        : new TextEncoder().encode(data);\n    const dataArray = new Uint8Array(dataBuffer);\n\n    // Use platform adapter's password-based encryption\n    const encrypted = await platformAdapter.crypto.encryptWithPassword(\n      dataArray,\n      key,\n    );\n\n    // Convert Uint8Array<ArrayBufferLike> to ArrayBuffer to satisfy BlobPart type\n    const encryptedArrayBuffer = encrypted.buffer.slice(\n      encrypted.byteOffset,\n      encrypted.byteOffset + encrypted.byteLength,\n    ) as ArrayBuffer;\n\n    return new Blob([encryptedArrayBuffer], {\n      type: \"application/octet-stream\",\n    });\n  } catch (error) {\n    throw new Error(`Failed to encrypt data: ${String(error)}`);\n  }\n}\n\n/**\n * Generate a new key pair for asymmetric encryption\n *\n * @param platformAdapter - The platform adapter for crypto operations\n * @returns Promise resolving to public and private key pair\n */\nexport async function generateEncryptionKeyPair(\n  platformAdapter: VanaPlatformAdapter,\n): Promise<{\n  publicKey: string;\n  privateKey: string;\n}> {\n  try {\n    return await platformAdapter.crypto.generateKeyPair();\n  } catch (error) {\n    throw new Error(`Failed to generate encryption key pair: ${String(error)}`);\n  }\n}\n\n/**\n * Generate a new PGP key pair with platform-appropriate configuration\n *\n * @param platformAdapter - The platform adapter for crypto operations\n * @param options - Key generation options\n * @param options.name - The name for the PGP key\n * @param options.email - The email for the PGP key\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Promise resolving to public and private key pair\n */\nexport async function generatePGPKeyPair(\n  platformAdapter: VanaPlatformAdapter,\n  options?: {\n    name?: string;\n    email?: string;\n    passphrase?: string;\n  },\n): Promise<{ publicKey: string; privateKey: string }> {\n  try {\n    return await platformAdapter.pgp.generateKeyPair(options);\n  } catch (error) {\n    throw new Error(`Failed to generate PGP key pair: ${String(error)}`);\n  }\n}\n\n/**\n * Decrypts data using a signed key generated from the user's wallet signature.\n *\n * @remarks\n * This is a pure cryptographic primitive for decrypting data that was encrypted using\n * `encryptBlobWithSignedKey`. It is network-agnostic and only handles decryption - it does\n * not fetch data from any URL or make network requests. To decrypt a file from a URL, you\n * must first fetch the encrypted blob using one of the fetch utilities, then pass it to\n * this function.\n *\n * The key parameter must be the same signature that was used for encryption, typically\n * generated by the `generateEncryptionKey` utility. This ensures that only the user who\n * encrypted the data (or someone with the same wallet signature) can decrypt it.\n *\n * @param encryptedData The encrypted data to decrypt (string or Blob)\n * @param key The signed key from `generateEncryptionKey` - MUST be the same wallet signature used for encryption\n * @param platformAdapter The platform adapter for crypto operations\n * @returns Promise resolving to the decrypted blob\n * @throws {Error} When decryption fails due to wrong key or corrupted data\n *\n * @example\n * ```typescript\n * // Generate the same encryption key used for encryption\n * const encryptionKey = await generateEncryptionKey(walletClient);\n *\n * // Fetch and decrypt using the high-level API\n * const file = await vana.data.getUserFiles({ owner: \"0x...\" })[0];\n * const decryptedBlob = await vana.data.decryptFile(file);\n *\n * // Or use the low-level primitives directly\n * const encryptedBlob = await vana.data.fetch(file.url);\n * const decryptedBlob = await decryptBlobWithSignedKey(\n *   encryptedBlob,\n *   encryptionKey,\n *   platformAdapter\n * );\n *\n * // With IPFS gateway fallback\n * const encryptedBlob = await vana.data.fetchFromIPFS(file.url, {\n *   gateways: ['https://my-gateway.com/ipfs/', 'https://ipfs.io/ipfs/']\n * });\n * const decryptedBlob = await decryptBlobWithSignedKey(\n *   encryptedBlob,\n *   encryptionKey,\n *   platformAdapter\n * );\n * ```\n */\nexport async function decryptBlobWithSignedKey(\n  encryptedData: string | Blob,\n  key: string,\n  platformAdapter: VanaPlatformAdapter,\n): Promise<Blob> {\n  try {\n    // Convert encrypted data to proper format\n    const encryptedBuffer =\n      encryptedData instanceof Blob\n        ? await encryptedData.arrayBuffer()\n        : new TextEncoder().encode(encryptedData);\n    const encryptedArray = new Uint8Array(encryptedBuffer);\n\n    // Use platform adapter's password-based decryption\n    const decrypted = await platformAdapter.crypto.decryptWithPassword(\n      encryptedArray,\n      key,\n    );\n\n    // Convert Uint8Array<ArrayBufferLike> to ArrayBuffer to satisfy BlobPart type\n    const decryptedArrayBuffer = decrypted.buffer.slice(\n      decrypted.byteOffset,\n      decrypted.byteOffset + decrypted.byteLength,\n    ) as ArrayBuffer;\n\n    // Convert decrypted data back to Blob\n    return new Blob([decryptedArrayBuffer], { type: \"text/plain\" });\n  } catch (error) {\n    throw new Error(`Failed to decrypt data: ${String(error)}`);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/utils/formatters.cjs

@@ -29,10 +29,12 @@ function formatNumber(value) {
   return Number(value);
 }
 function formatEth(wei, decimals = 4) {
-  return (0, import_viem.formatEther)(BigInt(wei.toString())).slice(0, decimals + 2);
+  const weiValue = typeof wei === "bigint" ? wei : BigInt(wei);
+  return (0, import_viem.formatEther)(weiValue).slice(0, decimals + 2);
 }
 function formatToken(amount, decimals = 18, displayDecimals = 4) {
-  const value = (0, import_viem.formatUnits)(BigInt(amount.toString()), decimals);
+  const amountValue = typeof amount === "bigint" ? amount : BigInt(amount);
+  const value = (0, import_viem.formatUnits)(amountValue, decimals);
   const parts = value.split(".");
   if (parts.length === 1) {
     return parts[0];

package/dist/utils/formatters.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/formatters.ts"],"sourcesContent":["import { formatEther, formatUnits } from \"viem\";\n\n/**\n * Format a bigint or BigNumber to a regular number\n *\n * @remarks\n * This function converts blockchain-specific large number types to standard JavaScript\n * numbers. Use with caution for values that may exceed safe integer range.\n *\n * **Edge Cases:**\n * - Values exceeding JavaScript's MAX_SAFE_INTEGER (2^53-1) lose precision\n * - Negative values are supported\n * - String values must be valid numeric strings or will return NaN\n *\n * @param value BigInt, BigNumber or numeric string to convert\n * @returns Regular JavaScript number\n * @example\n * ```typescript\n * formatNumber(1000000000000000000n) // Returns: 1000000000000000000\n * formatNumber(\"123456789\") // Returns: 123456789\n * formatNumber(-100n) // Returns: -100\n *\n * // Precision loss example:\n * const bigValue = 9007199254740993n; // MAX_SAFE_INTEGER + 2\n * formatNumber(bigValue) // Returns: 9007199254740992 (lost precision)\n * ```\n */\nexport function formatNumber(value: bigint | string | number): number {\n  return Number(value);\n}\n\n/**\n * Format wei value to ETH with specified decimal places\n *\n * @remarks\n * Converts wei (smallest ETH unit) to human-readable ETH format.\n * 1 ETH = 10^18 wei. The function truncates rather than rounds\n * to ensure predictable display in financial contexts.\n *\n * **Edge Cases:**\n * - Truncates (not rounds) to specified decimal places\n * - Negative values are supported\n * - Zero values return \"0.0000\" (based on decimals)\n * - Very small values may display as \"0.0000\" due to truncation\n *\n * @param wei Value in wei (as bigint, string, or number)\n * @param decimals Number of decimal places to display (default: 4)\n * @returns Formatted ETH value as string\n * @example\n * ```typescript\n * // Standard conversions\n * formatEth(1000000000000000000n) // Returns: \"1.0000\"\n * formatEth(1500000000000000000n, 2) // Returns: \"1.50\"\n * formatEth(\"2000000000000000000\") // Returns: \"2.0000\"\n *\n * // Edge cases\n * formatEth(1000000000000000n) // Returns: \"0.0010\" (0.001 ETH)\n * formatEth(100000000000000n) // Returns: \"0.0001\"\n * formatEth(10000000000000n) // Returns: \"0.0000\" (truncated)\n * formatEth(-1000000000000000000n) // Returns: \"-1.000\"\n * ```\n */\nexport function formatEth(wei: bigint | string | number, decimals = 4): string {\n  return formatEther(BigInt(wei.toString())).slice(0, decimals + 2);\n}\n\n/**\n * Format a token amount based on its decimals\n *\n * @remarks\n * Generic token formatter that handles any ERC20-style token with\n * configurable decimal places. Most tokens use 18 decimals like ETH,\n * but some use different values (e.g., USDC uses 6).\n *\n * @param amount Raw token amount\n * @param decimals Token decimals (default: 18)\n * @param displayDecimals Decimals to show in formatted output (default: 4)\n * @returns Formatted token amount as string\n * @example\n * ```typescript\n * // 18 decimal token (like ETH)\n * formatToken(1000000000000000000n) // Returns: \"1.0000\"\n * formatToken(1500000000000000000n, 18, 2) // Returns: \"1.50\"\n *\n * // 6 decimal token (like USDC)\n * formatToken(1000000n, 6) // Returns: \"1.0000\"\n * formatToken(1500000n, 6, 2) // Returns: \"1.50\"\n *\n * // Whole numbers\n * formatToken(5000000000000000000n) // Returns: \"5\"\n * formatToken(5123456789000000000n, 18, 6) // Returns: \"5.123456\"\n * ```\n */\nexport function formatToken(\n  amount: bigint | string | number,\n  decimals = 18,\n  displayDecimals = 4,\n): string {\n  const value = formatUnits(BigInt(amount.toString()), decimals);\n  const parts = value.split(\".\");\n\n  if (parts.length === 1) {\n    return parts[0];\n  }\n\n  return `${parts[0]}.${parts[1].slice(0, displayDecimals)}`;\n}\n\n/**\n * Format an address for display (showing first 6 and last 4 characters)\n *\n * @remarks\n * Creates a human-readable abbreviated version of Ethereum addresses\n * for UI display. Preserves enough characters to maintain uniqueness\n * while saving screen space. Does not validate address format.\n *\n * **Edge Cases:**\n * - Addresses shorter than 10 characters are returned unchanged\n * - Works with both checksummed and lowercase addresses\n * - Does not validate address format\n *\n * @param address EVM address\n * @returns Shortened address string\n * @example\n * ```typescript\n * // Standard addresses\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Checksummed address\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Edge cases\n * shortenAddress(\"0x123\") // Returns: \"0x123\" (too short)\n * shortenAddress(\"\") // Returns: \"\"\n * shortenAddress(\"not-an-address\") // Returns: \"not-an...ress\"\n * ```\n */\nexport function shortenAddress(address: string): string {\n  if (!address || address.length < 10) return address;\n  return `${address.slice(0, 6)}...${address.slice(-4)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAyC;AA2BlC,SAAS,aAAa,OAAyC;AACpE,SAAO,OAAO,KAAK;AACrB;AAiCO,SAAS,UAAU,KAA+B,WAAW,GAAW;AAC7E,aAAO,yBAAY,OAAO,IAAI,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;AAClE;AA6BO,SAAS,YACd,QACA,WAAW,IACX,kBAAkB,GACV;AACR,QAAM,YAAQ,yBAAY,OAAO,OAAO,SAAS,CAAC,GAAG,QAAQ;AAC7D,QAAM,QAAQ,MAAM,MAAM,GAAG;AAE7B,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,MAAM,CAAC;AAAA,EAChB;AAEA,SAAO,GAAG,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;AAC1D;AAiCO,SAAS,eAAe,SAAyB;AACtD,MAAI,CAAC,WAAW,QAAQ,SAAS,GAAI,QAAO;AAC5C,SAAO,GAAG,QAAQ,MAAM,GAAG,CAAC,CAAC,MAAM,QAAQ,MAAM,EAAE,CAAC;AACtD;","names":[]}
+{"version":3,"sources":["../../src/utils/formatters.ts"],"sourcesContent":["import { formatEther, formatUnits } from \"viem\";\n\n/**\n * Format a bigint or BigNumber to a regular number\n *\n * @remarks\n * This function converts blockchain-specific large number types to standard JavaScript\n * numbers. Use with caution for values that may exceed safe integer range.\n *\n * **Edge Cases:**\n * - Values exceeding JavaScript's MAX_SAFE_INTEGER (2^53-1) lose precision\n * - Negative values are supported\n * - String values must be valid numeric strings or will return NaN\n *\n * @param value BigInt, BigNumber or numeric string to convert\n * @returns Regular JavaScript number\n * @example\n * ```typescript\n * formatNumber(1000000000000000000n) // Returns: 1000000000000000000\n * formatNumber(\"123456789\") // Returns: 123456789\n * formatNumber(-100n) // Returns: -100\n *\n * // Precision loss example:\n * const bigValue = 9007199254740993n; // MAX_SAFE_INTEGER + 2\n * formatNumber(bigValue) // Returns: 9007199254740992 (lost precision)\n * ```\n */\nexport function formatNumber(value: bigint | string | number): number {\n  return Number(value);\n}\n\n/**\n * Format wei value to ETH with specified decimal places\n *\n * @remarks\n * Converts wei (smallest ETH unit) to human-readable ETH format.\n * 1 ETH = 10^18 wei. The function truncates rather than rounds\n * to ensure predictable display in financial contexts.\n *\n * **Edge Cases:**\n * - Truncates (not rounds) to specified decimal places\n * - Negative values are supported\n * - Zero values return \"0.0000\" (based on decimals)\n * - Very small values may display as \"0.0000\" due to truncation\n *\n * @param wei Value in wei (as bigint, string, or number)\n * @param decimals Number of decimal places to display (default: 4)\n * @returns Formatted ETH value as string\n * @example\n * ```typescript\n * // Standard conversions\n * formatEth(1000000000000000000n) // Returns: \"1.0000\"\n * formatEth(1500000000000000000n, 2) // Returns: \"1.50\"\n * formatEth(\"2000000000000000000\") // Returns: \"2.0000\"\n *\n * // Edge cases\n * formatEth(1000000000000000n) // Returns: \"0.0010\" (0.001 ETH)\n * formatEth(100000000000000n) // Returns: \"0.0001\"\n * formatEth(10000000000000n) // Returns: \"0.0000\" (truncated)\n * formatEth(-1000000000000000000n) // Returns: \"-1.000\"\n * ```\n */\nexport function formatEth(wei: bigint | string | number, decimals = 4): string {\n  const weiValue = typeof wei === \"bigint\" ? wei : BigInt(wei);\n  return formatEther(weiValue).slice(0, decimals + 2);\n}\n\n/**\n * Format a token amount based on its decimals\n *\n * @remarks\n * Generic token formatter that handles any ERC20-style token with\n * configurable decimal places. Most tokens use 18 decimals like ETH,\n * but some use different values (e.g., USDC uses 6).\n *\n * @param amount Raw token amount\n * @param decimals Token decimals (default: 18)\n * @param displayDecimals Decimals to show in formatted output (default: 4)\n * @returns Formatted token amount as string\n * @example\n * ```typescript\n * // 18 decimal token (like ETH)\n * formatToken(1000000000000000000n) // Returns: \"1.0000\"\n * formatToken(1500000000000000000n, 18, 2) // Returns: \"1.50\"\n *\n * // 6 decimal token (like USDC)\n * formatToken(1000000n, 6) // Returns: \"1.0000\"\n * formatToken(1500000n, 6, 2) // Returns: \"1.50\"\n *\n * // Whole numbers\n * formatToken(5000000000000000000n) // Returns: \"5\"\n * formatToken(5123456789000000000n, 18, 6) // Returns: \"5.123456\"\n * ```\n */\nexport function formatToken(\n  amount: bigint | string | number,\n  decimals = 18,\n  displayDecimals = 4,\n): string {\n  const amountValue = typeof amount === \"bigint\" ? amount : BigInt(amount);\n  const value = formatUnits(amountValue, decimals);\n  const parts = value.split(\".\");\n\n  if (parts.length === 1) {\n    return parts[0];\n  }\n\n  return `${parts[0]}.${parts[1].slice(0, displayDecimals)}`;\n}\n\n/**\n * Format an address for display (showing first 6 and last 4 characters)\n *\n * @remarks\n * Creates a human-readable abbreviated version of Ethereum addresses\n * for UI display. Preserves enough characters to maintain uniqueness\n * while saving screen space. Does not validate address format.\n *\n * **Edge Cases:**\n * - Addresses shorter than 10 characters are returned unchanged\n * - Works with both checksummed and lowercase addresses\n * - Does not validate address format\n *\n * @param address EVM address\n * @returns Shortened address string\n * @example\n * ```typescript\n * // Standard addresses\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Checksummed address\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Edge cases\n * shortenAddress(\"0x123\") // Returns: \"0x123\" (too short)\n * shortenAddress(\"\") // Returns: \"\"\n * shortenAddress(\"not-an-address\") // Returns: \"not-an...ress\"\n * ```\n */\nexport function shortenAddress(address: string): string {\n  if (!address || address.length < 10) return address;\n  return `${address.slice(0, 6)}...${address.slice(-4)}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAyC;AA2BlC,SAAS,aAAa,OAAyC;AACpE,SAAO,OAAO,KAAK;AACrB;AAiCO,SAAS,UAAU,KAA+B,WAAW,GAAW;AAC7E,QAAM,WAAW,OAAO,QAAQ,WAAW,MAAM,OAAO,GAAG;AAC3D,aAAO,yBAAY,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC;AACpD;AA6BO,SAAS,YACd,QACA,WAAW,IACX,kBAAkB,GACV;AACR,QAAM,cAAc,OAAO,WAAW,WAAW,SAAS,OAAO,MAAM;AACvE,QAAM,YAAQ,yBAAY,aAAa,QAAQ;AAC/C,QAAM,QAAQ,MAAM,MAAM,GAAG;AAE7B,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,MAAM,CAAC;AAAA,EAChB;AAEA,SAAO,GAAG,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;AAC1D;AAiCO,SAAS,eAAe,SAAyB;AACtD,MAAI,CAAC,WAAW,QAAQ,SAAS,GAAI,QAAO;AAC5C,SAAO,GAAG,QAAQ,MAAM,GAAG,CAAC,CAAC,MAAM,QAAQ,MAAM,EAAE,CAAC;AACtD;","names":[]}

package/dist/utils/formatters.d.ts

@@ -23,7 +23,7 @@
  * formatNumber(bigValue) // Returns: 9007199254740992 (lost precision)
  * ```
  */
-declare function formatNumber(value: bigint | string | number): number;
+export declare function formatNumber(value: bigint | string | number): number;
 /**
  * Format wei value to ETH with specified decimal places
  *
@@ -55,7 +55,7 @@ declare function formatNumber(value: bigint | string | number): number;
  * formatEth(-1000000000000000000n) // Returns: "-1.000"
  * ```
  */
-declare function formatEth(wei: bigint | string | number, decimals?: number): string;
+export declare function formatEth(wei: bigint | string | number, decimals?: number): string;
 /**
  * Format a token amount based on its decimals
  *
@@ -83,7 +83,7 @@ declare function formatEth(wei: bigint | string | number, decimals?: number): st
  * formatToken(5123456789000000000n, 18, 6) // Returns: "5.123456"
  * ```
  */
-declare function formatToken(amount: bigint | string | number, decimals?: number, displayDecimals?: number): string;
+export declare function formatToken(amount: bigint | string | number, decimals?: number, displayDecimals?: number): string;
 /**
  * Format an address for display (showing first 6 and last 4 characters)
  *
@@ -115,6 +115,4 @@ declare function formatToken(amount: bigint | string | number, decimals?: number
  * shortenAddress("not-an-address") // Returns: "not-an...ress"
  * ```
  */
-declare function shortenAddress(address: string): string;
-
-export { formatEth, formatNumber, formatToken, shortenAddress };
+export declare function shortenAddress(address: string): string;

package/dist/utils/formatters.js

@@ -3,10 +3,12 @@ function formatNumber(value) {
   return Number(value);
 }
 function formatEth(wei, decimals = 4) {
-  return formatEther(BigInt(wei.toString())).slice(0, decimals + 2);
+  const weiValue = typeof wei === "bigint" ? wei : BigInt(wei);
+  return formatEther(weiValue).slice(0, decimals + 2);
 }
 function formatToken(amount, decimals = 18, displayDecimals = 4) {
-  const value = formatUnits(BigInt(amount.toString()), decimals);
+  const amountValue = typeof amount === "bigint" ? amount : BigInt(amount);
+  const value = formatUnits(amountValue, decimals);
   const parts = value.split(".");
   if (parts.length === 1) {
     return parts[0];

package/dist/utils/formatters.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/formatters.ts"],"sourcesContent":["import { formatEther, formatUnits } from \"viem\";\n\n/**\n * Format a bigint or BigNumber to a regular number\n *\n * @remarks\n * This function converts blockchain-specific large number types to standard JavaScript\n * numbers. Use with caution for values that may exceed safe integer range.\n *\n * **Edge Cases:**\n * - Values exceeding JavaScript's MAX_SAFE_INTEGER (2^53-1) lose precision\n * - Negative values are supported\n * - String values must be valid numeric strings or will return NaN\n *\n * @param value BigInt, BigNumber or numeric string to convert\n * @returns Regular JavaScript number\n * @example\n * ```typescript\n * formatNumber(1000000000000000000n) // Returns: 1000000000000000000\n * formatNumber(\"123456789\") // Returns: 123456789\n * formatNumber(-100n) // Returns: -100\n *\n * // Precision loss example:\n * const bigValue = 9007199254740993n; // MAX_SAFE_INTEGER + 2\n * formatNumber(bigValue) // Returns: 9007199254740992 (lost precision)\n * ```\n */\nexport function formatNumber(value: bigint | string | number): number {\n  return Number(value);\n}\n\n/**\n * Format wei value to ETH with specified decimal places\n *\n * @remarks\n * Converts wei (smallest ETH unit) to human-readable ETH format.\n * 1 ETH = 10^18 wei. The function truncates rather than rounds\n * to ensure predictable display in financial contexts.\n *\n * **Edge Cases:**\n * - Truncates (not rounds) to specified decimal places\n * - Negative values are supported\n * - Zero values return \"0.0000\" (based on decimals)\n * - Very small values may display as \"0.0000\" due to truncation\n *\n * @param wei Value in wei (as bigint, string, or number)\n * @param decimals Number of decimal places to display (default: 4)\n * @returns Formatted ETH value as string\n * @example\n * ```typescript\n * // Standard conversions\n * formatEth(1000000000000000000n) // Returns: \"1.0000\"\n * formatEth(1500000000000000000n, 2) // Returns: \"1.50\"\n * formatEth(\"2000000000000000000\") // Returns: \"2.0000\"\n *\n * // Edge cases\n * formatEth(1000000000000000n) // Returns: \"0.0010\" (0.001 ETH)\n * formatEth(100000000000000n) // Returns: \"0.0001\"\n * formatEth(10000000000000n) // Returns: \"0.0000\" (truncated)\n * formatEth(-1000000000000000000n) // Returns: \"-1.000\"\n * ```\n */\nexport function formatEth(wei: bigint | string | number, decimals = 4): string {\n  return formatEther(BigInt(wei.toString())).slice(0, decimals + 2);\n}\n\n/**\n * Format a token amount based on its decimals\n *\n * @remarks\n * Generic token formatter that handles any ERC20-style token with\n * configurable decimal places. Most tokens use 18 decimals like ETH,\n * but some use different values (e.g., USDC uses 6).\n *\n * @param amount Raw token amount\n * @param decimals Token decimals (default: 18)\n * @param displayDecimals Decimals to show in formatted output (default: 4)\n * @returns Formatted token amount as string\n * @example\n * ```typescript\n * // 18 decimal token (like ETH)\n * formatToken(1000000000000000000n) // Returns: \"1.0000\"\n * formatToken(1500000000000000000n, 18, 2) // Returns: \"1.50\"\n *\n * // 6 decimal token (like USDC)\n * formatToken(1000000n, 6) // Returns: \"1.0000\"\n * formatToken(1500000n, 6, 2) // Returns: \"1.50\"\n *\n * // Whole numbers\n * formatToken(5000000000000000000n) // Returns: \"5\"\n * formatToken(5123456789000000000n, 18, 6) // Returns: \"5.123456\"\n * ```\n */\nexport function formatToken(\n  amount: bigint | string | number,\n  decimals = 18,\n  displayDecimals = 4,\n): string {\n  const value = formatUnits(BigInt(amount.toString()), decimals);\n  const parts = value.split(\".\");\n\n  if (parts.length === 1) {\n    return parts[0];\n  }\n\n  return `${parts[0]}.${parts[1].slice(0, displayDecimals)}`;\n}\n\n/**\n * Format an address for display (showing first 6 and last 4 characters)\n *\n * @remarks\n * Creates a human-readable abbreviated version of Ethereum addresses\n * for UI display. Preserves enough characters to maintain uniqueness\n * while saving screen space. Does not validate address format.\n *\n * **Edge Cases:**\n * - Addresses shorter than 10 characters are returned unchanged\n * - Works with both checksummed and lowercase addresses\n * - Does not validate address format\n *\n * @param address EVM address\n * @returns Shortened address string\n * @example\n * ```typescript\n * // Standard addresses\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Checksummed address\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Edge cases\n * shortenAddress(\"0x123\") // Returns: \"0x123\" (too short)\n * shortenAddress(\"\") // Returns: \"\"\n * shortenAddress(\"not-an-address\") // Returns: \"not-an...ress\"\n * ```\n */\nexport function shortenAddress(address: string): string {\n  if (!address || address.length < 10) return address;\n  return `${address.slice(0, 6)}...${address.slice(-4)}`;\n}\n"],"mappings":"AAAA,SAAS,aAAa,mBAAmB;AA2BlC,SAAS,aAAa,OAAyC;AACpE,SAAO,OAAO,KAAK;AACrB;AAiCO,SAAS,UAAU,KAA+B,WAAW,GAAW;AAC7E,SAAO,YAAY,OAAO,IAAI,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;AAClE;AA6BO,SAAS,YACd,QACA,WAAW,IACX,kBAAkB,GACV;AACR,QAAM,QAAQ,YAAY,OAAO,OAAO,SAAS,CAAC,GAAG,QAAQ;AAC7D,QAAM,QAAQ,MAAM,MAAM,GAAG;AAE7B,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,MAAM,CAAC;AAAA,EAChB;AAEA,SAAO,GAAG,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;AAC1D;AAiCO,SAAS,eAAe,SAAyB;AACtD,MAAI,CAAC,WAAW,QAAQ,SAAS,GAAI,QAAO;AAC5C,SAAO,GAAG,QAAQ,MAAM,GAAG,CAAC,CAAC,MAAM,QAAQ,MAAM,EAAE,CAAC;AACtD;","names":[]}
+{"version":3,"sources":["../../src/utils/formatters.ts"],"sourcesContent":["import { formatEther, formatUnits } from \"viem\";\n\n/**\n * Format a bigint or BigNumber to a regular number\n *\n * @remarks\n * This function converts blockchain-specific large number types to standard JavaScript\n * numbers. Use with caution for values that may exceed safe integer range.\n *\n * **Edge Cases:**\n * - Values exceeding JavaScript's MAX_SAFE_INTEGER (2^53-1) lose precision\n * - Negative values are supported\n * - String values must be valid numeric strings or will return NaN\n *\n * @param value BigInt, BigNumber or numeric string to convert\n * @returns Regular JavaScript number\n * @example\n * ```typescript\n * formatNumber(1000000000000000000n) // Returns: 1000000000000000000\n * formatNumber(\"123456789\") // Returns: 123456789\n * formatNumber(-100n) // Returns: -100\n *\n * // Precision loss example:\n * const bigValue = 9007199254740993n; // MAX_SAFE_INTEGER + 2\n * formatNumber(bigValue) // Returns: 9007199254740992 (lost precision)\n * ```\n */\nexport function formatNumber(value: bigint | string | number): number {\n  return Number(value);\n}\n\n/**\n * Format wei value to ETH with specified decimal places\n *\n * @remarks\n * Converts wei (smallest ETH unit) to human-readable ETH format.\n * 1 ETH = 10^18 wei. The function truncates rather than rounds\n * to ensure predictable display in financial contexts.\n *\n * **Edge Cases:**\n * - Truncates (not rounds) to specified decimal places\n * - Negative values are supported\n * - Zero values return \"0.0000\" (based on decimals)\n * - Very small values may display as \"0.0000\" due to truncation\n *\n * @param wei Value in wei (as bigint, string, or number)\n * @param decimals Number of decimal places to display (default: 4)\n * @returns Formatted ETH value as string\n * @example\n * ```typescript\n * // Standard conversions\n * formatEth(1000000000000000000n) // Returns: \"1.0000\"\n * formatEth(1500000000000000000n, 2) // Returns: \"1.50\"\n * formatEth(\"2000000000000000000\") // Returns: \"2.0000\"\n *\n * // Edge cases\n * formatEth(1000000000000000n) // Returns: \"0.0010\" (0.001 ETH)\n * formatEth(100000000000000n) // Returns: \"0.0001\"\n * formatEth(10000000000000n) // Returns: \"0.0000\" (truncated)\n * formatEth(-1000000000000000000n) // Returns: \"-1.000\"\n * ```\n */\nexport function formatEth(wei: bigint | string | number, decimals = 4): string {\n  const weiValue = typeof wei === \"bigint\" ? wei : BigInt(wei);\n  return formatEther(weiValue).slice(0, decimals + 2);\n}\n\n/**\n * Format a token amount based on its decimals\n *\n * @remarks\n * Generic token formatter that handles any ERC20-style token with\n * configurable decimal places. Most tokens use 18 decimals like ETH,\n * but some use different values (e.g., USDC uses 6).\n *\n * @param amount Raw token amount\n * @param decimals Token decimals (default: 18)\n * @param displayDecimals Decimals to show in formatted output (default: 4)\n * @returns Formatted token amount as string\n * @example\n * ```typescript\n * // 18 decimal token (like ETH)\n * formatToken(1000000000000000000n) // Returns: \"1.0000\"\n * formatToken(1500000000000000000n, 18, 2) // Returns: \"1.50\"\n *\n * // 6 decimal token (like USDC)\n * formatToken(1000000n, 6) // Returns: \"1.0000\"\n * formatToken(1500000n, 6, 2) // Returns: \"1.50\"\n *\n * // Whole numbers\n * formatToken(5000000000000000000n) // Returns: \"5\"\n * formatToken(5123456789000000000n, 18, 6) // Returns: \"5.123456\"\n * ```\n */\nexport function formatToken(\n  amount: bigint | string | number,\n  decimals = 18,\n  displayDecimals = 4,\n): string {\n  const amountValue = typeof amount === \"bigint\" ? amount : BigInt(amount);\n  const value = formatUnits(amountValue, decimals);\n  const parts = value.split(\".\");\n\n  if (parts.length === 1) {\n    return parts[0];\n  }\n\n  return `${parts[0]}.${parts[1].slice(0, displayDecimals)}`;\n}\n\n/**\n * Format an address for display (showing first 6 and last 4 characters)\n *\n * @remarks\n * Creates a human-readable abbreviated version of Ethereum addresses\n * for UI display. Preserves enough characters to maintain uniqueness\n * while saving screen space. Does not validate address format.\n *\n * **Edge Cases:**\n * - Addresses shorter than 10 characters are returned unchanged\n * - Works with both checksummed and lowercase addresses\n * - Does not validate address format\n *\n * @param address EVM address\n * @returns Shortened address string\n * @example\n * ```typescript\n * // Standard addresses\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Checksummed address\n * shortenAddress(\"0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36\")\n * // Returns: \"0x742d...Bd36\"\n *\n * // Edge cases\n * shortenAddress(\"0x123\") // Returns: \"0x123\" (too short)\n * shortenAddress(\"\") // Returns: \"\"\n * shortenAddress(\"not-an-address\") // Returns: \"not-an...ress\"\n * ```\n */\nexport function shortenAddress(address: string): string {\n  if (!address || address.length < 10) return address;\n  return `${address.slice(0, 6)}...${address.slice(-4)}`;\n}\n"],"mappings":"AAAA,SAAS,aAAa,mBAAmB;AA2BlC,SAAS,aAAa,OAAyC;AACpE,SAAO,OAAO,KAAK;AACrB;AAiCO,SAAS,UAAU,KAA+B,WAAW,GAAW;AAC7E,QAAM,WAAW,OAAO,QAAQ,WAAW,MAAM,OAAO,GAAG;AAC3D,SAAO,YAAY,QAAQ,EAAE,MAAM,GAAG,WAAW,CAAC;AACpD;AA6BO,SAAS,YACd,QACA,WAAW,IACX,kBAAkB,GACV;AACR,QAAM,cAAc,OAAO,WAAW,WAAW,SAAS,OAAO,MAAM;AACvE,QAAM,QAAQ,YAAY,aAAa,QAAQ;AAC/C,QAAM,QAAQ,MAAM,MAAM,GAAG;AAE7B,MAAI,MAAM,WAAW,GAAG;AACtB,WAAO,MAAM,CAAC;AAAA,EAChB;AAEA,SAAO,GAAG,MAAM,CAAC,CAAC,IAAI,MAAM,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;AAC1D;AAiCO,SAAS,eAAe,SAAyB;AACtD,MAAI,CAAC,WAAW,QAAQ,SAAS,GAAI,QAAO;AAC5C,SAAO,GAAG,QAAQ,MAAM,GAAG,CAAC,CAAC,MAAM,QAAQ,MAAM,EAAE,CAAC;AACtD;","names":[]}

package/dist/utils/grantFiles.cjs

@@ -68,9 +68,12 @@ async function storeGrantFile(grantFile, relayerUrl) {
     const responseData = await response.json();
     const data = responseData;
     if (!data.success) {
-      throw new import_errors.NetworkError(data.error || "Failed to store grant file");
+      throw new import_errors.NetworkError(data.error ?? "Failed to store grant file");
     }
-    return data.url || "";
+    if (!data.url) {
+      throw new import_errors.NetworkError("Upload succeeded but no URL was returned");
+    }
+    return data.url;
   } catch (error) {
     if (error instanceof import_errors.NetworkError) {
       throw error;
@@ -88,8 +91,8 @@ async function retrieveGrantFile(grantUrl, _relayerUrl, downloadRelayer) {
         `\u26A0\uFE0F  Grant URL uses HTTP gateway format instead of ipfs:// protocol. Found: ${grantUrl}. Consider using ipfs:// format for better protocol-agnostic storage.`
       );
     }
-    const { fetchWithRelayer } = await import("./download");
-    const response = await fetchWithRelayer(grantUrl, downloadRelayer);
+    const { universalFetch } = await import("./download");
+    const response = await universalFetch(grantUrl, downloadRelayer);
     if (!response.ok) {
       throw new import_errors.NetworkError(
         `Failed to retrieve grant file: HTTP ${response.status}`

package/dist/utils/grantFiles.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/grantFiles.ts"],"sourcesContent":["import { keccak256, toHex } from \"viem\";\nimport type { GrantFile, GrantPermissionParams } from \"../types/permissions\";\nimport { SerializationError, NetworkError } from \"../errors\";\n\ninterface GrantFileStorageResponse {\n  success: boolean;\n  error?: string;\n  url?: string;\n}\n\n/**\n * Creates a grant file structure from permission parameters.\n *\n * @remarks\n * This function constructs the JSON structure that represents a permission grant\n * in the Vana protocol. The grant file contains all necessary information for\n * a grantee to perform operations on behalf of the grantor.\n *\n * @param params - The permission parameters to create the grant file from\n * @returns The constructed grant file object\n * @example\n * ```typescript\n * const grantFile = createGrantFile({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'llm_inference',\n *   parameters: {\n *     model: 'gpt-4',\n *     maxTokens: 1000\n *   },\n *   expiresAt: Date.now() + 86400000 // 24 hours\n * });\n *\n * console.log(grantFile);\n * // {\n * //   grantee: '0x742d...',\n * //   operation: 'llm_inference',\n * //   parameters: { model: 'gpt-4', maxTokens: 1000 },\n * //   expires: 1234567890\n * // }\n * ```\n */\nexport function createGrantFile(params: GrantPermissionParams): GrantFile {\n  const grantFile: GrantFile = {\n    grantee: params.grantee,\n    operation: params.operation,\n    parameters: params.parameters,\n  };\n\n  // Add expiration if provided\n  if (params.expiresAt) {\n    grantFile.expires = params.expiresAt;\n  }\n\n  return grantFile;\n}\n\n/**\n * Stores a grant file in IPFS via the relayer service.\n *\n * @remarks\n * This function uploads the grant file to IPFS through the relayer's upload endpoint.\n * The returned URL can be stored on-chain as part of the permission grant, allowing\n * anyone to retrieve the detailed permission parameters later.\n *\n * @param grantFile - The grant file to store\n * @param relayerUrl - URL of the relayer service\n * @returns Promise resolving to the IPFS URL\n * @throws {NetworkError} When the upload fails or relayer is unavailable\n * @example\n * ```typescript\n * const grantFile = createGrantFile(params);\n *\n * try {\n *   const ipfsUrl = await storeGrantFile(grantFile, 'https://relayer.vana.com');\n *   console.log(`Grant file stored at: ${ipfsUrl}`);\n *   // ipfsUrl: \"ipfs://QmHash123...\"\n * } catch (error) {\n *   console.error('Failed to store grant file:', error);\n * }\n * ```\n */\nexport async function storeGrantFile(\n  grantFile: GrantFile,\n  relayerUrl: string,\n): Promise<string> {\n  try {\n    // Convert grant file to blob and use IPFS upload endpoint\n    const grantFileBlob = new Blob([JSON.stringify(grantFile, null, 2)], {\n      type: \"application/json\",\n    });\n\n    const formData = new FormData();\n    formData.append(\"file\", grantFileBlob, \"grant-file.json\");\n\n    const response = await fetch(`${relayerUrl}/api/ipfs/upload`, {\n      method: \"POST\",\n      body: formData,\n    });\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to store grant file: ${response.statusText}`,\n        new Error(`HTTP ${response.status}`),\n      );\n    }\n\n    const responseData: unknown = await response.json();\n    const data = responseData as GrantFileStorageResponse;\n\n    if (!data.success) {\n      throw new NetworkError(data.error || \"Failed to store grant file\");\n    }\n\n    return data.url || \"\"; // The IPFS URL from the upload response\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Network error while storing grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Retrieves detailed grant file data from IPFS or HTTP storage.\n *\n * @remarks\n * **This is Step 2 of the performant two-step permission API.**\n *\n * Use this method to resolve detailed permission data (operation, parameters, etc.)\n * for specific grants after first getting the fast on-chain data using\n * `getUserPermissionGrantsOnChain()`. This design eliminates N+1 query problems\n * by allowing selective lazy-loading of expensive off-chain data.\n *\n * **Performance**: Single network request per grant file (typically 100-500ms).\n * **Reliability**: Tries multiple IPFS gateways as fallbacks if primary URL fails.\n *\n * @param grantUrl - The grant file URL from OnChainPermissionGrant.grantUrl\n * @param _relayerUrl - URL of the relayer service (optional, unused)\n * @param downloadRelayer - Optional download relayer for proxying CORS-restricted downloads\n * @param downloadRelayer.proxyDownload - Function to proxy download requests through application server\n * @returns Promise resolving to the complete grant file with operation details\n * @throws {NetworkError} When all retrieval attempts fail\n * @throws {SerializationError} When grant file format is invalid\n * @example\n * ```typescript\n * // Step 1: Fast on-chain data (no N+1 queries)\n * const grants = await vana.permissions.getUserPermissionGrantsOnChain();\n *\n * // Step 2: Lazy-load details for specific grant when needed\n * const grantFile = await retrieveGrantFile(grants[0].grantUrl);\n *\n * console.log(`Operation: ${grantFile.operation}`);\n * console.log(`Grantee: ${grantFile.grantee}`);\n * console.log(`Parameters:`, grantFile.parameters);\n *\n * // Only fetch details for grants user actually wants to see\n * for (const grant of selectedGrants) {\n *   const details = await retrieveGrantFile(grant.grantUrl);\n *   displayGrantDetails(details);\n * }\n * ```\n */\nexport async function retrieveGrantFile(\n  grantUrl: string,\n  _relayerUrl?: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<GrantFile> {\n  try {\n    // Check if the URL is a gateway URL instead of ipfs:// protocol\n    if (grantUrl.startsWith(\"http\") && grantUrl.includes(\"/ipfs/\")) {\n      console.warn(\n        `⚠️  Grant URL uses HTTP gateway format instead of ipfs:// protocol. ` +\n          `Found: ${grantUrl}. ` +\n          `Consider using ipfs:// format for better protocol-agnostic storage.`,\n      );\n    }\n\n    // Use the unified download utility\n    const { fetchWithRelayer } = await import(\"./download\");\n    const response = await fetchWithRelayer(grantUrl, downloadRelayer);\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to retrieve grant file: HTTP ${response.status}`,\n      );\n    }\n\n    const text = await response.text();\n    const grantFile = JSON.parse(text);\n\n    if (!validateGrantFile(grantFile)) {\n      throw new NetworkError(`Invalid grant file format from ${grantUrl}`);\n    }\n\n    return grantFile;\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Error retrieving grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Generates a content hash for a grant file.\n * This can be used for integrity verification.\n *\n * @remarks\n * Creates a deterministic keccak256 hash of the grant file by first sorting\n * all object keys recursively to ensure consistent hashing regardless of\n * property order. This hash can be used to verify grant file integrity\n * or as a unique identifier.\n *\n * @param grantFile - The grant file to generate a hash for\n * @returns The keccak256 hash of the grant file as a hex string\n * @throws {SerializationError} When the grant file cannot be serialized\n * @example\n * ```typescript\n * const grantFile = {\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: { version: '1.0', mode: 'full' }\n * };\n *\n * const hash = getGrantFileHash(grantFile);\n * console.log(`Grant file hash: ${hash}`);\n * // \"0x1234567890abcdef...\"\n *\n * // Same grant file with different property order produces same hash\n * const grantFile2 = {\n *   operation: 'read',\n *   parameters: { mode: 'full', version: '1.0' },\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36'\n * };\n *\n * const hash2 = getGrantFileHash(grantFile2);\n * console.log(hash === hash2); // true\n * ```\n */\nexport function getGrantFileHash(grantFile: GrantFile): string {\n  try {\n    // Create a stable JSON representation\n    const sortedFile: GrantFile = {\n      grantee: grantFile.grantee,\n      operation: grantFile.operation,\n      parameters: sortObjectKeys(grantFile.parameters) as Record<\n        string,\n        unknown\n      >,\n    };\n\n    // Add expires if present\n    if (grantFile.expires !== undefined) {\n      sortedFile.expires = grantFile.expires;\n    }\n\n    const jsonString = JSON.stringify(sortedFile);\n    console.info(`Hash: ${keccak256(toHex(jsonString))}`);\n    return keccak256(toHex(jsonString));\n  } catch (error) {\n    throw new SerializationError(\n      `Failed to generate grant file hash: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n\n/**\n * Recursively sorts object keys for stable serialization.\n *\n * @param obj - The object to sort keys recursively\n * @returns The object with all keys sorted recursively\n */\nfunction sortObjectKeys(obj: unknown): unknown {\n  if (obj === null || typeof obj !== \"object\") {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => sortObjectKeys(item));\n  }\n\n  const sortedObj: Record<string, unknown> = {};\n  Object.keys(obj as Record<string, unknown>)\n    .sort()\n    .forEach((key) => {\n      sortedObj[key] = sortObjectKeys((obj as Record<string, unknown>)[key]);\n    });\n\n  return sortedObj;\n}\n\n/**\n * Validates that a grant file has the required structure.\n *\n * @remarks\n * Performs runtime validation to ensure data conforms to the GrantFile interface.\n * Checks for required fields (grantee, operation, parameters) and validates their\n * types and formats. This is a type guard function that enables TypeScript to\n * narrow the type when it returns true.\n *\n * @param data - The data to validate as a grant file\n * @returns True if the data is a valid grant file, false otherwise\n * @example\n * ```typescript\n * const unknownData = await fetch(url).then(r => r.json());\n *\n * if (validateGrantFile(unknownData)) {\n *   // TypeScript now knows unknownData is a GrantFile\n *   console.log(`Grant for operation: ${unknownData.operation}`);\n *   console.log(`Grantee: ${unknownData.grantee}`);\n * } else {\n *   throw new Error('Invalid grant file format');\n * }\n *\n * // Validation examples:\n * validateGrantFile({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: {}\n * }); // true\n *\n * validateGrantFile({\n *   grantee: 'invalid-address',\n *   operation: 'read',\n *   parameters: {}\n * }); // false (invalid address format)\n *\n * validateGrantFile({\n *   operation: 'read',\n *   parameters: {}\n * }); // false (missing grantee)\n * ```\n */\nexport function validateGrantFile(data: unknown): data is GrantFile {\n  if (!data || typeof data !== \"object\") {\n    return false;\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  // Validate required fields\n  // Validate grantee address\n  if (\n    typeof obj.grantee !== \"string\" ||\n    !obj.grantee.match(/^0x[a-fA-F0-9]{40}$/)\n  ) {\n    return false;\n  }\n\n  if (typeof obj.operation !== \"string\" || obj.operation.length === 0) {\n    return false;\n  }\n\n  // Files are no longer stored in grant files - they're tracked in the contract\n\n  if (!obj.parameters || typeof obj.parameters !== \"object\") {\n    return false;\n  }\n\n  // Validate optional expires field\n  if (obj.expires !== undefined) {\n    if (\n      typeof obj.expires !== \"number\" ||\n      obj.expires < 0 ||\n      !Number.isInteger(obj.expires)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/utils/grantFiles.ts"],"sourcesContent":["import { keccak256, toHex } from \"viem\";\nimport type { GrantFile, GrantPermissionParams } from \"../types/permissions\";\nimport { SerializationError, NetworkError } from \"../errors\";\n\ninterface GrantFileStorageResponse {\n  success: boolean;\n  error?: string;\n  url?: string;\n}\n\n/**\n * Creates a grant file structure from permission parameters.\n *\n * @remarks\n * This function constructs the JSON structure that represents a permission grant\n * in the Vana protocol. The grant file contains all necessary information for\n * a grantee to perform operations on behalf of the grantor.\n *\n * @param params - The permission parameters to create the grant file from\n * @returns The constructed grant file object\n * @example\n * ```typescript\n * const grantFile = createGrantFile({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'llm_inference',\n *   parameters: {\n *     model: 'gpt-4',\n *     maxTokens: 1000\n *   },\n *   expiresAt: Date.now() + 86400000 // 24 hours\n * });\n *\n * console.log(grantFile);\n * // {\n * //   grantee: '0x742d...',\n * //   operation: 'llm_inference',\n * //   parameters: { model: 'gpt-4', maxTokens: 1000 },\n * //   expires: 1234567890\n * // }\n * ```\n */\nexport function createGrantFile(params: GrantPermissionParams): GrantFile {\n  const grantFile: GrantFile = {\n    grantee: params.grantee,\n    operation: params.operation,\n    parameters: params.parameters,\n  };\n\n  // Add expiration if provided\n  if (params.expiresAt) {\n    grantFile.expires = params.expiresAt;\n  }\n\n  return grantFile;\n}\n\n/**\n * Stores a grant file in IPFS via the relayer service.\n *\n * @remarks\n * This function uploads the grant file to IPFS through the relayer's upload endpoint.\n * The returned URL can be stored on-chain as part of the permission grant, allowing\n * anyone to retrieve the detailed permission parameters later.\n *\n * @param grantFile - The grant file to store\n * @param relayerUrl - URL of the relayer service\n * @returns Promise resolving to the IPFS URL\n * @throws {NetworkError} When the upload fails or relayer is unavailable\n * @example\n * ```typescript\n * const grantFile = createGrantFile(params);\n *\n * try {\n *   const ipfsUrl = await storeGrantFile(grantFile, 'https://relayer.vana.com');\n *   console.log(`Grant file stored at: ${ipfsUrl}`);\n *   // ipfsUrl: \"ipfs://QmHash123...\"\n * } catch (error) {\n *   console.error('Failed to store grant file:', error);\n * }\n * ```\n */\nexport async function storeGrantFile(\n  grantFile: GrantFile,\n  relayerUrl: string,\n): Promise<string> {\n  try {\n    // Convert grant file to blob and use IPFS upload endpoint\n    const grantFileBlob = new Blob([JSON.stringify(grantFile, null, 2)], {\n      type: \"application/json\",\n    });\n\n    const formData = new FormData();\n    formData.append(\"file\", grantFileBlob, \"grant-file.json\");\n\n    const response = await fetch(`${relayerUrl}/api/ipfs/upload`, {\n      method: \"POST\",\n      body: formData,\n    });\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to store grant file: ${response.statusText}`,\n        new Error(`HTTP ${response.status}`),\n      );\n    }\n\n    const responseData: unknown = await response.json();\n    const data = responseData as GrantFileStorageResponse;\n\n    if (!data.success) {\n      throw new NetworkError(data.error ?? \"Failed to store grant file\");\n    }\n\n    if (!data.url) {\n      throw new NetworkError(\"Upload succeeded but no URL was returned\");\n    }\n    return data.url; // The IPFS URL from the upload response\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Network error while storing grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Retrieves detailed grant file data from IPFS or HTTP storage.\n *\n * @remarks\n * **This is Step 2 of the performant two-step permission API.**\n *\n * Use this method to resolve detailed permission data (operation, parameters, etc.)\n * for specific grants after first getting the fast on-chain data using\n * `getUserPermissionGrantsOnChain()`. This design eliminates N+1 query problems\n * by allowing selective lazy-loading of expensive off-chain data.\n *\n * **Performance**: Single network request per grant file (typically 100-500ms).\n * **Reliability**: Tries multiple IPFS gateways as fallbacks if primary URL fails.\n *\n * @param grantUrl - The grant file URL from OnChainPermissionGrant.grantUrl\n * @param _relayerUrl - URL of the relayer service (optional, unused)\n * @param downloadRelayer - Optional download relayer for proxying CORS-restricted downloads\n * @param downloadRelayer.proxyDownload - Function to proxy download requests through application server\n * @returns Promise resolving to the complete grant file with operation details\n * @throws {NetworkError} When all retrieval attempts fail\n * @throws {SerializationError} When grant file format is invalid\n * @example\n * ```typescript\n * // Step 1: Fast on-chain data (no N+1 queries)\n * const grants = await vana.permissions.getUserPermissionGrantsOnChain();\n *\n * // Step 2: Lazy-load details for specific grant when needed\n * const grantFile = await retrieveGrantFile(grants[0].grantUrl);\n *\n * console.log(`Operation: ${grantFile.operation}`);\n * console.log(`Grantee: ${grantFile.grantee}`);\n * console.log(`Parameters:`, grantFile.parameters);\n *\n * // Only fetch details for grants user actually wants to see\n * for (const grant of selectedGrants) {\n *   const details = await retrieveGrantFile(grant.grantUrl);\n *   displayGrantDetails(details);\n * }\n * ```\n */\nexport async function retrieveGrantFile(\n  grantUrl: string,\n  _relayerUrl?: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<GrantFile> {\n  try {\n    // Check if the URL is a gateway URL instead of ipfs:// protocol\n    if (grantUrl.startsWith(\"http\") && grantUrl.includes(\"/ipfs/\")) {\n      console.warn(\n        `⚠️  Grant URL uses HTTP gateway format instead of ipfs:// protocol. ` +\n          `Found: ${grantUrl}. ` +\n          `Consider using ipfs:// format for better protocol-agnostic storage.`,\n      );\n    }\n\n    // Use the unified download utility\n    const { universalFetch } = await import(\"./download\");\n    const response = await universalFetch(grantUrl, downloadRelayer);\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to retrieve grant file: HTTP ${response.status}`,\n      );\n    }\n\n    const text = await response.text();\n    const grantFile = JSON.parse(text);\n\n    if (!validateGrantFile(grantFile)) {\n      throw new NetworkError(`Invalid grant file format from ${grantUrl}`);\n    }\n\n    return grantFile;\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Error retrieving grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Generates a content hash for a grant file.\n * This can be used for integrity verification.\n *\n * @remarks\n * Creates a deterministic keccak256 hash of the grant file by first sorting\n * all object keys recursively to ensure consistent hashing regardless of\n * property order. This hash can be used to verify grant file integrity\n * or as a unique identifier.\n *\n * @param grantFile - The grant file to generate a hash for\n * @returns The keccak256 hash of the grant file as a hex string\n * @throws {SerializationError} When the grant file cannot be serialized\n * @example\n * ```typescript\n * const grantFile = {\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: { version: '1.0', mode: 'full' }\n * };\n *\n * const hash = getGrantFileHash(grantFile);\n * console.log(`Grant file hash: ${hash}`);\n * // \"0x1234567890abcdef...\"\n *\n * // Same grant file with different property order produces same hash\n * const grantFile2 = {\n *   operation: 'read',\n *   parameters: { mode: 'full', version: '1.0' },\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36'\n * };\n *\n * const hash2 = getGrantFileHash(grantFile2);\n * console.log(hash === hash2); // true\n * ```\n */\nexport function getGrantFileHash(grantFile: GrantFile): string {\n  try {\n    // Create a stable JSON representation\n    const sortedFile: GrantFile = {\n      grantee: grantFile.grantee,\n      operation: grantFile.operation,\n      parameters: sortObjectKeys(grantFile.parameters) as Record<\n        string,\n        unknown\n      >,\n    };\n\n    // Add expires if present\n    if (grantFile.expires !== undefined) {\n      sortedFile.expires = grantFile.expires;\n    }\n\n    const jsonString = JSON.stringify(sortedFile);\n    console.info(`Hash: ${keccak256(toHex(jsonString))}`);\n    return keccak256(toHex(jsonString));\n  } catch (error) {\n    throw new SerializationError(\n      `Failed to generate grant file hash: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n\n/**\n * Recursively sorts object keys for stable serialization.\n *\n * @param obj - The object to sort keys recursively\n * @returns The object with all keys sorted recursively\n */\nfunction sortObjectKeys(obj: unknown): unknown {\n  if (obj === null || typeof obj !== \"object\") {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => sortObjectKeys(item));\n  }\n\n  const sortedObj: Record<string, unknown> = {};\n  Object.keys(obj as Record<string, unknown>)\n    .sort()\n    .forEach((key) => {\n      sortedObj[key] = sortObjectKeys((obj as Record<string, unknown>)[key]);\n    });\n\n  return sortedObj;\n}\n\n/**\n * Validates that a grant file has the required structure.\n *\n * @remarks\n * Performs runtime validation to ensure data conforms to the GrantFile interface.\n * Checks for required fields (grantee, operation, parameters) and validates their\n * types and formats. This is a type guard function that enables TypeScript to\n * narrow the type when it returns true.\n *\n * @param data - The data to validate as a grant file\n * @returns True if the data is a valid grant file, false otherwise\n * @example\n * ```typescript\n * const unknownData = await fetch(url).then(r => r.json());\n *\n * if (validateGrantFile(unknownData)) {\n *   // TypeScript now knows unknownData is a GrantFile\n *   console.log(`Grant for operation: ${unknownData.operation}`);\n *   console.log(`Grantee: ${unknownData.grantee}`);\n * } else {\n *   throw new Error('Invalid grant file format');\n * }\n *\n * // Validation examples:\n * validateGrantFile({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: {}\n * }); // true\n *\n * validateGrantFile({\n *   grantee: 'invalid-address',\n *   operation: 'read',\n *   parameters: {}\n * }); // false (invalid address format)\n *\n * validateGrantFile({\n *   operation: 'read',\n *   parameters: {}\n * }); // false (missing grantee)\n * ```\n */\nexport function validateGrantFile(data: unknown): data is GrantFile {\n  if (!data || typeof data !== \"object\") {\n    return false;\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  // Validate required fields\n  // Validate grantee address\n  if (\n    typeof obj.grantee !== \"string\" ||\n    !obj.grantee.match(/^0x[a-fA-F0-9]{40}$/)\n  ) {\n    return false;\n  }\n\n  if (typeof obj.operation !== \"string\" || obj.operation.length === 0) {\n    return false;\n  }\n\n  // Files are no longer stored in grant files - they're tracked in the contract\n\n  if (!obj.parameters || typeof obj.parameters !== \"object\") {\n    return false;\n  }\n\n  // Validate optional expires field\n  if (obj.expires !== undefined) {\n    if (\n      typeof obj.expires !== \"number\" ||\n      obj.expires < 0 ||\n      !Number.isInteger(obj.expires)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"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","names":[]}

package/dist/utils/grantFiles.d.ts

@@ -1,6 +1,4 @@
-import { GrantPermissionParams, GrantFile } from '../types/permissions.js';
-import 'viem';
-
+import type { GrantFile, GrantPermissionParams } from "../types/permissions";
 /**
  * Creates a grant file structure from permission parameters.
  *
@@ -32,7 +30,7 @@ import 'viem';
  * // }
  * ```
  */
-declare function createGrantFile(params: GrantPermissionParams): GrantFile;
+export declare function createGrantFile(params: GrantPermissionParams): GrantFile;
 /**
  * Stores a grant file in IPFS via the relayer service.
  *
@@ -58,7 +56,7 @@ declare function createGrantFile(params: GrantPermissionParams): GrantFile;
  * }
  * ```
  */
-declare function storeGrantFile(grantFile: GrantFile, relayerUrl: string): Promise<string>;
+export declare function storeGrantFile(grantFile: GrantFile, relayerUrl: string): Promise<string>;
 /**
  * Retrieves detailed grant file data from IPFS or HTTP storage.
  *
@@ -99,7 +97,7 @@ declare function storeGrantFile(grantFile: GrantFile, relayerUrl: string): Promi
  * }
  * ```
  */
-declare function retrieveGrantFile(grantUrl: string, _relayerUrl?: string, downloadRelayer?: {
+export declare function retrieveGrantFile(grantUrl: string, _relayerUrl?: string, downloadRelayer?: {
     proxyDownload: (url: string) => Promise<Blob>;
 }): Promise<GrantFile>;
 /**
@@ -138,7 +136,7 @@ declare function retrieveGrantFile(grantUrl: string, _relayerUrl?: string, downl
  * console.log(hash === hash2); // true
  * ```
  */
-declare function getGrantFileHash(grantFile: GrantFile): string;
+export declare function getGrantFileHash(grantFile: GrantFile): string;
 /**
  * Validates that a grant file has the required structure.
  *
@@ -181,6 +179,4 @@ declare function getGrantFileHash(grantFile: GrantFile): string;
  * }); // false (missing grantee)
  * ```
  */
-declare function validateGrantFile(data: unknown): data is GrantFile;
-
-export { createGrantFile, getGrantFileHash, retrieveGrantFile, storeGrantFile, validateGrantFile };
+export declare function validateGrantFile(data: unknown): data is GrantFile;

package/dist/utils/grantFiles.js

@@ -31,9 +31,12 @@ async function storeGrantFile(grantFile, relayerUrl) {
     const responseData = await response.json();
     const data = responseData;
     if (!data.success) {
-      throw new NetworkError(data.error || "Failed to store grant file");
+      throw new NetworkError(data.error ?? "Failed to store grant file");
     }
-    return data.url || "";
+    if (!data.url) {
+      throw new NetworkError("Upload succeeded but no URL was returned");
+    }
+    return data.url;
   } catch (error) {
     if (error instanceof NetworkError) {
       throw error;
@@ -51,8 +54,8 @@ async function retrieveGrantFile(grantUrl, _relayerUrl, downloadRelayer) {
         `\u26A0\uFE0F  Grant URL uses HTTP gateway format instead of ipfs:// protocol. Found: ${grantUrl}. Consider using ipfs:// format for better protocol-agnostic storage.`
       );
     }
-    const { fetchWithRelayer } = await import("./download");
-    const response = await fetchWithRelayer(grantUrl, downloadRelayer);
+    const { universalFetch } = await import("./download");
+    const response = await universalFetch(grantUrl, downloadRelayer);
     if (!response.ok) {
       throw new NetworkError(
         `Failed to retrieve grant file: HTTP ${response.status}`