@opendatalabs/vana-sdk 0.1.0-alpha.82bbb39 → 0.1.0-alpha.899ca9d

package/dist/platform.node.d.ts

@@ -1,225 +1,15 @@
-/**
- * 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>;
-}
-/**
- * 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;
-}
+import { V as VanaPlatformAdapter, a as VanaCryptoAdapter, b as VanaPGPAdapter, c as VanaHttpAdapter, d as VanaCacheAdapter, P as PlatformType } from './node-D9-F9uEP.js';
+export { N as NodePlatformAdapter } from './node-D9-F9uEP.js';
 
 /**
  * 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.
+ *
+ * WARNING: Dependencies that access globals during init
+ * MUST be dynamically imported to support Turbopack.
+ * See: https://github.com/vercel/next.js/issues/82632
  */
 
 /**
@@ -234,25 +24,6 @@ declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
     constructor();
 }
 
-/**
- * Node.js implementation of the Vana Platform Adapter
- *
- * This implementation uses Node.js-specific libraries and configurations
- * to provide crypto, PGP, and HTTP functionality.
- */
-
-/**
- * Complete Node.js platform adapter implementation
- */
-declare class NodePlatformAdapter implements VanaPlatformAdapter {
-    crypto: VanaCryptoAdapter;
-    pgp: VanaPGPAdapter;
-    http: VanaHttpAdapter;
-    cache: VanaCacheAdapter;
-    platform: "node";
-    constructor();
-}
-
 /**
  * Platform detection and adapter utilities
  *
@@ -331,4 +102,4 @@ declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
  */
 declare function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter>;
 
-export { BrowserPlatformAdapter, NodePlatformAdapter, type VanaPlatformAdapter, createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapter, createPlatformAdapterFor, createPlatformAdapterSafe, detectPlatform, getPlatformCapabilities, isPlatformSupported };
+export { BrowserPlatformAdapter, VanaPlatformAdapter, createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapter, createPlatformAdapterFor, createPlatformAdapterSafe, detectPlatform, getPlatformCapabilities, isPlatformSupported };

package/dist/platform.node.js

@@ -75,26 +75,46 @@ var init_error_utils = __esm({
   }
 });
 
+// src/utils/lazy-import.ts
+function lazyImport(importFn) {
+  let cached = null;
+  return () => {
+    if (!cached) {
+      cached = importFn().catch((err) => {
+        cached = null;
+        throw new Error("Failed to load module", { cause: err });
+      });
+    }
+    return cached;
+  };
+}
+var init_lazy_import = __esm({
+  "src/utils/lazy-import.ts"() {
+    "use strict";
+  }
+});
+
 // src/platform/browser.ts
 var browser_exports = {};
 __export(browser_exports, {
   BrowserPlatformAdapter: () => BrowserPlatformAdapter,
   browserPlatformAdapter: () => browserPlatformAdapter
 });
