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

package/dist/types.d.cts

@@ -1,66 +0,0 @@
-export { BaseConfig, BaseConfigWithStorage, ChainConfig, ChainConfigWithStorage, ConfigValidationOptions, ConfigValidationResult, DownloadRelayerCallbacks, RelayerCallbacks, RuntimeConfig, StorageConfig, StorageRequiredMarker, VanaConfig, VanaConfigWithStorage, WalletConfig, WalletConfigWithStorage, hasStorageConfig, isChainConfig, isWalletConfig } from './types/config.cjs';
-export { VanaChain, VanaChainId, isVanaChain, isVanaChainId } from './types/chains.cjs';
-export { ContractAddresses, ContractDeployment, ContractInfo, ContractMethodParams, ContractMethodReturnType, VanaContractInstance, VanaContractName } from './types/contracts.cjs';
-export { StorageError, StorageFile, StorageListOptions, StorageProvider, StorageProviderConfig, StorageUploadResult } from './types/storage.cjs';
-export { AddRefinerParams, AddRefinerResult, AddSchemaParams, AddSchemaResult, BatchUploadParams, BatchUploadResult, CompleteSchema, DeleteFileParams, DeleteFileResult, DownloadFileParams, DownloadFileResult, EncryptedUploadParams, EncryptionInfo, FileAccessPermissions, FileMetadata, FilePermissionParams, FileSharingConfig, GetFileParams, GetUserFilesParams, GetUserTrustedServersParams, LegacyPermissionParams, Refiner, Schema, SchemaMetadata, TrustedServer, UnencryptedUploadParams, UpdateSchemaIdParams, UpdateSchemaIdResult, UploadEncryptedFileResult, UploadFileParams, UploadFileResult, UploadParams, UploadResult } from './types/data.cjs';
-export { CreateSchemaParams, CreateSchemaResult } from './controllers/schemas.cjs';
-export { DataSchema, SchemaValidationError, SchemaValidator, fetchAndValidateSchema, validateDataAgainstSchema, validateDataSchemaAgainstMetaSchema } from './utils/schemaValidation.cjs';
-export { AddAndTrustServerInput, AddAndTrustServerParams, AddAndTrustServerTypedData, BatchServerInfoResult, CheckPermissionParams, GenericTypedData, GetUserPermissionsOptions, GrantFile, GrantedPermission, Grantee, GranteeInfo, GranteeQueryOptions, OnChainPermissionGrant, PaginatedGrantees, PaginatedTrustedServers, Permission, PermissionAnalytics, PermissionCheckResult, PermissionEvent, PermissionGrantDomain, PermissionGrantMessage, PermissionGrantTypedData, PermissionInfo, PermissionInputMessage, PermissionOperation, PermissionQueryResult, PermissionStatus, QueryPermissionsParams, RegisterGranteeInput, RegisterGranteeParams, RegisterGranteeTypedData, RevokePermissionInput, RevokePermissionParams, RevokePermissionTypedData, Server, ServerFilesAndPermissionParams, ServerFilesAndPermissionTypedData, ServerInfo, ServerTrustStatus, SimplifiedPermissionMessage, SpecificTypedData, TrustServerInput, TrustServerParams, TrustServerTypedData, TrustedServerInfo, TrustedServerQueryOptions, TypedDataPrimaryType, UntrustServerInput, UntrustServerParams, UntrustServerTypedData } from './types/permissions.cjs';
-export { CreateOperationParams, InitPersonalServerParams, PersonalServerIdentity, PostRequestParams } from './types/personal.cjs';
-export { AuthenticationErrorResponse, BlockchainErrorResponse, ComputeErrorResponse, CreateOperationRequest, CreateOperationResponse, DecryptionErrorResponse, ErrorResponse, FileAccessErrorResponse, GetOperationResponse, GrantValidationErrorResponse, IdentityResponseModel, InternalServerErrorResponse, NotFoundErrorResponse, OperationErrorResponse, PersonalServerModel, ValidationErrorResponse } from './generated/server/server-exports.cjs';
-export { APIResponse, PinataListResponse, PinataPin, PinataUploadResponse, ReplicateAPIResponse, ReplicateStatus, isAPIResponse, isReplicateAPIResponse, parseReplicateOutput, safeParseJSON } from './types/external-apis.cjs';
-export { RelayerConfig, RelayerErrorResponse, RelayerMetrics, RelayerQueueInfo, RelayerRequestOptions, RelayerStatus, RelayerStorageResponse, RelayerStoreParams, RelayerSubmitParams, RelayerTransactionResponse, RelayerTransactionStatus, RelayerWebhookConfig, RelayerWebhookPayload } from './types/relayer.cjs';
-export { ApiResponse, Awaited, BlockRange, CacheConfig, GasEstimate, MaybeArray, MaybePromise, NetworkInfo, PaginationParams, PaginationResult, PartialExcept, RateLimitInfo, RequiredExcept, StatusInfo, TimeRange, TransactionOptions, TransactionReceipt, UploadProgress, ValidationResult } from './types/utils.cjs';
-export { AllKeys, AsyncResult, Brand, Cache, ConditionalOptional, ContractCall, Controller, ControllerContext, DeepPartial, DeepReadonly, EventFilter, EventLog, Factory, GenericRequest, GenericResponse, Middleware, Nominal, NonNullable, Observable, Observer, OmitByType, OptionalKeys, PickByType, Plugin, PromiseResult, RateLimiterConfig, Repository, RequireKeys, RetryConfig, Service, StateMachine, Transformer, Validator } from './types/generics.cjs';
-import { Address } from 'viem';
-export { Abi, Account, Address, Chain, GetContractReturnType, Hash, PublicClient, WalletClient } from 'viem';
-export { $defs, components as ServerComponents, $defs as ServerDefs, operations as ServerOperations, paths as ServerPaths, webhooks as ServerWebhooks, components, operations, paths, webhooks } from './generated/server/server.cjs';
-import './permissions-DNKPu_G0.cjs';
-import './types/operations.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 './platform/interface.cjs';
-
-/**
- * Represents a user's registered data file.
- */
-interface UserFile {
-    /** Unique identifier for the file */
-    id: number;
-    /** URL where the file is stored */
-    url: string;
-    /** EVM address of the file owner */
-    ownerAddress: Address;
-    /** Block number when the file was added to the registry */
-    addedAtBlock: bigint;
-}
-/**
- * Parameters for the `vana.permissions.grant` method.
- */
-interface GrantPermissionParams {
-    /** The on-chain identity of the application */
-    grantee: Address;
-    /** The class of computation, e.g., "llm_inference" */
-    operation: string;
-    /** Array of file IDs to grant permission for */
-    files: number[];
-    /** The full, off-chain parameters (e.g., LLM prompt) */
-    parameters: Record<string, unknown>;
-    /** Optional pre-stored grant URL to avoid duplicate IPFS storage */
-    grantUrl?: string;
-}
-
-export type { GrantPermissionParams, UserFile };

