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

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/eventParsing.cjs

@@ -0,0 +1,111 @@
+"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 eventParsing_exports = {};
+__export(eventParsing_exports, {
+  EventParsingError: () => EventParsingError,
+  parseFileAddedEvent: () => parseFileAddedEvent,
+  parseRefinerAddedEvent: () => parseRefinerAddedEvent,
+  parseSchemaAddedEvent: () => parseSchemaAddedEvent
+});
+module.exports = __toCommonJS(eventParsing_exports);
+var import_viem = require("viem");
+var import_abi = require("../generated/abi");
+class EventParsingError extends Error {
+  constructor(eventName, transactionHash, message) {
+    super(
+      message || `Event "${eventName}" not found in transaction ${transactionHash}`
+    );
+    this.eventName = eventName;
+    this.transactionHash = transactionHash;
+    this.name = "EventParsingError";
+  }
+}
+function parseSchemaAddedEvent(receipt) {
+  const abi = (0, import_abi.getAbi)("DataRefinerRegistry");
+  const logs = (0, import_viem.parseEventLogs)({
+    abi,
+    logs: receipt.logs,
+    eventName: "SchemaAdded"
+  });
+  if (logs.length === 0) {
+    throw new EventParsingError("SchemaAdded", receipt.transactionHash);
+  }
+  const event = logs[0];
+  return {
+    transactionHash: receipt.transactionHash,
+    blockNumber: receipt.blockNumber,
+    gasUsed: receipt.gasUsed,
+    schemaId: event.args.schemaId,
+    name: event.args.name,
+    dialect: event.args.dialect,
+    definitionUrl: event.args.definitionUrl
+  };
+}
+function parseFileAddedEvent(receipt) {
+  const abi = (0, import_abi.getAbi)("DataRegistry");
+  const logs = (0, import_viem.parseEventLogs)({
+    abi,
+    logs: receipt.logs,
+    eventName: "FileAddedV2"
+  });
+  if (logs.length === 0) {
+    throw new EventParsingError("FileAddedV2", receipt.transactionHash);
+  }
+  const event = logs[0];
+  return {
+    transactionHash: receipt.transactionHash,
+    blockNumber: receipt.blockNumber,
+    gasUsed: receipt.gasUsed,
+    fileId: event.args.fileId,
+    ownerAddress: event.args.ownerAddress,
+    url: event.args.url,
+    schemaId: event.args.schemaId
+  };
+}
+function parseRefinerAddedEvent(receipt) {
+  const abi = (0, import_abi.getAbi)("DataRefinerRegistry");
+  const logs = (0, import_viem.parseEventLogs)({
+    abi,
+    logs: receipt.logs,
+    eventName: "RefinerAdded"
+  });
+  if (logs.length === 0) {
+    throw new EventParsingError("RefinerAdded", receipt.transactionHash);
+  }
+  const event = logs[0];
+  return {
+    transactionHash: receipt.transactionHash,
+    blockNumber: receipt.blockNumber,
+    gasUsed: receipt.gasUsed,
+    refinerId: event.args.refinerId,
+    dlpId: event.args.dlpId,
+    name: event.args.name,
+    schemaId: event.args.schemaId,
+    schemaDefinitionUrl: event.args.schemaDefinitionUrl,
+    refinementInstructionUrl: event.args.refinementInstructionUrl
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventParsingError,
+  parseFileAddedEvent,
+  parseRefinerAddedEvent,
+  parseSchemaAddedEvent
+});
+//# sourceMappingURL=eventParsing.cjs.map

