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

package/dist/platform/interface.d.ts

@@ -0,0 +1,216 @@
+/**
+ * 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
+ */
+export type PlatformType = "node" | "browser";
+/**
+ * Encryption operations that require different implementations per platform
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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;
+ * }
+ * ```
+ */
+export 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;
+}

package/dist/platform/interface.js

@@ -0,0 +1 @@
+//# sourceMappingURL=interface.js.map

package/dist/platform/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/platform/node.cjs

@@ -0,0 +1,351 @@
+"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 node_exports = {};
+__export(node_exports, {
+  NodePlatformAdapter: () => NodePlatformAdapter,
+  nodePlatformAdapter: () => nodePlatformAdapter
+});
+module.exports = __toCommonJS(node_exports);
+var import_pgp_utils = require("./shared/pgp-utils");
+var import_error_utils = require("./shared/error-utils");
+var import_stream_utils = require("./shared/stream-utils");
+var import_lazy_import = require("../utils/lazy-import");
+var import_features = require("../config/features");
+var import_WalletKeyEncryptionService = require("../crypto/services/WalletKeyEncryptionService");
+var import_crypto_utils = require("../utils/crypto-utils");
+var import_node = require("../crypto/ecies/node");
+var import_interface = require("../crypto/ecies/interface");
+var import_crypto = require("crypto");
+var import_secp256k1 = __toESM(require("secp256k1"), 1);
+const getOpenPGP = (0, import_lazy_import.lazyImport)(() => import("openpgp"));
+const getEccryptoJS = (0, import_lazy_import.lazyImport)(() => import("eccrypto-js"));
+class NodeCryptoAdapter {
+  // Initialize both providers - only one will be used based on feature flag
+  customEciesProvider = new import_node.NodeECIESUint8Provider();
+  customWalletService = new import_WalletKeyEncryptionService.WalletKeyEncryptionService({
+    eciesProvider: this.customEciesProvider
+  });
+  async encryptWithPublicKey(data, publicKeyHex) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const publicKey = Buffer.from(publicKeyHex, "hex");
+        const message = Buffer.from(data, "utf8");
+        const encrypted = await this.customEciesProvider.encrypt(
+          publicKey,
+          message
+        );
+        const result = Buffer.concat([
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        ]);
+        return result.toString("hex");
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const publicKey = Buffer.from(publicKeyHex, "hex");
+        const message = Buffer.from(data, "utf8");
+        const encrypted = await eccryptojs.encrypt(publicKey, message);
+        const result = Buffer.concat([
+          encrypted.iv,
+          encrypted.ephemPublicKey,
+          encrypted.ciphertext,
+          encrypted.mac
+        ]);
+        return result.toString("hex");
+      }
+    } catch (error) {
+      if (import_features.features.useCustomECIES && error instanceof import_interface.ECIESError) {
+        throw error;
+      }
+      throw new Error(
+        `Encryption failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async decryptWithPrivateKey(encryptedData, privateKeyHex) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const privateKeyBuffer = (0, import_crypto_utils.processWalletPrivateKey)(privateKeyHex);
+        const encryptedBuffer = Buffer.from(encryptedData, "hex");
+        const { iv, ephemPublicKey, ciphertext, mac } = (0, import_crypto_utils.parseEncryptedDataBuffer)(encryptedBuffer);
+        const encryptedObj = {
+          iv,
+          ephemPublicKey,
+          ciphertext,
+          mac
+        };
+        const decrypted = await this.customEciesProvider.decrypt(
+          privateKeyBuffer,
+          encryptedObj
+        );
+        return new TextDecoder().decode(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) {
+      if (import_features.features.useCustomECIES && error instanceof import_interface.ECIESError) {
+        throw error;
+      }
+      throw new Error(
+        `Decryption failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  async generateKeyPair() {
+    try {
+      if (import_features.features.useCustomECIES) {
+        const secp256k1 = import_secp256k1.default;
+        let privateKey;
+        do {
+          privateKey = (0, import_crypto.randomBytes)(32);
+        } while (!secp256k1.privateKeyVerify(privateKey));
+        const publicKey = Buffer.from(
+          secp256k1.publicKeyCreate(privateKey, true)
+        );
+        return {
+          privateKey: privateKey.toString("hex"),
+          publicKey: publicKey.toString("hex")
+        };
+      } 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)("key generation", error);
+    }
+  }
+  async encryptWithWalletPublicKey(data, publicKey) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        return await this.customWalletService.encryptWithWalletPublicKey(
+          data,
+          publicKey
+        );
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const publicKeyBuffer = Buffer.from((0, import_crypto_utils.processWalletPublicKey)(publicKey));
+        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)("encrypt with wallet public key", error);
+    }
+  }
+  async decryptWithWalletPrivateKey(encryptedData, privateKey) {
+    try {
+      if (import_features.features.useCustomECIES) {
+        return await this.customWalletService.decryptWithWalletPrivateKey(
+          encryptedData,
+          privateKey
+        );
+      } else {
+        const eccryptojs = await getEccryptoJS();
+        const privateKeyBuffer = Buffer.from(
+          (0, import_crypto_utils.processWalletPrivateKey)(privateKey)
+        );
+        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)("decrypt with wallet private key", error);
+    }
+  }
+  async encryptWithPassword(data, password) {
+    try {
+      const openpgp = await getOpenPGP();
+      const message = await openpgp.createMessage({
+        binary: data
+      });
+      const encrypted = await openpgp.encrypt({
+        message,
+        passwords: [password],
+        format: "binary"
+      });
+      if (encrypted instanceof Uint8Array) {
+        return encrypted;
+      }
+      if (encrypted && typeof encrypted === "object" && "getReader" in encrypted) {
+        return await (0, import_stream_utils.streamToUint8Array)(
+          encrypted
+        );
+      }
+      throw new Error("Unexpected encrypted data format");
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("encrypt with password", error);
+    }
+  }
+  async decryptWithPassword(encryptedData, password) {
+    try {
+      const openpgp = await getOpenPGP();
+      const message = await openpgp.readMessage({
+        binaryMessage: encryptedData
+      });
+      const { data: decrypted } = await openpgp.decrypt({
+        message,
+        passwords: [password],
+        format: "binary"
+      });
+      return new Uint8Array(decrypted);
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("decrypt with password", error);
+    }
+  }
+}
+class NodePGPAdapter {
+  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 (0, import_error_utils.wrapCryptoError)("PGP encryption", error);
+    }
+  }
+  async decrypt(encryptedData, privateKeyArmored) {
+    try {
+      const openpgp = await getOpenPGP();
+      const privateKey = await openpgp.readPrivateKey({
+        armoredKey: privateKeyArmored
+      });
+      const message = await openpgp.readMessage({
+        armoredMessage: encryptedData
+      });
+      const { data: decrypted } = await openpgp.decrypt({
+        message,
+        decryptionKeys: privateKey
+      });
+      return decrypted;
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("PGP decryption", error);
+    }
+  }
+  async generateKeyPair(options) {
+    try {
+      const openpgp = await getOpenPGP();
+      const keyGenParams = (0, import_pgp_utils.getPGPKeyGenParams)(options);
+      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
+      return { publicKey, privateKey };
+    } catch (error) {
+      throw (0, import_error_utils.wrapCryptoError)("PGP key generation", error);
+    }
+  }
+}
+class NodeHttpAdapter {
+  async fetch(url, options) {
+    if (typeof globalThis.fetch !== "undefined") {
+      return globalThis.fetch(url, options);
+    }
+    throw new Error("No fetch implementation available in Node.js environment");
+  }
+}
+class NodeCacheAdapter {
+  cache = /* @__PURE__ */ new Map();
+  defaultTtl = 2 * 60 * 60 * 1e3;
+  // 2 hours in milliseconds
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expires) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    this.cache.set(key, {
+      value,
+      expires: Date.now() + this.defaultTtl
+    });
+  }
+  delete(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+class NodePlatformAdapter {
+  crypto;
+  pgp;
+  http;
+  cache;
+  platform = "node";
+  constructor() {
+    this.crypto = new NodeCryptoAdapter();
+    this.pgp = new NodePGPAdapter();
+    this.http = new NodeHttpAdapter();
+    this.cache = new NodeCacheAdapter();
+  }
+}
+const nodePlatformAdapter = new NodePlatformAdapter();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodePlatformAdapter,
+  nodePlatformAdapter
+});
+//# sourceMappingURL=node.cjs.map

