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

package/dist/utils/encryption.d.ts

@@ -0,0 +1,275 @@
+import { WalletClient } from 'viem';
+import { VanaPlatformAdapter } from '../platform/interface.js';
+
+/**
+ * Canonical Vana Protocol Encryption Functions
+ *
+ * These functions define the standard way user data is encrypted/decrypted in Vana.
+ * All applications should use these canonical functions to ensure compatibility
+ * with existing encrypted data on the Vana network.
+ *
+ * This module uses the platform adapter pattern to provide consistent
+ * encryption functionality across Node.js and browser environments.
+ */
+
+/**
+ * Default encryption seed message used throughout Vana protocol
+ */
+declare const DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
+/**
+ * Generate an encryption key by signing the canonical Vana encryption seed
+ *
+ * This is the standard protocol function for creating encryption keys in Vana.
+ * The signature serves as a symmetric encryption key for user data.
+ *
+ * @param wallet The user's wallet client for signing
+ * @param platformAdapter Platform adapter for cache operations
+ * @param seed Optional custom encryption seed (defaults to Vana standard)
+ * @returns The signature that serves as the encryption key
+ * @throws {Error} When wallet account is required but not provided
+ * @example
+ * ```typescript
+ * const encryptionKey = await generateEncryptionKey(walletClient, platformAdapter);
+ * console.log('Generated encryption key:', encryptionKey);
+ *
+ * // Use with custom seed
+ * const customKey = await generateEncryptionKey(walletClient, platformAdapter, 'my-custom-seed');
+ * ```
+ */
+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.
+ *
+ * @remarks
+ * This function implements asymmetric encryption using the recipient's public key,
+ * enabling secure data sharing where only the holder of the corresponding private key
+ * can decrypt the data. It automatically handles different data types and uses
+ * platform-appropriate cryptographic libraries for maximum compatibility.
+ *
+ * This is commonly used when granting permissions to applications or servers,
+ * where the data needs to be encrypted for a specific recipient's public key.
+ *
+ * @param data - The data to encrypt (string or Blob)
+ * @param publicKey - The recipient's public key in hexadecimal format
+ * @param platformAdapter - The platform adapter providing cryptographic operations
+ * @returns Promise resolving to the encrypted data as a string
+ * @throws {Error} When encryption fails due to invalid key or data format
+ * @example
+ * ```typescript
+ * // Encrypt data for a specific application's public key
+ * const appPublicKey = "0x04a1b2c3..."; // Application's public key
+ * const sensitiveData = "User's private information";
+ *
+ * const encrypted = await encryptWithWalletPublicKey(
+ *   sensitiveData,
+ *   appPublicKey,
+ *   platformAdapter
+ * );
+ *
+ * console.log('Encrypted for app:', encrypted);
+ *
+ * // Encrypt file data for server processing
+ * const fileBlob = new File(['{"name":"John","age":30}'], 'profile.json');
+ * const encryptedFile = await encryptWithWalletPublicKey(
+ *   fileBlob,
+ *   serverPublicKey,
+ *   platformAdapter
+ * );
+ * ```
+ */
+declare function encryptWithWalletPublicKey(data: string | Blob, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
+/**
+ * Decrypts data that was encrypted with the corresponding public key.
+ *
+ * @remarks
+ * This function performs asymmetric decryption using the recipient's private key
+ * to decrypt data that was encrypted with the corresponding public key. It's the
+ * counterpart to `encryptWithWalletPublicKey` and is typically used by applications
+ * or servers to decrypt data that was shared with them by users.
+ *
+ * The function automatically handles platform-specific cryptographic operations
+ * and provides consistent behavior across browser and Node.js environments.
+ *
+ * @param encryptedData - The encrypted data string to decrypt
+ * @param privateKey - The private key corresponding to the public key used for encryption
+ * @param platformAdapter - The platform adapter providing cryptographic operations
+ * @returns Promise resolving to the decrypted data as a string
+ * @throws {Error} When decryption fails due to invalid key, corrupted data, or key mismatch
+ * @example
+ * ```typescript
+ * // Decrypt data received from a user (server-side)
+ * const encryptedUserData = "encrypted_string_from_user";
+ * const serverPrivateKey = process.env.SERVER_PRIVATE_KEY;
+ *
+ * const decrypted = await decryptWithWalletPrivateKey(
+ *   encryptedUserData,
+ *   serverPrivateKey,
+ *   platformAdapter
+ * );
+ *
+ * const userData = JSON.parse(decrypted);
+ * console.log('User data:', userData);
+ *
+ * // Handle decryption errors gracefully
+ * try {
+ *   const result = await decryptWithWalletPrivateKey(
+ *     encryptedData,
+ *     privateKey,
+ *     platformAdapter
+ *   );
+ * } catch (error) {
+ *   if (error.message.includes('invalid key')) {
+ *     console.error('Key mismatch - data not encrypted for this recipient');
+ *   } else {
+ *     console.error('Decryption failed:', error.message);
+ *   }
+ * }
+ * ```
+ */
+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
+ *
+ * @param fileKey The symmetric key used to encrypt the file
+ * @param publicKey The DLP's public key
+ * @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>;
+/**
+ * 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<{
+    iv: string;
+    key: string;
+}>;
+/**
+ * Decrypt data that was encrypted with the DLP's public key using platform-appropriate cryptography
+ *
+ * @param encryptedData The encrypted data
+ * @param privateKey The private key corresponding to the public key used for encryption
+ * @param platformAdapter - The platform adapter for crypto operations
+ * @returns The decrypted data
+ */
+declare function decryptWithPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
+/**
+ * Encrypts data using a signed key generated from the user's wallet signature.
+ *
+ * @remarks
+ * This is a pure cryptographic primitive that encrypts data using the Vana protocol's
+ * standard encryption method. The key parameter must be a signature generated by the
+ * `generateEncryptionKey` utility - this ensures deterministic key generation from the
+ * user's wallet, enabling the same key to be regenerated for decryption.
+ *
+ * This function uses password-based encryption with the signature as the password,
+ * providing symmetric encryption that can be decrypted with the same signature.
+ *
+ * @param data The data to encrypt (string or Blob)
+ * @param key The signed key from `generateEncryptionKey` - MUST be a wallet signature
+ * @param platformAdapter The platform adapter for crypto operations
+ * @returns The encrypted data as Blob
+ * @throws {Error} When encryption fails
+ *
+ * @example
+ * ```typescript
+ * // Generate the encryption key from wallet signature
+ * const encryptionKey = await generateEncryptionKey(walletClient);
+ *
+ * // Encrypt data with the signed key
+ * const encryptedBlob = await encryptBlobWithSignedKey(
+ *   "My sensitive data",
+ *   encryptionKey,
+ *   platformAdapter
+ * );
+ *
+ * // Later, decrypt with the same key
+ * const decryptedBlob = await decryptBlobWithSignedKey(
+ *   encryptedBlob,
+ *   encryptionKey,
+ *   platformAdapter
+ * );
+ * ```
+ */
+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<{
+    publicKey: string;
+    privateKey: string;
+}>;
+/**
+ * Generate a new PGP key pair with platform-appropriate configuration
+ *
+ * @param platformAdapter - The platform adapter for crypto operations
+ * @param options - Key generation options
+ * @param options.name - The name for the PGP key
+ * @param options.email - The email for the PGP key
+ * @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?: {
+    name?: string;
+    email?: string;
+    passphrase?: string;
+}): Promise<{
+    publicKey: string;
+    privateKey: string;
+}>;
+/**
+ * Decrypts data using a signed key generated from the user's wallet signature.
+ *
+ * @remarks
+ * This is a pure cryptographic primitive for decrypting data that was encrypted using
+ * `encryptBlobWithSignedKey`. It is network-agnostic and only handles decryption - it does
+ * not fetch data from any URL or make network requests. To decrypt a file from a URL, you
+ * must first fetch the encrypted blob using one of the fetch utilities, then pass it to
+ * this function.
+ *
+ * The key parameter must be the same signature that was used for encryption, typically
+ * generated by the `generateEncryptionKey` utility. This ensures that only the user who
+ * encrypted the data (or someone with the same wallet signature) can decrypt it.
+ *
+ * @param encryptedData The encrypted data to decrypt (string or Blob)
+ * @param key The signed key from `generateEncryptionKey` - MUST be the same wallet signature used for encryption
+ * @param platformAdapter The platform adapter for crypto operations
+ * @returns Promise resolving to the decrypted blob
+ * @throws {Error} When decryption fails due to wrong key or corrupted data
+ *
+ * @example
+ * ```typescript
+ * // Generate the same encryption key used for encryption
+ * const encryptionKey = await generateEncryptionKey(walletClient);
+ *
+ * // Fetch and decrypt using the high-level API
+ * const file = await vana.data.getUserFiles({ owner: "0x..." })[0];
+ * const decryptedBlob = await vana.data.decryptFile(file);
+ *
+ * // Or use the low-level primitives directly
+ * const encryptedBlob = await vana.data.fetch(file.url);
+ * const decryptedBlob = await decryptBlobWithSignedKey(
+ *   encryptedBlob,
+ *   encryptionKey,
+ *   platformAdapter
+ * );
+ *
+ * // With IPFS gateway fallback
+ * const encryptedBlob = await vana.data.fetchFromIPFS(file.url, {
+ *   gateways: ['https://my-gateway.com/ipfs/', 'https://ipfs.io/ipfs/']
+ * });
+ * const decryptedBlob = await decryptBlobWithSignedKey(
+ *   encryptedBlob,
+ *   encryptionKey,
+ *   platformAdapter
+ * );
+ * ```
+ */
+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 };

