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

package/dist/utils/formatters.d.cts

@@ -1,120 +0,0 @@
-/**
- * Format a bigint or BigNumber to a regular number
- *
- * @remarks
- * This function converts blockchain-specific large number types to standard JavaScript
- * numbers. Use with caution for values that may exceed safe integer range.
- *
- * **Edge Cases:**
- * - Values exceeding JavaScript's MAX_SAFE_INTEGER (2^53-1) lose precision
- * - Negative values are supported
- * - String values must be valid numeric strings or will return NaN
- *
- * @param value BigInt, BigNumber or numeric string to convert
- * @returns Regular JavaScript number
- * @example
- * ```typescript
- * formatNumber(1000000000000000000n) // Returns: 1000000000000000000
- * formatNumber("123456789") // Returns: 123456789
- * formatNumber(-100n) // Returns: -100
- *
- * // Precision loss example:
- * const bigValue = 9007199254740993n; // MAX_SAFE_INTEGER + 2
- * formatNumber(bigValue) // Returns: 9007199254740992 (lost precision)
- * ```
- */
-declare function formatNumber(value: bigint | string | number): number;
-/**
- * Format wei value to ETH with specified decimal places
- *
- * @remarks
- * Converts wei (smallest ETH unit) to human-readable ETH format.
- * 1 ETH = 10^18 wei. The function truncates rather than rounds
- * to ensure predictable display in financial contexts.
- *
- * **Edge Cases:**
- * - Truncates (not rounds) to specified decimal places
- * - Negative values are supported
- * - Zero values return "0.0000" (based on decimals)
- * - Very small values may display as "0.0000" due to truncation
- *
- * @param wei Value in wei (as bigint, string, or number)
- * @param decimals Number of decimal places to display (default: 4)
- * @returns Formatted ETH value as string
- * @example
- * ```typescript
- * // Standard conversions
- * formatEth(1000000000000000000n) // Returns: "1.0000"
- * formatEth(1500000000000000000n, 2) // Returns: "1.50"
- * formatEth("2000000000000000000") // Returns: "2.0000"
- *
- * // Edge cases
- * formatEth(1000000000000000n) // Returns: "0.0010" (0.001 ETH)
- * formatEth(100000000000000n) // Returns: "0.0001"
- * formatEth(10000000000000n) // Returns: "0.0000" (truncated)
- * formatEth(-1000000000000000000n) // Returns: "-1.000"
- * ```
- */
-declare function formatEth(wei: bigint | string | number, decimals?: number): string;
-/**
- * Format a token amount based on its decimals
- *
- * @remarks
- * Generic token formatter that handles any ERC20-style token with
- * configurable decimal places. Most tokens use 18 decimals like ETH,
- * but some use different values (e.g., USDC uses 6).
- *
- * @param amount Raw token amount
- * @param decimals Token decimals (default: 18)
- * @param displayDecimals Decimals to show in formatted output (default: 4)
- * @returns Formatted token amount as string
- * @example
- * ```typescript
- * // 18 decimal token (like ETH)
- * formatToken(1000000000000000000n) // Returns: "1.0000"
- * formatToken(1500000000000000000n, 18, 2) // Returns: "1.50"
- *
- * // 6 decimal token (like USDC)
- * formatToken(1000000n, 6) // Returns: "1.0000"
- * formatToken(1500000n, 6, 2) // Returns: "1.50"
- *
- * // Whole numbers
- * formatToken(5000000000000000000n) // Returns: "5"
- * formatToken(5123456789000000000n, 18, 6) // Returns: "5.123456"
- * ```
- */
-declare function formatToken(amount: bigint | string | number, decimals?: number, displayDecimals?: number): string;
-/**
- * Format an address for display (showing first 6 and last 4 characters)
- *
- * @remarks
- * Creates a human-readable abbreviated version of Ethereum addresses
- * for UI display. Preserves enough characters to maintain uniqueness
- * while saving screen space. Does not validate address format.
- *
- * **Edge Cases:**
- * - Addresses shorter than 10 characters are returned unchanged
- * - Works with both checksummed and lowercase addresses
- * - Does not validate address format
- *
- * @param address EVM address
- * @returns Shortened address string
- * @example
- * ```typescript
- * // Standard addresses
- * shortenAddress("0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36")
- * // Returns: "0x742d...Bd36"
- *
- * // Checksummed address
- * shortenAddress("0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36")
- * // Returns: "0x742d...Bd36"
- *
- * // Edge cases
- * shortenAddress("0x123") // Returns: "0x123" (too short)
- * shortenAddress("") // Returns: ""
- * shortenAddress("not-an-address") // Returns: "not-an...ress"
- * ```
- */
-declare function shortenAddress(address: string): string;
-
-export { formatEth, formatNumber, formatToken, shortenAddress };

