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

package/dist/platform/browser.cjs

@@ -0,0 +1,329 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_exports = {};
+__export(browser_exports, {
+  BrowserPlatformAdapter: () => BrowserPlatformAdapter
+});
+module.exports = __toCommonJS(browser_exports);
+var import_pgp_utils = require("./shared/pgp-utils");
+var import_error_utils = require("./shared/error-utils");
+var import_lazy_import = require("../utils/lazy-import");
+var import_WalletKeyEncryptionService = require("../crypto/services/WalletKeyEncryptionService");
+var import_crypto_utils = require("../utils/crypto-utils");
+var import_viem = require("viem");
+var import_utils = require("../crypto/ecies/utils");
+var secp256k1 = __toESM(require("@noble/secp256k1"), 1);
+var import_features = require("../config/features");
+var import_browser = require("../crypto/ecies/browser");
+const getOpenPGP = (0, import_lazy_import.lazyImport)(() => import("openpgp"));
+const getEccryptoJS = (0, import_lazy_import.lazyImport)(() => import("eccrypto-js"));
+class BrowserCryptoAdapter {
+  // Initialize both providers - only one will be used based on feature flag
+  customEciesProvider = new import_browser.BrowserECIESUint8Provider();
+  customWalletService = new import_WalletKeyEncryptionService.WalletKeyEncryptionService({
+    eciesProvider: this.customEciesProvider
+  });
+  async encryptWithPublicKey(data, publicKeyHex) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const prefixedHex = publicKeyHex.startsWith("0x") ? publicKeyHex : `0x${publicKeyHex}`;
+        const publicKeyBytes = (0, import_viem.fromHex)(prefixedHex, "bytes");
+        const encrypted = await this.customEciesProvider.encrypt(
+          publicKeyBytes,
+          (0, import_viem.stringToBytes)(data)
+        );
+        const result = (0, import_utils.concatBytes)(
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        );
+        return (0, import_viem.toHex)(result).slice(2);
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const cleanKey = publicKeyHex.startsWith("0x") ? publicKeyHex.slice(2) : publicKeyHex;
+        const publicKeyBytes = Buffer.from(cleanKey, "hex");
+        const publicKeyBuffer = publicKeyBytes.length === 64 ? Buffer.concat([Buffer.from([4]), publicKeyBytes]) : publicKeyBytes;
+        const message = Buffer.from(data, "utf8");
+        const encrypted = await eccryptojs.encrypt(publicKeyBuffer, message);
+        const result = Buffer.concat([
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        ]);
+        return result.toString("hex");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("encryptWithPublicKey", error);
+    }
+  }
+  async decryptWithPrivateKey(encryptedData, privateKeyHex) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const encryptedHex = encryptedData.startsWith("0x") ? encryptedData : `0x${encryptedData}`;
+        const privateHex = privateKeyHex.startsWith("0x") ? privateKeyHex : `0x${privateKeyHex}`;
+        const encryptedBytes = (0, import_viem.fromHex)(encryptedHex, "bytes");
+        const privateKeyBytes = (0, import_viem.fromHex)(privateHex, "bytes");
+        const encrypted = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBytes);
+        const decrypted = await this.customEciesProvider.decrypt(
+          privateKeyBytes,
+          encrypted
+        );
+        return (0, import_viem.bytesToString)(decrypted);
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const privateKey = Buffer.from(privateKeyHex, "hex");
+        const encryptedBuffer = Buffer.from(encryptedData, "hex");
+        const { iv, ephemPublicKey, ciphertext, mac } = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBuffer);
+        const decrypted = await eccryptojs.decrypt(privateKey, {
+          iv: Buffer.from(iv),
+          ephemPublicKey: Buffer.from(ephemPublicKey),
+          ciphertext: Buffer.from(ciphertext),
+          mac: Buffer.from(mac)
+        });
+        return decrypted.toString("utf8");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("decryptWithPrivateKey", error);
+    }
+  }
+  async encryptWithWalletPublicKey(data, publicKey) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        return await this.customWalletService.encryptWithWalletPublicKey(
+          data,
+          publicKey
+        );
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const cleanKey = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+        const publicKeyBytes = Buffer.from(cleanKey, "hex");
+        const publicKeyBuffer = publicKeyBytes.length === 64 ? Buffer.concat([Buffer.from([4]), publicKeyBytes]) : publicKeyBytes;
+        const message = Buffer.from(data, "utf8");
+        const encrypted = await eccryptojs.encrypt(publicKeyBuffer, message);
+        const result = Buffer.concat([
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        ]);
+        return result.toString("hex");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("encryptWithWalletPublicKey", error);
+    }
+  }
+  async decryptWithWalletPrivateKey(encryptedData, privateKey) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        return await this.customWalletService.decryptWithWalletPrivateKey(
+          encryptedData,
+          privateKey
+        );
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const privateKeyBuffer = Buffer.from(privateKey, "hex");
+        const encryptedBuffer = Buffer.from(encryptedData, "hex");
+        const { iv, ephemPublicKey, ciphertext, mac } = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBuffer);
+        const decrypted = await eccryptojs.decrypt(privateKeyBuffer, {
+          iv: Buffer.from(iv),
+          ephemPublicKey: Buffer.from(ephemPublicKey),
+          ciphertext: Buffer.from(ciphertext),
+          mac: Buffer.from(mac)
+        });
+        return decrypted.toString("utf8");
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("decryptWithWalletPrivateKey", error);
+    }
+  }
+  async generateKeyPair() {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const privateKeyBytes = secp256k1.utils.randomPrivateKey();
+        const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
+        return {
+          privateKey: (0, import_viem.toHex)(privateKeyBytes).slice(2),
+          publicKey: (0, import_viem.toHex)(publicKeyBytes).slice(2)
+        };
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const privateKey = eccryptojs.generatePrivate();
+        const publicKey = eccryptojs.getPublic(privateKey);
+        return {
+          privateKey: privateKey.toString("hex"),
+          publicKey: publicKey.toString("hex")
+        };
+      }
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("generateKeyPair", error);
+    }
+  }
+  async encryptWithPassword(data, password) {
+    try {
+      const openpgp = await getOpenPGP();
+      const message = await openpgp.createMessage({ binary: data });
+      const encrypted = await openpgp.encrypt({
+        message,
+        passwords: [password],
+        format: "binary"
+      });
+      return new Uint8Array(encrypted);
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("encryptWithPassword", error);
+    }
+  }
+  async decryptWithPassword(encryptedData, password) {
+    try {
+      const openpgp = await getOpenPGP();
+      const message = await openpgp.readMessage({
+        binaryMessage: encryptedData
+      });
+      const { data } = await openpgp.decrypt({
+        message,
+        passwords: [password],
+        format: "binary"
+      });
+      return new Uint8Array(data);
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("decryptWithPassword", error);
+    }
+  }
+}
+class BrowserPGPAdapter {
+  async encrypt(data, publicKeyArmored) {
+    try {
+      const openpgp = await getOpenPGP();
+      const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
+      const encrypted = await openpgp.encrypt({
+        message: await openpgp.createMessage({ text: data }),
+        encryptionKeys: publicKey,
+        config: {
+          preferredCompressionAlgorithm: openpgp.enums.compression.zlib
+        }
+      });
+      return encrypted;
+    } catch (error) {
+      throw new Error(`PGP encryption failed: ${error}`);
+    }
+  }
+  async decrypt(encryptedData, privateKeyArmored) {
+    try {
+      const openpgp = await getOpenPGP();
+      const privateKey = await openpgp.readPrivateKey({
+        armoredKey: privateKeyArmored
+      });
+      const message = await openpgp.readMessage({
+        armoredMessage: encryptedData
+      });
+      const { data: decrypted } = await openpgp.decrypt({
+        message,
+        decryptionKeys: privateKey
+      });
+      return decrypted;
+    } catch (error) {
+      throw new Error(`PGP decryption failed: ${error}`);
+    }
+  }
+  async generateKeyPair(options) {
+    try {
+      const openpgp = await getOpenPGP();
+      const keyGenParams = (0, import_pgp_utils.getPGPKeyGenParams)(options);
+      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
+      return { publicKey, privateKey };
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("PGP key generation", error);
+    }
+  }
+}
+class BrowserHttpAdapter {
+  async fetch(url, options) {
+    return fetch(url, options);
+  }
+}
+class BrowserCacheAdapter {
+  prefix = "vana_cache_";
+  get(key) {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return null;
+      }
+      return sessionStorage.getItem(this.prefix + key);
+    } catch {
+      return null;
+    }
+  }
+  set(key, value) {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return;
+      }
+      sessionStorage.setItem(this.prefix + key, value);
+    } catch {
+    }
+  }
+  delete(key) {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return;
+      }
+      sessionStorage.removeItem(this.prefix + key);
+    } catch {
+    }
+  }
+  clear() {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return;
+      }
+      const keysToRemove = [];
+      for (let i = 0; i < sessionStorage.length; i++) {
+        const key = sessionStorage.key(i);
+        if (key?.startsWith(this.prefix)) {
+          keysToRemove.push(key);
+        }
+      }
+      keysToRemove.forEach((key) => sessionStorage.removeItem(key));
+    } catch {
+    }
+  }
+}
+class BrowserPlatformAdapter {
+  crypto = new BrowserCryptoAdapter();
+  pgp = new BrowserPGPAdapter();
+  http = new BrowserHttpAdapter();
+  cache = new BrowserCacheAdapter();
+  platform = "browser";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserPlatformAdapter
+});
+//# sourceMappingURL=browser.cjs.map