package/dist/utils/encryption.js

@@ -0,0 +1,136 @@
+import { withSignatureCache } from "./signatureCache";
+const DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
+async function generateEncryptionKey(wallet, platformAdapter, seed = DEFAULT_ENCRYPTION_SEED) {
+  if (!wallet.account) {
+    throw new Error("Wallet account is required for encryption key generation");
+  }
+  const account = wallet.account;
+  const messageData = { message: seed };
+  return await withSignatureCache(
+    platformAdapter.cache,
+    account.address,
+    messageData,
+    async () => {
+      return await wallet.signMessage({
+        account,
+        message: seed
+      });
+    }
+  );
+}
+async function encryptWithWalletPublicKey(data, publicKey, platformAdapter) {
+  try {
+    const dataString = data instanceof Blob ? await data.text() : data;
+    return await platformAdapter.crypto.encryptWithWalletPublicKey(
+      dataString,
+      publicKey
+    );
+  } catch (error) {
+    throw new Error(`Failed to encrypt with wallet public key: ${error}`);
+  }
+}
+async function decryptWithWalletPrivateKey(encryptedData, privateKey, platformAdapter) {
+  try {
+    return await platformAdapter.crypto.decryptWithWalletPrivateKey(
+      encryptedData,
+      privateKey
+    );
+  } catch (error) {
+    throw new Error(`Failed to decrypt with wallet private key: ${error}`);
+  }
+}
+async function encryptFileKey(fileKey, publicKey, platformAdapter) {
+  try {
+    return await platformAdapter.crypto.encryptWithPublicKey(
+      fileKey,
+      publicKey
+    );
+  } catch (error) {
+    throw new Error(`Failed to encrypt file key: ${error}`);
+  }
+}
+async function getEncryptionParameters(platformAdapter) {
+  try {
+    const keyPair = await platformAdapter.crypto.generateKeyPair();
+    return {
+      iv: keyPair.publicKey.substring(0, 16),
+      key: keyPair.privateKey.substring(0, 32)
+    };
+  } catch (error) {
+    throw new Error(`Failed to generate encryption parameters: ${error}`);
+  }
+}
+async function decryptWithPrivateKey(encryptedData, privateKey, platformAdapter) {
+  try {
+    return await platformAdapter.crypto.decryptWithPrivateKey(
+      encryptedData,
+      privateKey
+    );
+  } catch (error) {
+    throw new Error(`Failed to decrypt with private key: ${error}`);
+  }
+}
+async function encryptBlobWithSignedKey(data, key, platformAdapter) {
+  try {
+    const dataBuffer = data instanceof Blob ? await data.arrayBuffer() : new TextEncoder().encode(data);
+    const dataArray = new Uint8Array(dataBuffer);
+    const encrypted = await platformAdapter.crypto.encryptWithPassword(
+      dataArray,
+      key
+    );
+    const encryptedArrayBuffer = encrypted.buffer.slice(
+      encrypted.byteOffset,
+      encrypted.byteOffset + encrypted.byteLength
+    );
+    return new Blob([encryptedArrayBuffer], {
+      type: "application/octet-stream"
+    });
+  } catch (error) {
+    throw new Error(`Failed to encrypt data: ${error}`);
+  }
+}
+async function generateEncryptionKeyPair(platformAdapter) {
+  try {
+    return await platformAdapter.crypto.generateKeyPair();
+  } catch (error) {
+    throw new Error(`Failed to generate encryption key pair: ${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}`);
+  }
+}
+async function decryptBlobWithSignedKey(encryptedData, key, platformAdapter) {
+  try {
+    const encryptedBuffer = encryptedData instanceof Blob ? await encryptedData.arrayBuffer() : new TextEncoder().encode(encryptedData);
+    const encryptedArray = new Uint8Array(encryptedBuffer);
+    const decrypted = await platformAdapter.crypto.decryptWithPassword(
+      encryptedArray,
+      key
+    );
+    const decryptedArrayBuffer = decrypted.buffer.slice(
+      decrypted.byteOffset,
+      decrypted.byteOffset + decrypted.byteLength
+    );
+    return new Blob([decryptedArrayBuffer], { type: "text/plain" });
+  } catch (error) {
+    throw new Error(`Failed to decrypt data: ${error}`);
+  }
+}
+export {
+  DEFAULT_ENCRYPTION_SEED,
+  decryptBlobWithSignedKey,
+  decryptWithPrivateKey,
+  decryptWithWalletPrivateKey,
+  encryptBlobWithSignedKey,
+  encryptFileKey,
+  encryptWithWalletPublicKey,
+  generateEncryptionKey,
+  generateEncryptionKeyPair,
+  generatePGPKeyPair,
+  getEncryptionParameters
+};
+//# sourceMappingURL=encryption.js.map