package/dist/utils/eventParsing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/eventParsing.ts"],"sourcesContent":["import {\n  parseEventLogs,\n  type Log,\n  type TransactionReceipt,\n  type Hash,\n} from \"viem\";\nimport type {\n  SchemaAddedResult,\n  FileAddedResult,\n  RefinerAddedResult,\n} from \"../types/transactionResults\";\nimport { getAbi } from \"../generated/abi\";\n\n/**\n * Error thrown when expected events are not found in transaction logs\n */\nexport class EventParsingError extends Error {\n  constructor(\n    public readonly eventName: string,\n    public readonly transactionHash: Hash,\n    message?: string,\n  ) {\n    super(\n      message ||\n        `Event \"${eventName}\" not found in transaction ${transactionHash}`,\n    );\n    this.name = \"EventParsingError\";\n  }\n}\n\n/**\n * Parses SchemaAdded event from a transaction receipt.\n *\n * @param receipt - The transaction receipt containing event logs.\n * @returns A SchemaAddedResult with the schema ID and metadata from the event.\n * @throws {EventParsingError} When the SchemaAdded event is not present in the receipt logs.\n */\nexport function parseSchemaAddedEvent(\n  receipt: TransactionReceipt,\n): SchemaAddedResult {\n  const abi = getAbi(\"DataRefinerRegistry\");\n\n  const logs = parseEventLogs({\n    abi,\n    logs: receipt.logs as Log[],\n    eventName: \"SchemaAdded\",\n  });\n\n  if (logs.length === 0) {\n    throw new EventParsingError(\"SchemaAdded\", receipt.transactionHash);\n  }\n\n  const event = logs[0];\n  return {\n    transactionHash: receipt.transactionHash,\n    blockNumber: receipt.blockNumber,\n    gasUsed: receipt.gasUsed,\n    schemaId: event.args.schemaId as bigint,\n    name: event.args.name as string,\n    dialect: event.args.dialect as string,\n    definitionUrl: event.args.definitionUrl as string,\n  };\n}\n\n/**\n * Parses FileAddedV2 event from a transaction receipt.\n *\n * @param receipt - The transaction receipt containing event logs.\n * @returns A FileAddedResult with the file ID and metadata from the event.\n * @throws {EventParsingError} When the FileAddedV2 event is not present in the receipt logs.\n */\nexport function parseFileAddedEvent(\n  receipt: TransactionReceipt,\n): FileAddedResult {\n  const abi = getAbi(\"DataRegistry\");\n\n  const logs = parseEventLogs({\n    abi,\n    logs: receipt.logs as Log[],\n    eventName: \"FileAddedV2\",\n  });\n\n  if (logs.length === 0) {\n    throw new EventParsingError(\"FileAddedV2\", receipt.transactionHash);\n  }\n\n  const event = logs[0];\n  // FileAddedV2 event has 'ownerAddress' field, not 'owner'\n  return {\n    transactionHash: receipt.transactionHash,\n    blockNumber: receipt.blockNumber,\n    gasUsed: receipt.gasUsed,\n    fileId: event.args.fileId as bigint,\n    ownerAddress: event.args.ownerAddress as `0x${string}`,\n    url: event.args.url as string,\n    schemaId: event.args.schemaId as bigint,\n  };\n}\n\n/**\n * Parses RefinerAdded event from a transaction receipt.\n *\n * @param receipt - The transaction receipt containing event logs.\n * @returns A RefinerAddedResult with the refiner ID and metadata from the event.\n * @throws {EventParsingError} When the RefinerAdded event is not present in the receipt logs.\n */\nexport function parseRefinerAddedEvent(\n  receipt: TransactionReceipt,\n): RefinerAddedResult {\n  const abi = getAbi(\"DataRefinerRegistry\");\n\n  const logs = parseEventLogs({\n    abi,\n    logs: receipt.logs as Log[],\n    eventName: \"RefinerAdded\",\n  });\n\n  if (logs.length === 0) {\n    throw new EventParsingError(\"RefinerAdded\", receipt.transactionHash);\n  }\n\n  const event = logs[0];\n  return {\n    transactionHash: receipt.transactionHash,\n    blockNumber: receipt.blockNumber,\n    gasUsed: receipt.gasUsed,\n    refinerId: event.args.refinerId as bigint,\n    dlpId: event.args.dlpId as bigint,\n    name: event.args.name as string,\n    schemaId: event.args.schemaId as bigint,\n    schemaDefinitionUrl: event.args.schemaDefinitionUrl as string,\n    refinementInstructionUrl: event.args.refinementInstructionUrl as string,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAKO;AAMP,iBAAuB;AAKhB,MAAM,0BAA0B,MAAM;AAAA,EAC3C,YACkB,WACA,iBAChB,SACA;AACA;AAAA,MACE,WACE,UAAU,SAAS,8BAA8B,eAAe;AAAA,IACpE;AAPgB;AACA;AAOhB,SAAK,OAAO;AAAA,EACd;AACF;AASO,SAAS,sBACd,SACmB;AACnB,QAAM,UAAM,mBAAO,qBAAqB;AAExC,QAAM,WAAO,4BAAe;AAAA,IAC1B;AAAA,IACA,MAAM,QAAQ;AAAA,IACd,WAAW;AAAA,EACb,CAAC;AAED,MAAI,KAAK,WAAW,GAAG;AACrB,UAAM,IAAI,kBAAkB,eAAe,QAAQ,eAAe;AAAA,EACpE;AAEA,QAAM,QAAQ,KAAK,CAAC;AACpB,SAAO;AAAA,IACL,iBAAiB,QAAQ;AAAA,IACzB,aAAa,QAAQ;AAAA,IACrB,SAAS,QAAQ;AAAA,IACjB,UAAU,MAAM,KAAK;AAAA,IACrB,MAAM,MAAM,KAAK;AAAA,IACjB,SAAS,MAAM,KAAK;AAAA,IACpB,eAAe,MAAM,KAAK;AAAA,EAC5B;AACF;AASO,SAAS,oBACd,SACiB;AACjB,QAAM,UAAM,mBAAO,cAAc;AAEjC,QAAM,WAAO,4BAAe;AAAA,IAC1B;AAAA,IACA,MAAM,QAAQ;AAAA,IACd,WAAW;AAAA,EACb,CAAC;AAED,MAAI,KAAK,WAAW,GAAG;AACrB,UAAM,IAAI,kBAAkB,eAAe,QAAQ,eAAe;AAAA,EACpE;AAEA,QAAM,QAAQ,KAAK,CAAC;AAEpB,SAAO;AAAA,IACL,iBAAiB,QAAQ;AAAA,IACzB,aAAa,QAAQ;AAAA,IACrB,SAAS,QAAQ;AAAA,IACjB,QAAQ,MAAM,KAAK;AAAA,IACnB,cAAc,MAAM,KAAK;AAAA,IACzB,KAAK,MAAM,KAAK;AAAA,IAChB,UAAU,MAAM,KAAK;AAAA,EACvB;AACF;AASO,SAAS,uBACd,SACoB;AACpB,QAAM,UAAM,mBAAO,qBAAqB;AAExC,QAAM,WAAO,4BAAe;AAAA,IAC1B;AAAA,IACA,MAAM,QAAQ;AAAA,IACd,WAAW;AAAA,EACb,CAAC;AAED,MAAI,KAAK,WAAW,GAAG;AACrB,UAAM,IAAI,kBAAkB,gBAAgB,QAAQ,eAAe;AAAA,EACrE;AAEA,QAAM,QAAQ,KAAK,CAAC;AACpB,SAAO;AAAA,IACL,iBAAiB,QAAQ;AAAA,IACzB,aAAa,QAAQ;AAAA,IACrB,SAAS,QAAQ;AAAA,IACjB,WAAW,MAAM,KAAK;AAAA,IACtB,OAAO,MAAM,KAAK;AAAA,IAClB,MAAM,MAAM,KAAK;AAAA,IACjB,UAAU,MAAM,KAAK;AAAA,IACrB,qBAAqB,MAAM,KAAK;AAAA,IAChC,0BAA0B,MAAM,KAAK;AAAA,EACvC;AACF;","names":[]}

