@opendatalabs/vana-sdk 0.1.0-alpha.d44f792 → 0.1.0-alpha.d596df3

package/dist/platform/browser-only.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-only.ts"],"sourcesContent":["/**\n * Browser-only exports for platform adapters\n *\n * This file provides browser-only exports that completely avoid Node.js imports\n * when bundling for browser environments. This is used by the browser entry point.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-only platform adapter factory\n * This version does not include Node.js imports at all\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createPlatformAdapterSafe(): VanaPlatformAdapter {\n  // Always return browser adapter in browser environments\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,qBAAuC;AAOhC,SAAS,+BAAoD;AAClE,SAAO,IAAI,sCAAuB;AACpC;AAQO,SAAS,4BAAiD;AAE/D,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser-only.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Browser-only exports for platform adapters
+ *
+ * This file provides browser-only exports that completely avoid Node.js imports
+ * when bundling for browser environments. This is used by the browser entry point.
+ */
+import type { VanaPlatformAdapter } from "./interface";
+/**
+ * Creates a BrowserPlatformAdapter instance
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+export declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
+/**
+ * Browser-only platform adapter factory
+ * This version does not include Node.js imports at all
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+export declare function createPlatformAdapterSafe(): VanaPlatformAdapter;
+export type { VanaPlatformAdapter } from "./interface";
+export type { BrowserPlatformAdapter } from "./browser";

package/dist/platform/browser-only.js

@@ -0,0 +1,12 @@
+import { BrowserPlatformAdapter } from "./browser";
+function createBrowserPlatformAdapter() {
+  return new BrowserPlatformAdapter();
+}
+function createPlatformAdapterSafe() {
+  return createBrowserPlatformAdapter();
+}
+export {
+  createBrowserPlatformAdapter,
+  createPlatformAdapterSafe
+};
+//# sourceMappingURL=browser-only.js.map

package/dist/platform/browser-only.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-only.ts"],"sourcesContent":["/**\n * Browser-only exports for platform adapters\n *\n * This file provides browser-only exports that completely avoid Node.js imports\n * when bundling for browser environments. This is used by the browser entry point.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-only platform adapter factory\n * This version does not include Node.js imports at all\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createPlatformAdapterSafe(): VanaPlatformAdapter {\n  // Always return browser adapter in browser environments\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n"],"mappings":"AAQA,SAAS,8BAA8B;AAOhC,SAAS,+BAAoD;AAClE,SAAO,IAAI,uBAAuB;AACpC;AAQO,SAAS,4BAAiD;AAE/D,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser-only.test.d.ts

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

package/dist/platform/browser-safe.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_safe_exports = {};
+__export(browser_safe_exports, {
+  createBrowserPlatformAdapter: () => createBrowserPlatformAdapter,
+  createNodePlatformAdapter: () => createNodePlatformAdapter,
+  createPlatformAdapterSafe: () => createPlatformAdapterSafe
+});
+module.exports = __toCommonJS(browser_safe_exports);
+var import_browser = require("./browser");
+async function createNodePlatformAdapter() {
+  if (typeof window !== "undefined") {
+    throw new Error(
+      "NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead."
+    );
+  }
+  const moduleName = "./node";
+  const { NodePlatformAdapter } = await import(moduleName);
+  return new NodePlatformAdapter();
+}
+function createBrowserPlatformAdapter() {
+  return new import_browser.BrowserPlatformAdapter();
+}
+async function createPlatformAdapterSafe() {
+  if (typeof window !== "undefined") {
+    return createBrowserPlatformAdapter();
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    if (typeof window === "undefined") {
+      return await createNodePlatformAdapter();
+    }
+  }
+  return createBrowserPlatformAdapter();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBrowserPlatformAdapter,
+  createNodePlatformAdapter,
+  createPlatformAdapterSafe
+});
+//# sourceMappingURL=browser-safe.cjs.map

package/dist/platform/browser-safe.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-safe.ts"],"sourcesContent":["/**\n * Browser-safe exports for platform adapters\n *\n * This file provides browser-safe exports that avoid importing Node.js dependencies\n * when bundling for browser environments.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Dynamically imports the NodePlatformAdapter only when needed\n * This prevents Node.js modules from being bundled in browser builds\n *\n * @returns Promise resolving to a NodePlatformAdapter instance\n * @throws {Error} If running in a browser environment\n */\nexport async function createNodePlatformAdapter(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    throw new Error(\n      \"NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead.\",\n    );\n  }\n\n  // Use string concatenation to avoid static analysis during bundling\n  const moduleName = \"./node\";\n  const { NodePlatformAdapter } = await import(moduleName);\n  return new NodePlatformAdapter();\n}\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-safe platform adapter factory\n *\n * @returns Promise resolving to the appropriate platform adapter\n */\nexport async function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    return createBrowserPlatformAdapter();\n  }\n\n  // Check for Node.js environment\n  if (\n    typeof process !== \"undefined\" &&\n    process.versions &&\n    process.versions.node\n  ) {\n    // Only attempt Node.js import if we're not in a browser environment\n    if (typeof window === \"undefined\") {\n      return await createNodePlatformAdapter();\n    }\n  }\n\n  // Default to browser if we can't determine\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n// NodePlatformAdapter type is available through dynamic import to avoid bundling Node.js dependencies\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,qBAAuC;AASvC,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAGA,QAAM,aAAa;AACnB,QAAM,EAAE,oBAAoB,IAAI,MAAM,OAAO;AAC7C,SAAO,IAAI,oBAAoB;AACjC;AAOO,SAAS,+BAAoD;AAClE,SAAO,IAAI,sCAAuB;AACpC;AAOA,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,6BAA6B;AAAA,EACtC;AAGA,MACE,OAAO,YAAY,eACnB,QAAQ,YACR,QAAQ,SAAS,MACjB;AAEA,QAAI,OAAO,WAAW,aAAa;AACjC,aAAO,MAAM,0BAA0B;AAAA,IACzC;AAAA,EACF;AAGA,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser-safe.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Browser-safe exports for platform adapters
+ *
+ * This file provides browser-safe exports that avoid importing Node.js dependencies
+ * when bundling for browser environments.
+ */
+import type { VanaPlatformAdapter } from "./interface";
+/**
+ * Dynamically imports the NodePlatformAdapter only when needed
+ * This prevents Node.js modules from being bundled in browser builds
+ *
+ * @returns Promise resolving to a NodePlatformAdapter instance
+ * @throws {Error} If running in a browser environment
+ */
+export declare function createNodePlatformAdapter(): Promise<VanaPlatformAdapter>;
+/**
+ * Creates a BrowserPlatformAdapter instance
+ *
+ * @returns A BrowserPlatformAdapter instance
+ */
+export declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
+/**
+ * Browser-safe platform adapter factory
+ *
+ * @returns Promise resolving to the appropriate platform adapter
+ */
+export declare function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter>;
+export type { VanaPlatformAdapter } from "./interface";
+export type { BrowserPlatformAdapter } from "./browser";

package/dist/platform/browser-safe.js

@@ -0,0 +1,31 @@
+import { BrowserPlatformAdapter } from "./browser";
+async function createNodePlatformAdapter() {
+  if (typeof window !== "undefined") {
+    throw new Error(
+      "NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead."
+    );
+  }
+  const moduleName = "./node";
+  const { NodePlatformAdapter } = await import(moduleName);
+  return new NodePlatformAdapter();
+}
+function createBrowserPlatformAdapter() {
+  return new BrowserPlatformAdapter();
+}
+async function createPlatformAdapterSafe() {
+  if (typeof window !== "undefined") {
+    return createBrowserPlatformAdapter();
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    if (typeof window === "undefined") {
+      return await createNodePlatformAdapter();
+    }
+  }
+  return createBrowserPlatformAdapter();
+}
+export {
+  createBrowserPlatformAdapter,
+  createNodePlatformAdapter,
+  createPlatformAdapterSafe
+};
+//# sourceMappingURL=browser-safe.js.map

package/dist/platform/browser-safe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/browser-safe.ts"],"sourcesContent":["/**\n * Browser-safe exports for platform adapters\n *\n * This file provides browser-safe exports that avoid importing Node.js dependencies\n * when bundling for browser environments.\n */\n\nimport type { VanaPlatformAdapter } from \"./interface\";\nimport { BrowserPlatformAdapter } from \"./browser\";\n\n/**\n * Dynamically imports the NodePlatformAdapter only when needed\n * This prevents Node.js modules from being bundled in browser builds\n *\n * @returns Promise resolving to a NodePlatformAdapter instance\n * @throws {Error} If running in a browser environment\n */\nexport async function createNodePlatformAdapter(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    throw new Error(\n      \"NodePlatformAdapter is not available in browser environments. Use BrowserPlatformAdapter instead.\",\n    );\n  }\n\n  // Use string concatenation to avoid static analysis during bundling\n  const moduleName = \"./node\";\n  const { NodePlatformAdapter } = await import(moduleName);\n  return new NodePlatformAdapter();\n}\n\n/**\n * Creates a BrowserPlatformAdapter instance\n *\n * @returns A BrowserPlatformAdapter instance\n */\nexport function createBrowserPlatformAdapter(): VanaPlatformAdapter {\n  return new BrowserPlatformAdapter();\n}\n\n/**\n * Browser-safe platform adapter factory\n *\n * @returns Promise resolving to the appropriate platform adapter\n */\nexport async function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter> {\n  // Check if we're in a browser environment\n  if (typeof window !== \"undefined\") {\n    return createBrowserPlatformAdapter();\n  }\n\n  // Check for Node.js environment\n  if (\n    typeof process !== \"undefined\" &&\n    process.versions &&\n    process.versions.node\n  ) {\n    // Only attempt Node.js import if we're not in a browser environment\n    if (typeof window === \"undefined\") {\n      return await createNodePlatformAdapter();\n    }\n  }\n\n  // Default to browser if we can't determine\n  return createBrowserPlatformAdapter();\n}\n\n// Export types\nexport type { VanaPlatformAdapter } from \"./interface\";\nexport type { BrowserPlatformAdapter } from \"./browser\";\n// NodePlatformAdapter type is available through dynamic import to avoid bundling Node.js dependencies\n"],"mappings":"AAQA,SAAS,8BAA8B;AASvC,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAGA,QAAM,aAAa;AACnB,QAAM,EAAE,oBAAoB,IAAI,MAAM,OAAO;AAC7C,SAAO,IAAI,oBAAoB;AACjC;AAOO,SAAS,+BAAoD;AAClE,SAAO,IAAI,uBAAuB;AACpC;AAOA,eAAsB,4BAA0D;AAE9E,MAAI,OAAO,WAAW,aAAa;AACjC,WAAO,6BAA6B;AAAA,EACtC;AAGA,MACE,OAAO,YAAY,eACnB,QAAQ,YACR,QAAQ,SAAS,MACjB;AAEA,QAAI,OAAO,WAAW,aAAa;AACjC,aAAO,MAAM,0BAA0B;AAAA,IACzC;AAAA,EACF;AAGA,SAAO,6BAA6B;AACtC;","names":[]}