package/dist/platform/browser.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser.ts"],"sourcesContent":["/**\n * Browser implementation of the Vana Platform Adapter using Uint8Array\n *\n * This implementation uses browser-compatible libraries and native APIs\n * without requiring Buffer or other Node.js polyfills.\n */\n\nimport type {\n  VanaPlatformAdapter,\n  VanaCryptoAdapter,\n  VanaPGPAdapter,\n  VanaHttpAdapter,\n  VanaCacheAdapter,\n} from \"./interface\";\nimport { getPGPKeyGenParams } from \"./shared/pgp-utils\";\nimport { wrapCryptoError } from \"./shared/error-utils\";\nimport { lazyImport } from \"../utils/lazy-import\";\nimport { WalletKeyEncryptionService } from \"../crypto/services/WalletKeyEncryptionService\";\nimport { parseEncryptedDataBuffer } from \"../utils/crypto-utils\";\nimport { toHex, fromHex, stringToBytes, bytesToString } from \"viem\";\nimport { concatBytes } from \"../crypto/ecies/utils\";\nimport * as secp256k1 from \"@noble/secp256k1\";\nimport { features } from \"../config/features\";\n\n// Import browser ECIES provider\nimport { BrowserECIESUint8Provider } from \"../crypto/ecies/browser\";\n\n// Lazy-loaded dependencies to avoid Turbopack TDZ issues\nconst getOpenPGP = lazyImport(() => import(\"openpgp\"));\nconst getEccryptoJS = lazyImport(() => import(\"eccrypto-js\"));\n\n/**\n * Browser implementation of crypto operations using Uint8Array\n * Supports both eccrypto-js (default) and custom ECIES implementation\n */\nclass BrowserCryptoAdapter implements VanaCryptoAdapter {\n  // Initialize both providers - only one will be used based on feature flag\n  private customEciesProvider = new BrowserECIESUint8Provider();\n  private customWalletService = new WalletKeyEncryptionService({\n    eciesProvider: this.customEciesProvider,\n  });\n\n  async encryptWithPublicKey(\n    data: string,\n    publicKeyHex: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation\n        const prefixedHex = publicKeyHex.startsWith(\"0x\")\n          ? publicKeyHex\n          : `0x${publicKeyHex}`;\n        const publicKeyBytes = fromHex(prefixedHex as `0x${string}`, \"bytes\");\n\n        // Encrypt data using ECIES\n        const encrypted = await this.customEciesProvider.encrypt(\n          publicKeyBytes,\n          stringToBytes(data),\n        );\n\n        // Concatenate all components and return as hex string\n        const result = concatBytes(\n          encrypted.iv,\n          encrypted.ephemPublicKey,\n          encrypted.ciphertext,\n          encrypted.mac,\n        );\n\n        return toHex(result).slice(2); // Remove '0x' prefix for backward compatibility\n      } else {\n        // Use eccrypto-js (default)\n        const eccryptojs = await getEccryptoJS();\n\n        // Remove 0x prefix if present\n        const cleanKey = publicKeyHex.startsWith(\"0x\")\n          ? publicKeyHex.slice(2)\n          : publicKeyHex;\n        const publicKeyBytes = Buffer.from(cleanKey, \"hex\");\n\n        // Ensure public key is in uncompressed format (65 bytes with 0x04 prefix)\n        // If it's 64 bytes, add the 0x04 prefix; if already 65 bytes, use as-is\n        const publicKeyBuffer =\n          publicKeyBytes.length === 64\n            ? Buffer.concat([Buffer.from([4]), publicKeyBytes])\n            : publicKeyBytes;\n\n        const message = Buffer.from(data, \"utf8\");\n\n        const encrypted = await eccryptojs.encrypt(publicKeyBuffer, message);\n\n        // Concatenate all components and return as hex string\n        const result = Buffer.concat([\n          encrypted.iv,\n          encrypted.ephemPublicKey,\n          encrypted.ciphertext,\n          encrypted.mac,\n        ]);\n\n        return result.toString(\"hex\");\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"encryptWithPublicKey\", error);\n    }\n  }\n\n  async decryptWithPrivateKey(\n    encryptedData: string,\n    privateKeyHex: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation\n        const encryptedHex = encryptedData.startsWith(\"0x\")\n          ? encryptedData\n          : `0x${encryptedData}`;\n        const privateHex = privateKeyHex.startsWith(\"0x\")\n          ? privateKeyHex\n          : `0x${privateKeyHex}`;\n        const encryptedBytes = fromHex(encryptedHex as `0x${string}`, \"bytes\");\n        const privateKeyBytes = fromHex(privateHex as `0x${string}`, \"bytes\");\n\n        // Parse the encrypted data into components\n        const encrypted = parseEncryptedDataBuffer(encryptedBytes);\n\n        // Decrypt using ECIES\n        const decrypted = await this.customEciesProvider.decrypt(\n          privateKeyBytes,\n          encrypted,\n        );\n\n        return bytesToString(decrypted);\n      } else {\n        // Use eccrypto-js (default)\n        const eccryptojs = await getEccryptoJS();\n        const privateKey = Buffer.from(privateKeyHex, \"hex\");\n        const encryptedBuffer = Buffer.from(encryptedData, \"hex\");\n\n        // Parse the encrypted data\n        const { iv, ephemPublicKey, ciphertext, mac } =\n          parseEncryptedDataBuffer(encryptedBuffer);\n\n        const decrypted = await eccryptojs.decrypt(privateKey, {\n          iv: Buffer.from(iv),\n          ephemPublicKey: Buffer.from(ephemPublicKey),\n          ciphertext: Buffer.from(ciphertext),\n          mac: Buffer.from(mac),\n        });\n\n        return decrypted.toString(\"utf8\");\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"decryptWithPrivateKey\", error);\n    }\n  }\n\n  async encryptWithWalletPublicKey(\n    data: string,\n    publicKey: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation via WalletKeyEncryptionService\n        return await this.customWalletService.encryptWithWalletPublicKey(\n          data,\n          publicKey,\n        );\n      } else {\n        // Use eccrypto-js directly for wallet encryption\n        const eccryptojs = await getEccryptoJS();\n\n        // Remove 0x prefix if present\n        const cleanKey = publicKey.startsWith(\"0x\")\n          ? publicKey.slice(2)\n          : publicKey;\n        const publicKeyBytes = Buffer.from(cleanKey, \"hex\");\n\n        // Ensure public key is in uncompressed format (65 bytes with 0x04 prefix)\n        // If it's 64 bytes, add the 0x04 prefix; if already 65 bytes, use as-is\n        const publicKeyBuffer =\n          publicKeyBytes.length === 64\n            ? Buffer.concat([Buffer.from([4]), publicKeyBytes])\n            : publicKeyBytes;\n\n        const message = Buffer.from(data, \"utf8\");\n\n        const encrypted = await eccryptojs.encrypt(publicKeyBuffer, message);\n\n        // Concatenate all components and return as hex string\n        const result = Buffer.concat([\n          encrypted.iv,\n          encrypted.ephemPublicKey,\n          encrypted.ciphertext,\n          encrypted.mac,\n        ]);\n\n        return result.toString(\"hex\");\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"encryptWithWalletPublicKey\", error);\n    }\n  }\n\n  async decryptWithWalletPrivateKey(\n    encryptedData: string,\n    privateKey: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation via WalletKeyEncryptionService\n        return await this.customWalletService.decryptWithWalletPrivateKey(\n          encryptedData,\n          privateKey,\n        );\n      } else {\n        // Use eccrypto-js directly for wallet decryption\n        const eccryptojs = await getEccryptoJS();\n        const privateKeyBuffer = Buffer.from(privateKey, \"hex\");\n        const encryptedBuffer = Buffer.from(encryptedData, \"hex\");\n\n        // Parse the encrypted data\n        const { iv, ephemPublicKey, ciphertext, mac } =\n          parseEncryptedDataBuffer(encryptedBuffer);\n\n        const decrypted = await eccryptojs.decrypt(privateKeyBuffer, {\n          iv: Buffer.from(iv),\n          ephemPublicKey: Buffer.from(ephemPublicKey),\n          ciphertext: Buffer.from(ciphertext),\n          mac: Buffer.from(mac),\n        });\n\n        return decrypted.toString(\"utf8\");\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"decryptWithWalletPrivateKey\", error);\n    }\n  }\n\n  async generateKeyPair(): Promise<{\n    privateKey: string;\n    publicKey: string;\n  }> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom implementation with @noble/secp256k1\n        // Generate random private key\n        const privateKeyBytes = secp256k1.utils.randomPrivateKey();\n\n        // Generate public key (compressed for consistency with Node implementation)\n        const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);\n\n        return {\n          privateKey: toHex(privateKeyBytes).slice(2),\n          publicKey: toHex(publicKeyBytes).slice(2),\n        };\n      } else {\n        // Use eccrypto-js (default)\n        const eccryptojs = await getEccryptoJS();\n        const privateKey = eccryptojs.generatePrivate();\n        const publicKey = eccryptojs.getPublic(privateKey);\n\n        return {\n          privateKey: privateKey.toString(\"hex\"),\n          publicKey: publicKey.toString(\"hex\"),\n        };\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"generateKeyPair\", error);\n    }\n  }\n\n  async encryptWithPassword(\n    data: Uint8Array,\n    password: string,\n  ): Promise<Uint8Array> {\n    try {\n      const openpgp = await getOpenPGP();\n\n      // Create a message from the data\n      const message = await openpgp.createMessage({ binary: data });\n\n      // Encrypt with password\n      const encrypted = await openpgp.encrypt({\n        message,\n        passwords: [password],\n        format: \"binary\",\n      });\n\n      return new Uint8Array(encrypted as ArrayBuffer);\n    } catch (error) {\n      throw wrapCryptoError(\"encryptWithPassword\", error);\n    }\n  }\n\n  async decryptWithPassword(\n    encryptedData: Uint8Array,\n    password: string,\n  ): Promise<Uint8Array> {\n    try {\n      const openpgp = await getOpenPGP();\n\n      // Read the encrypted message\n      const message = await openpgp.readMessage({\n        binaryMessage: encryptedData,\n      });\n\n      // Decrypt with password\n      const { data } = await openpgp.decrypt({\n        message,\n        passwords: [password],\n        format: \"binary\",\n      });\n\n      return new Uint8Array(data as ArrayBuffer);\n    } catch (error) {\n      throw wrapCryptoError(\"decryptWithPassword\", error);\n    }\n  }\n}\n\n/**\n * Browser implementation of PGP operations\n */\nclass BrowserPGPAdapter implements VanaPGPAdapter {\n  async encrypt(data: string, publicKeyArmored: string): Promise<string> {\n    try {\n      const openpgp = await getOpenPGP();\n      const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });\n\n      const encrypted = await openpgp.encrypt({\n        message: await openpgp.createMessage({ text: data }),\n        encryptionKeys: publicKey,\n        config: {\n          preferredCompressionAlgorithm: openpgp.enums.compression.zlib,\n        },\n      });\n\n      return encrypted as string;\n    } catch (error) {\n      throw new Error(`PGP encryption failed: ${error}`);\n    }\n  }\n\n  async decrypt(\n    encryptedData: string,\n    privateKeyArmored: string,\n  ): Promise<string> {\n    try {\n      const openpgp = await getOpenPGP();\n      const privateKey = await openpgp.readPrivateKey({\n        armoredKey: privateKeyArmored,\n      });\n      const message = await openpgp.readMessage({\n        armoredMessage: encryptedData,\n      });\n\n      const { data: decrypted } = await openpgp.decrypt({\n        message,\n        decryptionKeys: privateKey,\n      });\n\n      return decrypted as string;\n    } catch (error) {\n      throw new Error(`PGP decryption failed: ${error}`);\n    }\n  }\n\n  async generateKeyPair(options?: {\n    name?: string;\n    email?: string;\n    passphrase?: string;\n  }): Promise<{ publicKey: string; privateKey: string }> {\n    try {\n      const openpgp = await getOpenPGP();\n      // Use shared utility to get standardized parameters\n      const keyGenParams = getPGPKeyGenParams(options);\n\n      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);\n\n      return { publicKey, privateKey };\n    } catch (error) {\n      throw wrapCryptoError(\"PGP key generation\", error);\n    }\n  }\n}\n\n/**\n * Browser implementation of HTTP operations using Fetch API\n */\nclass BrowserHttpAdapter implements VanaHttpAdapter {\n  async fetch(url: string, options?: RequestInit): Promise<Response> {\n    return fetch(url, options);\n  }\n}\n\n/**\n * Browser implementation of caching using sessionStorage for security\n * SessionStorage is cleared when the tab closes, making it more secure for signature caching\n */\nclass BrowserCacheAdapter implements VanaCacheAdapter {\n  private readonly prefix = \"vana_cache_\";\n\n  get(key: string): string | null {\n    try {\n      if (typeof sessionStorage === \"undefined\") {\n        return null;\n      }\n      return sessionStorage.getItem(this.prefix + key);\n    } catch {\n      return null;\n    }\n  }\n\n  set(key: string, value: string): void {\n    try {\n      if (typeof sessionStorage === \"undefined\") {\n        return;\n      }\n      sessionStorage.setItem(this.prefix + key, value);\n    } catch {\n      // Ignore storage errors (quota exceeded, etc.)\n    }\n  }\n\n  delete(key: string): void {\n    try {\n      if (typeof sessionStorage === \"undefined\") {\n        return;\n      }\n      sessionStorage.removeItem(this.prefix + key);\n    } catch {\n      // Ignore storage errors\n    }\n  }\n\n  clear(): void {\n    try {\n      if (typeof sessionStorage === \"undefined\") {\n        return;\n      }\n      // Only clear our prefixed keys to avoid affecting other data\n      const keysToRemove: string[] = [];\n      for (let i = 0; i < sessionStorage.length; i++) {\n        const key = sessionStorage.key(i);\n        if (key?.startsWith(this.prefix)) {\n          keysToRemove.push(key);\n        }\n      }\n      keysToRemove.forEach((key) => sessionStorage.removeItem(key));\n    } catch {\n      // Ignore storage errors\n    }\n  }\n}\n\n/**\n * Browser implementation of the Vana Platform Adapter\n *\n * This adapter provides all platform-specific functionality for browser environments\n * without requiring any Node.js polyfills.\n */\nexport class BrowserPlatformAdapter implements VanaPlatformAdapter {\n  public readonly crypto = new BrowserCryptoAdapter();\n  public readonly pgp = new BrowserPGPAdapter();\n  public readonly http = new BrowserHttpAdapter();\n  public readonly cache = new BrowserCacheAdapter();\n  public readonly platform = \"browser\" as const;\n}\n"],"mappings":"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","names":[]}