package/dist/utils/blockchain/registry.d.cts

@@ -1,34 +0,0 @@
-import { WalletClient, PublicClient } from 'viem';
-import { SchemaMetadata } from '../../types/data.cjs';
-
-/**
- * Shared context for blockchain operations.
- * Only includes the minimal required fields to avoid coupling.
- */
-interface BlockchainContext {
-    walletClient: WalletClient;
-    publicClient: PublicClient;
-}
-/**
- * Fetches schema metadata from the blockchain by its ID.
- *
- * @param context - The blockchain context containing wallet and public clients
- * @param schemaId - The ID of the schema to fetch
- * @returns The schema metadata with id, name, dialect, and definitionUrl
- * @throws Error if chain ID is not available, schema not found, or data is incomplete
- *
- * @internal
- */
-declare function fetchSchemaFromChain(context: BlockchainContext, schemaId: number): Promise<SchemaMetadata>;
-/**
- * Fetches the total count of schemas from the blockchain.
- *
- * @param context - The blockchain context containing wallet and public clients
- * @returns The total number of schemas
- * @throws Error if chain ID is not available or operation fails
- *
- * @internal
- */
-declare function fetchSchemaCountFromChain(context: BlockchainContext): Promise<number>;
-
-export { fetchSchemaCountFromChain, fetchSchemaFromChain };

package/dist/utils/crypto-utils.d.cts