package/dist/utils/encryption.js.map

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

package/dist/utils/formatters.cjs

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var formatters_exports = {};
+__export(formatters_exports, {
+  formatEth: () => formatEth,
+  formatNumber: () => formatNumber,
+  formatToken: () => formatToken,
+  shortenAddress: () => shortenAddress
+});
+module.exports = __toCommonJS(formatters_exports);
+var import_viem = require("viem");
+function formatNumber(value) {
+  return Number(value);
+}
+function formatEth(wei, decimals = 4) {
+  return (0, import_viem.formatEther)(BigInt(wei.toString())).slice(0, decimals + 2);
+}
+function formatToken(amount, decimals = 18, displayDecimals = 4) {
+  const value = (0, import_viem.formatUnits)(BigInt(amount.toString()), decimals);
+  const parts = value.split(".");
+  if (parts.length === 1) {
+    return parts[0];
+  }
+  return `${parts[0]}.${parts[1].slice(0, displayDecimals)}`;
+}
+function shortenAddress(address) {
+  if (!address || address.length < 10) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatEth,
+  formatNumber,
+  formatToken,
+  shortenAddress
+});
+//# sourceMappingURL=formatters.cjs.map

package/dist/utils/formatters.cjs.map

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

package/dist/utils/formatters.d.cts