package/dist/platform/browser.d.cts

@@ -0,0 +1,74 @@
+import { VanaPlatformAdapter, VanaCryptoAdapter, VanaPGPAdapter, VanaHttpAdapter, VanaCacheAdapter } from './interface.cjs';
+
+/**
+ * Browser implementation of the Vana Platform Adapter using Uint8Array
+ *
+ * This implementation uses browser-compatible libraries and native APIs
+ * without requiring Buffer or other Node.js polyfills.
+ */
+
+/**
+ * Browser implementation of crypto operations using Uint8Array
+ * Supports both eccrypto-js (default) and custom ECIES implementation
+ */
+declare class BrowserCryptoAdapter implements VanaCryptoAdapter {
+    private customEciesProvider;
+    private customWalletService;
+    encryptWithPublicKey(data: string, publicKeyHex: string): Promise<string>;
+    decryptWithPrivateKey(encryptedData: string, privateKeyHex: string): Promise<string>;
+    encryptWithWalletPublicKey(data: string, publicKey: string): Promise<string>;
+    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
+    generateKeyPair(): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+    encryptWithPassword(data: Uint8Array, password: string): Promise<Uint8Array>;
+    decryptWithPassword(encryptedData: Uint8Array, password: string): Promise<Uint8Array>;
+}
+/**
+ * Browser implementation of PGP operations
+ */
+declare class BrowserPGPAdapter implements VanaPGPAdapter {
+    encrypt(data: string, publicKeyArmored: string): Promise<string>;
+    decrypt(encryptedData: string, privateKeyArmored: string): Promise<string>;
+    generateKeyPair(options?: {
+        name?: string;
+        email?: string;
+        passphrase?: string;
+    }): Promise<{
+        publicKey: string;
+        privateKey: string;
+    }>;
+}
+/**
+ * Browser implementation of HTTP operations using Fetch API
+ */
+declare class BrowserHttpAdapter implements VanaHttpAdapter {
+    fetch(url: string, options?: RequestInit): Promise<Response>;
+}
+/**
+ * Browser implementation of caching using sessionStorage for security
+ * SessionStorage is cleared when the tab closes, making it more secure for signature caching
+ */
+declare class BrowserCacheAdapter implements VanaCacheAdapter {
+    private readonly prefix;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    clear(): void;
+}
+/**
+ * Browser implementation of the Vana Platform Adapter
+ *
+ * This adapter provides all platform-specific functionality for browser environments
+ * without requiring any Node.js polyfills.
+ */
+declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
+    readonly crypto: BrowserCryptoAdapter;
+    readonly pgp: BrowserPGPAdapter;
+    readonly http: BrowserHttpAdapter;
+    readonly cache: BrowserCacheAdapter;
+    readonly platform: "browser";
+}
+
+export { BrowserPlatformAdapter };