@@ -1,118 +0,0 @@
-/**
- * Provides platform-agnostic cryptographic utility functions.
- *
- * @remarks
- * This module contains utility functions for cryptographic operations that work
- * consistently across Node.js and browser environments. All functions use `Uint8Array`
- * exclusively for binary data to ensure cross-platform compatibility.
- *
- * @category Cryptography
- */
-/**
- * Concatenates multiple Uint8Arrays into a single array.
- *
- * @param arrays - The byte arrays to concatenate in order.
- * @returns A new Uint8Array containing all input arrays concatenated.
- *
- * @example
- * ```typescript
- * const combined = concatBytes(
- *   new Uint8Array([1, 2]),
- *   new Uint8Array([3, 4])
- * );
- * console.log(combined); // Uint8Array([1, 2, 3, 4])
- * ```
- */
-declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
-/**
- * Processes a wallet public key for cryptographic operations.
- *
- * @remarks
- * Converts hex string public keys to Uint8Array format.
- * For normalization to uncompressed format, use the crypto provider's
- * normalizeToUncompressed method.
- *
- * @param publicKey - The wallet public key as hex string or byte array.
- * @returns The public key as a Uint8Array.
- *
- * @example
- * ```typescript
- * const keyBytes = processWalletPublicKey("0x04...");
- * const normalized = provider.normalizeToUncompressed(keyBytes);
- * ```
- */
-declare function processWalletPublicKey(publicKey: string | Uint8Array): Uint8Array;
-/**
- * Processes a wallet private key for cryptographic operations.
- *
- * @param privateKey - The wallet private key as hex string or byte array.
- * @returns The private key as a Uint8Array.
- *
- * @example
- * ```typescript
- * const key = processWalletPrivateKey("0x...");
- * console.log(key.length); // 32 (secp256k1 private key)
- * ```
- */
-declare function processWalletPrivateKey(privateKey: string | Uint8Array): Uint8Array;
-/**
- * Parses legacy eccrypto-format encrypted data buffer.
- * Format: [iv(16)][ephemPublicKey(65)][ciphertext(variable)][mac(32)]
- *
- * @param encryptedBuffer - Buffer containing encrypted data in eccrypto format
- * @returns Parsed encrypted data components
- */
-declare function parseEncryptedDataBuffer(encryptedBuffer: Uint8Array): {
-    iv: Uint8Array;
-    ephemPublicKey: Uint8Array;
-    ciphertext: Uint8Array;
-    mac: Uint8Array;
-};
-/**
- * Generates a deterministic seed from a message for key derivation
- *
- * @param message - Message to derive seed from
- * @returns Seed as Uint8Array
- */
-declare function generateSeed(message: string): Uint8Array;
-/**
- * Compares two Uint8Arrays for equality
- *
- * @param a - First array
- * @param b - Second array
- * @returns True if arrays are equal
- */
-declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
-/**
- * Creates a copy of a Uint8Array
- *
- * @param bytes - Array to copy
- * @returns New array with same contents
- */
-declare function copyBytes(bytes: Uint8Array): Uint8Array;
-/**
- * Validates a secp256k1 public key format
- *
- * @param publicKey - Public key to validate
- * @returns True if valid format (33, 65, or 64 bytes)
- */
-declare function isValidPublicKeyFormat(publicKey: Uint8Array): boolean;
-/**
- * Validates a secp256k1 private key format
- *
- * @param privateKey - Private key to validate
- * @returns True if valid format (32 bytes)
- */
-declare function isValidPrivateKeyFormat(privateKey: Uint8Array): boolean;
-/**
- * Asserts that a public key is in uncompressed format (65 bytes with 0x04 prefix).
- * This validation function only checks format, it does not transform keys.
- * For key normalization (including decompression), use the crypto provider's
- * normalizeToUncompressed method.
- *
- * @param publicKey - Public key to validate
- * @throws {Error} When public key is not in uncompressed format
- */
-declare function assertUncompressedPublicKey(publicKey: Uint8Array): void;
-
-export { assertUncompressedPublicKey, bytesEqual, concatBytes, copyBytes, generateSeed, isValidPrivateKeyFormat, isValidPublicKeyFormat, parseEncryptedDataBuffer, processWalletPrivateKey, processWalletPublicKey };

package/dist/utils/download.d.cts

@@ -1,41 +0,0 @@
-/**
- * Universal download utility with CORS bypass and IPFS gateway fallbacks
- *
- * @category Utilities
- */
-/**
- * Fetch content with automatic fallbacks for CORS and IPFS
- *
- * @remarks
- * This utility provides a robust download mechanism that handles:
- * 1. Direct fetch for regular URLs
- * 2. Download relayer for CORS-restricted URLs
- * 3. IPFS gateway fallbacks for IPFS content
- *
- * The function automatically determines the best strategy based on the URL
- * and available configuration, providing transparent fallback behavior.
- *
- * @param url - The URL to fetch (HTTP, HTTPS, or IPFS)
- * @param downloadRelayer - Optional download relayer for CORS bypass
- * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
- * @returns Promise resolving to Response object
- * @throws Error if all download attempts fail
- * @example
- * ```typescript
- * // With download relayer configured
- * const response = await fetchWithRelayer(
- *   'https://drive.google.com/file.json',
- *   vana.downloadRelayer
- * );
- * const data = await response.json();
- *
- * // IPFS URL - will use gateway fallbacks
- * const ipfsResponse = await fetchWithRelayer('ipfs://QmHash123');
- * const content = await ipfsResponse.text();
- * ```
- */
-declare function fetchWithRelayer(url: string, downloadRelayer?: {
-    proxyDownload: (url: string) => Promise<Blob>;
-}): Promise<Response>;
-
-export { fetchWithRelayer };