package/dist/platform/node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/node.ts"],"sourcesContent":["/**\n * Node.js implementation of the Vana Platform Adapter\n *\n * WARNING: Dependencies that access globals during init\n * MUST be dynamically imported to support Turbopack.\n * See: https://github.com/vercel/next.js/issues/82632\n */\n\nimport type {\n  VanaPlatformAdapter,\n  VanaCryptoAdapter,\n  VanaPGPAdapter,\n  VanaHttpAdapter,\n  VanaCacheAdapter,\n} from \"./interface\";\nimport { getPGPKeyGenParams } from \"./shared/pgp-utils\";\nimport { wrapCryptoError } from \"./shared/error-utils\";\nimport { streamToUint8Array } from \"./shared/stream-utils\";\nimport { lazyImport } from \"../utils/lazy-import\";\nimport { features } from \"../config/features\";\nimport { WalletKeyEncryptionService } from \"../crypto/services/WalletKeyEncryptionService\";\nimport {\n  processWalletPrivateKey,\n  parseEncryptedDataBuffer,\n  processWalletPublicKey,\n} from \"../utils/crypto-utils\";\n\n// Lazy-loaded dependencies to avoid Turbopack TDZ issues\nconst getOpenPGP = lazyImport(() => import(\"openpgp\"));\nconst getEccryptoJS = lazyImport(() => import(\"eccrypto-js\"));\n\n// Import both ECIES implementations statically\nimport { NodeECIESUint8Provider } from \"../crypto/ecies/node\";\nimport { ECIESError } from \"../crypto/ecies/interface\";\nimport type { ECIESEncrypted } from \"../crypto/ecies\";\nimport { randomBytes } from \"crypto\";\nimport secp256k1Import from \"secp256k1\";\n\n// Type definition for secp256k1 module\ninterface Secp256k1Module {\n  privateKeyVerify(privateKey: Buffer): boolean;\n  publicKeyCreate(privateKey: Buffer, compressed: boolean): Buffer;\n  publicKeyVerify(publicKey: Buffer): boolean;\n  publicKeyConvert(publicKey: Buffer, compressed: boolean): Buffer;\n  ecdh(\n    publicKey: Buffer,\n    privateKey: Buffer,\n    options: {\n      hashfn: (x: Uint8Array, y: Uint8Array, output?: Uint8Array) => Uint8Array;\n    },\n    output: Buffer,\n  ): Buffer;\n}\n\n/**\n * Node.js implementation of crypto operations\n * Supports both eccrypto (default) and custom ECIES implementation\n */\nclass NodeCryptoAdapter implements VanaCryptoAdapter {\n  // Initialize both providers - only one will be used based on feature flag\n  private customEciesProvider = new NodeECIESUint8Provider();\n  private customWalletService = new WalletKeyEncryptionService({\n    eciesProvider: this.customEciesProvider,\n  });\n\n  async encryptWithPublicKey(\n    data: string,\n    publicKeyHex: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation\n        const publicKey = Buffer.from(publicKeyHex, \"hex\");\n        const message = Buffer.from(data, \"utf8\");\n\n        const encrypted = await this.customEciesProvider.encrypt(\n          publicKey,\n          message,\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      } else {\n        // Use eccrypto-js (default)\n        const eccryptojs = await getEccryptoJS();\n        const publicKey = Buffer.from(publicKeyHex, \"hex\");\n        const message = Buffer.from(data, \"utf8\");\n\n        const encrypted = await eccryptojs.encrypt(publicKey, message);\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      }\n    } catch (error) {\n      if (features.useCustomECIES && error instanceof ECIESError) {\n        throw error;\n      }\n      throw new Error(\n        `Encryption failed: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n\n  async decryptWithPrivateKey(\n    encryptedData: string,\n    privateKeyHex: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation\n        const 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\n        const encryptedObj: ECIESEncrypted = {\n          iv,\n          ephemPublicKey,\n          ciphertext,\n          mac,\n        };\n\n        const decrypted = await this.customEciesProvider.decrypt(\n          privateKeyBuffer,\n          encryptedObj,\n        );\n        return new TextDecoder().decode(decrypted);\n      } else {\n        // Use eccrypto-js (default)\n        const eccryptojs = await getEccryptoJS();\n        const privateKey = Buffer.from(privateKeyHex, \"hex\");\n        const encryptedBuffer = Buffer.from(encryptedData, \"hex\");\n\n        // Parse the encrypted data\n        const { iv, ephemPublicKey, ciphertext, mac } =\n          parseEncryptedDataBuffer(encryptedBuffer);\n\n        const decrypted = await eccryptojs.decrypt(privateKey, {\n          iv: Buffer.from(iv),\n          ephemPublicKey: Buffer.from(ephemPublicKey),\n          ciphertext: Buffer.from(ciphertext),\n          mac: Buffer.from(mac),\n        });\n\n        return decrypted.toString(\"utf8\");\n      }\n    } catch (error) {\n      if (features.useCustomECIES && error instanceof ECIESError) {\n        throw error;\n      }\n      throw new Error(\n        `Decryption failed: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n\n  async generateKeyPair(): Promise<{ publicKey: string; privateKey: string }> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom implementation with secp256k1\n        const secp256k1 = secp256k1Import as unknown as Secp256k1Module;\n\n        // Generate private key\n        let privateKey: Buffer;\n        do {\n          privateKey = randomBytes(32);\n        } while (!secp256k1.privateKeyVerify(privateKey));\n\n        // Get compressed public key\n        const publicKey = Buffer.from(\n          secp256k1.publicKeyCreate(privateKey, true),\n        );\n\n        return {\n          privateKey: privateKey.toString(\"hex\"),\n          publicKey: publicKey.toString(\"hex\"),\n        };\n      } else {\n        // Use eccrypto-js (default)\n        const eccryptojs = await getEccryptoJS();\n        const privateKey = eccryptojs.generatePrivate();\n        const publicKey = eccryptojs.getPublic(privateKey);\n\n        return {\n          privateKey: privateKey.toString(\"hex\"),\n          publicKey: publicKey.toString(\"hex\"),\n        };\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"key generation\", error);\n    }\n  }\n\n  async encryptWithWalletPublicKey(\n    data: string,\n    publicKey: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation via WalletKeyEncryptionService\n        return await this.customWalletService.encryptWithWalletPublicKey(\n          data,\n          publicKey,\n        );\n      } else {\n        // Use eccrypto-js directly for wallet encryption\n        const eccryptojs = await getEccryptoJS();\n        const publicKeyBuffer = Buffer.from(processWalletPublicKey(publicKey));\n        const message = Buffer.from(data, \"utf8\");\n\n        const encrypted = await eccryptojs.encrypt(publicKeyBuffer, message);\n\n        // Concatenate all components and return as hex string\n        const result = Buffer.concat([\n          encrypted.iv,\n          encrypted.ephemPublicKey,\n          encrypted.ciphertext,\n          encrypted.mac,\n        ]);\n\n        return result.toString(\"hex\");\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"encrypt with wallet public key\", error);\n    }\n  }\n\n  async decryptWithWalletPrivateKey(\n    encryptedData: string,\n    privateKey: string,\n  ): Promise<string> {\n    try {\n      if (features.useCustomECIES) {\n        // Use custom ECIES implementation via WalletKeyEncryptionService\n        return await this.customWalletService.decryptWithWalletPrivateKey(\n          encryptedData,\n          privateKey,\n        );\n      } else {\n        // Use eccrypto-js directly for wallet decryption\n        const eccryptojs = await getEccryptoJS();\n        const privateKeyBuffer = Buffer.from(\n          processWalletPrivateKey(privateKey),\n        );\n        const encryptedBuffer = Buffer.from(encryptedData, \"hex\");\n\n        // Parse the encrypted data\n        const { iv, ephemPublicKey, ciphertext, mac } =\n          parseEncryptedDataBuffer(encryptedBuffer);\n\n        const decrypted = await eccryptojs.decrypt(privateKeyBuffer, {\n          iv: Buffer.from(iv),\n          ephemPublicKey: Buffer.from(ephemPublicKey),\n          ciphertext: Buffer.from(ciphertext),\n          mac: Buffer.from(mac),\n        });\n\n        return decrypted.toString(\"utf8\");\n      }\n    } catch (error) {\n      throw wrapCryptoError(\"decrypt with wallet private key\", error);\n    }\n  }\n\n  async encryptWithPassword(\n    data: Uint8Array,\n    password: string,\n  ): Promise<Uint8Array> {\n    try {\n      const openpgp = await getOpenPGP();\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      // In Node.js, the encrypted result is already a Uint8Array\n      if (encrypted instanceof Uint8Array) {\n        return encrypted;\n      }\n\n      // If it's a stream (should not happen with format: \"binary\"), read it\n      if (\n        encrypted &&\n        typeof encrypted === \"object\" &&\n        \"getReader\" in encrypted\n      ) {\n        return await streamToUint8Array(\n          encrypted as ReadableStream<Uint8Array>,\n        );\n      }\n\n      throw new Error(\"Unexpected encrypted data format\");\n    } catch (error) {\n      throw wrapCryptoError(\"encrypt with password\", error);\n    }\n  }\n\n  async decryptWithPassword(\n    encryptedData: Uint8Array,\n    password: string,\n  ): Promise<Uint8Array> {\n    try {\n      const openpgp = await getOpenPGP();\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 wrapCryptoError(\"decrypt with password\", error);\n    }\n  }\n}\n\n/**\n * Node.js implementation of PGP operations using openpgp with Node-specific configuration\n */\nclass NodePGPAdapter implements VanaPGPAdapter {\n  async encrypt(data: string, publicKeyArmored: string): Promise<string> {\n    try {\n      const openpgp = await getOpenPGP();\n      const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });\n\n      const encrypted = await openpgp.encrypt({\n        message: await openpgp.createMessage({ text: data }),\n        encryptionKeys: publicKey,\n        config: {\n          preferredCompressionAlgorithm: openpgp.enums.compression.zlib,\n        },\n      });\n\n      return encrypted as string;\n    } catch (error) {\n      throw wrapCryptoError(\"PGP encryption\", error);\n    }\n  }\n\n  async decrypt(\n    encryptedData: string,\n    privateKeyArmored: string,\n  ): Promise<string> {\n    try {\n      const openpgp = await getOpenPGP();\n      const privateKey = await openpgp.readPrivateKey({\n        armoredKey: privateKeyArmored,\n      });\n      const message = await openpgp.readMessage({\n        armoredMessage: encryptedData,\n      });\n\n      const { data: decrypted } = await openpgp.decrypt({\n        message,\n        decryptionKeys: privateKey,\n      });\n\n      return decrypted as string;\n    } catch (error) {\n      throw wrapCryptoError(\"PGP decryption\", error);\n    }\n  }\n\n  async generateKeyPair(options?: {\n    name?: string;\n    email?: string;\n    passphrase?: string;\n  }): Promise<{ publicKey: string; privateKey: string }> {\n    try {\n      const openpgp = await getOpenPGP();\n      // Use shared utility to get standardized parameters\n      const keyGenParams = getPGPKeyGenParams(options);\n\n      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);\n\n      return { publicKey, privateKey };\n    } catch (error) {\n      throw wrapCryptoError(\"PGP key generation\", error);\n    }\n  }\n}\n\n/**\n * Node.js implementation of HTTP operations using node-fetch or native fetch\n */\nclass NodeHttpAdapter implements VanaHttpAdapter {\n  async fetch(url: string, options?: RequestInit): Promise<Response> {\n    if (typeof globalThis.fetch !== \"undefined\") {\n      return globalThis.fetch(url, options);\n    }\n\n    throw new Error(\"No fetch implementation available in Node.js environment\");\n  }\n}\n\n/**\n * Node.js implementation of cache operations using in-memory Map with TTL\n */\nclass NodeCacheAdapter implements VanaCacheAdapter {\n  private cache = new Map<string, { value: string; expires: number }>();\n  private readonly defaultTtl = 2 * 60 * 60 * 1000; // 2 hours in milliseconds\n\n  get(key: string): string | null {\n    const entry = this.cache.get(key);\n    if (!entry) {\n      return null;\n    }\n\n    // Check if expired\n    if (Date.now() > entry.expires) {\n      this.cache.delete(key);\n      return null;\n    }\n\n    return entry.value;\n  }\n\n  set(key: string, value: string): void {\n    this.cache.set(key, {\n      value,\n      expires: Date.now() + this.defaultTtl,\n    });\n  }\n\n  delete(key: string): void {\n    this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n}\n\n/**\n * Complete Node.js platform adapter implementation\n */\nexport class NodePlatformAdapter implements VanaPlatformAdapter {\n  crypto: VanaCryptoAdapter;\n  pgp: VanaPGPAdapter;\n  http: VanaHttpAdapter;\n  cache: VanaCacheAdapter;\n  platform: \"node\" = \"node\" as const;\n\n  constructor() {\n    this.crypto = new NodeCryptoAdapter();\n    this.pgp = new NodePGPAdapter();\n    this.http = new NodeHttpAdapter();\n    this.cache = new NodeCacheAdapter();\n  }\n}\n\n/**\n * Default instance export for backwards compatibility\n */\nexport const nodePlatformAdapter: VanaPlatformAdapter =\n  new NodePlatformAdapter();\n"],"mappings":"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","names":["secp256k1Import"]}

package/dist/platform/node.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Node.js implementation of the Vana Platform Adapter
+ *
+ * WARNING: Dependencies that access globals during init
+ * MUST be dynamically imported to support Turbopack.
+ * See: https://github.com/vercel/next.js/issues/82632
+ */
+import type { VanaPlatformAdapter, VanaCryptoAdapter, VanaPGPAdapter, VanaHttpAdapter, VanaCacheAdapter } from "./interface";
+/**
+ * Complete Node.js platform adapter implementation
+ */
+export declare class NodePlatformAdapter implements VanaPlatformAdapter {
+    crypto: VanaCryptoAdapter;
+    pgp: VanaPGPAdapter;
+    http: VanaHttpAdapter;
+    cache: VanaCacheAdapter;
+    platform: "node";
+    constructor();
+}
+/**
+ * Default instance export for backwards compatibility
+ */
+export declare const nodePlatformAdapter: VanaPlatformAdapter;