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

package/dist/core.d.cts

@@ -1,466 +0,0 @@
-import { Operation, PollingOptions, TransactionResult, TransactionWaitOptions } from './types/operations.cjs';
-import * as viem from 'viem';
-import { VanaConfigWithStorage, VanaConfig, StorageRequiredMarker, RuntimeConfig } from './types/config.cjs';
-import { SchemaController } from './controllers/schemas.cjs';
-import { P as PermissionsController } from './permissions-DNKPu_G0.cjs';
-import { DataController } from './controllers/data.cjs';
-import { ServerController } from './controllers/server.cjs';
-import { ProtocolController } from './controllers/protocol.cjs';
-import { VanaPlatformAdapter } from './platform/interface.cjs';
-import './generated/server/server-exports.cjs';
-import './generated/server/server.cjs';
-import './types/chains.cjs';
-import './types/storage.cjs';
-import './types/permissions.cjs';
-import './types/data.cjs';
-import './config/eventMappings.cjs';
-import './generated/abi/index.cjs';
-import './generated/abi/DataPortabilityPermissionsImplementation.cjs';
-import './generated/abi/DataPortabilityServersImplementation.cjs';
-import './generated/abi/DataPortabilityGranteesImplementation.cjs';
-import './generated/abi/VanaEpochImplementation.cjs';
-import './generated/abi/DLPRegistryImplementation.cjs';
-import './generated/abi/DLPTreasuryImplementation.cjs';
-import './generated/abi/DLPRewardDeployerTreasuryImplementation.cjs';
-import './generated/abi/DLPPerformanceImplementation.cjs';
-import './generated/abi/DLPRewardDeployerImplementation.cjs';
-import './generated/abi/DLPRootImplementation.cjs';
-import './generated/abi/DataLiquidityPoolImplementation.cjs';
-import './generated/abi/DLPRegistryTreasuryImplementation.cjs';
-import './storage/manager.cjs';
-import './utils/schemaValidation.cjs';
-import './types/personal.cjs';
-import './types/contracts.cjs';
-import './contracts/contractController.cjs';
-import 'abitype';
-import './core/client.cjs';
-import './config/chains.cjs';
-
-/**
- * Factory functions for creating VanaCore instances with proper type safety
- */
-declare class VanaCoreFactory {
-    /**
-     * Creates a VanaCore instance that enforces storage requirements at compile time.
-     * Use this factory when you know you'll need storage-dependent operations.
-     *
-     * @param platform - The platform adapter for environment-specific operations
-     * @param config - Configuration that includes required storage providers
-     * @returns VanaCore instance with storage validation
-     * @example
-     * ```typescript
-     * const vanaCore = VanaCoreFactory.createWithStorage(platformAdapter, {
-     *   walletClient: myWalletClient,
-     *   storage: {
-     *     providers: { ipfs: new IPFSStorage() },
-     *     defaultProvider: 'ipfs'
-     *   }
-     * });
-     * ```
-     */
-    static createWithStorage(platform: VanaPlatformAdapter, config: VanaConfigWithStorage): VanaCore & StorageRequiredMarker;
-    /**
-     * Creates a VanaCore instance without storage requirements.
-     * Storage-dependent operations will fail at runtime if not configured.
-     *
-     * @param platform - The platform adapter for environment-specific operations
-     * @param config - Basic configuration without required storage
-     * @returns VanaCore instance
-     * @example
-     * ```typescript
-     * const vanaCore = VanaCoreFactory.create(platformAdapter, {
-     *   walletClient: myWalletClient
-     * });
-     * ```
-     */
-    static create(platform: VanaPlatformAdapter, config: VanaConfig): VanaCore;
-}
-/**
- * Provides the core SDK functionality for interacting with the Vana network.
- *
- * @remarks
- * This environment-agnostic class contains all SDK logic and accepts a platform
- * adapter to handle environment-specific operations. It initializes all controllers
- * and manages shared context between them, providing a unified interface for
- * data management, permissions, smart contracts, and storage operations.
- *
- * The class uses TypeScript overloading to enforce storage requirements at compile time.
- * Methods that require storage will throw `InvalidConfigurationError` at runtime if
- * storage providers are not configured, implementing a fail-fast approach to prevent
- * errors during expensive operations.
- *
- * **Core Architecture:**
- * - **Controllers**: Specialized modules for different Vana features (data, permissions, etc.)
- * - **Platform Adapters**: Environment-specific implementations (browser vs Node.js)
- * - **Storage Managers**: Abstraction layer for multiple storage providers
- * - **Context Sharing**: Unified configuration and services across all controllers
- *
- * For public usage, use the platform-specific factory functions:
- * - Browser: `import { Vana } from '@opendatalabs/vana-sdk/browser'`
- * - Node.js: `import { Vana } from '@opendatalabs/vana-sdk/node'`
- *
- * @example
- * ```typescript
- * // Direct instantiation (advanced usage)
- * import { VanaCore, BrowserPlatformAdapter } from '@opendatalabs/vana-sdk/browser';
- *
- * const core = new VanaCore(new BrowserPlatformAdapter(), {
- *   walletClient: myWalletClient,
- *   storage: {
- *     providers: { ipfs: new IPFSStorage() },
- *     defaultProvider: 'ipfs'
- *   }
- * });
- *
- * // Access all controllers
- * const files = await core.data.getUserFiles();
- * const permissions = await core.permissions.grant({
- *   grantee: '0x742d35...',
- *   operation: 'read'
- * });
- * ```
- * @category Core SDK
- */
-declare class VanaCore {
-    /** Manages gasless data access permissions and trusted server registry. */
-    readonly permissions: PermissionsController;
-    /** Handles user data file operations. */
-    readonly data: DataController;
-    /** Manages data schemas and refiners. */
-    readonly schemas: SchemaController;
-    /** Provides personal server setup and trusted server interactions. */
-    readonly server: ServerController;
-    /** Offers low-level access to Vana protocol smart contracts. */
-    readonly protocol: ProtocolController;
-    /** Handles environment-specific operations like encryption and file systems. */
-    protected platform: VanaPlatformAdapter;
-    private readonly relayerCallbacks?;
-    private readonly downloadRelayer?;
-    private readonly storageManager?;
-    private readonly hasRequiredStorage;
-    private readonly ipfsGateways?;
-    private readonly defaultPersonalServerUrl?;
-    private readonly publicClient;
-    private readonly walletClient;
-    /**
-     * Initializes a new VanaCore client instance with the provided configuration.
-     *
-     * @remarks
-     * The constructor validates the configuration, initializes storage providers if configured,
-     * creates wallet and public clients, and sets up all SDK controllers with shared context.
-     *
-     * IMPORTANT: This constructor will validate storage requirements at runtime to fail fast.
-     * Methods that require storage will throw runtime errors if storage is not configured.
-     *
-     * @param platform - The platform adapter for environment-specific operations
-     * @param config - The configuration object specifying wallet or chain settings
-     * @throws {InvalidConfigurationError} When the configuration is invalid or incomplete
-     * @example
-     * ```typescript
-     * // Direct instantiation (consider using factory methods instead)
-     * const vanaCore = new VanaCore(platformAdapter, {
-     *   walletClient: myWalletClient,
-     * });
-     * ```
-     */
-    constructor(platform: VanaPlatformAdapter, config: VanaConfig);
-    /**
-     * Validates that storage is available for storage-dependent operations.
-     * This method enforces the fail-fast principle by checking storage availability
-     * at method call time rather than during expensive operations.
-     *
-     * @throws {InvalidConfigurationError} When storage is required but not configured
-     * @example
-     * ```typescript
-     * // This will throw if storage is not configured
-     * vana.validateStorageRequired();
-     * await vana.data.uploadFile(file); // Safe to proceed
-     * ```
-     */
-    validateStorageRequired(): void;
-    /**
-     * Checks whether storage is configured without throwing an error.
-     *
-     * @returns True if storage is properly configured
-     * @example
-     * ```typescript
-     * if (vana.hasStorage()) {
-     *   await vana.data.uploadFile(file);
-     * } else {
-     *   console.warn('Storage not configured - using pre-stored URLs only');
-     * }
-     * ```
-     */
-    hasStorage(): boolean;
-    /**
-     * Type guard to check if this instance has storage enabled at compile time.
-     * Use this when you need TypeScript to understand that storage is available.
-     *
-     * @returns True if storage is configured, with type narrowing
-     * @example
-     * ```typescript
-     * if (vana.isStorageEnabled()) {
-     *   // TypeScript knows storage is available here
-     *   await vana.data.uploadFile(file);
-     * }
-     * ```
-     */
-    isStorageEnabled(): this is VanaCore & StorageRequiredMarker;
-    /**
-     * Validates the provided configuration object against all requirements.
-     *
-     * @remarks
-     * This method performs comprehensive validation of wallet client configuration,
-     * chain configuration, storage providers, and relayer callbacks.
-     * @param config - The configuration object to validate
-     * @throws {InvalidConfigurationError} When any configuration parameter is invalid
-     */
-    private validateConfig;
-    /**
-     * Gets the current chain ID from the wallet client.
-     *
-     * @returns The numeric chain ID of the connected network
-     * @example
-     * ```typescript
-     * const chainId = vana.chainId;
-     * console.log(`Connected to chain: ${chainId}`); // e.g., "Connected to chain: 14800"
-     * ```
-     */
-    get chainId(): number;
-    /**
-     * Gets the current chain name from the wallet client.
-     *
-     * @returns The human-readable name of the connected network
-     * @example
-     * ```typescript
-     * const chainName = vana.chainName;
-     * console.log(`Connected to: ${chainName}`); // e.g., "Connected to: Moksha Testnet"
-     * ```
-     */
-    get chainName(): string;
-    /**
-     * Retrieves the user's wallet address from the connected client.
-     *
-     * @returns A Promise that resolves to the user's Ethereum address
-     * @example
-     * ```typescript
-     * const address = await vana.getUserAddress();
-     * console.log(`User address: ${address}`); // e.g., "User address: 0x742d35..."
-     * ```
-     */
-    getUserAddress(): Promise<viem.Address>;
-    /**
-     * Retrieves comprehensive runtime configuration information.
-     *
-     * @returns The current runtime configuration including chain, storage, and relayer settings
-     * @example
-     * ```typescript
-     * const config = vana.getConfig();
-     * console.log(`Chain: ${config.chainName} (${config.chainId})`);
-     * console.log(`Storage providers: ${config.storageProviders.join(", ")}`);
-     * ```
-     */
-    getConfig(): RuntimeConfig;
-    /**
-     * Sets the platform adapter for environment-specific operations.
-     * This is useful for testing and advanced use cases where you need
-     * to override the default platform detection.
-     *
-     * @param adapter - The platform adapter to use
-     * @example
-     * ```typescript
-     * // For testing with a mock adapter
-     * const mockAdapter = new MockPlatformAdapter();
-     * vana.setPlatformAdapter(mockAdapter);
-     *
-     * // For advanced use cases with custom adapters
-     * const customAdapter = new CustomPlatformAdapter();
-     * vana.setPlatformAdapter(customAdapter);
-     * ```
-     */
-    setPlatformAdapter(adapter: VanaPlatformAdapter): void;
-    /**
-     * Gets the current platform adapter.
-     * This is useful for advanced use cases where you need to access
-     * the platform adapter directly.
-     *
-     * @returns The current platform adapter
-     * @example
-     * ```typescript
-     * const adapter = vana.getPlatformAdapter();
-     * const encrypted = await adapter.encrypt(data, key);
-     * ```
-     */
-    getPlatformAdapter(): VanaPlatformAdapter;
-    /**
-     * Encrypts data using the Vana protocol standard encryption.
-     *
-     * @remarks
-     * This method implements the Vana network's standard encryption protocol using
-     * platform-appropriate cryptographic libraries. It automatically handles different
-     * input types (string or Blob) and produces encrypted output suitable for secure
-     * storage or transmission. The encryption is compatible with the network's
-     * decryption protocols and can be decrypted by authorized parties.
-     *
-     * @param data - The data to encrypt (string or Blob)
-     * @param key - The encryption key (typically generated via `generateEncryptionKey`)
-     * @returns The encrypted data as a Blob
-     * @throws {Error} When encryption fails due to invalid key or data format
-     * @example
-     * ```typescript
-     * import { generateEncryptionKey } from '@opendatalabs/vana-sdk/node';
-     *
-     * // Generate encryption key from wallet signature
-     * const encryptionKey = await generateEncryptionKey(vana.walletClient);
-     *
-     * // Encrypt string data
-     * const sensitiveData = "User's private information";
-     * const encrypted = await vana.encryptBlob(sensitiveData, encryptionKey);
-     *
-     * // Encrypt file data
-     * const fileBlob = new Blob([fileContent], { type: 'application/json' });
-     * const encryptedFile = await vana.encryptBlob(fileBlob, encryptionKey);
-     *
-     * // Store encrypted data safely
-     * await storageProvider.upload(encrypted, 'encrypted-data.bin');
-     * ```
-     */
-    encryptBlob(data: string | Blob, key: string): Promise<Blob>;
-    /**
-     * Decrypts data that was encrypted using the Vana protocol.
-     *
-     * @remarks
-     * This method decrypts data that was previously encrypted using the Vana network's
-     * standard encryption protocol. It requires the same wallet signature that was used
-     * for encryption and automatically uses the appropriate platform adapter for
-     * cryptographic operations. The decrypted output maintains the original data format.
-     *
-     * @param encryptedData - The encrypted data (string or Blob)
-     * @param walletSignature - The wallet signature used as decryption key
-     * @returns The decrypted data as a Blob
-     * @throws {Error} When decryption fails due to invalid signature or corrupted data
-     * @example
-     * ```typescript
-     * import { generateEncryptionKey } from '@opendatalabs/vana-sdk/node';
-     *
-     * // Retrieve encrypted data from storage
-     * const encryptedBlob = await storageProvider.download('encrypted-data.bin');
-     *
-     * // Generate the same key used for encryption
-     * const decryptionKey = await generateEncryptionKey(vana.walletClient);
-     *
-     * // Decrypt the data
-     * const decrypted = await vana.decryptBlob(encryptedBlob, decryptionKey);
-     *
-     * // Convert back to original format
-     * const originalText = await decrypted.text();
-     * const originalJson = JSON.parse(originalText);
-     *
-     * console.log('Decrypted data:', originalJson);
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // Decrypt file downloaded from Vana network
-     * const userFiles = await vana.data.getUserFiles();
-     * const file = userFiles[0];
-     *
-     * // Download encrypted content
-     * const encrypted = await fetch(file.url).then(r => r.blob());
-     *
-     * // Decrypt with user's key
-     * const decryptionKey = await generateEncryptionKey(vana.walletClient);
-     * const decrypted = await vana.decryptBlob(encrypted, decryptionKey);
-     *
-     * // Process original data
-     * const fileContent = await decrypted.arrayBuffer();
-     * ```
-     */
-    decryptBlob(encryptedData: string | Blob, walletSignature: string): Promise<Blob>;
-    /**
-     * Waits for an operation to complete and returns the final result.
-     *
-     * @remarks
-     * This method polls the operation status at regular intervals until it
-     * reaches a terminal state (succeeded, failed, or canceled). Supports
-     * ergonomic overloads to accept either an Operation object or just the ID.
-     *
-     * @param opOrId - Either an Operation object or operation ID string
-     * @param options - Optional polling configuration
-     * @returns The completed operation with result or error
-     * @throws {PersonalServerError} When the operation fails or times out
-     * @example
-     * ```typescript
-     * // Using operation object
-     * const operation = await vana.server.createOperation({ permissionId: 123 });
-     * const completed = await vana.waitForOperation(operation);
-     *
-     * // Using just the ID
-     * const completed = await vana.waitForOperation("op_abc123");
-     *
-     * // With custom timeout
-     * const completed = await vana.waitForOperation(operation, {
-     *   timeout: 60000,
-     *   pollingInterval: 1000
-     * });
-     * ```
-     */
-    waitForOperation<T = unknown>(opOrId: Operation<T> | string, options?: PollingOptions): Promise<Operation<T>>;
-    /**
-     * Waits for a transaction to be confirmed and returns the receipt.
-     *
-     * @remarks
-     * This method polls for transaction confirmation on the blockchain.
-     * Supports ergonomic overloads to accept either a transaction result
-     * object or just the hash string.
-     *
-     * @param hashOrObj - Either a TransactionResult object or hash string
-     * @param options - Optional wait configuration
-     * @returns The transaction receipt with logs and status
-     * @example
-     * ```typescript
-     * // Using transaction result object
-     * const tx = await vana.permissions.grant(params);
-     * const receipt = await vana.waitForTransactionReceipt(tx);
-     *
-     * // Using just the hash
-     * const receipt = await vana.waitForTransactionReceipt("0x123...");
-     *
-     * // With custom confirmations
-     * const receipt = await vana.waitForTransactionReceipt(tx, {
-     *   confirmations: 3,
-     *   timeout: 60000
-     * });
-     * ```
-     */
-    waitForTransactionReceipt(hashOrObj: TransactionResult | {
-        hash: viem.Hash;
-    } | viem.Hash, options?: TransactionWaitOptions): Promise<viem.TransactionReceipt>;
-    /**
-     * Waits for transaction confirmation and parses events.
-     *
-     * @remarks
-     * This method waits for a transaction to be confirmed and then
-     * parses the logs to extract typed event data. The specific event
-     * type depends on the transaction operation.
-     *
-     * @param hashOrObj - Either a TransactionResult object or hash string
-     * @param options - Optional wait configuration
-     * @returns The parsed event data from the transaction
-     * @example
-     * ```typescript
-     * // Wait for permission grant events
-     * const tx = await vana.permissions.grant(params);
-     * const events = await vana.waitForTransactionEvents(tx);
-     * console.log(`Permission ID: ${events.permissionId}`);
-     *
-     * // Using just the hash
-     * const events = await vana.waitForTransactionEvents("0x123...");
-     * ```
-     */
-    waitForTransactionEvents<T = unknown>(hashOrObj: TransactionResult | {
-        hash: viem.Hash;
-    } | viem.Hash, options?: TransactionWaitOptions): Promise<T>;
-}
-
-export { VanaCore, VanaCoreFactory };

