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

package/dist/utils/download.cjs

@@ -18,11 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var download_exports = {};
 __export(download_exports, {
-  fetchWithRelayer: () => fetchWithRelayer
+  universalFetch: () => universalFetch
 });
 module.exports = __toCommonJS(download_exports);
 var import_ipfs = require("./ipfs");
-async function fetchWithRelayer(url, downloadRelayer) {
+async function universalFetch(url, downloadRelayer) {
   let processedUrl = url;
   if (url.startsWith("ar://")) {
     const txId = url.replace("ar://", "");
@@ -64,6 +64,6 @@ async function fetchWithRelayer(url, downloadRelayer) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  fetchWithRelayer
+  universalFetch
 });
 //# sourceMappingURL=download.cjs.map

package/dist/utils/download.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/download.ts"],"sourcesContent":["/**\n * Universal download utility with CORS bypass and IPFS gateway fallbacks\n *\n * @category Utilities\n */\n\nimport { fetchWithFallbacks, extractIpfsHash } from \"./ipfs\";\n\n/**\n * Fetch content with automatic fallbacks for CORS and IPFS\n *\n * @remarks\n * This utility provides a robust download mechanism that handles:\n * 1. Direct fetch for regular URLs\n * 2. Download relayer for CORS-restricted URLs\n * 3. IPFS gateway fallbacks for IPFS content\n *\n * The function automatically determines the best strategy based on the URL\n * and available configuration, providing transparent fallback behavior.\n *\n * @param url - The URL to fetch (HTTP, HTTPS, or IPFS)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to Response object\n * @throws Error if all download attempts fail\n * @example\n * ```typescript\n * // With download relayer configured\n * const response = await fetchWithRelayer(\n *   'https://drive.google.com/file.json',\n *   vana.downloadRelayer\n * );\n * const data = await response.json();\n *\n * // IPFS URL - will use gateway fallbacks\n * const ipfsResponse = await fetchWithRelayer('ipfs://QmHash123');\n * const content = await ipfsResponse.text();\n * ```\n */\nexport async function fetchWithRelayer(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<Response> {\n  // Handle Arweave URLs\n  let processedUrl = url;\n  if (url.startsWith(\"ar://\")) {\n    const txId = url.replace(\"ar://\", \"\");\n    processedUrl = `https://arweave.net/${txId}`;\n  }\n\n  // For IPFS URLs, use the IPFS fallback mechanism\n  const ipfsHash = extractIpfsHash(processedUrl);\n  if (ipfsHash) {\n    try {\n      return await fetchWithFallbacks(url);\n    } catch (ipfsError) {\n      // If all IPFS gateways fail and we have a relayer, try it as last resort\n      if (downloadRelayer) {\n        try {\n          // Try with the first gateway URL format\n          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;\n          const blob = await downloadRelayer.proxyDownload(gatewayUrl);\n          return new Response(blob);\n        } catch {\n          // Re-throw original IPFS error\n          throw ipfsError;\n        }\n      }\n      throw ipfsError;\n    }\n  }\n\n  // For non-IPFS URLs, try direct then relayer\n  try {\n    const response = await fetch(processedUrl);\n    return response;\n  } catch (error) {\n    // Try download relayer if configured\n    if (downloadRelayer) {\n      try {\n        const blob = await downloadRelayer.proxyDownload(processedUrl);\n        return new Response(blob);\n      } catch {\n        // Re-throw original error\n        throw error;\n      }\n    }\n    throw new Error(\n      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAAoD;AAiCpD,eAAsB,iBACpB,KACA,iBACmB;AAEnB,MAAI,eAAe;AACnB,MAAI,IAAI,WAAW,OAAO,GAAG;AAC3B,UAAM,OAAO,IAAI,QAAQ,SAAS,EAAE;AACpC,mBAAe,uBAAuB,IAAI;AAAA,EAC5C;AAGA,QAAM,eAAW,6BAAgB,YAAY;AAC7C,MAAI,UAAU;AACZ,QAAI;AACF,aAAO,UAAM,gCAAmB,GAAG;AAAA,IACrC,SAAS,WAAW;AAElB,UAAI,iBAAiB;AACnB,YAAI;AAEF,gBAAM,aAAa,qCAAqC,QAAQ;AAChE,gBAAM,OAAO,MAAM,gBAAgB,cAAc,UAAU;AAC3D,iBAAO,IAAI,SAAS,IAAI;AAAA,QAC1B,QAAQ;AAEN,gBAAM;AAAA,QACR;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAGA,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,YAAY;AACzC,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,QAAI,iBAAiB;AACnB,UAAI;AACF,cAAM,OAAO,MAAM,gBAAgB,cAAc,YAAY;AAC7D,eAAO,IAAI,SAAS,IAAI;AAAA,MAC1B,QAAQ;AAEN,cAAM;AAAA,MACR;AAAA,IACF;AACA,UAAM,IAAI;AAAA,MACR,wBAAwB,YAAY,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,IACnG;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/download.ts"],"sourcesContent":["/**\n * Universal download utility with CORS bypass and IPFS gateway fallbacks\n *\n * @category Utilities\n */\n\nimport { fetchWithFallbacks, extractIpfsHash } from \"./ipfs\";\n\n/**\n * Universal fetch with protocol support and automatic fallbacks\n *\n * @remarks\n * This utility provides a robust download mechanism that handles:\n * 1. IPFS URLs with automatic gateway fallbacks (5 different gateways)\n * 2. Arweave URLs with ar:// protocol conversion\n * 3. Regular HTTP/HTTPS URLs with optional CORS bypass via relayer\n * 4. Automatic fallback strategies for resilient downloads\n *\n * The function automatically determines the best strategy based on the URL\n * and available configuration, providing transparent fallback behavior.\n *\n * @param url - The URL to fetch (HTTP, HTTPS, IPFS, or Arweave)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to Response object\n * @throws Error if all download attempts fail\n * @example\n * ```typescript\n * // IPFS URL - automatically uses gateway fallbacks\n * const ipfsResponse = await universalFetch('ipfs://QmHash123');\n * const content = await ipfsResponse.text();\n *\n * // With optional download relayer for CORS bypass\n * const response = await universalFetch(\n *   'https://drive.google.com/file.json',\n *   vana.downloadRelayer\n * );\n * const data = await response.json();\n * ```\n */\nexport async function universalFetch(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<Response> {\n  // Handle Arweave URLs\n  let processedUrl = url;\n  if (url.startsWith(\"ar://\")) {\n    const txId = url.replace(\"ar://\", \"\");\n    processedUrl = `https://arweave.net/${txId}`;\n  }\n\n  // For IPFS URLs, use the IPFS fallback mechanism\n  const ipfsHash = extractIpfsHash(processedUrl);\n  if (ipfsHash) {\n    try {\n      return await fetchWithFallbacks(url);\n    } catch (ipfsError) {\n      // If all IPFS gateways fail and we have a relayer, try it as last resort\n      if (downloadRelayer) {\n        try {\n          // Try with the first gateway URL format\n          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;\n          const blob = await downloadRelayer.proxyDownload(gatewayUrl);\n          return new Response(blob);\n        } catch {\n          // Re-throw original IPFS error\n          throw ipfsError;\n        }\n      }\n      throw ipfsError;\n    }\n  }\n\n  // For non-IPFS URLs, try direct then relayer\n  try {\n    const response = await fetch(processedUrl);\n    return response;\n  } catch (error) {\n    // Try download relayer if configured\n    if (downloadRelayer) {\n      try {\n        const blob = await downloadRelayer.proxyDownload(processedUrl);\n        return new Response(blob);\n      } catch {\n        // Re-throw original error\n        throw error;\n      }\n    }\n    throw new Error(\n      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAAoD;AAkCpD,eAAsB,eACpB,KACA,iBACmB;AAEnB,MAAI,eAAe;AACnB,MAAI,IAAI,WAAW,OAAO,GAAG;AAC3B,UAAM,OAAO,IAAI,QAAQ,SAAS,EAAE;AACpC,mBAAe,uBAAuB,IAAI;AAAA,EAC5C;AAGA,QAAM,eAAW,6BAAgB,YAAY;AAC7C,MAAI,UAAU;AACZ,QAAI;AACF,aAAO,UAAM,gCAAmB,GAAG;AAAA,IACrC,SAAS,WAAW;AAElB,UAAI,iBAAiB;AACnB,YAAI;AAEF,gBAAM,aAAa,qCAAqC,QAAQ;AAChE,gBAAM,OAAO,MAAM,gBAAgB,cAAc,UAAU;AAC3D,iBAAO,IAAI,SAAS,IAAI;AAAA,QAC1B,QAAQ;AAEN,gBAAM;AAAA,QACR;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAGA,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,YAAY;AACzC,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,QAAI,iBAAiB;AACnB,UAAI;AACF,cAAM,OAAO,MAAM,gBAAgB,cAAc,YAAY;AAC7D,eAAO,IAAI,SAAS,IAAI;AAAA,MAC1B,QAAQ;AAEN,cAAM;AAAA,MACR;AAAA,IACF;AACA,UAAM,IAAI;AAAA,MACR,wBAAwB,YAAY,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,IACnG;AAAA,EACF;AACF;","names":[]}

