@opendatalabs/vana-sdk 0.1.0-alpha.7e4db82 → 0.1.0-alpha.7ee7635

package/dist/platform/interface.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var interface_exports = {};
+module.exports = __toCommonJS(interface_exports);
+//# sourceMappingURL=interface.cjs.map

package/dist/platform/interface.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/platform/interface.ts"],"sourcesContent":["/**\n * Platform Adapter interface for environment-specific implementations\n *\n * This interface abstracts all environment-specific dependencies to ensure\n * the SDK works seamlessly across Node.js and browser/SSR environments.\n *\n * **Implementation Context:**\n * - Node.js: Uses native crypto modules and full OpenPGP support\n * - Browser: Uses Web Crypto API and browser-compatible libraries\n * - SSR: Automatically selects appropriate implementation based on runtime\n *\n * **Usage Notes:**\n * Platform adapters are automatically selected by the SDK. Direct usage is only\n * needed for custom implementations or testing.\n */\n\n/**\n * Platform type identifier\n */\nexport type PlatformType = \"node\" | \"browser\";\n\n/**\n * Encryption operations that require different implementations per platform\n */\nexport interface VanaCryptoAdapter {\n  /**\n   * Encrypt data with a public key using asymmetric cryptography\n   *\n   * **Usage Context:**\n   * - Used internally for file encryption before storage\n   * - Public key format: Armored PGP public key string\n   * - Returns base64-encoded encrypted data\n   *\n   * @param data The data to encrypt\n   * @param publicKey The public key for encryption\n   * @returns Promise resolving to encrypted data\n   */\n  encryptWithPublicKey(data: string, publicKey: string): Promise<string>;\n\n  /**\n   * Decrypt data with a private key using asymmetric cryptography\n   *\n   * @param encryptedData The encrypted data\n   * @param privateKey The private key for decryption\n   * @returns Promise resolving to decrypted data\n   */\n  decryptWithPrivateKey(\n    encryptedData: string,\n    privateKey: string,\n  ): Promise<string>;\n\n  /**\n   * Generate a new key pair for asymmetric cryptography\n   *\n   * @returns Promise resolving to public and private key pair\n   */\n  generateKeyPair(): Promise<{ publicKey: string; privateKey: string }>;\n\n  /**\n   * Encrypt data with a wallet's public key using ECDH cryptography\n   * Uses platform-appropriate ECDH implementation (eccrypto vs eccrypto-js)\n   *\n   * **Usage Context:**\n   * - Used for sharing encryption keys with permission recipients\n   * - Public key format: Compressed or uncompressed secp256k1 hex string\n   * - Compatible with Ethereum wallet public keys\n   *\n   * @param data The data to encrypt (string)\n   * @param publicKey The wallet's public key (secp256k1)\n   * @returns Promise resolving to encrypted data as hex string\n   */\n  encryptWithWalletPublicKey(data: string, publicKey: string): Promise<string>;\n\n  /**\n   * Decrypt data with a wallet's private key using ECDH cryptography\n   * Uses platform-appropriate ECDH implementation (eccrypto vs eccrypto-js)\n   *\n   * @param encryptedData The encrypted data as hex string\n   * @param privateKey The wallet's private key (secp256k1)\n   * @returns Promise resolving to decrypted data as string\n   */\n  decryptWithWalletPrivateKey(\n    encryptedData: string,\n    privateKey: string,\n  ): Promise<string>;\n\n  /**\n   * Encrypt data with a password using PGP password-based encryption\n   * Uses platform-appropriate OpenPGP implementation with consistent format\n   *\n   * @param data The data to encrypt as Uint8Array\n   * @param password The password for encryption (typically wallet signature)\n   * @returns Promise resolving to encrypted data as Uint8Array\n   */\n  encryptWithPassword(data: Uint8Array, password: string): Promise<Uint8Array>;\n\n  /**\n   * Decrypt data with a password using PGP password-based decryption\n   * Uses platform-appropriate OpenPGP implementation with consistent format\n   *\n   * @param encryptedData The encrypted data as Uint8Array\n   * @param password The password for decryption (typically wallet signature)\n   * @returns Promise resolving to decrypted data as Uint8Array\n   */\n  decryptWithPassword(\n    encryptedData: Uint8Array,\n    password: string,\n  ): Promise<Uint8Array>;\n}\n\n/**\n * PGP operations that require different configurations per platform\n */\nexport interface VanaPGPAdapter {\n  /**\n   * Encrypt data using PGP with proper platform configuration\n   *\n   * @param data The data to encrypt\n   * @param publicKey The PGP public key\n   * @returns Promise resolving to encrypted data\n   */\n  encrypt(data: string, publicKey: string): Promise<string>;\n\n  /**\n   * Decrypt data using PGP with proper platform configuration\n   *\n   * @param encryptedData The encrypted data\n   * @param privateKey The PGP private key\n   * @returns Promise resolving to decrypted data\n   */\n  decrypt(encryptedData: string, privateKey: string): Promise<string>;\n\n  /**\n   * Generate a new PGP key pair with platform-appropriate configuration\n   *\n   * @param options - Key generation options\n   * @param options.name - The name for the PGP key\n   * @param options.email - The email for the PGP key\n   * @param options.passphrase - Optional passphrase to protect the private key\n   * @returns Promise resolving to public and private key pair\n   */\n  generateKeyPair(options?: {\n    name?: string;\n    email?: string;\n    passphrase?: string;\n  }): Promise<{ publicKey: string; privateKey: string }>;\n}\n\n/**\n * HTTP operations that need consistent API across platforms\n */\nexport interface VanaHttpAdapter {\n  /**\n   * Perform HTTP request with platform-appropriate fetch implementation\n   *\n   * @param url The URL to request\n   * @param options Request options\n   * @returns Promise resolving to response\n   */\n  fetch(url: string, options?: RequestInit): Promise<Response>;\n}\n\n/**\n * Simple cache operations that work across platforms\n */\nexport interface VanaCacheAdapter {\n  /**\n   * Get a value from the cache\n   *\n   * @param key The cache key\n   * @returns The cached value or null if not found/expired\n   */\n  get(key: string): string | null;\n\n  /**\n   * Set a value in the cache\n   *\n   * @param key The cache key\n   * @param value The value to cache\n   */\n  set(key: string, value: string): void;\n\n  /**\n   * Delete a value from the cache\n   *\n   * @param key The cache key\n   */\n  delete(key: string): void;\n\n  /**\n   * Clear all values from the cache\n   */\n  clear(): void;\n}\n\n/**\n * Main platform adapter interface that combines all platform-specific functionality\n *\n * **Implementation Guidelines:**\n * 1. All methods must maintain consistent behavior across platforms\n * 2. Error types and messages should be unified\n * 3. Data formats (encoding, serialization) must be identical\n * 4. Performance characteristics can vary but API must be consistent\n *\n * **Custom Implementation Example:**\n * ```typescript\n * class CustomPlatformAdapter implements VanaPlatformAdapter {\n *   crypto = new CustomCryptoAdapter();\n *   pgp = new CustomPGPAdapter();\n *   http = new CustomHttpAdapter();\n *   platform = 'browser' as const;\n * }\n * ```\n */\nexport interface VanaPlatformAdapter {\n  /**\n   * Crypto operations adapter\n   */\n  crypto: VanaCryptoAdapter;\n\n  /**\n   * PGP operations adapter\n   */\n  pgp: VanaPGPAdapter;\n\n  /**\n   * HTTP operations adapter\n   */\n  http: VanaHttpAdapter;\n\n  /**\n   * Cache operations adapter\n   */\n  cache: VanaCacheAdapter;\n\n  /**\n   * Platform identifier for debugging/telemetry\n   */\n  readonly platform: PlatformType;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/platform/interface.d.cts

@@ -0,0 +1,218 @@
+/**
+ * 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;
+}
+
+export type { PlatformType, VanaCacheAdapter, VanaCryptoAdapter, VanaHttpAdapter, VanaPGPAdapter, VanaPlatformAdapter };

package/dist/platform/interface.d.ts

@@ -0,0 +1,218 @@
+/**
+ * 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;
+}
+
+export type { PlatformType, VanaCacheAdapter, VanaCryptoAdapter, VanaHttpAdapter, VanaPGPAdapter, VanaPlatformAdapter };

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":[]}