package/dist/utils/encoding.d.cts

@@ -1,54 +0,0 @@
-/**
- * Provides platform-aware base64 encoding utilities.
- *
- * @remarks
- * This module provides base64 encoding/decoding operations across Node.js and browser
- * environments. For hex and string conversions, use viem's utilities directly:
- * - `toHex` / `fromHex` from 'viem'
- * - `stringToBytes` / `bytesToString` from 'viem'
- *
- * @category Utilities
- */
-/**
- * Converts a Uint8Array to a base64 string.
- *
- * @param data - The byte array to encode into base64 format.
- * @returns The base64-encoded string representation.
- * @throws {Error} When no base64 encoding method is available in the environment.
- *
- * @example
- * ```typescript
- * const bytes = new Uint8Array([72, 101, 108, 108, 111]);
- * const encoded = toBase64(bytes);
- * console.log(encoded); // "SGVsbG8="
- * ```
- */
-declare function toBase64(data: Uint8Array): string;
-/**
- * Converts a base64 string to a Uint8Array.
- *
- * @param str - The base64-encoded string to decode.
- * @returns The decoded byte array.
- * @throws {Error} When no base64 decoding method is available in the environment.
- *
- * @example
- * ```typescript
- * const decoded = fromBase64("SGVsbG8=");
- * console.log(new TextDecoder().decode(decoded)); // "Hello"
- * ```
- */
-declare function fromBase64(str: string): Uint8Array;
-/**
- * Type guard to check if running in Node.js environment
- *
- * @returns True if running in Node.js
- */
-declare function isNodeEnvironment(): boolean;
-/**
- * Type guard to check if running in browser environment
- *
- * @returns True if running in browser
- */
-declare function isBrowserEnvironment(): boolean;
-
-export { fromBase64, isBrowserEnvironment, isNodeEnvironment, toBase64 };

package/dist/utils/encryption.d.cts

