@opendatalabs/vana-sdk 0.1.0-alpha.9a32094 → 0.1.0-alpha.9d6d871

package/README.md

@@ -121,10 +121,12 @@ const result = await vana.data.upload({
   content: "Sensitive user data",
   filename: "user-data.json",
   schemaId: 123,
-  permissions: [{
-    account: "0xServerAddress...",  // Who can decrypt
-    publicKey: "0x04ServerKey..."   // Their public key
-  }]
+  permissions: [
+    {
+      account: "0xServerAddress...", // Who can decrypt
+      publicKey: "0x04ServerKey...", // Their public key
+    },
+  ],
 });
 ```
 
@@ -239,11 +241,13 @@ async function shareDataWithServer() {
     content: { data: "sensitive medical records" },
     filename: "health-data.json",
     schemaId: 123,
-    permissions: [{
-      // Grant decryption access to the AI server
-      account: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
-      publicKey: "0x04abc..." // Server's public key for encryption
-    }]
+    permissions: [
+      {
+        // Grant decryption access to the AI server
+        account: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+        publicKey: "0x04abc...", // Server's public key for encryption
+      },
+    ],
   });
 
   // Step 2: Grant operation permissions for what the server can do
@@ -356,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