package/dist/utils/eventParsing.d.cts

@@ -0,0 +1,60 @@
+import { Hash, TransactionReceipt } from 'viem';
+import { S as SchemaAddedResult, a as FileAddedResult, R as RefinerAddedResult } from '../permissions-DNKPu_G0.cjs';
+import '../types/operations.cjs';
+import '../generated/server/server-exports.cjs';
+import '../generated/server/server.cjs';
+import '../types/config.cjs';
+import '../types/chains.cjs';
+import '../types/storage.cjs';
+import '../types/permissions.cjs';
+import '../config/eventMappings.cjs';
+import '../generated/abi/index.cjs';
+import '../generated/abi/DataPortabilityPermissionsImplementation.cjs';
+import '../generated/abi/DataPortabilityServersImplementation.cjs';
+import '../generated/abi/DataPortabilityGranteesImplementation.cjs';
+import '../generated/abi/VanaEpochImplementation.cjs';
+import '../generated/abi/DLPRegistryImplementation.cjs';
+import '../generated/abi/DLPTreasuryImplementation.cjs';
+import '../generated/abi/DLPRewardDeployerTreasuryImplementation.cjs';
+import '../generated/abi/DLPPerformanceImplementation.cjs';
+import '../generated/abi/DLPRewardDeployerImplementation.cjs';
+import '../generated/abi/DLPRootImplementation.cjs';
+import '../generated/abi/DataLiquidityPoolImplementation.cjs';
+import '../generated/abi/DLPRegistryTreasuryImplementation.cjs';
+import '../storage/manager.cjs';
+import '../platform/interface.cjs';
+
+/**
+ * Error thrown when expected events are not found in transaction logs
+ */
+declare class EventParsingError extends Error {
+    readonly eventName: string;
+    readonly transactionHash: Hash;
+    constructor(eventName: string, transactionHash: Hash, message?: string);
+}
+/**
+ * Parses SchemaAdded event from a transaction receipt.
+ *
+ * @param receipt - The transaction receipt containing event logs.
+ * @returns A SchemaAddedResult with the schema ID and metadata from the event.
+ * @throws {EventParsingError} When the SchemaAdded event is not present in the receipt logs.
+ */
+declare function parseSchemaAddedEvent(receipt: TransactionReceipt): SchemaAddedResult;
+/**
+ * Parses FileAddedV2 event from a transaction receipt.
+ *
+ * @param receipt - The transaction receipt containing event logs.
+ * @returns A FileAddedResult with the file ID and metadata from the event.
+ * @throws {EventParsingError} When the FileAddedV2 event is not present in the receipt logs.
+ */
+declare function parseFileAddedEvent(receipt: TransactionReceipt): FileAddedResult;
+/**
+ * Parses RefinerAdded event from a transaction receipt.
+ *
+ * @param receipt - The transaction receipt containing event logs.
+ * @returns A RefinerAddedResult with the refiner ID and metadata from the event.
+ * @throws {EventParsingError} When the RefinerAdded event is not present in the receipt logs.
+ */
+declare function parseRefinerAddedEvent(receipt: TransactionReceipt): RefinerAddedResult;
+
+export { EventParsingError, parseFileAddedEvent, parseRefinerAddedEvent, parseSchemaAddedEvent };