@@ -0,0 +1,120 @@
+/**
+ * Format a bigint or BigNumber to a regular number
+ *
+ * @remarks
+ * This function converts blockchain-specific large number types to standard JavaScript
+ * numbers. Use with caution for values that may exceed safe integer range.
+ *
+ * **Edge Cases:**
+ * - Values exceeding JavaScript's MAX_SAFE_INTEGER (2^53-1) lose precision
+ * - Negative values are supported
+ * - String values must be valid numeric strings or will return NaN
+ *
+ * @param value BigInt, BigNumber or numeric string to convert
+ * @returns Regular JavaScript number
+ * @example
+ * ```typescript
+ * formatNumber(1000000000000000000n) // Returns: 1000000000000000000
+ * formatNumber("123456789") // Returns: 123456789
+ * formatNumber(-100n) // Returns: -100
+ *
+ * // Precision loss example:
+ * const bigValue = 9007199254740993n; // MAX_SAFE_INTEGER + 2
+ * formatNumber(bigValue) // Returns: 9007199254740992 (lost precision)
+ * ```
+ */
+declare function formatNumber(value: bigint | string | number): number;
+/**
+ * Format wei value to ETH with specified decimal places
+ *
+ * @remarks
+ * Converts wei (smallest ETH unit) to human-readable ETH format.
+ * 1 ETH = 10^18 wei. The function truncates rather than rounds
+ * to ensure predictable display in financial contexts.
+ *
+ * **Edge Cases:**
+ * - Truncates (not rounds) to specified decimal places
+ * - Negative values are supported
+ * - Zero values return "0.0000" (based on decimals)
+ * - Very small values may display as "0.0000" due to truncation
+ *
+ * @param wei Value in wei (as bigint, string, or number)
+ * @param decimals Number of decimal places to display (default: 4)
+ * @returns Formatted ETH value as string
+ * @example
+ * ```typescript
+ * // Standard conversions
+ * formatEth(1000000000000000000n) // Returns: "1.0000"
+ * formatEth(1500000000000000000n, 2) // Returns: "1.50"
+ * formatEth("2000000000000000000") // Returns: "2.0000"
+ *
+ * // Edge cases
+ * formatEth(1000000000000000n) // Returns: "0.0010" (0.001 ETH)
+ * formatEth(100000000000000n) // Returns: "0.0001"
+ * formatEth(10000000000000n) // Returns: "0.0000" (truncated)
+ * formatEth(-1000000000000000000n) // Returns: "-1.000"
+ * ```
+ */
+declare function formatEth(wei: bigint | string | number, decimals?: number): string;
+/**
+ * Format a token amount based on its decimals
+ *
+ * @remarks
+ * Generic token formatter that handles any ERC20-style token with
+ * configurable decimal places. Most tokens use 18 decimals like ETH,
+ * but some use different values (e.g., USDC uses 6).
+ *
+ * @param amount Raw token amount
+ * @param decimals Token decimals (default: 18)
+ * @param displayDecimals Decimals to show in formatted output (default: 4)
+ * @returns Formatted token amount as string
+ * @example
+ * ```typescript
+ * // 18 decimal token (like ETH)
+ * formatToken(1000000000000000000n) // Returns: "1.0000"
+ * formatToken(1500000000000000000n, 18, 2) // Returns: "1.50"
+ *
+ * // 6 decimal token (like USDC)
+ * formatToken(1000000n, 6) // Returns: "1.0000"
+ * formatToken(1500000n, 6, 2) // Returns: "1.50"
+ *
+ * // Whole numbers
+ * formatToken(5000000000000000000n) // Returns: "5"
+ * formatToken(5123456789000000000n, 18, 6) // Returns: "5.123456"
+ * ```
+ */
+declare function formatToken(amount: bigint | string | number, decimals?: number, displayDecimals?: number): string;
+/**
+ * Format an address for display (showing first 6 and last 4 characters)
+ *
+ * @remarks
+ * Creates a human-readable abbreviated version of Ethereum addresses
+ * for UI display. Preserves enough characters to maintain uniqueness
+ * while saving screen space. Does not validate address format.
+ *
+ * **Edge Cases:**
+ * - Addresses shorter than 10 characters are returned unchanged
+ * - Works with both checksummed and lowercase addresses
+ * - Does not validate address format
+ *
+ * @param address EVM address
+ * @returns Shortened address string
+ * @example
+ * ```typescript
+ * // Standard addresses
+ * shortenAddress("0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36")
+ * // Returns: "0x742d...Bd36"
+ *
+ * // Checksummed address
+ * shortenAddress("0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36")
+ * // Returns: "0x742d...Bd36"
+ *
+ * // Edge cases
+ * shortenAddress("0x123") // Returns: "0x123" (too short)
+ * shortenAddress("") // Returns: ""
+ * shortenAddress("not-an-address") // Returns: "not-an...ress"
+ * ```
+ */
+declare function shortenAddress(address: string): string;
+
+export { formatEth, formatNumber, formatToken, shortenAddress };