package/dist/platform/browser-safe.test.d.ts

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

package/dist/platform/browser.cjs

@@ -0,0 +1,488 @@
+"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 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
+  });
+  /**
+   * Encrypts data using ECIES with a public key.
+   *
+   * @param data - The plaintext string to encrypt.
+   *   Typically user data or sensitive information.
+   * @param publicKeyHex - The recipient's public key in hex format.
+   *   Can include or omit the '0x' prefix.
+   * @returns Encrypted data as a hex string without '0x' prefix
+   *
+   * @throws {Error} If encryption fails or public key is invalid
+   */
+  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_viem.concat)([
+          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 uncompressed = this.customEciesProvider.normalizeToUncompressed(
+          new Uint8Array(publicKeyBytes)
+        );
+        const publicKeyBuffer = Buffer.from(uncompressed);
+        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);
+    }
+  }
+  /**
+   * Decrypts ECIES-encrypted data using a private key.
+   *
+   * @param encryptedData - Hex string containing encrypted data.
+   *   Can include or omit the '0x' prefix.
+   * @param privateKeyHex - The private key in hex format.
+   *   Must correspond to the public key used for encryption.
+   * @returns The decrypted plaintext string
+   *
+   * @throws {Error} If decryption fails or MAC verification fails
+   */
+  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);
+    }
+  }
+  /**
+   * Encrypts data using a wallet's public key.
+   *
+   * @param data - The plaintext string to encrypt.
+   *   Typically permission data or DLP metadata.
+   * @param publicKey - The wallet's public key.
+   *   Automatically handles compressed/uncompressed formats.
+   * @returns Encrypted data as a hex string
+   *
+   * @throws {Error} If encryption fails or key processing fails
+   */
+  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 uncompressed = this.customEciesProvider.normalizeToUncompressed(
+          new Uint8Array(publicKeyBytes)
+        );
+        const publicKeyBuffer = Buffer.from(uncompressed);
+        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);
+    }
+  }
+  /**
+   * Decrypts data using a wallet's private key.
+   *
+   * @param encryptedData - Hex string containing encrypted data.
+   *   Must be encrypted with corresponding wallet public key.
+   * @param privateKey - The wallet's private key.
+   *   Obtain from wallet connection (handle with care).
+   * @returns The decrypted plaintext string
+   *
+   * @throws {Error} If decryption fails or key is invalid
+   */
+  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);
+    }
+  }
+  /**
+   * Generates a new secp256k1 key pair for ECIES operations.
+   *
+   * @returns Object containing hex-encoded public and private keys
+   * @returns returns.privateKey - Private key in hex format without '0x'
+   * @returns returns.publicKey - Compressed public key in hex format without '0x'
+   *
+   * @throws {Error} If key generation fails
+   */
+  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);
+    }
+  }
+  /**
+   * Encrypts binary data using password-based encryption.
+   *
+   * @param data - Binary data to encrypt.
+   *   Typically file contents or serialized objects.
+   * @param password - Password for encryption.
+   *   Often derived from wallet signatures.
+   * @returns Encrypted data as Uint8Array
+   *
+   * @remarks
+   * Uses OpenPGP for password-based encryption with automatic
+   * salt generation for security.
+   *
+   * @throws {Error} If encryption fails
+   */
+  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);
+    }
+  }
+  /**
+   * Decrypts password-encrypted binary data.
+   *
+   * @param encryptedData - Password-encrypted data as Uint8Array.
+   *   Must be encrypted with the same password.
+   * @param password - Password for decryption.
+   *   Must match the encryption password.
+   * @returns Decrypted data as Uint8Array
+   *
+   * @throws {Error} If decryption fails or password is incorrect
+   */
+  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 {
+  /**
+   * Encrypts data using PGP public key encryption.
+   *
+   * @param data - The plaintext string to encrypt.
+   *   Typically messages or structured data.
+   * @param publicKeyArmored - ASCII-armored PGP public key.
+   *   Obtain from PGP key generation or key servers.
+   * @returns ASCII-armored encrypted message
+   *
+   * @throws {Error} If encryption fails or public key is invalid
+   */
+  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: ${String(error)}`);
+    }
+  }
+  /**
+   * Decrypts PGP-encrypted data using a private key.
+   *
+   * @param encryptedData - ASCII-armored encrypted message.
+   *   Must be encrypted with corresponding public key.
+   * @param privateKeyArmored - ASCII-armored PGP private key.
+   *   Must correspond to the public key used for encryption.
+   * @returns The decrypted plaintext string
+   *
+   * @throws {Error} If decryption fails or private key is invalid
+   */
+  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: ${String(error)}`);
+    }
+  }
+  /**
+   * Generates a new PGP key pair.
+   *
+   * @param options - Key generation options
+   * @param options.name - Name for the key identity.
+   *   Defaults to 'Vana User'.
+   * @param options.email - Email for the key identity.
+   *   Defaults to 'user@vana.com'.
+   * @param options.passphrase - Passphrase to protect the private key.
+   *   If not provided, key is unprotected.
+   * @returns ASCII-armored public and private keys
+   *
+   * @throws {Error} If key generation fails
+   */
+  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 {
+  /**
+   * Performs an HTTP request using the Fetch API.
+   *
+   * @param url - The URL to fetch.
+   *   Must be a valid HTTP/HTTPS URL.
+   * @param options - Standard fetch options.
+   *   See MDN fetch documentation for details.
+   * @returns Standard fetch Response object
+   */
+  async fetch(url, options) {
+    return fetch(url, options);
+  }
+}
+class BrowserCacheAdapter {
+  prefix = "vana_cache_";
+  /**
+   * Retrieves a cached value by key.
+   *
+   * @param key - The cache key to look up.
+   *   Automatically prefixed to avoid conflicts.
+   * @returns The cached value or null if not found
+   */
+  get(key) {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return null;
+      }
+      return sessionStorage.getItem(this.prefix + key);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Stores a value in sessionStorage.
+   *
+   * @param key - The cache key.
+   *   Automatically prefixed with 'vana_cache_'.
+   * @param value - The value to cache.
+   *   Will be cleared when tab closes.
+   */
+  set(key, value) {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return;
+      }
+      sessionStorage.setItem(this.prefix + key, value);
+    } catch {
+    }
+  }
+  /**
+   * Removes a specific key from the cache.
+   *
+   * @param key - The cache key to remove.
+   *   Only removes the prefixed key.
+   */
+  delete(key) {
+    try {
+      if (typeof sessionStorage === "undefined") {
+        return;
+      }
+      sessionStorage.removeItem(this.prefix + key);
+    } catch {
+    }
+  }
+  /**
+   * Clears all Vana-prefixed cache entries.
+   *
+   * @remarks
+   * Only removes entries with the 'vana_cache_' prefix,
+   * preserving other sessionStorage data.
+   */
+  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