package/dist/utils/grantFiles.d.cts

@@ -1,186 +0,0 @@
-import { GrantPermissionParams, GrantFile } from '../types/permissions.cjs';
-import 'viem';
-
-/**
- * Creates a grant file structure from permission parameters.
- *
- * @remarks
- * This function constructs the JSON structure that represents a permission grant
- * in the Vana protocol. The grant file contains all necessary information for
- * a grantee to perform operations on behalf of the grantor.
- *
- * @param params - The permission parameters to create the grant file from
- * @returns The constructed grant file object
- * @example
- * ```typescript
- * const grantFile = createGrantFile({
- *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',
- *   operation: 'llm_inference',
- *   parameters: {
- *     model: 'gpt-4',
- *     maxTokens: 1000
- *   },
- *   expiresAt: Date.now() + 86400000 // 24 hours
- * });
- *
- * console.log(grantFile);
- * // {
- * //   grantee: '0x742d...',
- * //   operation: 'llm_inference',
- * //   parameters: { model: 'gpt-4', maxTokens: 1000 },
- * //   expires: 1234567890
- * // }
- * ```
- */
-declare function createGrantFile(params: GrantPermissionParams): GrantFile;
-/**
- * Stores a grant file in IPFS via the relayer service.
- *
- * @remarks
- * This function uploads the grant file to IPFS through the relayer's upload endpoint.
- * The returned URL can be stored on-chain as part of the permission grant, allowing
- * anyone to retrieve the detailed permission parameters later.
- *
- * @param grantFile - The grant file to store
- * @param relayerUrl - URL of the relayer service
- * @returns Promise resolving to the IPFS URL
- * @throws {NetworkError} When the upload fails or relayer is unavailable
- * @example
- * ```typescript
- * const grantFile = createGrantFile(params);
- *
- * try {
- *   const ipfsUrl = await storeGrantFile(grantFile, 'https://relayer.vana.com');
- *   console.log(`Grant file stored at: ${ipfsUrl}`);
- *   // ipfsUrl: "ipfs://QmHash123..."
- * } catch (error) {
- *   console.error('Failed to store grant file:', error);
- * }
- * ```
- */
-declare function storeGrantFile(grantFile: GrantFile, relayerUrl: string): Promise<string>;
-/**
- * Retrieves detailed grant file data from IPFS or HTTP storage.
- *
- * @remarks
- * **This is Step 2 of the performant two-step permission API.**
- *
- * Use this method to resolve detailed permission data (operation, parameters, etc.)
- * for specific grants after first getting the fast on-chain data using
- * `getUserPermissionGrantsOnChain()`. This design eliminates N+1 query problems
- * by allowing selective lazy-loading of expensive off-chain data.
- *
- * **Performance**: Single network request per grant file (typically 100-500ms).
- * **Reliability**: Tries multiple IPFS gateways as fallbacks if primary URL fails.
- *
- * @param grantUrl - The grant file URL from OnChainPermissionGrant.grantUrl
- * @param _relayerUrl - URL of the relayer service (optional, unused)
- * @param downloadRelayer - Optional download relayer for proxying CORS-restricted downloads
- * @param downloadRelayer.proxyDownload - Function to proxy download requests through application server
- * @returns Promise resolving to the complete grant file with operation details
- * @throws {NetworkError} When all retrieval attempts fail
- * @throws {SerializationError} When grant file format is invalid
- * @example
- * ```typescript
- * // Step 1: Fast on-chain data (no N+1 queries)
- * const grants = await vana.permissions.getUserPermissionGrantsOnChain();
- *
- * // Step 2: Lazy-load details for specific grant when needed
- * const grantFile = await retrieveGrantFile(grants[0].grantUrl);
- *
- * console.log(`Operation: ${grantFile.operation}`);
- * console.log(`Grantee: ${grantFile.grantee}`);
- * console.log(`Parameters:`, grantFile.parameters);
- *
- * // Only fetch details for grants user actually wants to see
- * for (const grant of selectedGrants) {
- *   const details = await retrieveGrantFile(grant.grantUrl);
- *   displayGrantDetails(details);
- * }
- * ```
- */
-declare function retrieveGrantFile(grantUrl: string, _relayerUrl?: string, downloadRelayer?: {
-    proxyDownload: (url: string) => Promise<Blob>;
-}): Promise<GrantFile>;
-/**
- * Generates a content hash for a grant file.
- * This can be used for integrity verification.
- *
- * @remarks
- * Creates a deterministic keccak256 hash of the grant file by first sorting
- * all object keys recursively to ensure consistent hashing regardless of
- * property order. This hash can be used to verify grant file integrity
- * or as a unique identifier.
- *
- * @param grantFile - The grant file to generate a hash for
- * @returns The keccak256 hash of the grant file as a hex string
- * @throws {SerializationError} When the grant file cannot be serialized
- * @example
- * ```typescript
- * const grantFile = {
- *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',
- *   operation: 'read',
- *   parameters: { version: '1.0', mode: 'full' }
- * };
- *
- * const hash = getGrantFileHash(grantFile);
- * console.log(`Grant file hash: ${hash}`);
- * // "0x1234567890abcdef..."
- *
- * // Same grant file with different property order produces same hash
- * const grantFile2 = {
- *   operation: 'read',
- *   parameters: { mode: 'full', version: '1.0' },
- *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36'
- * };
- *
- * const hash2 = getGrantFileHash(grantFile2);
- * console.log(hash === hash2); // true
- * ```
- */
-declare function getGrantFileHash(grantFile: GrantFile): string;
-/**
- * Validates that a grant file has the required structure.
- *
- * @remarks
- * Performs runtime validation to ensure data conforms to the GrantFile interface.
- * Checks for required fields (grantee, operation, parameters) and validates their
- * types and formats. This is a type guard function that enables TypeScript to
- * narrow the type when it returns true.
- *
- * @param data - The data to validate as a grant file
- * @returns True if the data is a valid grant file, false otherwise
- * @example
- * ```typescript
- * const unknownData = await fetch(url).then(r => r.json());
- *
- * if (validateGrantFile(unknownData)) {
- *   // TypeScript now knows unknownData is a GrantFile
- *   console.log(`Grant for operation: ${unknownData.operation}`);
- *   console.log(`Grantee: ${unknownData.grantee}`);
- * } else {
- *   throw new Error('Invalid grant file format');
- * }
- *
- * // Validation examples:
- * validateGrantFile({
- *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',
- *   operation: 'read',
- *   parameters: {}
- * }); // true
- *
- * validateGrantFile({
- *   grantee: 'invalid-address',
- *   operation: 'read',
- *   parameters: {}
- * }); // false (invalid address format)
- *
- * validateGrantFile({
- *   operation: 'read',
- *   parameters: {}
- * }); // false (missing grantee)
- * ```
- */
-declare function validateGrantFile(data: unknown): data is GrantFile;
-
-export { createGrantFile, getGrantFileHash, retrieveGrantFile, storeGrantFile, validateGrantFile };