-import * as openpgp from "openpgp";
-var BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserCacheAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
+var getOpenPGP, 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();
+    init_lazy_import();
+    getOpenPGP = lazyImport(() => import("openpgp"));
     BrowserCryptoAdapter = class {
       async encryptWithPublicKey(data, publicKeyHex) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          const eccrypto = await import("eccrypto-js");
           const publicKeyBuffer = Buffer.from(publicKeyHex, "hex");
-          const encrypted = await eccrypto2.encrypt(
+          const encrypted = await eccrypto.encrypt(
             publicKeyBuffer,
             Buffer.from(data, "utf8")
           );
@@ -111,12 +131,12 @@ var init_browser = __esm({
       }
       async decryptWithPrivateKey(encryptedData, privateKeyHex) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          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 eccrypto2.decrypt(
+          const decryptedBuffer = await eccrypto.decrypt(
             privateKeyBuffer,
             encryptedObj
           );
@@ -127,11 +147,11 @@ var init_browser = __esm({
       }
       async generateKeyPair() {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          const eccrypto = await import("eccrypto-js");
           const privateKeyBytes = new Uint8Array(32);
           crypto.getRandomValues(privateKeyBytes);
           const privateKey = Buffer.from(privateKeyBytes);
-          const publicKey = eccrypto2.getPublicCompressed(privateKey);
+          const publicKey = eccrypto.getPublicCompressed(privateKey);
           return {
             privateKey: privateKey.toString("hex"),
             publicKey: publicKey.toString("hex")
@@ -142,9 +162,9 @@ var init_browser = __esm({
       }
       async encryptWithWalletPublicKey(data, publicKey) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          const eccrypto = await import("eccrypto-js");
           const uncompressedKey = processWalletPublicKey(publicKey);
-          const encryptedBuffer = await eccrypto2.encrypt(
+          const encryptedBuffer = await eccrypto.encrypt(
             uncompressedKey,
             Buffer.from(data)
           );
@@ -161,12 +181,12 @@ var init_browser = __esm({
       }
       async decryptWithWalletPrivateKey(encryptedData, privateKey) {
         try {
-          const eccrypto2 = await import("eccrypto-js");
+          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 eccrypto2.decrypt(
+          const decryptedBuffer = await eccrypto.decrypt(
             privateKeyBuffer,
             encryptedObj
           );
@@ -177,11 +197,11 @@ var init_browser = __esm({
       }
       async encryptWithPassword(data, password) {
         try {
-          const openpgp3 = await import("openpgp");
-          const message = await openpgp3.createMessage({
+          const openpgp = await getOpenPGP();
+          const message = await openpgp.createMessage({
             binary: data
           });
-          const encrypted = await openpgp3.encrypt({
+          const encrypted = await openpgp.encrypt({
             message,
             passwords: [password],
             format: "binary"
@@ -195,11 +215,11 @@ var init_browser = __esm({
       }
       async decryptWithPassword(encryptedData, password) {
         try {
-          const openpgp3 = await import("openpgp");
-          const message = await openpgp3.readMessage({
+          const openpgp = await getOpenPGP();
+          const message = await openpgp.readMessage({
             binaryMessage: encryptedData
           });
-          const { data: decrypted } = await openpgp3.decrypt({
+          const { data: decrypted } = await openpgp.decrypt({
             message,
             passwords: [password],
             format: "binary"
@@ -213,6 +233,7 @@ var init_browser = __esm({
     BrowserPGPAdapter = class {
       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 }),
@@ -228,6 +249,7 @@ var init_browser = __esm({
       }
       async decrypt(encryptedData, privateKeyArmored) {
         try {
+          const openpgp = await getOpenPGP();
           const privateKey = await openpgp.readPrivateKey({
             armoredKey: privateKeyArmored
           });
@@ -245,6 +267,7 @@ var init_browser = __esm({
       }
       async generateKeyPair(options) {
         try {
+          const openpgp = await getOpenPGP();
           const keyGenParams = getPGPKeyGenParams(options);
           const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
           return { publicKey, privateKey };
@@ -328,8 +351,6 @@ init_browser();
 init_crypto_utils();
 init_pgp_utils();
 init_error_utils();
-import { randomBytes } from "crypto";
-import * as openpgp2 from "openpgp";
 
 // src/platform/shared/stream-utils.ts
 async function streamToUint8Array(stream) {
@@ -355,29 +376,16 @@ async function streamToUint8Array(stream) {
 }
 
 // src/platform/node.ts
-var eccrypto = null;
-async function getEccrypto() {
-  if (!eccrypto) {
-    try {
-      const eccryptoLib = await import("eccrypto");
-      eccrypto = {
-        encrypt: eccryptoLib.encrypt,
-        decrypt: eccryptoLib.decrypt,
-        getPublicCompressed: eccryptoLib.getPublicCompressed
-      };
-    } catch (error) {
-      throw new Error(`Failed to load eccrypto library: ${error}`);
-    }
-  }
-  return eccrypto;
-}
+init_lazy_import();
+var getOpenPGP2 = lazyImport(() => import("openpgp"));
+var getEccrypto = lazyImport(() => import("eccrypto"));
 var NodeCryptoAdapter = class {
   async encryptWithPublicKey(data, publicKeyHex) {
     try {
-      const eccryptoLib = await getEccrypto();
+      const eccrypto = await getEccrypto();
       const publicKey = Buffer.from(publicKeyHex, "hex");
       const message = Buffer.from(data, "utf8");
-      const encrypted = await eccryptoLib.encrypt(publicKey, message);
+      const encrypted = await eccrypto.encrypt(publicKey, message);
       const result = Buffer.concat([
         encrypted.iv,
         encrypted.ephemPublicKey,
@@ -391,15 +399,12 @@ var NodeCryptoAdapter = class {
   }
   async decryptWithPrivateKey(encryptedData, privateKeyHex) {
     try {
-      const eccryptoLib = await getEccrypto();
+      const eccrypto = await getEccrypto();
       const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);
       const encryptedBuffer = Buffer.from(encryptedData, "hex");
       const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
       const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
-      const decrypted = await eccryptoLib.decrypt(
-        privateKeyBuffer,
-        encryptedObj
-      );
+      const decrypted = await eccrypto.decrypt(privateKeyBuffer, encryptedObj);
       return decrypted.toString("utf8");
     } catch (error) {
       throw new Error(`Decryption failed: ${error}`);
@@ -407,9 +412,9 @@ var NodeCryptoAdapter = class {
   }
   async generateKeyPair() {
     try {
-      const eccryptoLib = await getEccrypto();
-      const privateKey = randomBytes(32);
-      const publicKey = eccryptoLib.getPublicCompressed(privateKey);
+      const eccrypto = await getEccrypto();
+      const privateKey = eccrypto.generatePrivate();
+      const publicKey = eccrypto.getPublicCompressed(privateKey);
       return {
         privateKey: privateKey.toString("hex"),
         publicKey: publicKey.toString("hex")
@@ -420,9 +425,9 @@ var NodeCryptoAdapter = class {
   }
   async encryptWithWalletPublicKey(data, publicKey) {
     try {
-      const eccryptoLib = await getEccrypto();
+      const eccrypto = await getEccrypto();
       const uncompressedKey = processWalletPublicKey(publicKey);
-      const encrypted = await eccryptoLib.encrypt(
+      const encrypted = await eccrypto.encrypt(
         uncompressedKey,
         Buffer.from(data)
       );
@@ -439,12 +444,12 @@ var NodeCryptoAdapter = class {
   }
   async decryptWithWalletPrivateKey(encryptedData, privateKey) {
     try {
-      const eccryptoLib = await getEccrypto();
+      const eccrypto = await getEccrypto();
       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 eccryptoLib.decrypt(
+      const decryptedBuffer = await eccrypto.decrypt(
         privateKeyBuffer,
         encryptedObj
       );
@@ -455,10 +460,11 @@ var NodeCryptoAdapter = class {
   }
   async encryptWithPassword(data, password) {
     try {
-      const message = await openpgp2.createMessage({
+      const openpgp = await getOpenPGP2();
+      const message = await openpgp.createMessage({
         binary: data
       });
-      const encrypted = await openpgp2.encrypt({
+      const encrypted = await openpgp.encrypt({
         message,
         passwords: [password],
         format: "binary"
@@ -478,10 +484,11 @@ var NodeCryptoAdapter = class {
   }
   async decryptWithPassword(encryptedData, password) {
     try {
-      const message = await openpgp2.readMessage({
+      const openpgp = await getOpenPGP2();
+      const message = await openpgp.readMessage({
         binaryMessage: encryptedData
       });
-      const { data: decrypted } = await openpgp2.decrypt({
+      const { data: decrypted } = await openpgp.decrypt({
         message,
         passwords: [password],
         format: "binary"
@@ -495,12 +502,13 @@ var NodeCryptoAdapter = class {
 var NodePGPAdapter = class {
   async encrypt(data, publicKeyArmored) {
     try {
-      const publicKey = await openpgp2.readKey({ armoredKey: publicKeyArmored });
-      const encrypted = await openpgp2.encrypt({
-        message: await openpgp2.createMessage({ text: data }),
+      const openpgp = await getOpenPGP2();
+      const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
+      const encrypted = await openpgp.encrypt({
+        message: await openpgp.createMessage({ text: data }),
         encryptionKeys: publicKey,
         config: {
-          preferredCompressionAlgorithm: openpgp2.enums.compression.zlib
+          preferredCompressionAlgorithm: openpgp.enums.compression.zlib
         }
       });
       return encrypted;
@@ -510,13 +518,14 @@ var NodePGPAdapter = class {
   }
   async decrypt(encryptedData, privateKeyArmored) {
     try {
-      const privateKey = await openpgp2.readPrivateKey({
+      const openpgp = await getOpenPGP2();
+      const privateKey = await openpgp.readPrivateKey({
         armoredKey: privateKeyArmored
       });
-      const message = await openpgp2.readMessage({
+      const message = await openpgp.readMessage({
         armoredMessage: encryptedData
       });
-      const { data: decrypted } = await openpgp2.decrypt({
+      const { data: decrypted } = await openpgp.decrypt({
         message,
         decryptionKeys: privateKey
       });
@@ -527,8 +536,9 @@ var NodePGPAdapter = class {
   }
   async generateKeyPair(options) {
     try {
+      const openpgp = await getOpenPGP2();
       const keyGenParams = getPGPKeyGenParams(options);
-      const { privateKey, publicKey } = await openpgp2.generateKey(keyGenParams);
+      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
       return { publicKey, privateKey };
     } catch (error) {
       throw wrapCryptoError("PGP key generation", error);