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

package/dist/platform/browser-only.d.cts

@@ -1,25 +0,0 @@
-import { VanaPlatformAdapter } from './interface.cjs';
-export { BrowserPlatformAdapter } from './browser.cjs';
-
-/**
- * Browser-only exports for platform adapters
- *
- * This file provides browser-only exports that completely avoid Node.js imports
- * when bundling for browser environments. This is used by the browser entry point.
- */
-
-/**
- * Creates a BrowserPlatformAdapter instance
- *
- * @returns A BrowserPlatformAdapter instance
- */
-declare function createBrowserPlatformAdapter(): VanaPlatformAdapter;
-/**
- * Browser-only platform adapter factory
- * This version does not include Node.js imports at all
- *
- * @returns A BrowserPlatformAdapter instance
- */
-declare function createPlatformAdapterSafe(): VanaPlatformAdapter;
-
-export { VanaPlatformAdapter, createBrowserPlatformAdapter, createPlatformAdapterSafe };

package/dist/platform/browser-safe.d.cts

@@ -1,32 +0,0 @@
-import { VanaPlatformAdapter } from './interface.cjs';
-export { BrowserPlatformAdapter } from './browser.cjs';
-
-/**
- * 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 { VanaPlatformAdapter, createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe };

package/dist/platform/browser.d.cts

@@ -1,74 +0,0 @@
-import { VanaPlatformAdapter, VanaCryptoAdapter, VanaPGPAdapter, VanaHttpAdapter, VanaCacheAdapter } from './interface.cjs';
-
-/**
- * Browser implementation of the Vana Platform Adapter using Uint8Array
- *
- * This implementation uses browser-compatible libraries and native APIs
- * without requiring Buffer or other Node.js polyfills.
- */
-
-/**
- * Browser implementation of crypto operations using Uint8Array
- * Supports both eccrypto-js (default) and custom ECIES implementation
- */
-declare class BrowserCryptoAdapter implements VanaCryptoAdapter {
-    private customEciesProvider;
-    private customWalletService;
-    encryptWithPublicKey(data: string, publicKeyHex: string): Promise<string>;
-    decryptWithPrivateKey(encryptedData: string, privateKeyHex: string): Promise<string>;
-    encryptWithWalletPublicKey(data: string, publicKey: string): Promise<string>;
-    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
-    generateKeyPair(): Promise<{
-        privateKey: string;
-        publicKey: string;
-    }>;
-    encryptWithPassword(data: Uint8Array, password: string): Promise<Uint8Array>;
-    decryptWithPassword(encryptedData: Uint8Array, password: string): Promise<Uint8Array>;
-}
-/**
- * Browser implementation of PGP operations
- */
-declare class BrowserPGPAdapter implements VanaPGPAdapter {
-    encrypt(data: string, publicKeyArmored: string): Promise<string>;
-    decrypt(encryptedData: string, privateKeyArmored: string): Promise<string>;
-    generateKeyPair(options?: {
-        name?: string;
-        email?: string;
-        passphrase?: string;
-    }): Promise<{
-        publicKey: string;
-        privateKey: string;
-    }>;
-}
-/**
- * Browser implementation of HTTP operations using Fetch API
- */
-declare class BrowserHttpAdapter implements VanaHttpAdapter {
-    fetch(url: string, options?: RequestInit): Promise<Response>;
-}
-/**
- * Browser implementation of caching using sessionStorage for security
- * SessionStorage is cleared when the tab closes, making it more secure for signature caching
- */
-declare class BrowserCacheAdapter implements VanaCacheAdapter {
-    private readonly prefix;
-    get(key: string): string | null;
-    set(key: string, value: string): void;
-    delete(key: string): void;
-    clear(): void;
-}
-/**
- * Browser implementation of the Vana Platform Adapter
- *
- * This adapter provides all platform-specific functionality for browser environments
- * without requiring any Node.js polyfills.
- */
-declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
-    readonly crypto: BrowserCryptoAdapter;
-    readonly pgp: BrowserPGPAdapter;
-    readonly http: BrowserHttpAdapter;
-    readonly cache: BrowserCacheAdapter;
-    readonly platform: "browser";
-}
-
-export { BrowserPlatformAdapter };

