@opendatalabs/vana-sdk 0.1.0-alpha.e2e45dd → 0.1.0-alpha.e2f8234

package/dist/node-CkdgwBiv.d.ts

@@ -1,237 +0,0 @@
-/**
- * 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;
-}
-
-/**
- * Node.js implementation of the Vana Platform Adapter
- *
- * This implementation uses Node.js-specific libraries and configurations
- * to provide crypto, PGP, and HTTP functionality.
- */
-
-/**
- * Complete Node.js platform adapter implementation
- */
-declare class NodePlatformAdapter implements VanaPlatformAdapter {
-    crypto: VanaCryptoAdapter;
-    pgp: VanaPGPAdapter;
-    http: VanaHttpAdapter;
-    cache: VanaCacheAdapter;
-    platform: "node";
-    constructor();
-}
-
-export { NodePlatformAdapter as N, type PlatformType as P, type VanaPlatformAdapter as V, type VanaCryptoAdapter as a, type VanaPGPAdapter as b, type VanaHttpAdapter as c, type VanaCacheAdapter as d };

package/dist/node.d.cts

@@ -1 +0,0 @@
-export { N as NodePlatformAdapter } from './node-CkdgwBiv.cjs';

package/dist/platform.d.cts

@@ -1,2 +0,0 @@
-export { BrowserPlatformAdapter, createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapter, createPlatformAdapterFor, createPlatformAdapterSafe, detectPlatform, getPlatformCapabilities, isPlatformSupported } from './platform.node.cjs';
-export { N as NodePlatformAdapter, V as VanaPlatformAdapter } from './node-CkdgwBiv.cjs';

package/dist/platform.node.d.cts

@@ -1,101 +0,0 @@
-import { V as VanaPlatformAdapter, a as VanaCryptoAdapter, b as VanaPGPAdapter, c as VanaHttpAdapter, d as VanaCacheAdapter, P as PlatformType } from './node-CkdgwBiv.cjs';
-export { N as NodePlatformAdapter } from './node-CkdgwBiv.cjs';
-
-/**
- * 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.
- */
-
-/**
- * Complete browser platform adapter implementation
- */
-declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
-    crypto: VanaCryptoAdapter;
-    pgp: VanaPGPAdapter;
-    http: VanaHttpAdapter;
-    cache: VanaCacheAdapter;
-    platform: "browser";
-    constructor();
-}
-
-/**
- * Platform detection and adapter utilities
- *
- * This module provides utilities for detecting the current runtime environment
- * and creating appropriate platform adapters automatically.
- */
-
-/**
- * Detects the current runtime environment
- *
- * @returns The detected platform type
- */
-declare function detectPlatform(): PlatformType;
-/**
- * Creates the appropriate platform adapter based on the current environment
- *
- * @returns A platform adapter instance for the current environment
- * @throws {Error} If platform adapters cannot be imported or created
- */
-declare function createPlatformAdapter(): Promise<VanaPlatformAdapter>;
-/**
- * Creates a platform adapter for a specific platform type
- *
- * @param platformType - The platform type to create an adapter for
- * @returns A platform adapter instance for the specified platform
- * @throws {Error} If platform adapters cannot be imported or created
- */
-declare function createPlatformAdapterFor(platformType: PlatformType): Promise<VanaPlatformAdapter>;
-/**
- * Checks if the current environment supports the given platform adapter
- *
- * @param platformType - The platform type to check
- * @returns True if the platform is supported, false otherwise
- */
-declare function isPlatformSupported(platformType: PlatformType): boolean;
-/**
- * Gets platform-specific capabilities
- *
- * @returns Object describing available platform capabilities
- */
-declare function getPlatformCapabilities(): {
-    platform: PlatformType;
-    crypto: {
-        webCrypto: false | SubtleCrypto;
-        nodeCrypto: string | false;
-    };
-    fetch: boolean;
-    streams: boolean;
-};
-
-/**
- * Browser-safe exports for platform adapters
- *
- * This file provides browser-safe exports that avoid importing Node.js dependencies
- * when bundling for browser environments.
- */
-
-/**
- * Dynamically imports the NodePlatformAdapter only when needed
- * This prevents Node.js modules from being bundled in browser builds
- *
- * @returns Promise resolving to a NodePlatformAdapter instance
- * @throws {Error} If running in a browser environment
- */
-declare function createNodePlatformAdapter(): Promise<VanaPlatformAdapter>;
-/**
- * Creates a BrowserPlatformAdapter instance
- *
- * @returns A BrowserPlatformAdapter instance
- */
-declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
-/**
- * Browser-safe platform adapter factory
- *
- * @returns Promise resolving to the appropriate platform adapter
- */
-declare function createPlatformAdapterSafe(): Promise<VanaPlatformAdapter>;
-
-export { BrowserPlatformAdapter, VanaPlatformAdapter, createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapter, createPlatformAdapterFor, createPlatformAdapterSafe, detectPlatform, getPlatformCapabilities, isPlatformSupported };