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

package/dist/platform.browser.d.ts

@@ -1,259 +0,0 @@
-/**
- * Platform Adapter interface for environment-specific implementations
- *
- * This interface abstracts all environment-specific dependencies to ensure
- * the SDK works seamlessly across Node.js and browser/SSR environments.
- *
- * **Implementation Context:**
- * - Node.js: Uses native crypto modules and full OpenPGP support
- * - Browser: Uses Web Crypto API and browser-compatible libraries
- * - SSR: Automatically selects appropriate implementation based on runtime
- *
- * **Usage Notes:**
- * Platform adapters are automatically selected by the SDK. Direct usage is only
- * needed for custom implementations or testing.
- */
-/**
- * Platform type identifier
- */
-type PlatformType = "node" | "browser";
-/**
- * Encryption operations that require different implementations per platform
- */
-interface VanaCryptoAdapter {
-    /**
-     * Encrypt data with a public key using asymmetric cryptography
-     *
-     * **Usage Context:**
-     * - Used internally for file encryption before storage
-     * - Public key format: Armored PGP public key string
-     * - Returns base64-encoded encrypted data
-     *
-     * @param data The data to encrypt
-     * @param publicKey The public key for encryption
-     * @returns Promise resolving to encrypted data
-     */
-    encryptWithPublicKey(data: string, publicKey: string): Promise<string>;
-    /**
-     * Decrypt data with a private key using asymmetric cryptography
-     *
-     * @param encryptedData The encrypted data
-     * @param privateKey The private key for decryption
-     * @returns Promise resolving to decrypted data
-     */
-    decryptWithPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
-    /**
-     * Generate a new key pair for asymmetric cryptography
-     *
-     * @returns Promise resolving to public and private key pair
-     */
-    generateKeyPair(): Promise<{
-        publicKey: string;
-        privateKey: string;
-    }>;
-    /**
-     * Encrypt data with a wallet's public key using ECDH cryptography
-     * Uses platform-appropriate ECDH implementation (eccrypto vs eccrypto-js)
-     *
-     * **Usage Context:**
-     * - Used for sharing encryption keys with permission recipients
-     * - Public key format: Compressed or uncompressed secp256k1 hex string
-     * - Compatible with Ethereum wallet public keys
-     *
-     * @param data The data to encrypt (string)
-     * @param publicKey The wallet's public key (secp256k1)
-     * @returns Promise resolving to encrypted data as hex string
-     */
-    encryptWithWalletPublicKey(data: string, publicKey: string): Promise<string>;
-    /**
-     * Decrypt data with a wallet's private key using ECDH cryptography
-     * Uses platform-appropriate ECDH implementation (eccrypto vs eccrypto-js)
-     *
-     * @param encryptedData The encrypted data as hex string
-     * @param privateKey The wallet's private key (secp256k1)
-     * @returns Promise resolving to decrypted data as string
-     */
-    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
-    /**
-     * Encrypt data with a password using PGP password-based encryption
-     * Uses platform-appropriate OpenPGP implementation with consistent format
-     *
-     * @param data The data to encrypt as Uint8Array
-     * @param password The password for encryption (typically wallet signature)
-     * @returns Promise resolving to encrypted data as Uint8Array
-     */
-    encryptWithPassword(data: Uint8Array, password: string): Promise<Uint8Array>;
-    /**
-     * Decrypt data with a password using PGP password-based decryption
-     * Uses platform-appropriate OpenPGP implementation with consistent format
-     *
-     * @param encryptedData The encrypted data as Uint8Array
-     * @param password The password for decryption (typically wallet signature)
-     * @returns Promise resolving to decrypted data as Uint8Array
-     */
-    decryptWithPassword(encryptedData: Uint8Array, password: string): Promise<Uint8Array>;
-}
-/**
- * PGP operations that require different configurations per platform
- */
-interface VanaPGPAdapter {
-    /**
-     * Encrypt data using PGP with proper platform configuration
-     *
-     * @param data The data to encrypt
-     * @param publicKey The PGP public key
-     * @returns Promise resolving to encrypted data
-     */
-    encrypt(data: string, publicKey: string): Promise<string>;
-    /**
-     * Decrypt data using PGP with proper platform configuration
-     *
-     * @param encryptedData The encrypted data
-     * @param privateKey The PGP private key
-     * @returns Promise resolving to decrypted data
-     */
-    decrypt(encryptedData: string, privateKey: string): Promise<string>;
-    /**
-     * Generate a new PGP key pair with platform-appropriate configuration
-     *
-     * @param options - Key generation options
-     * @param options.name - The name for the PGP key
-     * @param options.email - The email for the PGP key
-     * @param options.passphrase - Optional passphrase to protect the private key
-     * @returns Promise resolving to public and private key pair
-     */
-    generateKeyPair(options?: {
-        name?: string;
-        email?: string;
-        passphrase?: string;
-    }): Promise<{
-        publicKey: string;
-        privateKey: string;
-    }>;
-}
-/**
- * HTTP operations that need consistent API across platforms
- */
-interface VanaHttpAdapter {
-    /**
-     * Perform HTTP request with platform-appropriate fetch implementation
-     *
-     * @param url The URL to request
-     * @param options Request options
-     * @returns Promise resolving to response
-     */
-    fetch(url: string, options?: RequestInit): Promise<Response>;
-}
-/**
- * Main platform adapter interface that combines all platform-specific functionality
- *
- * **Implementation Guidelines:**
- * 1. All methods must maintain consistent behavior across platforms
- * 2. Error types and messages should be unified
- * 3. Data formats (encoding, serialization) must be identical
- * 4. Performance characteristics can vary but API must be consistent
- *
- * **Custom Implementation Example:**
- * ```typescript
- * class CustomPlatformAdapter implements VanaPlatformAdapter {
- *   crypto = new CustomCryptoAdapter();
- *   pgp = new CustomPGPAdapter();
- *   http = new CustomHttpAdapter();
- *   platform = 'browser' as const;
- * }
- * ```
- */
-interface VanaPlatformAdapter {
-    /**
-     * Crypto operations adapter
-     */
-    crypto: VanaCryptoAdapter;
-    /**
-     * PGP operations adapter
-     */
-    pgp: VanaPGPAdapter;
-    /**
-     * HTTP operations adapter
-     */
-    http: VanaHttpAdapter;
-    /**
-     * Platform identifier for debugging/telemetry
-     */
-    readonly platform: PlatformType;
-}
-
-/**
- * Browser implementation of the Vana Platform Adapter
- *
- * This implementation uses browser-compatible libraries and configurations
- * to provide crypto, PGP, and HTTP functionality without Node.js dependencies.
- */
-
-/**
- * Complete browser platform adapter implementation
- */
-declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
-    crypto: VanaCryptoAdapter;
-    pgp: VanaPGPAdapter;
-    http: VanaHttpAdapter;
-    platform: "browser";
-    constructor();
-}
-
-/**
- * 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.
- */
-
-/**
- * Creates a BrowserPlatformAdapter instance
- *
- * @returns A BrowserPlatformAdapter instance
- */
-declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
-/**
- * Browser-only platform adapter factory
- * This version does not include Node.js imports at all
- *
- * @returns A BrowserPlatformAdapter instance
- */
-declare function createPlatformAdapterSafe(): VanaPlatformAdapter;
-
-/**
- * Platform detection and adapter utilities
- *
- * This module provides utilities for detecting the current runtime environment
- * and creating appropriate platform adapters automatically.
- */
-
-/**
- * Detects the current runtime environment
- *
- * @returns The detected platform type
- */
-declare function detectPlatform(): PlatformType;
-/**
- * Checks if the current environment supports the given platform adapter
- *
- * @param platformType - The platform type to check
- * @returns True if the platform is supported, false otherwise
- */
-declare function isPlatformSupported(platformType: PlatformType): boolean;
-/**
- * Gets platform-specific capabilities
- *
- * @returns Object describing available platform capabilities
- */
-declare function getPlatformCapabilities(): {
-    platform: PlatformType;
-    crypto: {
-        webCrypto: false | SubtleCrypto;
-        nodeCrypto: string | false;
-    };
-    fetch: boolean;
-    streams: boolean;
-};
-
-export { BrowserPlatformAdapter, type VanaPlatformAdapter, createBrowserPlatformAdapter, createPlatformAdapterSafe, detectPlatform, getPlatformCapabilities, isPlatformSupported };