package/dist/platform/index.d.cts

@@ -1,5 +0,0 @@
-export { PlatformType, VanaCryptoAdapter, VanaHttpAdapter, VanaPGPAdapter, VanaPlatformAdapter } from './interface.cjs';
-export { NodePlatformAdapter } from './node.cjs';
-export { BrowserPlatformAdapter } from './browser.cjs';
-export { createPlatformAdapter, createPlatformAdapterFor, detectPlatform, getPlatformCapabilities, isPlatformSupported } from './utils.cjs';
-export { createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe } from './browser-safe.cjs';

package/dist/platform/interface.d.cts

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

package/dist/platform/node.d.cts

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

package/dist/platform/shared/error-utils.d.cts

@@ -1,25 +0,0 @@
-/**
- * Shared error utilities for platform adapters
- *
- * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.
- * All functions are pure utilities that can be safely shared across platforms.
- */
-/**
- * Wrap platform-specific errors with consistent messaging
- * Provides consistent error formatting across all crypto operations
- *
- * @param operation The operation that failed (e.g., "encryption", "decryption")
- * @param error The original error that occurred
- * @returns Wrapped error with consistent format
- */
-declare function wrapCryptoError(operation: string, error: unknown): Error;
-/**
- * Validate encrypted data structure has required fields
- * Ensures encrypted data objects contain the expected properties
- *
- * @param data The data structure to validate
- * @throws Error if data structure is invalid
- */
-declare function validateEncryptedDataStructure(data: unknown): void;
-
-export { validateEncryptedDataStructure, wrapCryptoError };

package/dist/platform/shared/pgp-utils.d.cts

@@ -1,61 +0,0 @@
-/**
- * Shared PGP utilities for platform adapters
- *
- * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.
- * All functions are pure utilities that can be safely shared across platforms.
- */
-/**
- * Standard OpenPGP configuration for consistent behavior across platforms
- * Uses enum values instead of importing openpgp to avoid loading issues
- */
-declare const STANDARD_PGP_CONFIG: {
-    readonly preferredCompressionAlgorithm: 2;
-    readonly preferredSymmetricAlgorithm: 7;
-};
-/**
- * Process PGP key generation options with sensible defaults
- *
- * @param options - Optional key generation parameters
- * @param options.name - The name for the PGP key (defaults to "Vana User")
- * @param options.email - The email for the PGP key (defaults to "user@vana.org")
- * @param options.passphrase - Optional passphrase to protect the private key
- * @returns Processed options with defaults applied
- */
-declare function processPGPKeyOptions(options?: {
-    name?: string;
-    email?: string;
-    passphrase?: string;
-}): {
-    name: string;
-    email: string;
-    passphrase: string | undefined;
-};
-/**
- * Get standard PGP key generation parameters
- * Combines default values with standard configuration
- *
- * @param options - Optional key generation parameters
- * @param options.name - The name for the PGP key (defaults to "Vana User")
- * @param options.email - The email for the PGP key (defaults to "user@vana.org")
- * @param options.passphrase - Optional passphrase to protect the private key
- * @returns Complete key generation parameters object
- */
-declare function getPGPKeyGenParams(options?: {
-    name?: string;
-    email?: string;
-    passphrase?: string;
-}): {
-    type: "rsa";
-    rsaBits: number;
-    userIDs: {
-        name: string;
-        email: string;
-    }[];
-    passphrase: string | undefined;
-    config: {
-        readonly preferredCompressionAlgorithm: 2;
-        readonly preferredSymmetricAlgorithm: 7;
-    };
-};
-
-export { STANDARD_PGP_CONFIG, getPGPKeyGenParams, processPGPKeyOptions };

package/dist/platform/shared/stream-utils.d.cts