package/dist/crypto/ecies/__tests__/test-vectors.d.cts

@@ -1,40 +0,0 @@
-/**
- * Test vectors generated from eccrypto for compatibility verification
- * Generated on: 2025-08-17T15:03:45.067Z
- * eccrypto version: 1.1.6
- *
- * These vectors ensure our ECIES implementation is compatible with eccrypto
- */
-declare const eccryptoTestVectors: ({
-    name: string;
-    privateKey: string;
-    publicKey: string;
-    message: string;
-    encrypted: {
-        iv: string;
-        ephemPublicKey: string;
-        ciphertext: string;
-        mac: string;
-    };
-    messageText?: undefined;
-} | {
-    name: string;
-    privateKey: string;
-    publicKey: string;
-    message: string;
-    messageText: string;
-    encrypted: {
-        iv: string;
-        ephemPublicKey: string;
-        ciphertext: string;
-        mac: string;
-    };
-})[];
-declare const eccryptoFormat: {
-    ivLength: number;
-    ephemPublicKeyLength: number;
-    macLength: number;
-    getFormatLength: (ciphertextLength: number) => number;
-};
-
-export { eccryptoFormat, eccryptoTestVectors };

package/dist/crypto/ecies/base.d.cts

@@ -1,143 +0,0 @@
-import { ECIESProvider, ECIESEncrypted } from './interface.cjs';
-
-/**
- * Provides shared ECIES encryption logic across platforms using Uint8Array.
- *
- * @remarks
- * Platform implementations extend this class and provide crypto primitives.
- * The base class handles the ECIES protocol flow while maintaining
- * compatibility with the eccrypto data format.
- *
- * **Implementation details:**
- * - KDF: SHA-512(shared_secret) → encKey (32B) || macKey (32B)
- * - Cipher: AES-256-CBC with random 16-byte IV
- * - MAC: HMAC-SHA256(macKey, iv || ephemPublicKey || ciphertext)
- *
- * @category Cryptography
- */
-declare abstract class BaseECIESUint8 implements ECIESProvider {
-    private static readonly validatedKeys;
-    /**
-     * Generates cryptographically secure random bytes.
-     *
-     * @param length - Number of random bytes to generate.
-     * @returns Random bytes array.
-     */
-    protected abstract generateRandomBytes(length: number): Uint8Array;
-    /**
-     * Verifies a private key is valid for secp256k1.
-     *
-     * @param privateKey - Private key to verify (32 bytes).
-     * @returns `true` if valid private key.
-     */
-    protected abstract verifyPrivateKey(privateKey: Uint8Array): boolean;
-    /**
-     * Creates a public key from a private key.
-     *
-     * @param privateKey - Source private key (32 bytes).
-     * @param compressed - Generate compressed (33B) or uncompressed (65B) format.
-     * @returns Public key or `null` if creation failed.
-     */
-    protected abstract createPublicKey(privateKey: Uint8Array, compressed: boolean): Uint8Array | null;
-    /**
-     * Validates a public key on the secp256k1 curve.
-     *
-     * @param publicKey - Public key to validate.
-     * @returns `true` if valid public key.
-     */
-    protected abstract validatePublicKey(publicKey: Uint8Array): boolean;
-    /**
-     * Decompresses a compressed public key.
-     *
-     * @param publicKey - Compressed public key (33 bytes).
-     * @returns Uncompressed public key (65 bytes) or `null` if decompression failed.
-     */
-    protected abstract decompressPublicKey(publicKey: Uint8Array): Uint8Array | null;
-    /**
-     * Performs ECDH key agreement.
-     *
-     * @param publicKey - Other party's public key.
-     * @param privateKey - Your private key.
-     * @returns Raw X coordinate of shared point (32 bytes).
-     */
-    protected abstract performECDH(publicKey: Uint8Array, privateKey: Uint8Array): Uint8Array;
-    /**
-     * Computes SHA-512 hash.
-     *
-     * @param data - Data to hash.
-     * @returns SHA-512 hash (64 bytes).
-     */
-    protected abstract sha512(data: Uint8Array): Uint8Array;
-    /**
-     * Computes HMAC-SHA256 authentication tag.
-     *
-     * @param key - HMAC key.
-     * @param data - Data to authenticate.
-     * @returns HMAC-SHA256 (32 bytes).
-     */
-    protected abstract hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array;
-    /**
-     * Encrypts data using AES-256-CBC.
-     *
-     * @param key - Encryption key (32 bytes).
-     * @param iv - Initialization vector (16 bytes).
-     * @param plaintext - Data to encrypt.
-     * @returns Ciphertext with PKCS#7 padding.
-     */
-    protected abstract aesEncrypt(key: Uint8Array, iv: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
-    /**
-     * Decrypts data using AES-256-CBC.
-     *
-     * @param key - Decryption key (32 bytes).
-     * @param iv - Initialization vector (16 bytes).
-     * @param ciphertext - Data to decrypt.
-     * @returns Plaintext with padding removed.
-     */
-    protected abstract aesDecrypt(key: Uint8Array, iv: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
-    /**
-     * Normalizes a public key to uncompressed format.
-     *
-     * @param publicKey - Public key in any format.
-     * @returns Uncompressed public key (65 bytes).
-     * @throws {ECIESError} If key format is invalid.
-     */
-    protected normalizePublicKey(publicKey: Uint8Array): Uint8Array;
-    /**
-     * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).
-     * Must be implemented by derived classes to handle platform-specific operations.
-     *
-     * @param publicKey - The public key to normalize
-     * @returns The normalized uncompressed public key
-     */
-    abstract normalizeToUncompressed(publicKey: Uint8Array): Uint8Array;
-    /**
-     * Encrypts data using ECIES.
-     *
-     * @param publicKey - The recipient's public key (compressed or uncompressed)
-     * @param message - The data to encrypt
-     * @returns Promise resolving to encrypted data structure
-     */
-    encrypt(publicKey: Uint8Array, message: Uint8Array): Promise<ECIESEncrypted>;
-    /**
-     * Decrypts ECIES encrypted data.
-     *
-     * @param privateKey - The recipient's private key (32 bytes)
-     * @param encrypted - The encrypted data structure from encrypt()
-     * @returns Promise resolving to the original plaintext
-     */
-    decrypt(privateKey: Uint8Array, encrypted: ECIESEncrypted): Promise<Uint8Array>;
-    /**
-     * Clears sensitive data from memory using multi-pass overwrite.
-     *
-     * @remarks
-     * Uses multiple passes with different patterns to make it harder
-     * for JIT compilers to optimize away the operation. While not
-     * guaranteed in JavaScript, this is a best-effort approach to
-     * clear sensitive data from memory.
-     *
-     * @param buffer - The buffer to clear
-     */
-    protected clearBuffer(buffer: Uint8Array): void;
-}
-
-export { BaseECIESUint8 };

package/dist/crypto/ecies/browser.d.cts

@@ -1,48 +0,0 @@
-import { BaseECIESUint8 } from './base.cjs';
-import './interface.cjs';
-
-/**
- * Browser implementation of ECIES using @noble/secp256k1 with Uint8Array
- *
- * @remarks
- * Uses native browser crypto APIs and @noble/secp256k1 for elliptic curve operations.
- * This implementation is polyfill-free and works in all modern browsers.
- */
-
-/**
- * Browser-specific ECIES provider using @noble/secp256k1
- *
- * @remarks
- * This implementation uses:
- * - Web Crypto API for AES operations
- * - @noble/secp256k1 for elliptic curve operations
- * - @noble/hashes for SHA and HMAC operations
- * - No Buffer or Node.js dependencies
- */
-declare class BrowserECIESUint8Provider extends BaseECIESUint8 {
-    protected generateRandomBytes(length: number): Uint8Array;
-    protected verifyPrivateKey(privateKey: Uint8Array): boolean;
-    protected createPublicKey(privateKey: Uint8Array, compressed: boolean): Uint8Array | null;
-    protected validatePublicKey(publicKey: Uint8Array): boolean;
-    protected decompressPublicKey(publicKey: Uint8Array): Uint8Array | null;
-    protected performECDH(publicKey: Uint8Array, privateKey: Uint8Array): Uint8Array;
-    protected sha512(data: Uint8Array): Uint8Array;
-    protected hmacSha256(key: Uint8Array, data: Uint8Array): Uint8Array;
-    protected aesEncrypt(key: Uint8Array, iv: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
-    protected aesDecrypt(key: Uint8Array, iv: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
-    /**
-     * Normalizes a public key to uncompressed format (65 bytes with 0x04 prefix).
-     * Handles compressed (33 bytes) and uncompressed (65 bytes) formats only.
-     *
-     * @remarks
-     * Strict policy: Does not accept 64-byte raw coordinates to avoid masking
-     * malformed data. Callers must provide properly formatted keys.
-     *
-     * @param publicKey - The public key to normalize (33 or 65 bytes)
-     * @returns The normalized uncompressed public key (65 bytes)
-     * @throws {Error} When public key format is invalid or decompression fails
-     */
-    normalizeToUncompressed(publicKey: Uint8Array): Uint8Array;
-}
-
-export { BrowserECIESUint8Provider };