package/dist/platform.browser.js

@@ -1,318 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/platform/shared/crypto-utils.ts
-function processWalletPublicKey(publicKey) {
-  const publicKeyHex = publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
-  const publicKeyBytes = Buffer.from(publicKeyHex, "hex");
-  return publicKeyBytes.length === 64 ? Buffer.concat([Buffer.from([4]), publicKeyBytes]) : publicKeyBytes;
-}
-function processWalletPrivateKey(privateKey) {
-  const privateKeyHex = privateKey.startsWith("0x") ? privateKey.slice(2) : privateKey;
-  return Buffer.from(privateKeyHex, "hex");
-}
-function parseEncryptedDataBuffer(encryptedBuffer) {
-  return {
-    iv: encryptedBuffer.slice(0, 16),
-    ephemPublicKey: encryptedBuffer.slice(16, 81),
-    // 65 bytes for uncompressed public key
-    ciphertext: encryptedBuffer.slice(81, -32),
-    mac: encryptedBuffer.slice(-32)
-  };
-}
-var init_crypto_utils = __esm({
-  "src/platform/shared/crypto-utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/platform/shared/pgp-utils.ts
-function processPGPKeyOptions(options) {
-  return {
-    name: options?.name || "Vana User",
-    email: options?.email || "user@vana.org",
-    passphrase: options?.passphrase
-  };
-}
-function getPGPKeyGenParams(options) {
-  const { name, email, passphrase } = processPGPKeyOptions(options);
-  return {
-    type: "rsa",
-    rsaBits: 2048,
-    userIDs: [{ name, email }],
-    passphrase,
-    config: STANDARD_PGP_CONFIG
-  };
-}
-var STANDARD_PGP_CONFIG;
-var init_pgp_utils = __esm({
-  "src/platform/shared/pgp-utils.ts"() {
-    "use strict";
-    STANDARD_PGP_CONFIG = {
-      preferredCompressionAlgorithm: 2,
-      // zlib (openpgp.enums.compression.zlib)
-      preferredSymmetricAlgorithm: 7
-      // aes256 (openpgp.enums.symmetric.aes256)
-    };
-  }
-});
-
-// src/platform/shared/error-utils.ts
-function wrapCryptoError(operation, error) {
-  const message = error instanceof Error ? error.message : "Unknown error";
-  return new Error(`${operation} failed: ${message}`);
-}
-var init_error_utils = __esm({
-  "src/platform/shared/error-utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/platform/browser.ts
-import * as openpgp from "openpgp";
-var BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
-var init_browser = __esm({
-  "src/platform/browser.ts"() {
-    "use strict";
-    init_crypto_utils();
-    init_pgp_utils();
-    init_error_utils();
-    BrowserCryptoAdapter = class {
-      async encryptWithPublicKey(data, publicKeyHex) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const publicKeyBuffer = Buffer.from(publicKeyHex, "hex");
-          const encrypted = await eccrypto.encrypt(
-            publicKeyBuffer,
-            Buffer.from(data, "utf8")
-          );
-          const result = Buffer.concat([
-            encrypted.iv,
-            encrypted.ephemPublicKey,
-            encrypted.ciphertext,
-            encrypted.mac
-          ]);
-          return result.toString("hex");
-        } catch (error) {
-          throw new Error(`Encryption failed: ${error}`);
-        }
-      }
-      async decryptWithPrivateKey(encryptedData, privateKeyHex) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);
-          const encryptedBuffer = Buffer.from(encryptedData, "hex");
-          const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
-          const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
-          const decryptedBuffer = await eccrypto.decrypt(
-            privateKeyBuffer,
-            encryptedObj
-          );
-          return decryptedBuffer.toString("utf8");
-        } catch (error) {
-          throw new Error(`Decryption failed: ${error}`);
-        }
-      }
-      async generateKeyPair() {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const privateKeyBytes = new Uint8Array(32);
-          crypto.getRandomValues(privateKeyBytes);
-          const privateKey = Buffer.from(privateKeyBytes);
-          const publicKey = eccrypto.getPublicCompressed(privateKey);
-          return {
-            privateKey: privateKey.toString("hex"),
-            publicKey: publicKey.toString("hex")
-          };
-        } catch (error) {
-          throw wrapCryptoError("key generation", error);
-        }
-      }
-      async encryptWithWalletPublicKey(data, publicKey) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const uncompressedKey = processWalletPublicKey(publicKey);
-          const encryptedBuffer = await eccrypto.encrypt(
-            uncompressedKey,
-            Buffer.from(data)
-          );
-          const result = Buffer.concat([
-            encryptedBuffer.iv,
-            encryptedBuffer.ephemPublicKey,
-            encryptedBuffer.ciphertext,
-            encryptedBuffer.mac
-          ]);
-          return result.toString("hex");
-        } catch (error) {
-          throw wrapCryptoError("encrypt with wallet public key", error);
-        }
-      }
-      async decryptWithWalletPrivateKey(encryptedData, privateKey) {
-        try {
-          const eccrypto = await import("eccrypto-js");
-          const privateKeyBuffer = processWalletPrivateKey(privateKey);
-          const encryptedBuffer = Buffer.from(encryptedData, "hex");
-          const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
-          const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
-          const decryptedBuffer = await eccrypto.decrypt(
-            privateKeyBuffer,
-            encryptedObj
-          );
-          return decryptedBuffer.toString("utf8");
-        } catch (error) {
-          throw wrapCryptoError("decrypt with wallet private key", error);
-        }
-      }
-      async encryptWithPassword(data, password) {
-        try {
-          const openpgp2 = await import("openpgp");
-          const message = await openpgp2.createMessage({
-            binary: data
-          });
-          const encrypted = await openpgp2.encrypt({
-            message,
-            passwords: [password],
-            format: "binary"
-          });
-          const response = new Response(encrypted);
-          const arrayBuffer = await response.arrayBuffer();
-          return new Uint8Array(arrayBuffer);
-        } catch (error) {
-          throw new Error(`Failed to encrypt with password: ${error}`);
-        }
-      }
-      async decryptWithPassword(encryptedData, password) {
-        try {
-          const openpgp2 = await import("openpgp");
-          const message = await openpgp2.readMessage({
-            binaryMessage: encryptedData
-          });
-          const { data: decrypted } = await openpgp2.decrypt({
-            message,
-            passwords: [password],
-            format: "binary"
-          });
-          return new Uint8Array(decrypted);
-        } catch (error) {
-          throw new Error(`Failed to decrypt with password: ${error}`);
-        }
-      }
-    };
-    BrowserPGPAdapter = class {
-      async encrypt(data, publicKeyArmored) {
-        try {
-          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 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 keyGenParams = getPGPKeyGenParams(options);
-          const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
-          return { publicKey, privateKey };
-        } catch (error) {
-          throw wrapCryptoError("PGP key generation", error);
-        }
-      }
-    };
-    BrowserHttpAdapter = class {
-      async fetch(url, options) {
-        if (typeof fetch === "undefined") {
-          throw new Error("Fetch API not available in this browser environment");
-        }
-        return fetch(url, options);
-      }
-    };
-    BrowserPlatformAdapter = class {
-      constructor() {
-        __publicField(this, "crypto");
-        __publicField(this, "pgp");
-        __publicField(this, "http");
-        __publicField(this, "platform", "browser");
-        this.crypto = new BrowserCryptoAdapter();
-        this.pgp = new BrowserPGPAdapter();
-        this.http = new BrowserHttpAdapter();
-      }
-    };
-    browserPlatformAdapter = new BrowserPlatformAdapter();
-  }
-});
-
-// src/platform.browser.ts
-init_browser();
-
-// src/platform/browser-only.ts
-init_browser();
-function createBrowserPlatformAdapter() {
-  return new BrowserPlatformAdapter();
-}
-function createPlatformAdapterSafe() {
-  return createBrowserPlatformAdapter();
-}
-
-// src/platform/utils.ts
-function detectPlatform() {
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    return "node";
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return "browser";
-  }
-  return "node";
-}
-function isPlatformSupported(platformType) {
-  const currentPlatform = detectPlatform();
-  return currentPlatform === platformType;
-}
-function getPlatformCapabilities() {
-  const platform = detectPlatform();
-  return {
-    platform,
-    crypto: {
-      webCrypto: typeof crypto !== "undefined" && crypto.subtle,
-      nodeCrypto: typeof process !== "undefined" && process.versions && process.versions.node
-    },
-    fetch: typeof fetch !== "undefined" || typeof globalThis.fetch !== "undefined",
-    streams: typeof ReadableStream !== "undefined"
-  };
-}
-export {
-  BrowserPlatformAdapter,
-  createBrowserPlatformAdapter,
-  createPlatformAdapterSafe,
-  detectPlatform,
-  getPlatformCapabilities,
-  isPlatformSupported
-};
-//# sourceMappingURL=platform.browser.js.map

