@opendatalabs/vana-sdk 0.1.0-alpha.f0290d0 → 0.1.0-alpha.ffe4659

package/README.md

@@ -360,6 +360,48 @@ vana.data.validateDataAgainstSchema(data: unknown, schema: DataSchema): void
 - **Issues**: [GitHub Issues](https://github.com/vana-com/vana-sdk/issues)
 - **Discord**: [Join our community](https://discord.gg/vanabuilders)
 
+## Generated Code
+
+The SDK includes automatically generated code from various sources to provide type-safe interfaces. All generated files are located in `src/generated/` and should **never be edited manually**.
+
+### Code Generation Scripts
+
+| Script                       | Purpose                                | Generated Files             |
+| ---------------------------- | -------------------------------------- | --------------------------- |
+| `npm run fetch-abis`         | Smart contract ABIs from blockchain    | `src/generated/abi/*.ts`    |
+| `npm run fetch-server-types` | Personal server API types from OpenAPI | `src/generated/server/*.ts` |
+| `npm run codegen:subgraph`   | GraphQL types from subgraph schema     | `src/generated/subgraph.ts` |
+
+### Network-Specific Generation
+
+Some generation scripts support different networks:
+
+```bash
+# Generate subgraph types for different networks
+npm run codegen:subgraph:moksha   # Moksha testnet (default)
+npm run codegen:subgraph:mainnet  # Vana mainnet
+
+# Generate ABIs for different networks
+npm run fetch-abis moksha         # Moksha testnet (default)
+npm run fetch-abis mainnet        # Vana mainnet
+```
+
+### Development Workflow
+
+When working with the SDK:
+
+1. **Never edit generated files** - They are overwritten on regeneration
+2. **Regenerate after schema changes** - Run generation scripts when external schemas change
+3. **Generated files are committed** - They're included in version control for consistency
+4. **ESLint ignores generated code** - Style rules don't apply to generated files
+
+```bash
+# Regenerate all code after schema updates
+npm run fetch-abis
+npm run fetch-server-types
+npm run codegen:subgraph
+```
+
 ## Development
 
 ```bash

package/dist/browser-DY8XDblx.d.ts

@@ -0,0 +1,241 @@
+/**
+ * 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;
+}
+
+/**
+ * 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
+ */
+
+/**
+ * Complete browser platform adapter implementation
+ */
+declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
+    crypto: VanaCryptoAdapter;
+    pgp: VanaPGPAdapter;
+    http: VanaHttpAdapter;
+    cache: VanaCacheAdapter;
+    platform: "browser";
+    constructor();
+}
+
+export { BrowserPlatformAdapter as B, type PlatformType as P, type VanaPlatformAdapter as V };

package/dist/browser.d.ts

@@ -0,0 +1 @@
+export { B as BrowserPlatformAdapter } from './browser-DY8XDblx.js';

package/dist/browser.js

@@ -0,0 +1,309 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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)
+  };
+}
+
+// src/platform/shared/pgp-utils.ts
+var STANDARD_PGP_CONFIG = {
+  preferredCompressionAlgorithm: 2,
+  // zlib (openpgp.enums.compression.zlib)
+  preferredSymmetricAlgorithm: 7
+  // aes256 (openpgp.enums.symmetric.aes256)
+};
+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
+  };
+}
+
+// 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}`);
+}
+
+// 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;
+  };
+}
+
+// src/platform/browser.ts
+var getOpenPGP = lazyImport(() => import("openpgp"));
+var 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 openpgp = await getOpenPGP();
+      const message = await openpgp.createMessage({
+        binary: data
+      });
+      const encrypted = await openpgp.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 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 new Error(`Failed to decrypt with password: ${error}`);
+    }
+  }
+};
+var 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 }),
+        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 openpgp = await getOpenPGP();
+      const privateKey = await openpgp.readPrivateKey({
+        armoredKey: privateKeyArmored
+      });
+      const message = await openpgp.readMessage({
+        armoredMessage: encryptedData
+      });
+      const { data: decrypted } = await openpgp.decrypt({
+        message,
+        decryptionKeys: privateKey
+      });
+      return decrypted;
+    } catch (error) {
+      throw new Error(`PGP decryption failed: ${error}`);
+    }
+  }
+  async generateKeyPair(options) {
+    try {
+      const openpgp = await getOpenPGP();
+      const keyGenParams = getPGPKeyGenParams(options);
+      const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
+      return { publicKey, privateKey };
+    } catch (error) {
+      throw wrapCryptoError("PGP key generation", error);
+    }
+  }
+};
+var 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);
+  }
+};
+var 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 {
+    }
+  }
+};
+var 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();
+  }
+};
+var browserPlatformAdapter = new BrowserPlatformAdapter();
+export {
+  BrowserPlatformAdapter
+};
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/platform/shared/crypto-utils.ts","../src/platform/shared/pgp-utils.ts","../src/platform/shared/error-utils.ts","../src/utils/lazy-import.ts","../src/platform/browser.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/**\n * Cross-platform base64 encoding\n * Works in both Node.js and browser environments\n *\n * @param str The string to encode\n * @returns Base64 encoded string\n */\nexport function toBase64(str: string): string {\n  if (typeof Buffer !== \"undefined\") {\n    // Node.js environment\n    return Buffer.from(str, \"utf8\").toString(\"base64\");\n  } else if (typeof btoa !== \"undefined\") {\n    // Browser environment\n    return btoa(str);\n  } else {\n    // Fallback manual implementation\n    const chars =\n      \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    let result = \"\";\n    let i = 0;\n    while (i < str.length) {\n      const a = str.charCodeAt(i++);\n      const b = i < str.length ? str.charCodeAt(i++) : 0;\n      const c = i < str.length ? str.charCodeAt(i++) : 0;\n\n      const bitmap = (a << 16) | (b << 8) | c;\n\n      result += chars.charAt((bitmap >> 18) & 63);\n      result += chars.charAt((bitmap >> 12) & 63);\n      result += i - 2 < str.length ? chars.charAt((bitmap >> 6) & 63) : \"=\";\n      result += i - 1 < str.length ? chars.charAt(bitmap & 63) : \"=\";\n    }\n    return result;\n  }\n}\n\n/**\n * Cross-platform base64 decoding\n * Works in both Node.js and browser environments\n *\n * @param str The base64 string to decode\n * @returns Decoded string\n */\nexport function fromBase64(str: string): string {\n  if (typeof Buffer !== \"undefined\") {\n    // Node.js environment\n    return Buffer.from(str, \"base64\").toString(\"utf8\");\n  } else if (typeof atob !== \"undefined\") {\n    // Browser environment\n    return atob(str);\n  } else {\n    // Fallback manual implementation\n    const chars =\n      \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n    let result = \"\";\n    let i = 0;\n\n    // Remove any characters not in the base64 character set\n    str = str.replace(/[^A-Za-z0-9+/]/g, \"\");\n\n    while (i < str.length) {\n      const encoded1 = chars.indexOf(str.charAt(i++));\n      const encoded2 = chars.indexOf(str.charAt(i++));\n      const encoded3 = chars.indexOf(str.charAt(i++));\n      const encoded4 = chars.indexOf(str.charAt(i++));\n\n      const bitmap =\n        (encoded1 << 18) | (encoded2 << 12) | (encoded3 << 6) | encoded4;\n\n      result += String.fromCharCode((bitmap >> 16) & 255);\n      if (encoded3 !== 64) result += String.fromCharCode((bitmap >> 8) & 255);\n      if (encoded4 !== 64) result += String.fromCharCode(bitmap & 255);\n    }\n    return result;\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 * Utility for lazy-loading modules to avoid Turbopack TDZ issues\n *\n * WARNING: This is a workaround for Turbopack's strict module initialization.\n * Dependencies that access globals during init must be dynamically imported.\n */\n\n/**\n * Creates a lazy import function that caches the promise (not the module)\n * to avoid race conditions on concurrent first calls\n *\n * @param importFn - Function that returns a dynamic import promise\n * @returns Function that returns the cached import promise\n *\n * @example\n * const getOpenPGP = lazyImport(() => import('openpgp'));\n * const openpgp = await getOpenPGP();\n */\nexport function lazyImport<T>(importFn: () => Promise<T>): () => Promise<T> {\n  let cached: Promise<T> | null = null;\n\n  return () => {\n    if (!cached) {\n      cached = importFn().catch((err) => {\n        // Clear cache on error so next attempt can retry\n        cached = null;\n        throw new Error(\"Failed to load module\", { cause: err });\n      });\n    }\n    return cached;\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 * 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 {\n  processWalletPublicKey,\n  processWalletPrivateKey,\n  parseEncryptedDataBuffer,\n} from \"./shared/crypto-utils\";\nimport { getPGPKeyGenParams } from \"./shared/pgp-utils\";\nimport { wrapCryptoError } from \"./shared/error-utils\";\nimport { lazyImport } from \"../utils/lazy-import\";\n\n// Lazy-loaded dependencies to avoid Turbopack TDZ issues\nconst getOpenPGP = lazyImport(() => import(\"openpgp\"));\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 getOpenPGP();\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 getOpenPGP();\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 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 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 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 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      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 * 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 * Browser implementation of cache operations using sessionStorage\n */\nclass BrowserCacheAdapter implements VanaCacheAdapter {\n  private readonly prefix = \"vana_cache_\";\n\n  get(key: string): string | null {\n    try {\n      if (typeof sessionStorage === \"undefined\") {\n        return null;\n      }\n      return sessionStorage.getItem(this.prefix + key);\n    } catch {\n      return null;\n    }\n  }\n\n  set(key: string, value: string): void {\n    try {\n      if (typeof sessionStorage !== \"undefined\") {\n        sessionStorage.setItem(this.prefix + key, value);\n      }\n    } catch {\n      // Silently ignore storage errors (quota exceeded, etc.)\n    }\n  }\n\n  delete(key: string): void {\n    try {\n      if (typeof sessionStorage !== \"undefined\") {\n        sessionStorage.removeItem(this.prefix + key);\n      }\n    } catch {\n      // Silently ignore storage errors\n    }\n  }\n\n  clear(): void {\n    try {\n      if (typeof sessionStorage === \"undefined\") {\n        return;\n      }\n\n      const keys = Object.keys(sessionStorage);\n      for (const key of keys) {\n        if (key.startsWith(this.prefix)) {\n          sessionStorage.removeItem(key);\n        }\n      }\n    } catch {\n      // Silently ignore storage errors\n    }\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  cache: VanaCacheAdapter;\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    this.cache = new BrowserCacheAdapter();\n  }\n}\n\n/**\n * Default instance export for backwards compatibility\n */\nexport const browserPlatformAdapter: VanaPlatformAdapter =\n  new BrowserPlatformAdapter();\n"],"mappings":"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","names":[]}

package/dist/chains.browser.cjs

@@ -48,7 +48,7 @@ var vanaMainnet = {
       url: "https://vanascan.io"
     }
   },
-  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/vana/7.0.6/gn"
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/vana/7.0.7/gn"
 };
 var moksha = {
   id: 14800,
@@ -69,7 +69,7 @@ var moksha = {
       url: "https://moksha.vanascan.io"
     }
   },
-  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/7.0.6/gn"
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/7.0.7/gn"
 };
 function getChainConfig(chainId) {
   switch (chainId) {