package/dist/platform/browser.d.ts

@@ -0,0 +1,74 @@
+import { VanaPlatformAdapter, VanaCryptoAdapter, VanaPGPAdapter, VanaHttpAdapter, VanaCacheAdapter } from './interface.js';
+
+/**
+ * Browser implementation of the Vana Platform Adapter using Uint8Array
+ *
+ * This implementation uses browser-compatible libraries and native APIs
+ * without requiring Buffer or other Node.js polyfills.
+ */
+
+/**
+ * Browser implementation of crypto operations using Uint8Array
+ * Supports both eccrypto-js (default) and custom ECIES implementation
+ */
+declare class BrowserCryptoAdapter implements VanaCryptoAdapter {
+    private customEciesProvider;
+    private customWalletService;
+    encryptWithPublicKey(data: string, publicKeyHex: string): Promise<string>;
+    decryptWithPrivateKey(encryptedData: string, privateKeyHex: string): Promise<string>;
+    encryptWithWalletPublicKey(data: string, publicKey: string): Promise<string>;
+    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
+    generateKeyPair(): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+    encryptWithPassword(data: Uint8Array, password: string): Promise<Uint8Array>;
+    decryptWithPassword(encryptedData: Uint8Array, password: string): Promise<Uint8Array>;
+}
+/**
+ * Browser implementation of PGP operations
+ */
+declare class BrowserPGPAdapter implements VanaPGPAdapter {
+    encrypt(data: string, publicKeyArmored: string): Promise<string>;
+    decrypt(encryptedData: string, privateKeyArmored: string): Promise<string>;
+    generateKeyPair(options?: {
+        name?: string;
+        email?: string;
+        passphrase?: string;
+    }): Promise<{
+        publicKey: string;
+        privateKey: string;
+    }>;
+}
+/**
+ * Browser implementation of HTTP operations using Fetch API
+ */
+declare class BrowserHttpAdapter implements VanaHttpAdapter {
+    fetch(url: string, options?: RequestInit): Promise<Response>;
+}
+/**
+ * Browser implementation of caching using sessionStorage for security
+ * SessionStorage is cleared when the tab closes, making it more secure for signature caching
+ */
+declare class BrowserCacheAdapter implements VanaCacheAdapter {
+    private readonly prefix;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    clear(): void;
+}
+/**
+ * Browser implementation of the Vana Platform Adapter
+ *
+ * This adapter provides all platform-specific functionality for browser environments
+ * without requiring any Node.js polyfills.
+ */
+declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
+    readonly crypto: BrowserCryptoAdapter;
+    readonly pgp: BrowserPGPAdapter;
+    readonly http: BrowserHttpAdapter;
+    readonly cache: BrowserCacheAdapter;
+    readonly platform: "browser";
+}
+
+export { BrowserPlatformAdapter };