package/dist/utils/download.d.ts

@@ -4,38 +4,37 @@
  * @category Utilities
  */
 /**
- * Fetch content with automatic fallbacks for CORS and IPFS
+ * Universal fetch with protocol support and automatic fallbacks
  *
  * @remarks
  * This utility provides a robust download mechanism that handles:
- * 1. Direct fetch for regular URLs
- * 2. Download relayer for CORS-restricted URLs
- * 3. IPFS gateway fallbacks for IPFS content
+ * 1. IPFS URLs with automatic gateway fallbacks (5 different gateways)
+ * 2. Arweave URLs with ar:// protocol conversion
+ * 3. Regular HTTP/HTTPS URLs with optional CORS bypass via relayer
+ * 4. Automatic fallback strategies for resilient downloads
  *
  * The function automatically determines the best strategy based on the URL
  * and available configuration, providing transparent fallback behavior.
  *
- * @param url - The URL to fetch (HTTP, HTTPS, or IPFS)
+ * @param url - The URL to fetch (HTTP, HTTPS, IPFS, or Arweave)
  * @param downloadRelayer - Optional download relayer for CORS bypass
  * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
  * @returns Promise resolving to Response object
  * @throws Error if all download attempts fail
  * @example
  * ```typescript
- * // With download relayer configured
- * const response = await fetchWithRelayer(
+ * // IPFS URL - automatically uses gateway fallbacks
+ * const ipfsResponse = await universalFetch('ipfs://QmHash123');
+ * const content = await ipfsResponse.text();
+ *
+ * // With optional download relayer for CORS bypass
+ * const response = await universalFetch(
  *   'https://drive.google.com/file.json',
  *   vana.downloadRelayer
  * );
  * const data = await response.json();
- *
- * // IPFS URL - will use gateway fallbacks
- * const ipfsResponse = await fetchWithRelayer('ipfs://QmHash123');
- * const content = await ipfsResponse.text();
  * ```
  */