package/dist/utils/grantValidation.d.cts

@@ -1,150 +0,0 @@
-import { Address } from 'viem';
-import { GrantFile } from '../types/permissions.cjs';
-
-/**
- * Base error class for grant validation failures
- *
- * @category Permissions
- */
-declare class GrantValidationError extends Error {
-    details?: Record<string, unknown> | undefined;
-    constructor(message: string, details?: Record<string, unknown> | undefined);
-}
-/**
- * Error thrown when a grant has expired
- *
- * @category Permissions
- */
-declare class GrantExpiredError extends GrantValidationError {
-    expires: number;
-    currentTime: number;
-    constructor(message: string, expires: number, currentTime: number);
-}
-/**
- * Error thrown when grantee doesn't match requesting address
- *
- * @category Permissions
- */
-declare class GranteeMismatchError extends GrantValidationError {
-    grantee: Address;
-    requestingAddress: Address;
-    constructor(message: string, grantee: Address, requestingAddress: Address);
-}
-/**
- * Error thrown when operation is not allowed by grant
- *
- * @category Permissions
- */
-declare class OperationNotAllowedError extends GrantValidationError {
-    grantedOperation: string;
-    requestedOperation: string;
-    constructor(message: string, grantedOperation: string, requestedOperation: string);
-}
-/**
- * Error thrown when grant file structure is invalid
- *
- * @category Permissions
- */
-declare class GrantSchemaError extends GrantValidationError {
-    schemaErrors: unknown[];
-    invalidData: unknown;
-    constructor(message: string, schemaErrors: unknown[], invalidData: unknown);
-}
-/**
- * Options for grant validation
- *
- * @category Permissions
- */
-interface GrantValidationOptions {
-    /** Enable JSON schema validation (default: true) */
-    schema?: boolean;
-    /** Grantee address to validate access for */
-    grantee?: Address;
-    /** Operation to validate permission for */
-    operation?: string;
-    /** Override current time for expiry checking (Unix timestamp) */
-    currentTime?: number;
-    /** Return detailed results instead of throwing (default: false) */
-    throwOnError?: boolean;
-}
-/**
- * Detailed validation result
- *
- * @category Permissions
- */
-interface GrantValidationResult {
-    /** Whether validation passed */
-    valid: boolean;
-    /** Validation errors encountered */
-    errors: Array<{
-        type: "schema" | "business";
-        field?: string;
-        message: string;
-        error?: Error;
-    }>;
-    /** The validated grant file (if validation passed) */
-    grant?: GrantFile;
-}
-/**
- * Validates a grant file with comprehensive schema and business rule checking.
- *
- * This function provides flexible validation with TypeScript overloads:
- * - When `throwOnError` is false (or `{ throwOnError: false }`), returns a detailed validation result
- * - When `throwOnError` is true (default), throws specific errors or returns the validated grant
- *
- * @param data - The grant file data to validate (unknown type for safety)
- * @param options - Validation options including grantee, operation, files, etc.
- * @returns Either a GrantFile (when throwing) or GrantValidationResult (when not throwing)
- * @throws {GrantSchemaError} When the grant file structure is invalid
- * @throws {GrantExpiredError} When the grant has expired
- * @throws {GranteeMismatchError} When the grantee doesn't match the requesting address
- * @throws {OperationNotAllowedError} When the requested operation is not allowed
- * @example
- * ```typescript
- * // Throwing mode (default) - returns GrantFile or throws
- * const grant = validateGrant(data, {
- *   grantee: '0x123...',
- *   operation: 'llm_inference',
- * });
- *
- * // Non-throwing mode - returns validation result
- * const result = validateGrant(data, {
- *   grantee: '0x123...',
- *   throwOnError: false
- * });
- * if (result.valid) {
- *   console.log('Grant is valid:', result.grant);
- * } else {
- *   console.log('Validation errors:', result.errors);
- * }
- * ```
- */
-declare function validateGrant(data: unknown, options: GrantValidationOptions & {
-    throwOnError: false;
-}): GrantValidationResult;
-declare function validateGrant(data: unknown, options?: Omit<GrantValidationOptions, "throwOnError"> | (GrantValidationOptions & {
-    throwOnError?: true;
-})): GrantFile;
-/**
- * Validates that a grant file allows access for a specific grantee
- *
- * @param grantFile - The grant file to validate access for
- * @param requestingAddress - The address requesting access to check against the grantee
- */
-declare function validateGranteeAccess(grantFile: GrantFile, requestingAddress: Address): void;
-/**
- * Validates that a grant has not expired (if expiry is set)
- *
- * @param grantFile - The grant file to check expiration for
- * @param currentTime - Optional override for current time (Unix timestamp)
- */
-declare function validateGrantExpiry(grantFile: GrantFile, currentTime?: number): void;
-/**
- * Validates that a grant allows a specific operation
- *
- * @param grantFile - The grant file to validate operation access for
- * @param requestedOperation - The operation being requested to validate against the grant
- */
-declare function validateOperationAccess(grantFile: GrantFile, requestedOperation: string): void;
-
-export { GrantExpiredError, GrantSchemaError, GrantValidationError, type GrantValidationOptions, type GrantValidationResult, GranteeMismatchError, OperationNotAllowedError, validateGrant, validateGrantExpiry, validateGranteeAccess, validateOperationAccess };