@@ -1,275 +0,0 @@
-import { WalletClient } from 'viem';
-import { VanaPlatformAdapter } from '../platform/interface.cjs';
-
-/**
- * Canonical Vana Protocol Encryption Functions
- *
- * These functions define the standard way user data is encrypted/decrypted in Vana.
- * All applications should use these canonical functions to ensure compatibility
- * with existing encrypted data on the Vana network.
- *
- * This module uses the platform adapter pattern to provide consistent
- * encryption functionality across Node.js and browser environments.
- */
-
-/**
- * Default encryption seed message used throughout Vana protocol
- */
-declare const DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
-/**
- * Generate an encryption key by signing the canonical Vana encryption seed
- *
- * This is the standard protocol function for creating encryption keys in Vana.
- * The signature serves as a symmetric encryption key for user data.
- *
- * @param wallet The user's wallet client for signing
- * @param platformAdapter Platform adapter for cache operations
- * @param seed Optional custom encryption seed (defaults to Vana standard)
- * @returns The signature that serves as the encryption key
- * @throws {Error} When wallet account is required but not provided
- * @example
- * ```typescript
- * const encryptionKey = await generateEncryptionKey(walletClient, platformAdapter);
- * console.log('Generated encryption key:', encryptionKey);
- *
- * // Use with custom seed
- * const customKey = await generateEncryptionKey(walletClient, platformAdapter, 'my-custom-seed');
- * ```
- */
-declare function generateEncryptionKey(wallet: WalletClient, platformAdapter: VanaPlatformAdapter, seed?: string): Promise<string>;
-/**
- * Encrypts data using a wallet's public key for secure sharing with specific recipients.
- *
- * @remarks
- * This function implements asymmetric encryption using the recipient's public key,
- * enabling secure data sharing where only the holder of the corresponding private key
- * can decrypt the data. It automatically handles different data types and uses
- * platform-appropriate cryptographic libraries for maximum compatibility.
- *
- * This is commonly used when granting permissions to applications or servers,
- * where the data needs to be encrypted for a specific recipient's public key.
- *
- * @param data - The data to encrypt (string or Blob)
- * @param publicKey - The recipient's public key in hexadecimal format
- * @param platformAdapter - The platform adapter providing cryptographic operations
- * @returns Promise resolving to the encrypted data as a string
- * @throws {Error} When encryption fails due to invalid key or data format
- * @example
- * ```typescript
- * // Encrypt data for a specific application's public key
- * const appPublicKey = "0x04a1b2c3..."; // Application's public key
- * const sensitiveData = "User's private information";
- *
- * const encrypted = await encryptWithWalletPublicKey(
- *   sensitiveData,
- *   appPublicKey,
- *   platformAdapter
- * );
- *
- * console.log('Encrypted for app:', encrypted);
- *
- * // Encrypt file data for server processing
- * const fileBlob = new File(['{"name":"John","age":30}'], 'profile.json');
- * const encryptedFile = await encryptWithWalletPublicKey(
- *   fileBlob,
- *   serverPublicKey,
- *   platformAdapter
- * );
- * ```
- */
-declare function encryptWithWalletPublicKey(data: string | Blob, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
-/**
- * Decrypts data that was encrypted with the corresponding public key.
- *
- * @remarks
- * This function performs asymmetric decryption using the recipient's private key
- * to decrypt data that was encrypted with the corresponding public key. It's the
- * counterpart to `encryptWithWalletPublicKey` and is typically used by applications
- * or servers to decrypt data that was shared with them by users.
- *
- * The function automatically handles platform-specific cryptographic operations
- * and provides consistent behavior across browser and Node.js environments.
- *
- * @param encryptedData - The encrypted data string to decrypt
- * @param privateKey - The private key corresponding to the public key used for encryption
- * @param platformAdapter - The platform adapter providing cryptographic operations
- * @returns Promise resolving to the decrypted data as a string
- * @throws {Error} When decryption fails due to invalid key, corrupted data, or key mismatch
- * @example
- * ```typescript
- * // Decrypt data received from a user (server-side)
- * const encryptedUserData = "encrypted_string_from_user";
- * const serverPrivateKey = process.env.SERVER_PRIVATE_KEY;
- *
- * const decrypted = await decryptWithWalletPrivateKey(
- *   encryptedUserData,
- *   serverPrivateKey,
- *   platformAdapter
- * );
- *
- * const userData = JSON.parse(decrypted);
- * console.log('User data:', userData);
- *
- * // Handle decryption errors gracefully
- * try {
- *   const result = await decryptWithWalletPrivateKey(
- *     encryptedData,
- *     privateKey,
- *     platformAdapter
- *   );
- * } catch (error) {
- *   if (error.message.includes('invalid key')) {
- *     console.error('Key mismatch - data not encrypted for this recipient');
- *   } else {
- *     console.error('Decryption failed:', error.message);
- *   }
- * }
- * ```
- */
-declare function decryptWithWalletPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
-/**
- * Encrypt a file key with a DLP's public key using platform-appropriate cryptography
- *
- * @param fileKey The symmetric key used to encrypt the file
- * @param publicKey The DLP's public key
- * @param platformAdapter - The platform adapter for crypto operations
- * @returns The encrypted key that can be stored on-chain
- */
-declare function encryptFileKey(fileKey: string, publicKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
-/**
- * Generate encryption parameters for secure file storage
- *
- * @param platformAdapter - The platform adapter for crypto operations
- * @returns An object containing the initialization vector and encryption key
- */
-declare function getEncryptionParameters(platformAdapter: VanaPlatformAdapter): Promise<{
-    iv: string;
-    key: string;
-}>;
-/**
- * Decrypt data that was encrypted with the DLP's public key using platform-appropriate cryptography
- *
- * @param encryptedData The encrypted data
- * @param privateKey The private key corresponding to the public key used for encryption
- * @param platformAdapter - The platform adapter for crypto operations
- * @returns The decrypted data
- */
-declare function decryptWithPrivateKey(encryptedData: string, privateKey: string, platformAdapter: VanaPlatformAdapter): Promise<string>;
-/**
- * Encrypts data using a signed key generated from the user's wallet signature.
- *
- * @remarks
- * This is a pure cryptographic primitive that encrypts data using the Vana protocol's
- * standard encryption method. The key parameter must be a signature generated by the
- * `generateEncryptionKey` utility - this ensures deterministic key generation from the
- * user's wallet, enabling the same key to be regenerated for decryption.
- *
- * This function uses password-based encryption with the signature as the password,
- * providing symmetric encryption that can be decrypted with the same signature.
- *
- * @param data The data to encrypt (string or Blob)
- * @param key The signed key from `generateEncryptionKey` - MUST be a wallet signature
- * @param platformAdapter The platform adapter for crypto operations
- * @returns The encrypted data as Blob
- * @throws {Error} When encryption fails
- *
- * @example
- * ```typescript
- * // Generate the encryption key from wallet signature
- * const encryptionKey = await generateEncryptionKey(walletClient);
- *
- * // Encrypt data with the signed key
- * const encryptedBlob = await encryptBlobWithSignedKey(
- *   "My sensitive data",
- *   encryptionKey,
- *   platformAdapter
- * );
- *
- * // Later, decrypt with the same key
- * const decryptedBlob = await decryptBlobWithSignedKey(
- *   encryptedBlob,
- *   encryptionKey,
- *   platformAdapter
- * );
- * ```
- */
-declare function encryptBlobWithSignedKey(data: string | Blob, key: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;
-/**
- * Generate a new key pair for asymmetric encryption
- *
- * @param platformAdapter - The platform adapter for crypto operations
- * @returns Promise resolving to public and private key pair
- */
-declare function generateEncryptionKeyPair(platformAdapter: VanaPlatformAdapter): Promise<{
-    publicKey: string;
-    privateKey: string;
-}>;
-/**
- * Generate a new PGP key pair with platform-appropriate configuration
- *
- * @param platformAdapter - The platform adapter for crypto operations
- * @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
- */
-declare function generatePGPKeyPair(platformAdapter: VanaPlatformAdapter, options?: {
-    name?: string;
-    email?: string;
-    passphrase?: string;
-}): Promise<{
-    publicKey: string;
-    privateKey: string;
-}>;
-/**
- * Decrypts data using a signed key generated from the user's wallet signature.
- *
- * @remarks
- * This is a pure cryptographic primitive for decrypting data that was encrypted using
- * `encryptBlobWithSignedKey`. It is network-agnostic and only handles decryption - it does
- * not fetch data from any URL or make network requests. To decrypt a file from a URL, you
- * must first fetch the encrypted blob using one of the fetch utilities, then pass it to
- * this function.
- *
- * The key parameter must be the same signature that was used for encryption, typically
- * generated by the `generateEncryptionKey` utility. This ensures that only the user who
- * encrypted the data (or someone with the same wallet signature) can decrypt it.
- *
- * @param encryptedData The encrypted data to decrypt (string or Blob)
- * @param key The signed key from `generateEncryptionKey` - MUST be the same wallet signature used for encryption
- * @param platformAdapter The platform adapter for crypto operations
- * @returns Promise resolving to the decrypted blob
- * @throws {Error} When decryption fails due to wrong key or corrupted data
- *
- * @example
- * ```typescript
- * // Generate the same encryption key used for encryption
- * const encryptionKey = await generateEncryptionKey(walletClient);
- *
- * // Fetch and decrypt using the high-level API
- * const file = await vana.data.getUserFiles({ owner: "0x..." })[0];
- * const decryptedBlob = await vana.data.decryptFile(file);
- *
- * // Or use the low-level primitives directly
- * const encryptedBlob = await vana.data.fetch(file.url);
- * const decryptedBlob = await decryptBlobWithSignedKey(
- *   encryptedBlob,
- *   encryptionKey,
- *   platformAdapter
- * );
- *
- * // With IPFS gateway fallback
- * const encryptedBlob = await vana.data.fetchFromIPFS(file.url, {
- *   gateways: ['https://my-gateway.com/ipfs/', 'https://ipfs.io/ipfs/']
- * });
- * const decryptedBlob = await decryptBlobWithSignedKey(
- *   encryptedBlob,
- *   encryptionKey,
- *   platformAdapter
- * );
- * ```
- */
-declare function decryptBlobWithSignedKey(encryptedData: string | Blob, key: string, platformAdapter: VanaPlatformAdapter): Promise<Blob>;
-
-export { DEFAULT_ENCRYPTION_SEED, decryptBlobWithSignedKey, decryptWithPrivateKey, decryptWithWalletPrivateKey, encryptBlobWithSignedKey, encryptFileKey, encryptWithWalletPublicKey, generateEncryptionKey, generateEncryptionKeyPair, generatePGPKeyPair, getEncryptionParameters };