-declare function fetchWithRelayer(url: string, downloadRelayer?: {
+export declare function universalFetch(url: string, downloadRelayer?: {
     proxyDownload: (url: string) => Promise<Blob>;
 }): Promise<Response>;
-
-export { fetchWithRelayer };

package/dist/utils/download.js

@@ -1,5 +1,5 @@
 import { fetchWithFallbacks, extractIpfsHash } from "./ipfs";
-async function fetchWithRelayer(url, downloadRelayer) {
+async function universalFetch(url, downloadRelayer) {
   let processedUrl = url;
   if (url.startsWith("ar://")) {
     const txId = url.replace("ar://", "");
@@ -40,6 +40,6 @@ async function fetchWithRelayer(url, downloadRelayer) {
   }
 }
 export {
-  fetchWithRelayer
+  universalFetch
 };
 //# sourceMappingURL=download.js.map

package/dist/utils/download.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/download.ts"],"sourcesContent":["/**\n * Universal download utility with CORS bypass and IPFS gateway fallbacks\n *\n * @category Utilities\n */\n\nimport { fetchWithFallbacks, extractIpfsHash } from \"./ipfs\";\n\n/**\n * Fetch content with automatic fallbacks for CORS and IPFS\n *\n * @remarks\n * This utility provides a robust download mechanism that handles:\n * 1. Direct fetch for regular URLs\n * 2. Download relayer for CORS-restricted URLs\n * 3. IPFS gateway fallbacks for IPFS content\n *\n * The function automatically determines the best strategy based on the URL\n * and available configuration, providing transparent fallback behavior.\n *\n * @param url - The URL to fetch (HTTP, HTTPS, or IPFS)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to Response object\n * @throws Error if all download attempts fail\n * @example\n * ```typescript\n * // With download relayer configured\n * const response = await fetchWithRelayer(\n *   'https://drive.google.com/file.json',\n *   vana.downloadRelayer\n * );\n * const data = await response.json();\n *\n * // IPFS URL - will use gateway fallbacks\n * const ipfsResponse = await fetchWithRelayer('ipfs://QmHash123');\n * const content = await ipfsResponse.text();\n * ```\n */\nexport async function fetchWithRelayer(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<Response> {\n  // Handle Arweave URLs\n  let processedUrl = url;\n  if (url.startsWith(\"ar://\")) {\n    const txId = url.replace(\"ar://\", \"\");\n    processedUrl = `https://arweave.net/${txId}`;\n  }\n\n  // For IPFS URLs, use the IPFS fallback mechanism\n  const ipfsHash = extractIpfsHash(processedUrl);\n  if (ipfsHash) {\n    try {\n      return await fetchWithFallbacks(url);\n    } catch (ipfsError) {\n      // If all IPFS gateways fail and we have a relayer, try it as last resort\n      if (downloadRelayer) {\n        try {\n          // Try with the first gateway URL format\n          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;\n          const blob = await downloadRelayer.proxyDownload(gatewayUrl);\n          return new Response(blob);\n        } catch {\n          // Re-throw original IPFS error\n          throw ipfsError;\n        }\n      }\n      throw ipfsError;\n    }\n  }\n\n  // For non-IPFS URLs, try direct then relayer\n  try {\n    const response = await fetch(processedUrl);\n    return response;\n  } catch (error) {\n    // Try download relayer if configured\n    if (downloadRelayer) {\n      try {\n        const blob = await downloadRelayer.proxyDownload(processedUrl);\n        return new Response(blob);\n      } catch {\n        // Re-throw original error\n        throw error;\n      }\n    }\n    throw new Error(\n      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n"],"mappings":"AAMA,SAAS,oBAAoB,uBAAuB;AAiCpD,eAAsB,iBACpB,KACA,iBACmB;AAEnB,MAAI,eAAe;AACnB,MAAI,IAAI,WAAW,OAAO,GAAG;AAC3B,UAAM,OAAO,IAAI,QAAQ,SAAS,EAAE;AACpC,mBAAe,uBAAuB,IAAI;AAAA,EAC5C;AAGA,QAAM,WAAW,gBAAgB,YAAY;AAC7C,MAAI,UAAU;AACZ,QAAI;AACF,aAAO,MAAM,mBAAmB,GAAG;AAAA,IACrC,SAAS,WAAW;AAElB,UAAI,iBAAiB;AACnB,YAAI;AAEF,gBAAM,aAAa,qCAAqC,QAAQ;AAChE,gBAAM,OAAO,MAAM,gBAAgB,cAAc,UAAU;AAC3D,iBAAO,IAAI,SAAS,IAAI;AAAA,QAC1B,QAAQ;AAEN,gBAAM;AAAA,QACR;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAGA,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,YAAY;AACzC,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,QAAI,iBAAiB;AACnB,UAAI;AACF,cAAM,OAAO,MAAM,gBAAgB,cAAc,YAAY;AAC7D,eAAO,IAAI,SAAS,IAAI;AAAA,MAC1B,QAAQ;AAEN,cAAM;AAAA,MACR;AAAA,IACF;AACA,UAAM,IAAI;AAAA,MACR,wBAAwB,YAAY,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,IACnG;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/utils/download.ts"],"sourcesContent":["/**\n * Universal download utility with CORS bypass and IPFS gateway fallbacks\n *\n * @category Utilities\n */\n\nimport { fetchWithFallbacks, extractIpfsHash } from \"./ipfs\";\n\n/**\n * Universal fetch with protocol support and automatic fallbacks\n *\n * @remarks\n * This utility provides a robust download mechanism that handles:\n * 1. IPFS URLs with automatic gateway fallbacks (5 different gateways)\n * 2. Arweave URLs with ar:// protocol conversion\n * 3. Regular HTTP/HTTPS URLs with optional CORS bypass via relayer\n * 4. Automatic fallback strategies for resilient downloads\n *\n * The function automatically determines the best strategy based on the URL\n * and available configuration, providing transparent fallback behavior.\n *\n * @param url - The URL to fetch (HTTP, HTTPS, IPFS, or Arweave)\n * @param downloadRelayer - Optional download relayer for CORS bypass\n * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server\n * @returns Promise resolving to Response object\n * @throws Error if all download attempts fail\n * @example\n * ```typescript\n * // IPFS URL - automatically uses gateway fallbacks\n * const ipfsResponse = await universalFetch('ipfs://QmHash123');\n * const content = await ipfsResponse.text();\n *\n * // With optional download relayer for CORS bypass\n * const response = await universalFetch(\n *   'https://drive.google.com/file.json',\n *   vana.downloadRelayer\n * );\n * const data = await response.json();\n * ```\n */\nexport async function universalFetch(\n  url: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<Response> {\n  // Handle Arweave URLs\n  let processedUrl = url;\n  if (url.startsWith(\"ar://\")) {\n    const txId = url.replace(\"ar://\", \"\");\n    processedUrl = `https://arweave.net/${txId}`;\n  }\n\n  // For IPFS URLs, use the IPFS fallback mechanism\n  const ipfsHash = extractIpfsHash(processedUrl);\n  if (ipfsHash) {\n    try {\n      return await fetchWithFallbacks(url);\n    } catch (ipfsError) {\n      // If all IPFS gateways fail and we have a relayer, try it as last resort\n      if (downloadRelayer) {\n        try {\n          // Try with the first gateway URL format\n          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;\n          const blob = await downloadRelayer.proxyDownload(gatewayUrl);\n          return new Response(blob);\n        } catch {\n          // Re-throw original IPFS error\n          throw ipfsError;\n        }\n      }\n      throw ipfsError;\n    }\n  }\n\n  // For non-IPFS URLs, try direct then relayer\n  try {\n    const response = await fetch(processedUrl);\n    return response;\n  } catch (error) {\n    // Try download relayer if configured\n    if (downloadRelayer) {\n      try {\n        const blob = await downloadRelayer.proxyDownload(processedUrl);\n        return new Response(blob);\n      } catch {\n        // Re-throw original error\n        throw error;\n      }\n    }\n    throw new Error(\n      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n"],"mappings":"AAMA,SAAS,oBAAoB,uBAAuB;AAkCpD,eAAsB,eACpB,KACA,iBACmB;AAEnB,MAAI,eAAe;AACnB,MAAI,IAAI,WAAW,OAAO,GAAG;AAC3B,UAAM,OAAO,IAAI,QAAQ,SAAS,EAAE;AACpC,mBAAe,uBAAuB,IAAI;AAAA,EAC5C;AAGA,QAAM,WAAW,gBAAgB,YAAY;AAC7C,MAAI,UAAU;AACZ,QAAI;AACF,aAAO,MAAM,mBAAmB,GAAG;AAAA,IACrC,SAAS,WAAW;AAElB,UAAI,iBAAiB;AACnB,YAAI;AAEF,gBAAM,aAAa,qCAAqC,QAAQ;AAChE,gBAAM,OAAO,MAAM,gBAAgB,cAAc,UAAU;AAC3D,iBAAO,IAAI,SAAS,IAAI;AAAA,QAC1B,QAAQ;AAEN,gBAAM;AAAA,QACR;AAAA,MACF;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAGA,MAAI;AACF,UAAM,WAAW,MAAM,MAAM,YAAY;AACzC,WAAO;AAAA,EACT,SAAS,OAAO;AAEd,QAAI,iBAAiB;AACnB,UAAI;AACF,cAAM,OAAO,MAAM,gBAAgB,cAAc,YAAY;AAC7D,eAAO,IAAI,SAAS,IAAI;AAAA,MAC1B,QAAQ;AAEN,cAAM;AAAA,MACR;AAAA,IACF;AACA,UAAM,IAAI;AAAA,MACR,wBAAwB,YAAY,KAAK,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,IACnG;AAAA,EACF;AACF;","names":[]}

package/dist/utils/encoding.cjs

@@ -51,7 +51,7 @@ function fromBase64(str) {
   throw new Error("No base64 decoding method available in this environment");
 }
 function isNodeEnvironment() {
-  return typeof Buffer !== "undefined" && typeof Buffer.from === "function" && typeof process !== "undefined" && process.versions && process.versions.node !== void 0;
+  return typeof Buffer !== "undefined" && typeof Buffer.from === "function" && typeof process !== "undefined" && process.versions?.node !== void 0;
 }
 function isBrowserEnvironment() {
   return typeof window !== "undefined" && typeof window.document !== "undefined";

package/dist/utils/encoding.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/encoding.ts"],"sourcesContent":["/**\n * Provides platform-aware base64 encoding utilities.\n *\n * @remarks\n * This module provides base64 encoding/decoding operations across Node.js and browser\n * environments. For hex and string conversions, use viem's utilities directly:\n * - `toHex` / `fromHex` from 'viem'\n * - `stringToBytes` / `bytesToString` from 'viem'\n *\n * @category Utilities\n */\n\n/**\n * Converts a Uint8Array to a base64 string.\n *\n * @param data - The byte array to encode into base64 format.\n * @returns The base64-encoded string representation.\n * @throws {Error} When no base64 encoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([72, 101, 108, 108, 111]);\n * const encoded = toBase64(bytes);\n * console.log(encoded); // \"SGVsbG8=\"\n * ```\n */\nexport function toBase64(data: Uint8Array): string {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return Buffer.from(data).toString(\"base64\");\n  }\n\n  // Browser path - using native btoa\n  if (typeof btoa !== \"undefined\") {\n    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(\n      \"\",\n    );\n    return btoa(binary);\n  }\n\n  throw new Error(\"No base64 encoding method available in this environment\");\n}\n\n/**\n * Converts a base64 string to a Uint8Array.\n *\n * @param str - The base64-encoded string to decode.\n * @returns The decoded byte array.\n * @throws {Error} When no base64 decoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const decoded = fromBase64(\"SGVsbG8=\");\n * console.log(new TextDecoder().decode(decoded)); // \"Hello\"\n * ```\n */\nexport function fromBase64(str: string): Uint8Array {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return new Uint8Array(Buffer.from(str, \"base64\"));\n  }\n\n  // Browser path - using native atob\n  if (typeof atob !== \"undefined\") {\n    const binary = atob(str);\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n      bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n  }\n\n  throw new Error(\"No base64 decoding method available in this environment\");\n}\n\n/**\n * Type guard to check if running in Node.js environment\n *\n * @returns True if running in Node.js\n */\nexport function isNodeEnvironment(): boolean {\n  return (\n    typeof Buffer !== \"undefined\" &&\n    typeof Buffer.from === \"function\" &&\n    typeof process !== \"undefined\" &&\n    process.versions &&\n    process.versions.node !== undefined\n  );\n}\n\n/**\n * Type guard to check if running in browser environment\n *\n * @returns True if running in browser\n */\nexport function isBrowserEnvironment(): boolean {\n  return (\n    typeof window !== \"undefined\" && typeof window.document !== \"undefined\"\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BO,SAAS,SAAS,MAA0B;AAEjD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,OAAO,KAAK,IAAI,EAAE,SAAS,QAAQ;AAAA,EAC5C;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,MAAM,KAAK,MAAM,CAAC,SAAS,OAAO,aAAa,IAAI,CAAC,EAAE;AAAA,MACnE;AAAA,IACF;AACA,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAeO,SAAS,WAAW,KAAyB;AAElD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,IAAI,WAAW,OAAO,KAAK,KAAK,QAAQ,CAAC;AAAA,EAClD;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,KAAK,GAAG;AACvB,UAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;AAC1C,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,CAAC,IAAI,OAAO,WAAW,CAAC;AAAA,IAChC;AACA,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAOO,SAAS,oBAA6B;AAC3C,SACE,OAAO,WAAW,eAClB,OAAO,OAAO,SAAS,cACvB,OAAO,YAAY,eACnB,QAAQ,YACR,QAAQ,SAAS,SAAS;AAE9B;AAOO,SAAS,uBAAgC;AAC9C,SACE,OAAO,WAAW,eAAe,OAAO,OAAO,aAAa;AAEhE;","names":[]}
+{"version":3,"sources":["../../src/utils/encoding.ts"],"sourcesContent":["/**\n * Provides platform-aware base64 encoding utilities.\n *\n * @remarks\n * This module provides base64 encoding/decoding operations across Node.js and browser\n * environments. For hex and string conversions, use viem's utilities directly:\n * - `toHex` / `fromHex` from 'viem'\n * - `stringToBytes` / `bytesToString` from 'viem'\n *\n * @category Utilities\n */\n\n/**\n * Converts a Uint8Array to a base64 string.\n *\n * @param data - The byte array to encode into base64 format.\n * @returns The base64-encoded string representation.\n * @throws {Error} When no base64 encoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([72, 101, 108, 108, 111]);\n * const encoded = toBase64(bytes);\n * console.log(encoded); // \"SGVsbG8=\"\n * ```\n */\nexport function toBase64(data: Uint8Array): string {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return Buffer.from(data).toString(\"base64\");\n  }\n\n  // Browser path - using native btoa\n  if (typeof btoa !== \"undefined\") {\n    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(\n      \"\",\n    );\n    return btoa(binary);\n  }\n\n  throw new Error(\"No base64 encoding method available in this environment\");\n}\n\n/**\n * Converts a base64 string to a Uint8Array.\n *\n * @param str - The base64-encoded string to decode.\n * @returns The decoded byte array.\n * @throws {Error} When no base64 decoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const decoded = fromBase64(\"SGVsbG8=\");\n * console.log(new TextDecoder().decode(decoded)); // \"Hello\"\n * ```\n */\nexport function fromBase64(str: string): Uint8Array {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return new Uint8Array(Buffer.from(str, \"base64\"));\n  }\n\n  // Browser path - using native atob\n  if (typeof atob !== \"undefined\") {\n    const binary = atob(str);\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n      bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n  }\n\n  throw new Error(\"No base64 decoding method available in this environment\");\n}\n\n/**\n * Type guard to check if running in Node.js environment\n *\n * @returns True if running in Node.js\n */\nexport function isNodeEnvironment(): boolean {\n  return (\n    typeof Buffer !== \"undefined\" &&\n    typeof Buffer.from === \"function\" &&\n    typeof process !== \"undefined\" &&\n    process.versions?.node !== undefined\n  );\n}\n\n/**\n * Type guard to check if running in browser environment\n *\n * @returns True if running in browser\n */\nexport function isBrowserEnvironment(): boolean {\n  return (\n    typeof window !== \"undefined\" && typeof window.document !== \"undefined\"\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA0BO,SAAS,SAAS,MAA0B;AAEjD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,OAAO,KAAK,IAAI,EAAE,SAAS,QAAQ;AAAA,EAC5C;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,MAAM,KAAK,MAAM,CAAC,SAAS,OAAO,aAAa,IAAI,CAAC,EAAE;AAAA,MACnE;AAAA,IACF;AACA,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAeO,SAAS,WAAW,KAAyB;AAElD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,IAAI,WAAW,OAAO,KAAK,KAAK,QAAQ,CAAC;AAAA,EAClD;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,KAAK,GAAG;AACvB,UAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;AAC1C,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,CAAC,IAAI,OAAO,WAAW,CAAC;AAAA,IAChC;AACA,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAOO,SAAS,oBAA6B;AAC3C,SACE,OAAO,WAAW,eAClB,OAAO,OAAO,SAAS,cACvB,OAAO,YAAY,eACnB,QAAQ,UAAU,SAAS;AAE/B;AAOO,SAAS,uBAAgC;AAC9C,SACE,OAAO,WAAW,eAAe,OAAO,OAAO,aAAa;AAEhE;","names":[]}

package/dist/utils/encoding.d.ts

@@ -23,7 +23,7 @@
  * console.log(encoded); // "SGVsbG8="
  * ```
  */
-declare function toBase64(data: Uint8Array): string;
+export declare function toBase64(data: Uint8Array): string;
 /**
  * Converts a base64 string to a Uint8Array.
  *
@@ -37,18 +37,16 @@ declare function toBase64(data: Uint8Array): string;
  * console.log(new TextDecoder().decode(decoded)); // "Hello"
  * ```
  */
-declare function fromBase64(str: string): Uint8Array;
+export declare function fromBase64(str: string): Uint8Array;
 /**
  * Type guard to check if running in Node.js environment
  *
  * @returns True if running in Node.js
  */
-declare function isNodeEnvironment(): boolean;
+export declare function isNodeEnvironment(): boolean;
 /**
  * Type guard to check if running in browser environment
  *
  * @returns True if running in browser
  */
-declare function isBrowserEnvironment(): boolean;
-
-export { fromBase64, isBrowserEnvironment, isNodeEnvironment, toBase64 };
+export declare function isBrowserEnvironment(): boolean;

package/dist/utils/encoding.js

@@ -25,7 +25,7 @@ function fromBase64(str) {
   throw new Error("No base64 decoding method available in this environment");
 }
 function isNodeEnvironment() {
-  return typeof Buffer !== "undefined" && typeof Buffer.from === "function" && typeof process !== "undefined" && process.versions && process.versions.node !== void 0;
+  return typeof Buffer !== "undefined" && typeof Buffer.from === "function" && typeof process !== "undefined" && process.versions?.node !== void 0;
 }
 function isBrowserEnvironment() {
   return typeof window !== "undefined" && typeof window.document !== "undefined";

package/dist/utils/encoding.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/encoding.ts"],"sourcesContent":["/**\n * Provides platform-aware base64 encoding utilities.\n *\n * @remarks\n * This module provides base64 encoding/decoding operations across Node.js and browser\n * environments. For hex and string conversions, use viem's utilities directly:\n * - `toHex` / `fromHex` from 'viem'\n * - `stringToBytes` / `bytesToString` from 'viem'\n *\n * @category Utilities\n */\n\n/**\n * Converts a Uint8Array to a base64 string.\n *\n * @param data - The byte array to encode into base64 format.\n * @returns The base64-encoded string representation.\n * @throws {Error} When no base64 encoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([72, 101, 108, 108, 111]);\n * const encoded = toBase64(bytes);\n * console.log(encoded); // \"SGVsbG8=\"\n * ```\n */\nexport function toBase64(data: Uint8Array): string {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return Buffer.from(data).toString(\"base64\");\n  }\n\n  // Browser path - using native btoa\n  if (typeof btoa !== \"undefined\") {\n    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(\n      \"\",\n    );\n    return btoa(binary);\n  }\n\n  throw new Error(\"No base64 encoding method available in this environment\");\n}\n\n/**\n * Converts a base64 string to a Uint8Array.\n *\n * @param str - The base64-encoded string to decode.\n * @returns The decoded byte array.\n * @throws {Error} When no base64 decoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const decoded = fromBase64(\"SGVsbG8=\");\n * console.log(new TextDecoder().decode(decoded)); // \"Hello\"\n * ```\n */\nexport function fromBase64(str: string): Uint8Array {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return new Uint8Array(Buffer.from(str, \"base64\"));\n  }\n\n  // Browser path - using native atob\n  if (typeof atob !== \"undefined\") {\n    const binary = atob(str);\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n      bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n  }\n\n  throw new Error(\"No base64 decoding method available in this environment\");\n}\n\n/**\n * Type guard to check if running in Node.js environment\n *\n * @returns True if running in Node.js\n */\nexport function isNodeEnvironment(): boolean {\n  return (\n    typeof Buffer !== \"undefined\" &&\n    typeof Buffer.from === \"function\" &&\n    typeof process !== \"undefined\" &&\n    process.versions &&\n    process.versions.node !== undefined\n  );\n}\n\n/**\n * Type guard to check if running in browser environment\n *\n * @returns True if running in browser\n */\nexport function isBrowserEnvironment(): boolean {\n  return (\n    typeof window !== \"undefined\" && typeof window.document !== \"undefined\"\n  );\n}\n"],"mappings":"AA0BO,SAAS,SAAS,MAA0B;AAEjD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,OAAO,KAAK,IAAI,EAAE,SAAS,QAAQ;AAAA,EAC5C;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,MAAM,KAAK,MAAM,CAAC,SAAS,OAAO,aAAa,IAAI,CAAC,EAAE;AAAA,MACnE;AAAA,IACF;AACA,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAeO,SAAS,WAAW,KAAyB;AAElD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,IAAI,WAAW,OAAO,KAAK,KAAK,QAAQ,CAAC;AAAA,EAClD;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,KAAK,GAAG;AACvB,UAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;AAC1C,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,CAAC,IAAI,OAAO,WAAW,CAAC;AAAA,IAChC;AACA,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAOO,SAAS,oBAA6B;AAC3C,SACE,OAAO,WAAW,eAClB,OAAO,OAAO,SAAS,cACvB,OAAO,YAAY,eACnB,QAAQ,YACR,QAAQ,SAAS,SAAS;AAE9B;AAOO,SAAS,uBAAgC;AAC9C,SACE,OAAO,WAAW,eAAe,OAAO,OAAO,aAAa;AAEhE;","names":[]}
+{"version":3,"sources":["../../src/utils/encoding.ts"],"sourcesContent":["/**\n * Provides platform-aware base64 encoding utilities.\n *\n * @remarks\n * This module provides base64 encoding/decoding operations across Node.js and browser\n * environments. For hex and string conversions, use viem's utilities directly:\n * - `toHex` / `fromHex` from 'viem'\n * - `stringToBytes` / `bytesToString` from 'viem'\n *\n * @category Utilities\n */\n\n/**\n * Converts a Uint8Array to a base64 string.\n *\n * @param data - The byte array to encode into base64 format.\n * @returns The base64-encoded string representation.\n * @throws {Error} When no base64 encoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([72, 101, 108, 108, 111]);\n * const encoded = toBase64(bytes);\n * console.log(encoded); // \"SGVsbG8=\"\n * ```\n */\nexport function toBase64(data: Uint8Array): string {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return Buffer.from(data).toString(\"base64\");\n  }\n\n  // Browser path - using native btoa\n  if (typeof btoa !== \"undefined\") {\n    const binary = Array.from(data, (byte) => String.fromCharCode(byte)).join(\n      \"\",\n    );\n    return btoa(binary);\n  }\n\n  throw new Error(\"No base64 encoding method available in this environment\");\n}\n\n/**\n * Converts a base64 string to a Uint8Array.\n *\n * @param str - The base64-encoded string to decode.\n * @returns The decoded byte array.\n * @throws {Error} When no base64 decoding method is available in the environment.\n *\n * @example\n * ```typescript\n * const decoded = fromBase64(\"SGVsbG8=\");\n * console.log(new TextDecoder().decode(decoded)); // \"Hello\"\n * ```\n */\nexport function fromBase64(str: string): Uint8Array {\n  // Node.js path - most efficient\n  if (typeof Buffer !== \"undefined\" && Buffer.from) {\n    return new Uint8Array(Buffer.from(str, \"base64\"));\n  }\n\n  // Browser path - using native atob\n  if (typeof atob !== \"undefined\") {\n    const binary = atob(str);\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n      bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n  }\n\n  throw new Error(\"No base64 decoding method available in this environment\");\n}\n\n/**\n * Type guard to check if running in Node.js environment\n *\n * @returns True if running in Node.js\n */\nexport function isNodeEnvironment(): boolean {\n  return (\n    typeof Buffer !== \"undefined\" &&\n    typeof Buffer.from === \"function\" &&\n    typeof process !== \"undefined\" &&\n    process.versions?.node !== undefined\n  );\n}\n\n/**\n * Type guard to check if running in browser environment\n *\n * @returns True if running in browser\n */\nexport function isBrowserEnvironment(): boolean {\n  return (\n    typeof window !== \"undefined\" && typeof window.document !== \"undefined\"\n  );\n}\n"],"mappings":"AA0BO,SAAS,SAAS,MAA0B;AAEjD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,OAAO,KAAK,IAAI,EAAE,SAAS,QAAQ;AAAA,EAC5C;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,MAAM,KAAK,MAAM,CAAC,SAAS,OAAO,aAAa,IAAI,CAAC,EAAE;AAAA,MACnE;AAAA,IACF;AACA,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAeO,SAAS,WAAW,KAAyB;AAElD,MAAI,OAAO,WAAW,eAAe,OAAO,MAAM;AAChD,WAAO,IAAI,WAAW,OAAO,KAAK,KAAK,QAAQ,CAAC;AAAA,EAClD;AAGA,MAAI,OAAO,SAAS,aAAa;AAC/B,UAAM,SAAS,KAAK,GAAG;AACvB,UAAM,QAAQ,IAAI,WAAW,OAAO,MAAM;AAC1C,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,YAAM,CAAC,IAAI,OAAO,WAAW,CAAC;AAAA,IAChC;AACA,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,yDAAyD;AAC3E;AAOO,SAAS,oBAA6B;AAC3C,SACE,OAAO,WAAW,eAClB,OAAO,OAAO,SAAS,cACvB,OAAO,YAAY,eACnB,QAAQ,UAAU,SAAS;AAE/B;AAOO,SAAS,uBAAgC;AAC9C,SACE,OAAO,WAAW,eAAe,OAAO,OAAO,aAAa;AAEhE;","names":[]}

package/dist/utils/encoding.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/encryption.cjs

@@ -37,7 +37,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 (0, import_signatureCache.withSignatureCache)(
     platformAdapter.cache,
@@ -59,7 +59,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) {
@@ -69,7 +71,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) {
@@ -79,7 +83,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) {
@@ -90,7 +94,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) {
@@ -100,7 +106,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) {
@@ -119,21 +125,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) {
@@ -150,7 +156,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)}`);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/utils/encryption.cjs.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":"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","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/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 {