package/dist/utils/grants.d.cts

@@ -1,70 +0,0 @@
-import { Address } from 'viem';
-import { GrantPermissionParams, GrantFile } from '../types/permissions.cjs';
-
-/**
- * High-level utilities for working with grants in the Vana SDK
- */
-/**
- * Creates and validates a grant file from permission parameters
- *
- * @param params - The permission parameters to create and validate the grant from
- * @returns The validated grant file object
- */
-declare function createValidatedGrant(params: GrantPermissionParams): GrantFile;
-/**
- * Creates a grant file and stores it in IPFS
- *
- * @param params - The permission parameters to create the grant from
- * @param relayerUrl - The URL of the relayer service for IPFS storage
- * @returns Promise resolving to an object containing the grant file and its IPFS URL
- */
-declare function createAndStoreGrant(params: GrantPermissionParams, relayerUrl: string): Promise<{
-    grantFile: GrantFile;
-    grantUrl: string;
-}>;
-/**
- * Retrieves and validates a grant file from IPFS
- *
- * @param grantUrl - The IPFS URL of the grant file to retrieve
- * @param relayerUrl - Optional URL of the relayer service
- * @returns Promise resolving to the validated grant file
- */
-declare function retrieveAndValidateGrant(grantUrl: string, relayerUrl?: string): Promise<GrantFile>;
-/**
- * Checks if a grant allows access for a specific request
- *
- * @param grantUrl - The IPFS URL of the grant file to check
- * @param requestingAddress - The address making the access request
- * @param operation - The operation being requested
- * @param fileIds - Array of file IDs being accessed (currently unused but part of interface)
- * @param relayerUrl - Optional URL of the relayer service
- * @returns Promise resolving to access result with allowed status, reason, and grant file
- */
-declare function checkGrantAccess(grantUrl: string, requestingAddress: Address, operation: string, fileIds: number[], relayerUrl?: string): Promise<{
-    allowed: boolean;
-    reason?: string;
-    grantFile?: GrantFile;
-}>;
-/**
- * Utility to check if a grant has expired
- *
- * @param grantFile - The grant file to check for expiration
- * @returns True if the grant has expired, false otherwise
- */
-declare function isGrantExpired(grantFile: GrantFile): boolean;
-/**
- * Utility to get the time remaining before grant expires (in seconds)
- *
- * @param grantFile - The grant file to check time remaining for
- * @returns Number of seconds remaining, or null if no expiration is set
- */
-declare function getGrantTimeRemaining(grantFile: GrantFile): number | null;
-/**
- * Creates a human-readable summary of a grant
- *
- * @param grantFile - The grant file to create a summary for
- * @returns A human-readable string describing the grant
- */
-declare function summarizeGrant(grantFile: GrantFile): string;
-
-export { checkGrantAccess, createAndStoreGrant, createValidatedGrant, getGrantTimeRemaining, isGrantExpired, retrieveAndValidateGrant, summarizeGrant };