@@ -1,16 +0,0 @@
-/**
- * Shared stream utilities for platform adapters
- *
- * IMPORTANT: This module contains NO IMPORTS to avoid affecting bundle loading.
- * All functions are pure utilities that can be safely shared across platforms.
- */
-/**
- * Convert ReadableStream to Uint8Array
- * Used primarily in Node.js environment where OpenPGP may return streams
- *
- * @param stream The ReadableStream to convert
- * @returns Promise resolving to Uint8Array containing all stream data
- */
-declare function streamToUint8Array(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
-
-export { streamToUint8Array };

package/dist/platform/utils.d.cts

@@ -1,53 +0,0 @@
-import { PlatformType, VanaPlatformAdapter } from './interface.cjs';
-
-/**
- * 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;
-};
-
-export { createPlatformAdapter, createPlatformAdapterFor, detectPlatform, getPlatformCapabilities, isPlatformSupported };

package/dist/platform.browser.cjs

@@ -1,41 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var platform_browser_exports = {};
-__export(platform_browser_exports, {
-  BrowserPlatformAdapter: () => import_browser.BrowserPlatformAdapter,
-  createBrowserPlatformAdapter: () => import_browser_only.createBrowserPlatformAdapter,
-  createPlatformAdapterSafe: () => import_browser_only.createPlatformAdapterSafe,
-  detectPlatform: () => import_utils.detectPlatform,
-  getPlatformCapabilities: () => import_utils.getPlatformCapabilities,
-  isPlatformSupported: () => import_utils.isPlatformSupported
-});
-module.exports = __toCommonJS(platform_browser_exports);
-var import_browser = require("./platform/browser");
-var import_browser_only = require("./platform/browser-only");
-var import_utils = require("./platform/utils");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserPlatformAdapter,
-  createBrowserPlatformAdapter,
-  createPlatformAdapterSafe,
-  detectPlatform,
-  getPlatformCapabilities,
-  isPlatformSupported
-});
-//# sourceMappingURL=platform.browser.cjs.map

package/dist/platform.browser.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/platform.browser.ts"],"sourcesContent":["/**\n * Browser-specific platform adapters entry point\n *\n * This module provides browser-safe platform utilities without Node.js dependencies.\n */\n\n// Export browser platform adapter\nexport { BrowserPlatformAdapter } from \"./platform/browser\";\n\n// Export platform interface\nexport type { VanaPlatformAdapter } from \"./platform/interface\";\n\n// Export browser-safe utilities only\nexport {\n  createBrowserPlatformAdapter,\n  createPlatformAdapterSafe,\n} from \"./platform/browser-only\";\n\n// Export safe platform utilities (no Node.js imports)\nexport {\n  detectPlatform,\n  isPlatformSupported,\n  getPlatformCapabilities,\n} from \"./platform/utils\";\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,qBAAuC;AAMvC,0BAGO;AAGP,mBAIO;","names":[]}

package/dist/platform.browser.d.cts

@@ -1,4 +0,0 @@
-export { BrowserPlatformAdapter } from './platform/browser.cjs';
-export { VanaPlatformAdapter } from './platform/interface.cjs';
-export { createBrowserPlatformAdapter, createPlatformAdapterSafe } from './platform/browser-only.cjs';
-export { detectPlatform, getPlatformCapabilities, isPlatformSupported } from './platform/utils.cjs';

package/dist/platform.d.cts

@@ -1,5 +0,0 @@
-export { BrowserPlatformAdapter } from './platform/browser.cjs';
-export { NodePlatformAdapter } from './platform/node.cjs';
-export { VanaPlatformAdapter } from './platform/interface.cjs';
-export { createPlatformAdapter, createPlatformAdapterFor, detectPlatform, getPlatformCapabilities, isPlatformSupported } from './platform/utils.cjs';
-export { createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe } from './platform/browser-safe.cjs';

package/dist/platform.node.d.cts

@@ -1,5 +0,0 @@
-export { BrowserPlatformAdapter } from './platform/browser.cjs';
-export { NodePlatformAdapter } from './platform/node.cjs';
-export { VanaPlatformAdapter } from './platform/interface.cjs';
-export { createPlatformAdapter, createPlatformAdapterFor, detectPlatform, getPlatformCapabilities, isPlatformSupported } from './platform/utils.cjs';
-export { createBrowserPlatformAdapter, createNodePlatformAdapter, createPlatformAdapterSafe } from './platform/browser-safe.cjs';