@opendatalabs/vana-sdk 0.1.0-alpha.ee24d86 → 0.1.0-alpha.eebb656

package/dist/platform.browser.d.ts

@@ -1,293 +1,9 @@
 /**
- * Platform Adapter interface for environment-specific implementations
+ * Browser-specific platform adapters entry point
  *
- * 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>;
-}
-/**
- * Simple cache operations that work across platforms
- */
-interface VanaCacheAdapter {
-    /**
-     * Get a value from the cache
-     *
-     * @param key The cache key
-     * @returns The cached value or null if not found/expired
-     */
-    get(key: string): string | null;
-    /**
-     * Set a value in the cache
-     *
-     * @param key The cache key
-     * @param value The value to cache
-     */
-    set(key: string, value: string): void;
-    /**
-     * Delete a value from the cache
-     *
-     * @param key The cache key
-     */
-    delete(key: string): void;
-    /**
-     * Clear all values from the cache
-     */
-    clear(): void;
-}
-/**
- * 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;
-    /**
-     * Cache operations adapter
-     */
-    cache: VanaCacheAdapter;
-    /**
-     * 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;
-    cache: VanaCacheAdapter;
-    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
+ * This module provides browser-safe platform utilities without Node.js dependencies.
  */
-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 };
+export { BrowserPlatformAdapter } from "./platform/browser";
+export type { VanaPlatformAdapter } from "./platform/interface";
+export { createBrowserPlatformAdapter, createPlatformAdapterSafe, } from "./platform/browser-only";
+export { detectPlatform, isPlatformSupported, getPlatformCapabilities, } from "./platform/utils";

package/dist/platform.browser.js

@@ -1,359 +1,13 @@
-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, BrowserCacheAdapter, 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);
-      }
-    };
-    BrowserCacheAdapter = class {
-      constructor() {
-        __publicField(this, "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") {
-            sessionStorage.setItem(this.prefix + key, value);
-          }
-        } catch {
-        }
-      }
-      delete(key) {
-        try {
-          if (typeof sessionStorage !== "undefined") {
-            sessionStorage.removeItem(this.prefix + key);
-          }
-        } catch {
-        }
-      }
-      clear() {
-        try {
-          if (typeof sessionStorage === "undefined") {
-            return;
-          }
-          const keys = Object.keys(sessionStorage);
-          for (const key of keys) {
-            if (key.startsWith(this.prefix)) {
-              sessionStorage.removeItem(key);
-            }
-          }
-        } catch {
-        }
-      }
-    };
-    BrowserPlatformAdapter = class {
-      constructor() {
-        __publicField(this, "crypto");
-        __publicField(this, "pgp");
-        __publicField(this, "http");
-        __publicField(this, "cache");
-        __publicField(this, "platform", "browser");
-        this.crypto = new BrowserCryptoAdapter();
-        this.pgp = new BrowserPGPAdapter();
-        this.http = new BrowserHttpAdapter();
-        this.cache = new BrowserCacheAdapter();
-      }
-    };
-    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"
-  };
-}
+import { BrowserPlatformAdapter } from "./platform/browser";
+import {
+  createBrowserPlatformAdapter,
+  createPlatformAdapterSafe
+} from "./platform/browser-only";
+import {
+  detectPlatform,
+  isPlatformSupported,
+  getPlatformCapabilities
+} from "./platform/utils";
 export {
   BrowserPlatformAdapter,
   createBrowserPlatformAdapter,