package/dist/utils/ipfs.d.cts

@@ -1,90 +0,0 @@
-/**
- * IPFS URL utilities for the Vana SDK
- *
- * Centralized functions for handling IPFS URLs, converting them to gateway URLs,
- * and extracting IPFS hashes from various URL formats.
- */
-/**
- * Default IPFS gateway URL
- */
-declare const DEFAULT_IPFS_GATEWAY = "https://dweb.link/ipfs/";
-/**
- * Alternative IPFS gateways for fallback - ordered by reliability and rate limits
- */
-declare const IPFS_GATEWAYS: readonly ["https://dweb.link/ipfs/", "https://ipfs.io/ipfs/", "https://cloudflare-ipfs.com/ipfs/", "https://gateway.pinata.cloud/ipfs/", "https://ipfs.filebase.io/ipfs/"];
-/**
- * Check if a URL is an IPFS URL (starts with ipfs://)
- *
- * @param url - The URL to check
- * @returns True if the URL is an IPFS URL
- */
-declare function isIpfsUrl(url: string): boolean;
-/**
- * Convert an IPFS URL to an HTTP gateway URL
- *
- * @param url - The IPFS URL to convert (e.g., "ipfs://QmHash...")
- * @param gateway - Optional gateway URL (defaults to DEFAULT_IPFS_GATEWAY)
- * @returns The HTTP gateway URL or original URL if not an IPFS URL
- * @example
- * ```ts
- * convertIpfsUrl("ipfs://QmHash123")
- * // Returns: "https://ipfs.io/ipfs/QmHash123"
- *
- * convertIpfsUrl("ipfs://QmHash123", "https://gateway.pinata.cloud/ipfs/")
- * // Returns: "https://gateway.pinata.cloud/ipfs/QmHash123"
- * ```
- */
-declare function convertIpfsUrl(url: string, gateway?: string): string;
-/**
- * Extract IPFS hash from various URL formats
- *
- * **Edge Cases:**
- * - Returns null for non-IPFS URLs or malformed hashes
- * - Handles both CIDv0 (starts with Qm) and CIDv1 formats
- * - Minimum 46 characters required for standalone hash detection
- * - Gateway paths with subdirectories are not supported
- *
- * @param url - The URL to extract hash from
- * @returns The IPFS hash or null if not found
- * @example
- * ```ts
- * extractIpfsHash("ipfs://QmHash123") // Returns: "QmHash123"
- * extractIpfsHash("https://gateway.pinata.cloud/ipfs/QmHash123") // Returns: "QmHash123"
- * extractIpfsHash("QmHash123456789012345678901234567890123456") // Returns: "QmHash123456789012345678901234567890123456"
- * extractIpfsHash("https://example.com/file.json") // Returns: null (not IPFS)
- * extractIpfsHash("ipfs://QmHash/subdirectory") // Returns: null (subdirectories not supported)
- * ```
- */
-declare function extractIpfsHash(url: string): string | null;
-/**
- * Get multiple gateway URLs for an IPFS hash (useful for fallback)
- *
- * @param hash - The IPFS hash
- * @returns Array of gateway URLs
- */
-declare function getGatewayUrls(hash: string): string[];
-/**
- * Convert an IPFS URL to multiple gateway URLs for fallback
- *
- * @param url - The IPFS URL
- * @returns Array of gateway URLs or original URL if not IPFS
- */
-declare function convertIpfsUrlWithFallbacks(url: string): string[];
-/**
- * Fetch content from IPFS with automatic gateway fallbacks
- *
- * **Edge Cases:**
- * - Non-IPFS URLs are fetched directly without fallback
- * - 10-second timeout per gateway attempt to prevent hanging
- * - Rate-limited gateways (429) are skipped immediately
- * - Exponential backoff between retries (1s, 2s, 3s, etc.)
- * - AbortSignal in options is merged with timeout signal
- *
- * @param url - The IPFS URL to fetch
- * @param options - Optional fetch options
- * @returns Promise resolving to Response object
- * @throws Error if all gateways fail
- */
-declare function fetchWithFallbacks(url: string, options?: RequestInit): Promise<Response>;
-
-export { DEFAULT_IPFS_GATEWAY, IPFS_GATEWAYS, convertIpfsUrl, convertIpfsUrlWithFallbacks, extractIpfsHash, fetchWithFallbacks, getGatewayUrls, isIpfsUrl };

package/dist/utils/lazy-import.d.cts

@@ -1,20 +0,0 @@
-/**
- * Utility for lazy-loading modules to avoid Turbopack TDZ issues
- *
- * WARNING: This is a workaround for Turbopack's strict module initialization.
- * Dependencies that access globals during init must be dynamically imported.
- */
-/**
- * Creates a lazy import function that caches the promise (not the module)
- * to avoid race conditions on concurrent first calls
- *
- * @param importFn - Function that returns a dynamic import promise
- * @returns Function that returns the cached import promise
- *
- * @example
- * const getOpenPGP = lazyImport(() => import('openpgp'));
- * const openpgp = await getOpenPGP();
- */
-declare function lazyImport<T>(importFn: () => Promise<T>): () => Promise<T>;
-
-export { lazyImport };