package/dist/platform.browser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/platform/shared/crypto-utils.ts","../src/platform/shared/pgp-utils.ts","../src/platform/shared/error-utils.ts","../src/platform/browser.ts","../src/platform.browser.ts","../src/platform/browser-only.ts","../src/platform/utils.ts"],"sourcesContent":["/**\n * Shared crypto utilities for platform adapters\n *\n * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.\n * All functions are pure utilities that can be safely shared across platforms.\n */\n\n/**\n * Process wallet public key for encryption operations\n * Removes 0x prefix and ensures uncompressed format (65 bytes with 0x04 prefix)\n *\n * @param publicKey The public key (with or without 0x prefix)\n * @returns Buffer containing uncompressed public key\n */\nexport function processWalletPublicKey(publicKey: string): Buffer {\n  const publicKeyHex = publicKey.startsWith(\"0x\")\n    ? publicKey.slice(2)\n    : publicKey;\n  const publicKeyBytes = Buffer.from(publicKeyHex, \"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  return publicKeyBytes.length === 64\n    ? Buffer.concat([Buffer.from([4]), publicKeyBytes])\n    : publicKeyBytes;\n}\n\n/**\n * Process wallet private key for decryption operations\n * Removes 0x prefix and converts to Buffer\n *\n * @param privateKey The private key (with or without 0x prefix)\n * @returns Buffer containing private key\n */\nexport function processWalletPrivateKey(privateKey: string): Buffer {\n  const privateKeyHex = privateKey.startsWith(\"0x\")\n    ? privateKey.slice(2)\n    : privateKey;\n  return Buffer.from(privateKeyHex, \"hex\");\n}\n\n/**\n * Parse encrypted data buffer into components\n * Extracts IV, ephemeral public key, ciphertext, and MAC from a concatenated buffer\n *\n * @param encryptedBuffer The buffer containing encrypted data\n * @returns Object with parsed components\n */\nexport function parseEncryptedDataBuffer(encryptedBuffer: Buffer) {\n  return {\n    iv: encryptedBuffer.slice(0, 16),\n    ephemPublicKey: encryptedBuffer.slice(16, 81), // 65 bytes for uncompressed public key\n    ciphertext: encryptedBuffer.slice(81, -32),\n    mac: encryptedBuffer.slice(-32),\n  };\n}\n\n/**\n * Convert hex string to Uint8Array\n *\n * @param hex The hex string to convert\n * @returns Uint8Array representation\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  const result = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    result[i / 2] = parseInt(hex.substr(i, 2), 16);\n  }\n  return result;\n}\n\n/**\n * Convert Uint8Array to hex string\n *\n * @param array The Uint8Array to convert\n * @returns Hex string representation\n */\nexport function uint8ArrayToHex(array: Uint8Array): string {\n  return Array.from(array, (byte) => byte.toString(16).padStart(2, \"0\")).join(\n    \"\",\n  );\n}\n","/**\n * Shared PGP utilities for platform adapters\n *\n * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.\n * All functions are pure utilities that can be safely shared across platforms.\n */\n\n/**\n * Standard OpenPGP configuration for consistent behavior across platforms\n * Uses enum values instead of importing openpgp to avoid loading issues\n */\nexport const STANDARD_PGP_CONFIG = {\n  preferredCompressionAlgorithm: 2, // zlib (openpgp.enums.compression.zlib)\n  preferredSymmetricAlgorithm: 7, // aes256 (openpgp.enums.symmetric.aes256)\n} as const;\n\n/**\n * Process PGP key generation options with sensible defaults\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Processed options with defaults applied\n */\nexport function processPGPKeyOptions(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  return {\n    name: options?.name || \"Vana User\",\n    email: options?.email || \"user@vana.org\",\n    passphrase: options?.passphrase,\n  };\n}\n\n/**\n * Get standard PGP key generation parameters\n * Combines default values with standard configuration\n *\n * @param options - Optional key generation parameters\n * @param options.name - The name for the PGP key (defaults to \"Vana User\")\n * @param options.email - The email for the PGP key (defaults to \"user@vana.org\")\n * @param options.passphrase - Optional passphrase to protect the private key\n * @returns Complete key generation parameters object\n */\nexport function getPGPKeyGenParams(options?: {\n  name?: string;\n  email?: string;\n  passphrase?: string;\n}) {\n  const { name, email, passphrase } = processPGPKeyOptions(options);\n\n  return {\n    type: \"rsa\" as const,\n    rsaBits: 2048,\n    userIDs: [{ name, email }],\n    passphrase,\n    config: STANDARD_PGP_CONFIG,\n  };\n}\n","/**\n * Shared error utilities for platform adapters\n *\n * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.\n * All functions are pure utilities that can be safely shared across platforms.\n */\n\n/**\n * Wrap platform-specific errors with consistent messaging\n * Provides consistent error formatting across all crypto operations\n *\n * @param operation The operation that failed (e.g., \"encryption\", \"decryption\")\n * @param error The original error that occurred\n * @returns Wrapped error with consistent format\n */\nexport function wrapCryptoError(operation: string, error: unknown): Error {\n  const message = error instanceof Error ? error.message : \"Unknown error\";\n  return new Error(`${operation} failed: ${message}`);\n}\n\n/**\n * Validate encrypted data structure has required fields\n * Ensures encrypted data objects contain the expected properties\n *\n * @param data The data structure to validate\n * @throws Error if data structure is invalid\n */\nexport function validateEncryptedDataStructure(data: unknown): void {\n  if (!data || typeof data !== \"object\") {\n    throw new Error(\"Invalid encrypted data format\");\n  }\n\n  const obj = data as Record<string, unknown>;\n  if (!obj.encrypted || !obj.iv || !obj.ephemeralPublicKey) {\n    throw new Error(\"Invalid encrypted data format\");\n  }\n}\n","/**\n * Browser implementation of the Vana Platform Adapter\n *\n * This implementation uses browser-compatible libraries and configurations\n * to provide crypto, PGP, and HTTP functionality without Node.js dependencies.\n */\n\nimport * as openpgp from \"openpgp\";\nimport {\n  VanaPlatformAdapter,\n  VanaCryptoAdapter,\n  VanaPGPAdapter,\n  VanaHttpAdapter,\n} from \"./interface\";\nimport {\n  processWalletPublicKey,\n  processWalletPrivateKey,\n  parseEncryptedDataBuffer,\n} from \"./shared/crypto-utils\";\nimport { getPGPKeyGenParams } from \"./shared/pgp-utils\";\nimport { wrapCryptoError } from \"./shared/error-utils\";\n\n/**\n * Browser implementation of crypto operations using eccrypto-js\n */\nclass BrowserCryptoAdapter implements VanaCryptoAdapter {\n  async encryptWithPublicKey(\n    data: string,\n    publicKeyHex: string,\n  ): Promise<string> {\n    try {\n      // Import eccrypto-js for secp256k1 encryption\n      const eccrypto = await import(\"eccrypto-js\");\n\n      // Convert hex public key to Buffer\n      const publicKeyBuffer = Buffer.from(publicKeyHex, \"hex\");\n\n      // Encrypt data using secp256k1 ECDH\n      const encrypted = await eccrypto.encrypt(\n        publicKeyBuffer,\n        Buffer.from(data, \"utf8\"),\n      );\n\n      // Concatenate all components and return as hex string for API consistency\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    } catch (error) {\n      throw new Error(`Encryption failed: ${error}`);\n    }\n  }\n\n  async decryptWithPrivateKey(\n    encryptedData: string,\n    privateKeyHex: string,\n  ): Promise<string> {\n    try {\n      // Import eccrypto-js for secp256k1 decryption\n      const eccrypto = await import(\"eccrypto-js\");\n\n      // Use shared utilities to process keys and parse data\n      const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);\n      const encryptedBuffer = Buffer.from(encryptedData, \"hex\");\n      const { iv, ephemPublicKey, ciphertext, mac } =\n        parseEncryptedDataBuffer(encryptedBuffer);\n\n      // Reconstruct the encrypted data structure for eccrypto\n      const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };\n\n      // Decrypt using secp256k1 ECDH\n      const decryptedBuffer = await eccrypto.decrypt(\n        privateKeyBuffer,\n        encryptedObj,\n      );\n\n      return decryptedBuffer.toString(\"utf8\");\n    } catch (error) {\n      throw new Error(`Decryption failed: ${error}`);\n    }\n  }\n\n  async generateKeyPair(): Promise<{ publicKey: string; privateKey: string }> {\n    try {\n      // Import eccrypto-js for secp256k1 key generation (browser-compatible)\n      const eccrypto = await import(\"eccrypto-js\");\n\n      // Generate a random 32-byte private key for secp256k1\n      const privateKeyBytes = new Uint8Array(32);\n      crypto.getRandomValues(privateKeyBytes);\n      const privateKey = Buffer.from(privateKeyBytes);\n\n      // Generate the corresponding compressed public key\n      const publicKey = eccrypto.getPublicCompressed(privateKey);\n\n      return {\n        privateKey: privateKey.toString(\"hex\"),\n        publicKey: publicKey.toString(\"hex\"),\n      };\n    } catch (error) {\n      throw wrapCryptoError(\"key generation\", error);\n    }\n  }\n\n  async encryptWithWalletPublicKey(\n    data: string,\n    publicKey: string,\n  ): Promise<string> {\n    try {\n      // Import eccrypto for ECDH encryption\n      const eccrypto = await import(\"eccrypto-js\");\n\n      // Use shared utility to process public key\n      const uncompressedKey = processWalletPublicKey(publicKey);\n\n      // Encrypt using ECDH with randomly generated parameters\n      const encryptedBuffer = await eccrypto.encrypt(\n        uncompressedKey,\n        Buffer.from(data),\n      );\n\n      // Concatenate all components and return as hex\n      const result = Buffer.concat([\n        encryptedBuffer.iv,\n        encryptedBuffer.ephemPublicKey,\n        encryptedBuffer.ciphertext,\n        encryptedBuffer.mac,\n      ]);\n\n      return result.toString(\"hex\");\n    } catch (error) {\n      throw wrapCryptoError(\"encrypt with wallet public key\", error);\n    }\n  }\n\n  async decryptWithWalletPrivateKey(\n    encryptedData: string,\n    privateKey: string,\n  ): Promise<string> {\n    try {\n      // Import eccrypto for ECDH decryption\n      const eccrypto = await import(\"eccrypto-js\");\n\n      // Use shared utilities to process keys and parse data\n      const privateKeyBuffer = processWalletPrivateKey(privateKey);\n      const encryptedBuffer = Buffer.from(encryptedData, \"hex\");\n      const { iv, ephemPublicKey, ciphertext, mac } =\n        parseEncryptedDataBuffer(encryptedBuffer);\n\n      // Reconstruct the encrypted data structure for eccrypto\n      const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };\n\n      // Decrypt using ECDH\n      const decryptedBuffer = await eccrypto.decrypt(\n        privateKeyBuffer,\n        encryptedObj,\n      );\n\n      return decryptedBuffer.toString(\"utf8\");\n    } catch (error) {\n      throw wrapCryptoError(\"decrypt with wallet private key\", error);\n    }\n  }\n\n  async encryptWithPassword(\n    data: Uint8Array,\n    password: string,\n  ): Promise<Uint8Array> {\n    try {\n      // Import openpgp for password-based encryption\n      const openpgp = await import(\"openpgp\");\n\n      const message = await openpgp.createMessage({\n        binary: data,\n      });\n\n      // Use password-based encryption with wallet signature as password\n      // Note: For deterministic encryption, we would need to control the salt\n      // This implementation is secure but not deterministic due to OpenPGP's design\n      const encrypted = await openpgp.encrypt({\n        message,\n        passwords: [password],\n        format: \"binary\",\n      });\n\n      // Convert WebStream<Uint8Array> to Uint8Array\n      const response = new Response(encrypted as ReadableStream<Uint8Array>);\n      const arrayBuffer = await response.arrayBuffer();\n      return new Uint8Array(arrayBuffer);\n    } catch (error) {\n      throw new Error(`Failed to encrypt with password: ${error}`);\n    }\n  }\n\n  async decryptWithPassword(\n    encryptedData: Uint8Array,\n    password: string,\n  ): Promise<Uint8Array> {\n    try {\n      // Import openpgp for password-based decryption\n      const openpgp = await import(\"openpgp\");\n\n      const message = await openpgp.readMessage({\n        binaryMessage: encryptedData,\n      });\n\n      // Use password-based decryption with wallet signature as password\n      const { data: decrypted } = await openpgp.decrypt({\n        message,\n        passwords: [password],\n        format: \"binary\",\n      });\n\n      // Convert decrypted data back to Uint8Array\n      return new Uint8Array(decrypted as ArrayBuffer);\n    } catch (error) {\n      throw new Error(`Failed to decrypt with password: ${error}`);\n    }\n  }\n}\n\n/**\n * Browser implementation of PGP operations using openpgp with browser-specific configuration\n */\nclass BrowserPGPAdapter implements VanaPGPAdapter {\n  async encrypt(data: string, publicKeyArmored: string): Promise<string> {\n    try {\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 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      // 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    if (typeof fetch === \"undefined\") {\n      throw new Error(\"Fetch API not available in this browser environment\");\n    }\n\n    return fetch(url, options);\n  }\n}\n\n/**\n * Complete browser platform adapter implementation\n */\nexport class BrowserPlatformAdapter implements VanaPlatformAdapter {\n  crypto: VanaCryptoAdapter;\n  pgp: VanaPGPAdapter;\n  http: VanaHttpAdapter;\n  platform: \"browser\" = \"browser\" as const;\n\n  constructor() {\n    this.crypto = new BrowserCryptoAdapter();\n    this.pgp = new BrowserPGPAdapter();\n    this.http = new BrowserHttpAdapter();\n  }\n}\n\n/**\n * Default instance export for backwards compatibility\n */\nexport const browserPlatformAdapter: VanaPlatformAdapter =\n  new BrowserPlatformAdapter();\n","/**\n * Browser-specific platform adapters entry point\n *\n * This module provides browser-safe platform utilities without Node.js dependencies.\n */\n\n// Export browser platform adapter\nexport { BrowserPlatformAdapter } from \"./platform/browser\";\n\n// Export platform interface\nexport type { VanaPlatformAdapter } from \"./platform/interface\";\n\n// Export browser-safe utilities only\nexport {\n  createBrowserPlatformAdapter,\n  createPlatformAdapterSafe,\n} from \"./platform/browser-only\";\n\n// Export safe platform utilities (no Node.js imports)\nexport {\n  detectPlatform,\n  isPlatformSupported,\n  getPlatformCapabilities,\n} from \"./platform/utils\";\n","/**\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","/**\n * Platform detection and adapter utilities\n *\n * This module provides utilities for detecting the current runtime environment\n * and creating appropriate platform adapters automatically.\n */\n\nimport type { VanaPlatformAdapter, PlatformType } from \"./interface\";\n\n/**\n * Detects the current runtime environment\n *\n * @returns The detected platform type\n */\nexport function detectPlatform(): PlatformType {\n  // Check for Node.js environment\n  if (\n    typeof process !== \"undefined\" &&\n    process.versions &&\n    process.versions.node\n  ) {\n    return \"node\";\n  }\n\n  // Check for browser environment\n  if (typeof window !== \"undefined\" && typeof document !== \"undefined\") {\n    return \"browser\";\n  }\n\n  // Default to Node.js if we can't determine (e.g., SSR environments)\n  return \"node\";\n}\n\n/**\n * Creates the appropriate platform adapter based on the current environment\n *\n * @returns A platform adapter instance for the current environment\n * @throws {Error} If platform adapters cannot be imported or created\n */\nexport async function createPlatformAdapter(): Promise<VanaPlatformAdapter> {\n  const platform = detectPlatform();\n\n  try {\n    if (platform === \"node\") {\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\n      const moduleName = \"./node\";\n      const { NodePlatformAdapter } = await import(moduleName);\n      return new NodePlatformAdapter();\n    } else {\n      const { BrowserPlatformAdapter } = await import(\"./browser\");\n      return new BrowserPlatformAdapter();\n    }\n  } catch (error) {\n    throw new Error(\n      `Failed to create platform adapter for ${platform}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n\n/**\n * Creates a platform adapter for a specific platform type\n *\n * @param platformType - The platform type to create an adapter for\n * @returns A platform adapter instance for the specified platform\n * @throws {Error} If platform adapters cannot be imported or created\n */\nexport async function createPlatformAdapterFor(\n  platformType: PlatformType,\n): Promise<VanaPlatformAdapter> {\n  try {\n    if (platformType === \"node\") {\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\n      const moduleName = \"./node\";\n      const { NodePlatformAdapter } = await import(moduleName);\n      return new NodePlatformAdapter();\n    } else {\n      const { BrowserPlatformAdapter } = await import(\"./browser\");\n      return new BrowserPlatformAdapter();\n    }\n  } catch (error) {\n    throw new Error(\n      `Failed to create platform adapter for ${platformType}: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n\n/**\n * Checks if the current environment supports the given platform adapter\n *\n * @param platformType - The platform type to check\n * @returns True if the platform is supported, false otherwise\n */\nexport function isPlatformSupported(platformType: PlatformType): boolean {\n  const currentPlatform = detectPlatform();\n  return currentPlatform === platformType;\n}\n\n/**\n * Gets platform-specific capabilities\n *\n * @returns Object describing available platform capabilities\n */\nexport function getPlatformCapabilities() {\n  const platform = detectPlatform();\n\n  return {\n    platform,\n    crypto: {\n      webCrypto: typeof crypto !== \"undefined\" && crypto.subtle,\n      nodeCrypto:\n        typeof process !== \"undefined\" &&\n        process.versions &&\n        process.versions.node,\n    },\n    fetch:\n      typeof fetch !== \"undefined\" || typeof globalThis.fetch !== \"undefined\",\n    streams: typeof ReadableStream !== \"undefined\",\n  };\n}\n"],"mappings":"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","names":["openpgp"]}