@opendatalabs/vana-sdk 0.1.0-alpha.fd33fc9 → 2.0.0

package/dist/types/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/utils.ts"],"sourcesContent":["import type { Address, Hash } from \"viem\";\n\n/**\n * Makes all properties in T optional except for those in K\n *\n * @remarks\n * This utility type is useful when you want to create a variant of an interface\n * where most properties are optional, but specific properties remain required.\n * Commonly used for update operations where only certain fields must be provided.\n *\n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name: string;\n *   email: string;\n *   age: number;\n * }\n *\n * // Only 'id' is required, all other properties are optional\n * type UserUpdate = PartialExcept<User, 'id'>;\n *\n * const update: UserUpdate = {\n *   id: '123', // Required\n *   name: 'John' // Optional\n *   // email and age are also optional\n * };\n * ```\n * @category Reference\n */\nexport type PartialExcept<T, K extends keyof T> = Partial<T> & Pick<T, K>;\n\n/**\n * Makes all properties in T required except for those in K\n *\n * @remarks\n * This utility type is useful when you want to create a variant of an interface\n * where most properties are required, but specific properties remain optional.\n * Commonly used for creation operations where most fields are mandatory.\n *\n * @example\n * ```typescript\n * interface Config {\n *   apiUrl: string;\n *   timeout?: number;\n *   retries?: number;\n *   debug?: boolean;\n * }\n *\n * // All properties required except 'debug'\n * type StrictConfig = RequiredExcept<Config, 'debug'>;\n *\n * const config: StrictConfig = {\n *   apiUrl: 'https://api.vana.com', // Required\n *   timeout: 5000, // Required (was optional, now required)\n *   retries: 3, // Required (was optional, now required)\n *   // debug remains optional\n * };\n * ```\n * @category Reference\n */\nexport type RequiredExcept<T, K extends keyof T> = Required<T> &\n  Partial<Pick<T, K>>;\n\n/**\n * Extracts the return type of a promise\n *\n * @remarks\n * This utility type unwraps the type contained within a Promise.\n * If the type is not a Promise, it returns the type unchanged.\n * Note: TypeScript 4.5+ includes a built-in Awaited type with similar functionality.\n *\n * @example\n * ```typescript\n * type AsyncString = Promise<string>;\n * type SyncString = string;\n *\n * // Extracts 'string' from Promise<string>\n * type Result1 = Awaited<AsyncString>; // string\n *\n * // Returns 'string' unchanged since it's not a Promise\n * type Result2 = Awaited<SyncString>; // string\n *\n * // Practical usage with async functions\n * async function fetchUser(): Promise<{ id: string; name: string }> {\n *   // ...\n * }\n *\n * type User = Awaited<ReturnType<typeof fetchUser>>; // { id: string; name: string }\n * ```\n * @category Reference\n */\nexport type Awaited<T> = T extends Promise<infer U> ? U : T;\n\n/**\n * Creates a type that accepts either T or a Promise<T>\n *\n * @remarks\n * This utility type is useful for functions that can work with both\n * synchronous and asynchronous values. It allows flexible APIs that\n * can accept immediate values or promises that resolve to those values.\n *\n * @example\n * ```typescript\n * // Function that accepts either a value or a promise of that value\n * async function processData(data: MaybePromise<string>): Promise<string> {\n *   // await works on both promises and regular values\n *   const resolved = await data;\n *   return resolved.toUpperCase();\n * }\n *\n * // Both calls are valid:\n * processData('hello'); // Synchronous value\n * processData(Promise.resolve('world')); // Asynchronous value\n *\n * // Common use case in SDK callbacks\n * interface StorageProvider {\n *   // Provider can implement sync or async file reading\n *   read(path: string): MaybePromise<Buffer>;\n * }\n * ```\n * @category Reference\n */\nexport type MaybePromise<T> = T | Promise<T>;\n\n/**\n * Creates a type that accepts either T or an array of T\n *\n * @remarks\n * This utility type is useful for functions that can accept either a single\n * value or an array of values, providing a more flexible API. The implementation\n * can normalize the input to always work with arrays internally.\n *\n * @example\n * ```typescript\n * // Function that accepts either a single ID or multiple IDs\n * function deleteItems(ids: MaybeArray<string>): void {\n *   // Normalize to array\n *   const idArray = Array.isArray(ids) ? ids : [ids];\n *   idArray.forEach(id => console.log(`Deleting ${id}`));\n * }\n *\n * // Both calls are valid:\n * deleteItems('item-1'); // Single item\n * deleteItems(['item-1', 'item-2', 'item-3']); // Multiple items\n *\n * // Common use case in permissions\n * interface GrantPermissionsParams {\n *   permissions: MaybeArray<Permission>;\n * }\n * ```\n * @category Reference\n */\nexport type MaybeArray<T> = T | T[];\n\n/**\n * Pagination parameters for controlling result set size and navigation.\n *\n * Used across SDK methods that return lists of items to control how many items\n * are returned and to navigate through large result sets efficiently.\n *\n * @category Reference\n * @example\n * ```typescript\n * const pagination: PaginationParams = {\n *   limit: 20, // Return 20 items\n *   offset: 40, // Skip first 40 items (page 3)\n *   cursor: 'eyJpZCI6MTIzfQ==' // Or use cursor-based pagination\n * };\n *\n * const files = await vana.data.getUserFiles({\n *   owner: userAddress,\n *   pagination\n * });\n * ```\n */\nexport interface PaginationParams {\n  /** Maximum number of items to return */\n  limit?: number;\n  /** Number of items to skip */\n  offset?: number;\n  /** Cursor for cursor-based pagination */\n  cursor?: string;\n}\n\n/**\n * Pagination result containing items and metadata for navigating large datasets.\n *\n * @remarks\n * This interface standardizes paginated responses across the SDK, providing\n * consistent metadata for implementing pagination UI components and handling\n * multi-page data fetching. Supports both offset-based and cursor-based pagination.\n *\n * @example\n * ```typescript\n * // Fetching paginated user files\n * async function getAllUserFiles(userAddress: string): Promise<File[]> {\n *   const allFiles: File[] = [];\n *   let cursor: string | undefined;\n *\n *   do {\n *     const result: PaginationResult<File> = await vana.data.getUserFiles({\n *       owner: userAddress,\n *       pagination: { limit: 50, cursor }\n *     });\n *\n *     allFiles.push(...result.items);\n *     cursor = result.nextCursor;\n *\n *     console.log(`Fetched ${result.count} of ${result.total} files`);\n *   } while (result.hasMore);\n *\n *   return allFiles;\n * }\n * ```\n * @category Reference\n */\nexport interface PaginationResult<T> {\n  /** Array of items */\n  items: T[];\n  /** Total number of items available */\n  total: number;\n  /** Number of items returned */\n  count: number;\n  /** Whether there are more items available */\n  hasMore: boolean;\n  /** Cursor for next page */\n  nextCursor?: string;\n}\n\n/**\n * Block range parameters for filtering blockchain events and transactions.\n *\n * @remarks\n * Used to specify a range of blocks when querying blockchain data.\n * Both parameters are optional - omitting fromBlock starts from genesis,\n * omitting toBlock goes to the latest block. Be cautious with large ranges\n * as they may result in heavy RPC loads or timeouts.\n *\n * @example\n * ```typescript\n * // Get events from the last 1000 blocks\n * const currentBlock = await vana.protocol.getBlockNumber();\n * const events = await vana.protocol.getEvents({\n *   blockRange: {\n *     fromBlock: currentBlock - 1000n,\n *     toBlock: currentBlock\n *   }\n * });\n *\n * // Get all historical events (use with caution)\n * const allEvents = await vana.protocol.getEvents({\n *   blockRange: {\n *     fromBlock: 0n\n *     // toBlock omitted = up to latest\n *   }\n * });\n * ```\n * @category Reference\n */\nexport interface BlockRange {\n  /** Starting block number */\n  fromBlock?: bigint;\n  /** Ending block number */\n  toBlock?: bigint;\n}\n\n/**\n * Transaction options for customizing blockchain transaction parameters.\n *\n * @remarks\n * Provides fine-grained control over transaction execution. Supports both\n * legacy (gasPrice) and EIP-1559 (maxFeePerGas) transaction types. When\n * not specified, the SDK will use appropriate defaults based on network\n * conditions. Use these options to optimize for speed or cost.\n *\n * @example\n * ```typescript\n * // High priority transaction with EIP-1559 pricing\n * await vana.permissions.grant(params, {\n *   maxFeePerGas: 100n * 10n ** 9n, // 100 gwei\n *   maxPriorityFeePerGas: 2n * 10n ** 9n, // 2 gwei tip\n * });\n *\n * // Legacy transaction with specific gas limit\n * await vana.data.registerFile(params, {\n *   gasLimit: 500000n,\n *   gasPrice: 50n * 10n ** 9n // 50 gwei\n * });\n *\n * // Send ETH with the transaction\n * await vana.protocol.execute(params, {\n *   value: 10n ** 18n, // 1 ETH\n *   gasLimit: 21000n\n * });\n * ```\n * @category Reference\n */\nexport interface TransactionOptions {\n  /** Gas limit */\n  gasLimit?: bigint;\n  /** Gas price */\n  gasPrice?: bigint;\n  /** Max fee per gas (EIP-1559) */\n  maxFeePerGas?: bigint;\n  /** Max priority fee per gas (EIP-1559) */\n  maxPriorityFeePerGas?: bigint;\n  /** Nonce */\n  nonce?: number;\n  /** Value to send with transaction */\n  value?: bigint;\n}\n\n/**\n * Transaction receipt with additional metadata for tracking transaction results.\n *\n * @remarks\n * Provides comprehensive information about executed transactions including\n * gas usage, success status, and emitted events. Use the logs array to\n * decode events emitted by smart contracts during transaction execution.\n * The receipt is available after a transaction is mined and included in a block.\n *\n * @example\n * ```typescript\n * // Execute transaction and wait for receipt\n * const receipt = await vana.permissions.grant({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   dataId: 123\n * });\n *\n * // Check transaction success\n * if (receipt.status === 'success') {\n *   console.log(`Gas used: ${receipt.gasUsed}`);\n *   console.log(`Block: ${receipt.blockNumber}`);\n *\n *   // Decode events from logs\n *   receipt.logs.forEach(log => {\n *     if (log.topics[0] === PERMISSION_GRANTED_TOPIC) {\n *       console.log('Permission granted event detected');\n *     }\n *   });\n * } else {\n *   console.error('Transaction reverted');\n * }\n * ```\n * @category Reference\n */\nexport interface TransactionReceipt {\n  /** Transaction hash */\n  transactionHash: Hash;\n  /** Block number */\n  blockNumber: bigint;\n  /** Block hash */\n  blockHash: Hash;\n  /** Gas used */\n  gasUsed: bigint;\n  /** Transaction status */\n  status: \"success\" | \"reverted\";\n  /** Contract address if contract deployment */\n  contractAddress?: Address;\n  /** Event logs */\n  logs: Array<{\n    address: Address;\n    topics: Hash[];\n    data: string;\n  }>;\n}\n\n/**\n * Response wrapper for API results providing consistent error handling.\n *\n * @remarks\n * Standardizes API responses across the SDK, making it easy to handle\n * both successful and failed requests. The generic type parameter T\n * represents the expected data type for successful responses. Check\n * the success flag before accessing data to ensure type safety.\n *\n * @example\n * ```typescript\n * // Handling API responses\n * async function fetchUserData(userId: string): Promise<User | null> {\n *   const response: ApiResponse<User> = await api.getUser(userId);\n *\n *   if (response.success) {\n *     console.log('User fetched:', response.data.name);\n *     // Access metadata if available\n *     if (response.metadata?.cached) {\n *       console.log('Data was cached');\n *     }\n *     return response.data;\n *   } else {\n *     console.error('Failed to fetch user:', response.error);\n *     return null;\n *   }\n * }\n *\n * // Type-safe error handling\n * interface UserData {\n *   id: string;\n *   name: string;\n * }\n *\n * const result: ApiResponse<UserData> = await api.call('/users/123');\n * if (result.success) {\n *   // TypeScript knows result.data is UserData here\n *   console.log(result.data.name);\n * }\n * ```\n * @category Reference\n */\nexport interface ApiResponse<T> {\n  /** Response data */\n  data: T;\n  /** Success status */\n  success: boolean;\n  /** Error message if not successful */\n  error?: string;\n  /** Additional metadata */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Retry configuration for handling transient failures with exponential backoff.\n *\n * @remarks\n * Configures automatic retry behavior for operations that may fail due to\n * temporary issues like network problems or rate limits. Supports exponential\n * backoff to avoid overwhelming services. The shouldRetry function allows\n * custom logic to determine which errors warrant a retry attempt.\n *\n * @example\n * ```typescript\n * // Simple retry configuration\n * const basicRetry: RetryConfig = {\n *   attempts: 3,\n *   delay: 1000 // 1 second between retries\n * };\n *\n * // Exponential backoff configuration\n * const exponentialRetry: RetryConfig = {\n *   attempts: 5,\n *   delay: 1000,\n *   backoffMultiplier: 2, // Double delay each time\n *   maxDelay: 30000, // Cap at 30 seconds\n *   shouldRetry: (error) => {\n *     // Only retry network and timeout errors\n *     return error.name === 'NetworkError' ||\n *            error.message.includes('timeout');\n *   }\n * };\n *\n * // Usage with SDK\n * const vana = new Vana({\n *   retryConfig: exponentialRetry\n * });\n * ```\n * @category Reference\n */\nexport interface RetryConfig {\n  /** Number of retry attempts */\n  attempts: number;\n  /** Delay between retries in milliseconds */\n  delay: number;\n  /** Backoff multiplier */\n  backoffMultiplier?: number;\n  /** Maximum delay in milliseconds */\n  maxDelay?: number;\n  /** Function to determine if error should be retried */\n  shouldRetry?: (error: Error) => boolean;\n}\n\n/**\n * Cache configuration for optimizing repeated data fetches.\n *\n * @remarks\n * Configures in-memory caching behavior to reduce redundant API calls and\n * improve performance. The cache automatically evicts expired entries based\n * on TTL and removes least-recently-used items when maxSize is reached.\n * Use appropriate TTL values based on your data freshness requirements.\n *\n * @example\n * ```typescript\n * // Short-lived cache for frequently changing data\n * const userCache: CacheConfig = {\n *   ttl: 60000, // 1 minute\n *   maxSize: 100, // Store up to 100 users\n *   prefix: 'user:' // Cache keys like 'user:123'\n * };\n *\n * // Long-lived cache for stable data\n * const schemaCache: CacheConfig = {\n *   ttl: 3600000, // 1 hour\n *   maxSize: 1000, // Store up to 1000 schemas\n *   prefix: 'schema:'\n * };\n *\n * // Disable caching by setting TTL to 0\n * const noCache: CacheConfig = {\n *   ttl: 0 // No caching\n * };\n * ```\n * @category Reference\n */\nexport interface CacheConfig {\n  /** Cache TTL in milliseconds */\n  ttl: number;\n  /** Maximum cache size */\n  maxSize?: number;\n  /** Cache key prefix */\n  prefix?: string;\n}\n\n/**\n * Validation result for data integrity checks and schema validation.\n *\n * @remarks\n * Provides detailed feedback about validation outcomes, distinguishing between\n * errors (which prevent processing) and warnings (which indicate potential issues).\n * Used throughout the SDK for validating permissions, file formats, schemas,\n * and API parameters before operations.\n *\n * @example\n * ```typescript\n * // Validating user input\n * function validateFileUpload(file: File): ValidationResult {\n *   const errors: string[] = [];\n *   const warnings: string[] = [];\n *\n *   // Check file size\n *   if (file.size > 100 * 1024 * 1024) {\n *     errors.push('File size exceeds 100MB limit');\n *   } else if (file.size > 50 * 1024 * 1024) {\n *     warnings.push('Large file may take time to upload');\n *   }\n *\n *   // Check file type\n *   if (!file.type.startsWith('image/')) {\n *     errors.push('Only image files are allowed');\n *   }\n *\n *   return {\n *     valid: errors.length === 0,\n *     errors,\n *     warnings\n *   };\n * }\n *\n * // Using validation result\n * const result = validateFileUpload(file);\n * if (!result.valid) {\n *   console.error('Validation failed:', result.errors.join(', '));\n * } else {\n *   if (result.warnings.length > 0) {\n *     console.warn('Warnings:', result.warnings.join(', '));\n *   }\n *   // Proceed with upload\n * }\n * ```\n * @category Reference\n */\nexport interface ValidationResult {\n  /** Whether validation passed */\n  valid: boolean;\n  /** Validation errors */\n  errors: string[];\n  /** Validation warnings */\n  warnings: string[];\n}\n\n/**\n * Status information for health checks and service monitoring.\n *\n * @remarks\n * Used to report the health status of various SDK components including\n * storage providers, RPC connections, and personal servers. The details\n * field can contain provider-specific information for debugging.\n * Timestamps use Unix epoch milliseconds.\n *\n * @example\n * ```typescript\n * // Checking storage provider health\n * const status: StatusInfo = await storage.getStatus();\n *\n * if (!status.healthy) {\n *   console.error(`Storage unhealthy: ${status.message}`);\n *   // Check how long the issue has persisted\n *   const downtime = Date.now() - status.lastCheck;\n *   if (downtime > 300000) { // 5 minutes\n *     // Switch to backup provider\n *   }\n * }\n *\n * // Detailed status with custom fields\n * const serverStatus: StatusInfo = {\n *   healthy: true,\n *   message: 'All systems operational',\n *   lastCheck: Date.now(),\n *   details: {\n *     uptime: 3600000, // 1 hour\n *     requestsServed: 1234,\n *     avgResponseTime: 145, // ms\n *     activeConnections: 23\n *   }\n * };\n * ```\n * @category Reference\n */\nexport interface StatusInfo {\n  /** Whether the service is healthy */\n  healthy: boolean;\n  /** Status message */\n  message?: string;\n  /** Last check timestamp */\n  lastCheck: number;\n  /** Additional status details */\n  details?: Record<string, unknown>;\n}\n\n/**\n * Rate limit information for API throttling and quota management.\n *\n * @remarks\n * Provides visibility into rate limiting status to help applications\n * implement appropriate backoff strategies. Rate limits protect services\n * from overload and ensure fair resource usage. Use this information\n * to pace requests and avoid hitting limits.\n *\n * @example\n * ```typescript\n * // Check rate limit before making requests\n * const rateLimit: RateLimitInfo = await api.getRateLimit();\n *\n * console.log(`Requests: ${rateLimit.requests}/${rateLimit.limit}`);\n * console.log(`Resets in: ${rateLimit.resetTime} seconds`);\n *\n * // Implement backoff if approaching limit\n * if (rateLimit.requests >= rateLimit.limit * 0.9) {\n *   console.warn('Approaching rate limit, slowing down');\n *   await new Promise(resolve =>\n *     setTimeout(resolve, rateLimit.resetTime * 1000)\n *   );\n * }\n *\n * // Calculate requests per second allowed\n * const rps = rateLimit.limit / rateLimit.window;\n * console.log(`Max ${rps} requests per second allowed`);\n * ```\n * @category Reference\n */\nexport interface RateLimitInfo {\n  /** Current request count */\n  requests: number;\n  /** Maximum requests allowed */\n  limit: number;\n  /** Time window in seconds */\n  window: number;\n  /** Time until reset in seconds */\n  resetTime: number;\n}\n\n/**\n * File upload progress tracking for user feedback and monitoring.\n *\n * @remarks\n * Provides real-time progress information during file uploads, enabling\n * applications to show progress bars and estimated completion times.\n * The speed calculation is typically based on a rolling average to\n * smooth out network fluctuations.\n *\n * @example\n * ```typescript\n * // Upload with progress tracking\n * await vana.data.upload(file, {\n *   onProgress: (progress: UploadProgress) => {\n *     // Update progress bar\n *     progressBar.style.width = `${progress.percentage}%`;\n *\n *     // Show upload speed\n *     const speedMBps = (progress.speed / 1024 / 1024).toFixed(2);\n *     speedDisplay.textContent = `${speedMBps} MB/s`;\n *\n *     // Show time remaining\n *     const minutes = Math.floor(progress.estimatedTimeRemaining / 60);\n *     const seconds = progress.estimatedTimeRemaining % 60;\n *     timeDisplay.textContent = `${minutes}:${seconds.toString().padStart(2, '0')}`;\n *\n *     // Log progress milestones\n *     if (progress.percentage === 25 ||\n *         progress.percentage === 50 ||\n *         progress.percentage === 75) {\n *       console.log(`Upload ${progress.percentage}% complete`);\n *     }\n *   }\n * });\n * ```\n * @category Reference\n */\nexport interface UploadProgress {\n  /** Bytes uploaded */\n  loaded: number;\n  /** Total bytes to upload */\n  total: number;\n  /** Upload percentage (0-100) */\n  percentage: number;\n  /** Upload speed in bytes per second */\n  speed: number;\n  /** Estimated time remaining in seconds */\n  estimatedTimeRemaining: number;\n}\n\n/**\n * Network information for blockchain connectivity and monitoring.\n *\n * @remarks\n * Provides comprehensive details about the connected blockchain network,\n * including configuration URLs and real-time status. Use this information\n * to verify network connectivity, display network details to users, and\n * construct explorer links for transactions.\n *\n * @example\n * ```typescript\n * // Get current network info\n * const network: NetworkInfo = await vana.protocol.getNetworkInfo();\n *\n * console.log(`Connected to: ${network.chainName} (ID: ${network.chainId})`);\n * console.log(`Current block: ${network.currentBlock}`);\n *\n * // Check network health\n * if (network.status !== 'healthy') {\n *   console.warn(`Network ${network.status}: consider switching RPC`);\n * }\n *\n * // Generate explorer link for transaction\n * function getExplorerLink(txHash: string): string {\n *   if (!network.explorerUrl) {\n *     return `Transaction: ${txHash}`;\n *   }\n *   return `${network.explorerUrl}/tx/${txHash}`;\n * }\n *\n * // Verify expected network\n * const EXPECTED_CHAIN_ID = 1337; // Vana testnet\n * if (network.chainId !== EXPECTED_CHAIN_ID) {\n *   throw new Error(`Wrong network! Expected ${EXPECTED_CHAIN_ID}, got ${network.chainId}`);\n * }\n * ```\n * @category Reference\n */\nexport interface NetworkInfo {\n  /** Chain ID */\n  chainId: number;\n  /** Chain name */\n  chainName: string;\n  /** RPC URL */\n  rpcUrl: string;\n  /** Block explorer URL */\n  explorerUrl?: string;\n  /** Current block number */\n  currentBlock: bigint;\n  /** Network status */\n  status: \"healthy\" | \"degraded\" | \"down\";\n}\n\n/**\n * Gas estimate information for transaction cost prediction.\n *\n * @remarks\n * Provides detailed gas pricing estimates to help users understand transaction\n * costs before execution. Supports both legacy (gasPrice) and EIP-1559\n * (maxFeePerGas) pricing models. The estimatedCost is calculated based on\n * current network conditions and may vary by the time of actual execution.\n *\n * @example\n * ```typescript\n * // Get gas estimate before transaction\n * const estimate: GasEstimate = await vana.permissions.estimateGas({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   dataId: 123\n * });\n *\n * // Convert to human-readable format\n * const costInEth = Number(estimate.estimatedCost) / 1e18;\n * console.log(`Estimated cost: ${costInEth.toFixed(6)} ETH`);\n *\n * // Check if user has sufficient balance\n * const balance = await vana.protocol.getBalance(userAddress);\n * if (balance < estimate.estimatedCost) {\n *   throw new Error(`Insufficient balance. Need ${costInEth} ETH`);\n * }\n *\n * // Use estimate for transaction with buffer\n * await vana.permissions.grant(params, {\n *   gasLimit: estimate.gasLimit * 110n / 100n, // 10% buffer\n *   maxFeePerGas: estimate.maxFeePerGas,\n *   maxPriorityFeePerGas: estimate.maxPriorityFeePerGas\n * });\n * ```\n * @category Reference\n */\nexport interface GasEstimate {\n  /** Gas limit */\n  gasLimit: bigint;\n  /** Gas price */\n  gasPrice: bigint;\n  /** Max fee per gas */\n  maxFeePerGas?: bigint;\n  /** Max priority fee per gas */\n  maxPriorityFeePerGas?: bigint;\n  /** Estimated cost in wei */\n  estimatedCost: bigint;\n}\n\n/**\n * Time range parameters for filtering operations by time period.\n *\n * Used in various SDK methods to specify date/time ranges for queries,\n * analytics, and data filtering operations. Times are specified as Unix timestamps.\n *\n * @category Reference\n * @example\n * ```typescript\n * const lastWeek: TimeRange = {\n *   from: Date.now() - (7 * 24 * 60 * 60 * 1000), // 7 days ago\n *   to: Date.now()\n * };\n *\n * const permissions = await vana.permissions.getUserPermissions({\n *   timeRange: lastWeek\n * });\n * ```\n */\nexport interface TimeRange {\n  /** Start time (Unix timestamp) */\n  from?: number;\n  /** End time (Unix timestamp) */\n  to?: number;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}
+{"version":3,"sources":["../../src/types/utils.ts"],"sourcesContent":["import type { Address, Hash } from \"viem\";\n\n/**\n * Makes all properties in T optional except for those in K\n *\n * @remarks\n * This utility type is useful when you want to create a variant of an interface\n * where most properties are optional, but specific properties remain required.\n * Commonly used for update operations where only certain fields must be provided.\n *\n * @example\n * ```typescript\n * interface User {\n *   id: string;\n *   name: string;\n *   email: string;\n *   age: number;\n * }\n *\n * // Only 'id' is required, all other properties are optional\n * type UserUpdate = PartialExcept<User, 'id'>;\n *\n * const update: UserUpdate = {\n *   id: '123', // Required\n *   name: 'John' // Optional\n *   // email and age are also optional\n * };\n * ```\n * @category Reference\n */\nexport type PartialExcept<T, K extends keyof T> = Partial<T> & Pick<T, K>;\n\n/**\n * Makes all properties in T required except for those in K\n *\n * @remarks\n * This utility type is useful when you want to create a variant of an interface\n * where most properties are required, but specific properties remain optional.\n * Commonly used for creation operations where most fields are mandatory.\n *\n * @example\n * ```typescript\n * interface Config {\n *   apiUrl: string;\n *   timeout?: number;\n *   retries?: number;\n *   debug?: boolean;\n * }\n *\n * // All properties required except 'debug'\n * type StrictConfig = RequiredExcept<Config, 'debug'>;\n *\n * const config: StrictConfig = {\n *   apiUrl: 'https://api.vana.com', // Required\n *   timeout: 5000, // Required (was optional, now required)\n *   retries: 3, // Required (was optional, now required)\n *   // debug remains optional\n * };\n * ```\n * @category Reference\n */\nexport type RequiredExcept<T, K extends keyof T> = Required<T> &\n  Partial<Pick<T, K>>;\n\n/**\n * Extracts the return type of a promise\n *\n * @remarks\n * This utility type unwraps the type contained within a Promise.\n * If the type is not a Promise, it returns the type unchanged.\n * Note: TypeScript 4.5+ includes a built-in Awaited type with similar functionality.\n *\n * @example\n * ```typescript\n * type AsyncString = Promise<string>;\n * type SyncString = string;\n *\n * // Extracts 'string' from Promise<string>\n * type Result1 = Awaited<AsyncString>; // string\n *\n * // Returns 'string' unchanged since it's not a Promise\n * type Result2 = Awaited<SyncString>; // string\n *\n * // Practical usage with async functions\n * async function fetchUser(): Promise<{ id: string; name: string }> {\n *   // ...\n * }\n *\n * type User = Awaited<ReturnType<typeof fetchUser>>; // { id: string; name: string }\n * ```\n * @category Reference\n */\nexport type Awaited<T> = T extends Promise<infer U> ? U : T;\n\n/**\n * Creates a type that accepts either T or a Promise<T>\n *\n * @remarks\n * This utility type is useful for functions that can work with both\n * synchronous and asynchronous values. It allows flexible APIs that\n * can accept immediate values or promises that resolve to those values.\n *\n * @example\n * ```typescript\n * // Function that accepts either a value or a promise of that value\n * async function processData(data: MaybePromise<string>): Promise<string> {\n *   // await works on both promises and regular values\n *   const resolved = await data;\n *   return resolved.toUpperCase();\n * }\n *\n * // Both calls are valid:\n * processData('hello'); // Synchronous value\n * processData(Promise.resolve('world')); // Asynchronous value\n *\n * // Common use case in SDK callbacks\n * interface StorageProvider {\n *   // Provider can implement sync or async file reading\n *   read(path: string): MaybePromise<Buffer>;\n * }\n * ```\n * @category Reference\n */\nexport type MaybePromise<T> = T | Promise<T>;\n\n/**\n * Creates a type that accepts either T or an array of T\n *\n * @remarks\n * This utility type is useful for functions that can accept either a single\n * value or an array of values, providing a more flexible API. The implementation\n * can normalize the input to always work with arrays internally.\n *\n * @example\n * ```typescript\n * // Function that accepts either a single ID or multiple IDs\n * function deleteItems(ids: MaybeArray<string>): void {\n *   // Normalize to array\n *   const idArray = Array.isArray(ids) ? ids : [ids];\n *   idArray.forEach(id => console.log(`Deleting ${id}`));\n * }\n *\n * // Both calls are valid:\n * deleteItems('item-1'); // Single item\n * deleteItems(['item-1', 'item-2', 'item-3']); // Multiple items\n *\n * // Common use case in permissions\n * interface GrantPermissionsParams {\n *   permissions: MaybeArray<Permission>;\n * }\n * ```\n * @category Reference\n */\nexport type MaybeArray<T> = T | T[];\n\n/**\n * Pagination parameters for controlling result set size and navigation.\n *\n * Used across SDK methods that return lists of items to control how many items\n * are returned and to navigate through large result sets efficiently.\n *\n * @category Reference\n * @example\n * ```typescript\n * const pagination: PaginationParams = {\n *   limit: 20, // Return 20 items\n *   offset: 40, // Skip first 40 items (page 3)\n *   cursor: 'eyJpZCI6MTIzfQ==' // Or use cursor-based pagination\n * };\n *\n * const files = await vana.data.getUserFiles({\n *   owner: userAddress,\n *   pagination\n * });\n * ```\n */\nexport interface PaginationParams {\n  /** Maximum number of items to return */\n  limit?: number;\n  /** Number of items to skip */\n  offset?: number;\n  /** Cursor for cursor-based pagination */\n  cursor?: string;\n}\n\n/**\n * Pagination result containing items and metadata for navigating large datasets.\n *\n * @remarks\n * This interface standardizes paginated responses across the SDK, providing\n * consistent metadata for implementing pagination UI components and handling\n * multi-page data fetching. Supports both offset-based and cursor-based pagination.\n *\n * @example\n * ```typescript\n * // Fetching paginated user files\n * async function getAllUserFiles(userAddress: string): Promise<File[]> {\n *   const allFiles: File[] = [];\n *   let cursor: string | undefined;\n *\n *   do {\n *     const result: PaginationResult<File> = await vana.data.getUserFiles({\n *       owner: userAddress,\n *       pagination: { limit: 50, cursor }\n *     });\n *\n *     allFiles.push(...result.items);\n *     cursor = result.nextCursor;\n *\n *     console.log(`Fetched ${result.count} of ${result.total} files`);\n *   } while (result.hasMore);\n *\n *   return allFiles;\n * }\n * ```\n * @category Reference\n */\nexport interface PaginationResult<T> {\n  /** Array of items */\n  items: T[];\n  /** Total number of items available */\n  total: number;\n  /** Number of items returned */\n  count: number;\n  /** Whether there are more items available */\n  hasMore: boolean;\n  /** Cursor for next page */\n  nextCursor?: string;\n}\n\n/**\n * Block range parameters for filtering blockchain events and transactions.\n *\n * @remarks\n * Used to specify a range of blocks when querying blockchain data.\n * Both parameters are optional - omitting fromBlock starts from genesis,\n * omitting toBlock goes to the latest block. Be cautious with large ranges\n * as they may result in heavy RPC loads or timeouts.\n *\n * @example\n * ```typescript\n * // Get events from the last 1000 blocks\n * const currentBlock = await vana.protocol.getBlockNumber();\n * const events = await vana.protocol.getEvents({\n *   blockRange: {\n *     fromBlock: currentBlock - 1000n,\n *     toBlock: currentBlock\n *   }\n * });\n *\n * // Get all historical events (use with caution)\n * const allEvents = await vana.protocol.getEvents({\n *   blockRange: {\n *     fromBlock: 0n\n *     // toBlock omitted = up to latest\n *   }\n * });\n * ```\n * @category Reference\n */\nexport interface BlockRange {\n  /** Starting block number */\n  fromBlock?: bigint;\n  /** Ending block number */\n  toBlock?: bigint;\n}\n\n/**\n * Transaction receipt with additional metadata for tracking transaction results.\n *\n * @remarks\n * Provides comprehensive information about executed transactions including\n * gas usage, success status, and emitted events. Use the logs array to\n * decode events emitted by smart contracts during transaction execution.\n * The receipt is available after a transaction is mined and included in a block.\n *\n * @example\n * ```typescript\n * // Execute transaction and wait for receipt\n * const receipt = await vana.permissions.grant({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   dataId: 123\n * });\n *\n * // Check transaction success\n * if (receipt.status === 'success') {\n *   console.log(`Gas used: ${receipt.gasUsed}`);\n *   console.log(`Block: ${receipt.blockNumber}`);\n *\n *   // Decode events from logs\n *   receipt.logs.forEach(log => {\n *     if (log.topics[0] === PERMISSION_GRANTED_TOPIC) {\n *       console.log('Permission granted event detected');\n *     }\n *   });\n * } else {\n *   console.error('Transaction reverted');\n * }\n * ```\n * @category Reference\n */\nexport interface TransactionReceipt {\n  /** Transaction hash */\n  transactionHash: Hash;\n  /** Block number */\n  blockNumber: bigint;\n  /** Block hash */\n  blockHash: Hash;\n  /** Gas used */\n  gasUsed: bigint;\n  /** Transaction status */\n  status: \"success\" | \"reverted\";\n  /** Contract address if contract deployment */\n  contractAddress?: Address;\n  /** Event logs */\n  logs: Array<{\n    address: Address;\n    topics: Hash[];\n    data: string;\n  }>;\n}\n\n/**\n * Response wrapper for API results providing consistent error handling.\n *\n * @remarks\n * Standardizes API responses across the SDK, making it easy to handle\n * both successful and failed requests. The generic type parameter T\n * represents the expected data type for successful responses. Check\n * the success flag before accessing data to ensure type safety.\n *\n * @example\n * ```typescript\n * // Handling API responses\n * async function fetchUserData(userId: string): Promise<User | null> {\n *   const response: ApiResponse<User> = await api.getUser(userId);\n *\n *   if (response.success) {\n *     console.log('User fetched:', response.data.name);\n *     // Access metadata if available\n *     if (response.metadata?.cached) {\n *       console.log('Data was cached');\n *     }\n *     return response.data;\n *   } else {\n *     console.error('Failed to fetch user:', response.error);\n *     return null;\n *   }\n * }\n *\n * // Type-safe error handling\n * interface UserData {\n *   id: string;\n *   name: string;\n * }\n *\n * const result: ApiResponse<UserData> = await api.call('/users/123');\n * if (result.success) {\n *   // TypeScript knows result.data is UserData here\n *   console.log(result.data.name);\n * }\n * ```\n * @category Reference\n */\nexport interface ApiResponse<T> {\n  /** Response data */\n  data: T;\n  /** Success status */\n  success: boolean;\n  /** Error message if not successful */\n  error?: string;\n  /** Additional metadata */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Retry configuration for handling transient failures with exponential backoff.\n *\n * @remarks\n * Configures automatic retry behavior for operations that may fail due to\n * temporary issues like network problems or rate limits. Supports exponential\n * backoff to avoid overwhelming services. The shouldRetry function allows\n * custom logic to determine which errors warrant a retry attempt.\n *\n * @example\n * ```typescript\n * // Simple retry configuration\n * const basicRetry: RetryConfig = {\n *   attempts: 3,\n *   delay: 1000 // 1 second between retries\n * };\n *\n * // Exponential backoff configuration\n * const exponentialRetry: RetryConfig = {\n *   attempts: 5,\n *   delay: 1000,\n *   backoffMultiplier: 2, // Double delay each time\n *   maxDelay: 30000, // Cap at 30 seconds\n *   shouldRetry: (error) => {\n *     // Only retry network and timeout errors\n *     return error.name === 'NetworkError' ||\n *            error.message.includes('timeout');\n *   }\n * };\n *\n * // Usage with SDK\n * const vana = new Vana({\n *   retryConfig: exponentialRetry\n * });\n * ```\n * @category Reference\n */\nexport interface RetryConfig {\n  /** Number of retry attempts */\n  attempts: number;\n  /** Delay between retries in milliseconds */\n  delay: number;\n  /** Backoff multiplier */\n  backoffMultiplier?: number;\n  /** Maximum delay in milliseconds */\n  maxDelay?: number;\n  /** Function to determine if error should be retried */\n  shouldRetry?: (error: Error) => boolean;\n}\n\n/**\n * Cache configuration for optimizing repeated data fetches.\n *\n * @remarks\n * Configures in-memory caching behavior to reduce redundant API calls and\n * improve performance. The cache automatically evicts expired entries based\n * on TTL and removes least-recently-used items when maxSize is reached.\n * Use appropriate TTL values based on your data freshness requirements.\n *\n * @example\n * ```typescript\n * // Short-lived cache for frequently changing data\n * const userCache: CacheConfig = {\n *   ttl: 60000, // 1 minute\n *   maxSize: 100, // Store up to 100 users\n *   prefix: 'user:' // Cache keys like 'user:123'\n * };\n *\n * // Long-lived cache for stable data\n * const schemaCache: CacheConfig = {\n *   ttl: 3600000, // 1 hour\n *   maxSize: 1000, // Store up to 1000 schemas\n *   prefix: 'schema:'\n * };\n *\n * // Disable caching by setting TTL to 0\n * const noCache: CacheConfig = {\n *   ttl: 0 // No caching\n * };\n * ```\n * @category Reference\n */\nexport interface CacheConfig {\n  /** Cache TTL in milliseconds */\n  ttl: number;\n  /** Maximum cache size */\n  maxSize?: number;\n  /** Cache key prefix */\n  prefix?: string;\n}\n\n/**\n * Validation result for data integrity checks and schema validation.\n *\n * @remarks\n * Provides detailed feedback about validation outcomes, distinguishing between\n * errors (which prevent processing) and warnings (which indicate potential issues).\n * Used throughout the SDK for validating permissions, file formats, schemas,\n * and API parameters before operations.\n *\n * @example\n * ```typescript\n * // Validating user input\n * function validateFileUpload(file: File): ValidationResult {\n *   const errors: string[] = [];\n *   const warnings: string[] = [];\n *\n *   // Check file size\n *   if (file.size > 100 * 1024 * 1024) {\n *     errors.push('File size exceeds 100MB limit');\n *   } else if (file.size > 50 * 1024 * 1024) {\n *     warnings.push('Large file may take time to upload');\n *   }\n *\n *   // Check file type\n *   if (!file.type.startsWith('image/')) {\n *     errors.push('Only image files are allowed');\n *   }\n *\n *   return {\n *     valid: errors.length === 0,\n *     errors,\n *     warnings\n *   };\n * }\n *\n * // Using validation result\n * const result = validateFileUpload(file);\n * if (!result.valid) {\n *   console.error('Validation failed:', result.errors.join(', '));\n * } else {\n *   if (result.warnings.length > 0) {\n *     console.warn('Warnings:', result.warnings.join(', '));\n *   }\n *   // Proceed with upload\n * }\n * ```\n * @category Reference\n */\nexport interface ValidationResult {\n  /** Whether validation passed */\n  valid: boolean;\n  /** Validation errors */\n  errors: string[];\n  /** Validation warnings */\n  warnings: string[];\n}\n\n/**\n * Status information for health checks and service monitoring.\n *\n * @remarks\n * Used to report the health status of various SDK components including\n * storage providers, RPC connections, and personal servers. The details\n * field can contain provider-specific information for debugging.\n * Timestamps use Unix epoch milliseconds.\n *\n * @example\n * ```typescript\n * // Checking storage provider health\n * const status: StatusInfo = await storage.getStatus();\n *\n * if (!status.healthy) {\n *   console.error(`Storage unhealthy: ${status.message}`);\n *   // Check how long the issue has persisted\n *   const downtime = Date.now() - status.lastCheck;\n *   if (downtime > 300000) { // 5 minutes\n *     // Switch to backup provider\n *   }\n * }\n *\n * // Detailed status with custom fields\n * const serverStatus: StatusInfo = {\n *   healthy: true,\n *   message: 'All systems operational',\n *   lastCheck: Date.now(),\n *   details: {\n *     uptime: 3600000, // 1 hour\n *     requestsServed: 1234,\n *     avgResponseTime: 145, // ms\n *     activeConnections: 23\n *   }\n * };\n * ```\n * @category Reference\n */\nexport interface StatusInfo {\n  /** Whether the service is healthy */\n  healthy: boolean;\n  /** Status message */\n  message?: string;\n  /** Last check timestamp */\n  lastCheck: number;\n  /** Additional status details */\n  details?: Record<string, unknown>;\n}\n\n/**\n * Rate limit information for API throttling and quota management.\n *\n * @remarks\n * Provides visibility into rate limiting status to help applications\n * implement appropriate backoff strategies. Rate limits protect services\n * from overload and ensure fair resource usage. Use this information\n * to pace requests and avoid hitting limits.\n *\n * @example\n * ```typescript\n * // Check rate limit before making requests\n * const rateLimit: RateLimitInfo = await api.getRateLimit();\n *\n * console.log(`Requests: ${rateLimit.requests}/${rateLimit.limit}`);\n * console.log(`Resets in: ${rateLimit.resetTime} seconds`);\n *\n * // Implement backoff if approaching limit\n * if (rateLimit.requests >= rateLimit.limit * 0.9) {\n *   console.warn('Approaching rate limit, slowing down');\n *   await new Promise(resolve =>\n *     setTimeout(resolve, rateLimit.resetTime * 1000)\n *   );\n * }\n *\n * // Calculate requests per second allowed\n * const rps = rateLimit.limit / rateLimit.window;\n * console.log(`Max ${rps} requests per second allowed`);\n * ```\n * @category Reference\n */\nexport interface RateLimitInfo {\n  /** Current request count */\n  requests: number;\n  /** Maximum requests allowed */\n  limit: number;\n  /** Time window in seconds */\n  window: number;\n  /** Time until reset in seconds */\n  resetTime: number;\n}\n\n/**\n * File upload progress tracking for user feedback and monitoring.\n *\n * @remarks\n * Provides real-time progress information during file uploads, enabling\n * applications to show progress bars and estimated completion times.\n * The speed calculation is typically based on a rolling average to\n * smooth out network fluctuations.\n *\n * @example\n * ```typescript\n * // Upload with progress tracking\n * await vana.data.upload(file, {\n *   onProgress: (progress: UploadProgress) => {\n *     // Update progress bar\n *     progressBar.style.width = `${progress.percentage}%`;\n *\n *     // Show upload speed\n *     const speedMBps = (progress.speed / 1024 / 1024).toFixed(2);\n *     speedDisplay.textContent = `${speedMBps} MB/s`;\n *\n *     // Show time remaining\n *     const minutes = Math.floor(progress.estimatedTimeRemaining / 60);\n *     const seconds = progress.estimatedTimeRemaining % 60;\n *     timeDisplay.textContent = `${minutes}:${seconds.toString().padStart(2, '0')}`;\n *\n *     // Log progress milestones\n *     if (progress.percentage === 25 ||\n *         progress.percentage === 50 ||\n *         progress.percentage === 75) {\n *       console.log(`Upload ${progress.percentage}% complete`);\n *     }\n *   }\n * });\n * ```\n * @category Reference\n */\nexport interface UploadProgress {\n  /** Bytes uploaded */\n  loaded: number;\n  /** Total bytes to upload */\n  total: number;\n  /** Upload percentage (0-100) */\n  percentage: number;\n  /** Upload speed in bytes per second */\n  speed: number;\n  /** Estimated time remaining in seconds */\n  estimatedTimeRemaining: number;\n}\n\n/**\n * Network information for blockchain connectivity and monitoring.\n *\n * @remarks\n * Provides comprehensive details about the connected blockchain network,\n * including configuration URLs and real-time status. Use this information\n * to verify network connectivity, display network details to users, and\n * construct explorer links for transactions.\n *\n * @example\n * ```typescript\n * // Get current network info\n * const network: NetworkInfo = await vana.protocol.getNetworkInfo();\n *\n * console.log(`Connected to: ${network.chainName} (ID: ${network.chainId})`);\n * console.log(`Current block: ${network.currentBlock}`);\n *\n * // Check network health\n * if (network.status !== 'healthy') {\n *   console.warn(`Network ${network.status}: consider switching RPC`);\n * }\n *\n * // Generate explorer link for transaction\n * function getExplorerLink(txHash: string): string {\n *   if (!network.explorerUrl) {\n *     return `Transaction: ${txHash}`;\n *   }\n *   return `${network.explorerUrl}/tx/${txHash}`;\n * }\n *\n * // Verify expected network\n * const EXPECTED_CHAIN_ID = 1337; // Vana testnet\n * if (network.chainId !== EXPECTED_CHAIN_ID) {\n *   throw new Error(`Wrong network! Expected ${EXPECTED_CHAIN_ID}, got ${network.chainId}`);\n * }\n * ```\n * @category Reference\n */\nexport interface NetworkInfo {\n  /** Chain ID */\n  chainId: number;\n  /** Chain name */\n  chainName: string;\n  /** RPC URL */\n  rpcUrl: string;\n  /** Block explorer URL */\n  explorerUrl?: string;\n  /** Current block number */\n  currentBlock: bigint;\n  /** Network status */\n  status: \"healthy\" | \"degraded\" | \"down\";\n}\n\n/**\n * Gas estimate information for transaction cost prediction.\n *\n * @remarks\n * Provides detailed gas pricing estimates to help users understand transaction\n * costs before execution. Supports both legacy (gasPrice) and EIP-1559\n * (maxFeePerGas) pricing models. The estimatedCost is calculated based on\n * current network conditions and may vary by the time of actual execution.\n *\n * @example\n * ```typescript\n * // Get gas estimate before transaction\n * const estimate: GasEstimate = await vana.permissions.estimateGas({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   dataId: 123\n * });\n *\n * // Convert to human-readable format\n * const costInEth = Number(estimate.estimatedCost) / 1e18;\n * console.log(`Estimated cost: ${costInEth.toFixed(6)} ETH`);\n *\n * // Check if user has sufficient balance\n * const balance = await vana.protocol.getBalance(userAddress);\n * if (balance < estimate.estimatedCost) {\n *   throw new Error(`Insufficient balance. Need ${costInEth} ETH`);\n * }\n *\n * // Use estimate for transaction with buffer\n * await vana.permissions.grant(params, {\n *   gasLimit: estimate.gasLimit * 110n / 100n, // 10% buffer\n *   maxFeePerGas: estimate.maxFeePerGas,\n *   maxPriorityFeePerGas: estimate.maxPriorityFeePerGas\n * });\n * ```\n * @category Reference\n */\nexport interface GasEstimate {\n  /** Gas limit */\n  gasLimit: bigint;\n  /** Gas price */\n  gasPrice: bigint;\n  /** Max fee per gas */\n  maxFeePerGas?: bigint;\n  /** Max priority fee per gas */\n  maxPriorityFeePerGas?: bigint;\n  /** Estimated cost in wei */\n  estimatedCost: bigint;\n}\n\n/**\n * Time range parameters for filtering operations by time period.\n *\n * Used in various SDK methods to specify date/time ranges for queries,\n * analytics, and data filtering operations. Times are specified as Unix timestamps.\n *\n * @category Reference\n * @example\n * ```typescript\n * const lastWeek: TimeRange = {\n *   from: Date.now() - (7 * 24 * 60 * 60 * 1000), // 7 days ago\n *   to: Date.now()\n * };\n *\n * const permissions = await vana.permissions.getUserPermissions({\n *   timeRange: lastWeek\n * });\n * ```\n */\nexport interface TimeRange {\n  /** Start time (Unix timestamp) */\n  from?: number;\n  /** End time (Unix timestamp) */\n  to?: number;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/types/utils.d.ts

@@ -255,51 +255,6 @@ export interface BlockRange {
     /** Ending block number */
     toBlock?: bigint;
 }
-/**
- * Transaction options for customizing blockchain transaction parameters.
- *
- * @remarks
- * Provides fine-grained control over transaction execution. Supports both
- * legacy (gasPrice) and EIP-1559 (maxFeePerGas) transaction types. When
- * not specified, the SDK will use appropriate defaults based on network
- * conditions. Use these options to optimize for speed or cost.
- *
- * @example
- * ```typescript
- * // High priority transaction with EIP-1559 pricing
- * await vana.permissions.grant(params, {
- *   maxFeePerGas: 100n * 10n ** 9n, // 100 gwei
- *   maxPriorityFeePerGas: 2n * 10n ** 9n, // 2 gwei tip
- * });
- *
- * // Legacy transaction with specific gas limit
- * await vana.data.registerFile(params, {
- *   gasLimit: 500000n,
- *   gasPrice: 50n * 10n ** 9n // 50 gwei
- * });
- *
- * // Send ETH with the transaction
- * await vana.protocol.execute(params, {
- *   value: 10n ** 18n, // 1 ETH
- *   gasLimit: 21000n
- * });
- * ```
- * @category Reference
- */
-export interface TransactionOptions {
-    /** Gas limit */
-    gasLimit?: bigint;
-    /** Gas price */
-    gasPrice?: bigint;
-    /** Max fee per gas (EIP-1559) */
-    maxFeePerGas?: bigint;
-    /** Max priority fee per gas (EIP-1559) */
-    maxPriorityFeePerGas?: bigint;
-    /** Nonce */
-    nonce?: number;
-    /** Value to send with transaction */
-    value?: bigint;
-}
 /**
  * Transaction receipt with additional metadata for tracking transaction results.
  *

package/dist/utils/__tests__/chainQuery.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/subgraphConsistency.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @file Tests for subgraph consistency utilities
+ */
+export {};

package/dist/utils/__tests__/subgraphPagination.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @file Tests for subgraph pagination utilities
+ */
+export {};

package/dist/utils/chainQuery.cjs

@@ -0,0 +1,107 @@
+"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 chainQuery_exports = {};
+__export(chainQuery_exports, {
+  determineDataSource: () => determineDataSource,
+  getUserFilesFromChain: () => getUserFilesFromChain
+});
+module.exports = __toCommonJS(chainQuery_exports);
+var import_viem = require("viem");
+async function getUserFilesFromChain(publicClient, contractAddress, owner, fromBlock, toBlock) {
+  const fileAddedV2Events = await publicClient.getLogs({
+    address: contractAddress,
+    event: (0, import_viem.parseAbiItem)(
+      "event FileAddedV2(uint256 indexed fileId, address indexed ownerAddress, string url, uint256 schemaId)"
+    ),
+    args: {
+      ownerAddress: owner
+    },
+    fromBlock: fromBlock ?? "earliest",
+    toBlock: toBlock ?? "latest"
+  });
+  const fileAddedEvents = await publicClient.getLogs({
+    address: contractAddress,
+    event: (0, import_viem.parseAbiItem)(
+      "event FileAdded(uint256 indexed fileId, address indexed ownerAddress, string url)"
+    ),
+    args: {
+      ownerAddress: owner
+    },
+    fromBlock: fromBlock ?? "earliest",
+    toBlock: toBlock ?? "latest"
+  });
+  const filesFromV2 = fileAddedV2Events.map((event) => ({
+    id: Number(event.args.fileId),
+    url: event.args.url,
+    ownerAddress: event.args.ownerAddress,
+    schemaId: Number(event.args.schemaId),
+    addedAtBlock: event.blockNumber,
+    addedAtTimestamp: BigInt(0),
+    // Would need to fetch block for timestamp
+    transactionHash: event.transactionHash
+  }));
+  const filesFromV1 = fileAddedEvents.map((event) => ({
+    id: Number(event.args.fileId),
+    url: event.args.url,
+    ownerAddress: event.args.ownerAddress,
+    schemaId: 0,
+    // No schema in V1
+    addedAtBlock: event.blockNumber,
+    addedAtTimestamp: BigInt(0),
+    // Would need to fetch block for timestamp
+    transactionHash: event.transactionHash
+  }));
+  const allFiles = [...filesFromV2];
+  const v2FileIds = new Set(filesFromV2.map((f) => f.id));
+  for (const v1File of filesFromV1) {
+    if (!v2FileIds.has(v1File.id)) {
+      allFiles.push(v1File);
+    }
+  }
+  allFiles.sort((a, b) => {
+    if (a.addedAtBlock > b.addedAtBlock) return -1;
+    if (a.addedAtBlock < b.addedAtBlock) return 1;
+    return 0;
+  });
+  return allFiles;
+}
+function determineDataSource(source, minBlock, currentBlock, subgraphBlock) {
+  if (source === "subgraph" || source === "chain") {
+    return source;
+  }
+  if (source === "auto" || source === void 0) {
+    if (!minBlock) {
+      return "subgraph";
+    }
+    if (!subgraphBlock || subgraphBlock < minBlock) {
+      const staleness = Number(currentBlock) - (subgraphBlock ?? 0);
+      if (staleness > 100) {
+        return "chain";
+      }
+    }
+    return "subgraph";
+  }
+  return "subgraph";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  determineDataSource,
+  getUserFilesFromChain
+});
+//# sourceMappingURL=chainQuery.cjs.map

package/dist/utils/chainQuery.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/chainQuery.ts"],"sourcesContent":["/**\n * @file Utilities for querying data directly from the blockchain\n * @module vana-sdk/utils/chainQuery\n */\n\nimport type { Address, PublicClient } from \"viem\";\nimport { parseAbiItem } from \"viem\";\nimport type { UserFile } from \"../types\";\n\n/**\n * Query user files directly from the blockchain using events\n *\n * @remarks\n * This bypasses the subgraph entirely and queries events directly from the chain.\n * Slower than subgraph but guarantees real-time consistency.\n *\n * @param publicClient - Viem public client for chain interaction\n * @param contractAddress - DataRegistry contract address\n * @param owner - Owner address to query files for\n * @param fromBlock - Starting block number (optional)\n * @param toBlock - Ending block number (optional)\n * @returns Array of UserFile objects\n */\nexport async function getUserFilesFromChain(\n  publicClient: PublicClient,\n  contractAddress: Address,\n  owner: Address,\n  fromBlock?: bigint,\n  toBlock?: bigint,\n): Promise<UserFile[]> {\n  // Query FileAddedV2 events (has schema support)\n  const fileAddedV2Events = await publicClient.getLogs({\n    address: contractAddress,\n    event: parseAbiItem(\n      \"event FileAddedV2(uint256 indexed fileId, address indexed ownerAddress, string url, uint256 schemaId)\",\n    ),\n    args: {\n      ownerAddress: owner,\n    },\n    fromBlock: fromBlock ?? \"earliest\",\n    toBlock: toBlock ?? \"latest\",\n  });\n\n  // Also query older FileAdded events (no schema)\n  const fileAddedEvents = await publicClient.getLogs({\n    address: contractAddress,\n    event: parseAbiItem(\n      \"event FileAdded(uint256 indexed fileId, address indexed ownerAddress, string url)\",\n    ),\n    args: {\n      ownerAddress: owner,\n    },\n    fromBlock: fromBlock ?? \"earliest\",\n    toBlock: toBlock ?? \"latest\",\n  });\n\n  // Convert events to UserFile objects\n  const filesFromV2 = fileAddedV2Events.map((event) => ({\n    id: Number(event.args.fileId),\n    url: event.args.url as string,\n    ownerAddress: event.args.ownerAddress as Address,\n    schemaId: Number(event.args.schemaId),\n    addedAtBlock: event.blockNumber,\n    addedAtTimestamp: BigInt(0), // Would need to fetch block for timestamp\n    transactionHash: event.transactionHash,\n  }));\n\n  const filesFromV1 = fileAddedEvents.map((event) => ({\n    id: Number(event.args.fileId),\n    url: event.args.url as string,\n    ownerAddress: event.args.ownerAddress as Address,\n    schemaId: 0, // No schema in V1\n    addedAtBlock: event.blockNumber,\n    addedAtTimestamp: BigInt(0), // Would need to fetch block for timestamp\n    transactionHash: event.transactionHash,\n  }));\n\n  // Combine and deduplicate (V2 takes precedence)\n  const allFiles = [...filesFromV2];\n  const v2FileIds = new Set(filesFromV2.map((f) => f.id));\n\n  for (const v1File of filesFromV1) {\n    if (!v2FileIds.has(v1File.id)) {\n      allFiles.push(v1File);\n    }\n  }\n\n  // Sort by block number descending (most recent first)\n  allFiles.sort((a, b) => {\n    if (a.addedAtBlock > b.addedAtBlock) return -1;\n    if (a.addedAtBlock < b.addedAtBlock) return 1;\n    return 0;\n  });\n\n  return allFiles;\n}\n\n/**\n * Determine optimal data source based on requirements\n *\n * @param source - Explicitly requested source\n * @param minBlock - Minimum required block\n * @param currentBlock - Current chain block\n * @param subgraphBlock - Current subgraph block\n * @returns The data source to use\n */\nexport function determineDataSource(\n  source: \"subgraph\" | \"chain\" | \"auto\" | undefined,\n  minBlock: number | undefined,\n  currentBlock: bigint,\n  subgraphBlock: number | undefined,\n): \"subgraph\" | \"chain\" {\n  // If explicitly specified, use that\n  if (source === \"subgraph\" || source === \"chain\") {\n    return source;\n  }\n\n  // Auto mode or unspecified\n  if (source === \"auto\" || source === undefined) {\n    // If no consistency requirement, use subgraph (faster)\n    if (!minBlock) {\n      return \"subgraph\";\n    }\n\n    // If subgraph is unknown or too far behind, use chain\n    if (!subgraphBlock || subgraphBlock < minBlock) {\n      // Calculate staleness\n      const staleness = Number(currentBlock) - (subgraphBlock ?? 0);\n\n      // If more than 100 blocks behind, use chain\n      if (staleness > 100) {\n        return \"chain\";\n      }\n    }\n\n    // Default to subgraph\n    return \"subgraph\";\n  }\n\n  // Default fallback\n  return \"subgraph\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAA6B;AAiB7B,eAAsB,sBACpB,cACA,iBACA,OACA,WACA,SACqB;AAErB,QAAM,oBAAoB,MAAM,aAAa,QAAQ;AAAA,IACnD,SAAS;AAAA,IACT,WAAO;AAAA,MACL;AAAA,IACF;AAAA,IACA,MAAM;AAAA,MACJ,cAAc;AAAA,IAChB;AAAA,IACA,WAAW,aAAa;AAAA,IACxB,SAAS,WAAW;AAAA,EACtB,CAAC;AAGD,QAAM,kBAAkB,MAAM,aAAa,QAAQ;AAAA,IACjD,SAAS;AAAA,IACT,WAAO;AAAA,MACL;AAAA,IACF;AAAA,IACA,MAAM;AAAA,MACJ,cAAc;AAAA,IAChB;AAAA,IACA,WAAW,aAAa;AAAA,IACxB,SAAS,WAAW;AAAA,EACtB,CAAC;AAGD,QAAM,cAAc,kBAAkB,IAAI,CAAC,WAAW;AAAA,IACpD,IAAI,OAAO,MAAM,KAAK,MAAM;AAAA,IAC5B,KAAK,MAAM,KAAK;AAAA,IAChB,cAAc,MAAM,KAAK;AAAA,IACzB,UAAU,OAAO,MAAM,KAAK,QAAQ;AAAA,IACpC,cAAc,MAAM;AAAA,IACpB,kBAAkB,OAAO,CAAC;AAAA;AAAA,IAC1B,iBAAiB,MAAM;AAAA,EACzB,EAAE;AAEF,QAAM,cAAc,gBAAgB,IAAI,CAAC,WAAW;AAAA,IAClD,IAAI,OAAO,MAAM,KAAK,MAAM;AAAA,IAC5B,KAAK,MAAM,KAAK;AAAA,IAChB,cAAc,MAAM,KAAK;AAAA,IACzB,UAAU;AAAA;AAAA,IACV,cAAc,MAAM;AAAA,IACpB,kBAAkB,OAAO,CAAC;AAAA;AAAA,IAC1B,iBAAiB,MAAM;AAAA,EACzB,EAAE;AAGF,QAAM,WAAW,CAAC,GAAG,WAAW;AAChC,QAAM,YAAY,IAAI,IAAI,YAAY,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AAEtD,aAAW,UAAU,aAAa;AAChC,QAAI,CAAC,UAAU,IAAI,OAAO,EAAE,GAAG;AAC7B,eAAS,KAAK,MAAM;AAAA,IACtB;AAAA,EACF;AAGA,WAAS,KAAK,CAAC,GAAG,MAAM;AACtB,QAAI,EAAE,eAAe,EAAE,aAAc,QAAO;AAC5C,QAAI,EAAE,eAAe,EAAE,aAAc,QAAO;AAC5C,WAAO;AAAA,EACT,CAAC;AAED,SAAO;AACT;AAWO,SAAS,oBACd,QACA,UACA,cACA,eACsB;AAEtB,MAAI,WAAW,cAAc,WAAW,SAAS;AAC/C,WAAO;AAAA,EACT;AAGA,MAAI,WAAW,UAAU,WAAW,QAAW;AAE7C,QAAI,CAAC,UAAU;AACb,aAAO;AAAA,IACT;AAGA,QAAI,CAAC,iBAAiB,gBAAgB,UAAU;AAE9C,YAAM,YAAY,OAAO,YAAY,KAAK,iBAAiB;AAG3D,UAAI,YAAY,KAAK;AACnB,eAAO;AAAA,MACT;AAAA,IACF;AAGA,WAAO;AAAA,EACT;AAGA,SAAO;AACT;","names":[]}

package/dist/utils/chainQuery.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file Utilities for querying data directly from the blockchain
+ * @module vana-sdk/utils/chainQuery
+ */
+import type { Address, PublicClient } from "viem";
+import type { UserFile } from "../types";
+/**
+ * Query user files directly from the blockchain using events
+ *
+ * @remarks
+ * This bypasses the subgraph entirely and queries events directly from the chain.
+ * Slower than subgraph but guarantees real-time consistency.
+ *
+ * @param publicClient - Viem public client for chain interaction
+ * @param contractAddress - DataRegistry contract address
+ * @param owner - Owner address to query files for
+ * @param fromBlock - Starting block number (optional)
+ * @param toBlock - Ending block number (optional)
+ * @returns Array of UserFile objects
+ */
+export declare function getUserFilesFromChain(publicClient: PublicClient, contractAddress: Address, owner: Address, fromBlock?: bigint, toBlock?: bigint): Promise<UserFile[]>;
+/**
+ * Determine optimal data source based on requirements
+ *
+ * @param source - Explicitly requested source
+ * @param minBlock - Minimum required block
+ * @param currentBlock - Current chain block
+ * @param subgraphBlock - Current subgraph block
+ * @returns The data source to use
+ */
+export declare function determineDataSource(source: "subgraph" | "chain" | "auto" | undefined, minBlock: number | undefined, currentBlock: bigint, subgraphBlock: number | undefined): "subgraph" | "chain";

package/dist/utils/chainQuery.js

@@ -0,0 +1,82 @@
+import { parseAbiItem } from "viem";
+async function getUserFilesFromChain(publicClient, contractAddress, owner, fromBlock, toBlock) {
+  const fileAddedV2Events = await publicClient.getLogs({
+    address: contractAddress,
+    event: parseAbiItem(
+      "event FileAddedV2(uint256 indexed fileId, address indexed ownerAddress, string url, uint256 schemaId)"
+    ),
+    args: {
+      ownerAddress: owner
+    },
+    fromBlock: fromBlock ?? "earliest",
+    toBlock: toBlock ?? "latest"
+  });
+  const fileAddedEvents = await publicClient.getLogs({
+    address: contractAddress,
+    event: parseAbiItem(
+      "event FileAdded(uint256 indexed fileId, address indexed ownerAddress, string url)"
+    ),
+    args: {
+      ownerAddress: owner
+    },
+    fromBlock: fromBlock ?? "earliest",
+    toBlock: toBlock ?? "latest"
+  });
+  const filesFromV2 = fileAddedV2Events.map((event) => ({
+    id: Number(event.args.fileId),
+    url: event.args.url,
+    ownerAddress: event.args.ownerAddress,
+    schemaId: Number(event.args.schemaId),
+    addedAtBlock: event.blockNumber,
+    addedAtTimestamp: BigInt(0),
+    // Would need to fetch block for timestamp
+    transactionHash: event.transactionHash
+  }));
+  const filesFromV1 = fileAddedEvents.map((event) => ({
+    id: Number(event.args.fileId),
+    url: event.args.url,
+    ownerAddress: event.args.ownerAddress,
+    schemaId: 0,
+    // No schema in V1
+    addedAtBlock: event.blockNumber,
+    addedAtTimestamp: BigInt(0),
+    // Would need to fetch block for timestamp
+    transactionHash: event.transactionHash
+  }));
+  const allFiles = [...filesFromV2];
+  const v2FileIds = new Set(filesFromV2.map((f) => f.id));
+  for (const v1File of filesFromV1) {
+    if (!v2FileIds.has(v1File.id)) {
+      allFiles.push(v1File);
+    }
+  }
+  allFiles.sort((a, b) => {
+    if (a.addedAtBlock > b.addedAtBlock) return -1;
+    if (a.addedAtBlock < b.addedAtBlock) return 1;
+    return 0;
+  });
+  return allFiles;
+}
+function determineDataSource(source, minBlock, currentBlock, subgraphBlock) {
+  if (source === "subgraph" || source === "chain") {
+    return source;
+  }
+  if (source === "auto" || source === void 0) {
+    if (!minBlock) {
+      return "subgraph";
+    }
+    if (!subgraphBlock || subgraphBlock < minBlock) {
+      const staleness = Number(currentBlock) - (subgraphBlock ?? 0);
+      if (staleness > 100) {
+        return "chain";
+      }
+    }
+    return "subgraph";
+  }
+  return "subgraph";
+}
+export {
+  determineDataSource,
+  getUserFilesFromChain
+};
+//# sourceMappingURL=chainQuery.js.map

package/dist/utils/chainQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/chainQuery.ts"],"sourcesContent":["/**\n * @file Utilities for querying data directly from the blockchain\n * @module vana-sdk/utils/chainQuery\n */\n\nimport type { Address, PublicClient } from \"viem\";\nimport { parseAbiItem } from \"viem\";\nimport type { UserFile } from \"../types\";\n\n/**\n * Query user files directly from the blockchain using events\n *\n * @remarks\n * This bypasses the subgraph entirely and queries events directly from the chain.\n * Slower than subgraph but guarantees real-time consistency.\n *\n * @param publicClient - Viem public client for chain interaction\n * @param contractAddress - DataRegistry contract address\n * @param owner - Owner address to query files for\n * @param fromBlock - Starting block number (optional)\n * @param toBlock - Ending block number (optional)\n * @returns Array of UserFile objects\n */\nexport async function getUserFilesFromChain(\n  publicClient: PublicClient,\n  contractAddress: Address,\n  owner: Address,\n  fromBlock?: bigint,\n  toBlock?: bigint,\n): Promise<UserFile[]> {\n  // Query FileAddedV2 events (has schema support)\n  const fileAddedV2Events = await publicClient.getLogs({\n    address: contractAddress,\n    event: parseAbiItem(\n      \"event FileAddedV2(uint256 indexed fileId, address indexed ownerAddress, string url, uint256 schemaId)\",\n    ),\n    args: {\n      ownerAddress: owner,\n    },\n    fromBlock: fromBlock ?? \"earliest\",\n    toBlock: toBlock ?? \"latest\",\n  });\n\n  // Also query older FileAdded events (no schema)\n  const fileAddedEvents = await publicClient.getLogs({\n    address: contractAddress,\n    event: parseAbiItem(\n      \"event FileAdded(uint256 indexed fileId, address indexed ownerAddress, string url)\",\n    ),\n    args: {\n      ownerAddress: owner,\n    },\n    fromBlock: fromBlock ?? \"earliest\",\n    toBlock: toBlock ?? \"latest\",\n  });\n\n  // Convert events to UserFile objects\n  const filesFromV2 = fileAddedV2Events.map((event) => ({\n    id: Number(event.args.fileId),\n    url: event.args.url as string,\n    ownerAddress: event.args.ownerAddress as Address,\n    schemaId: Number(event.args.schemaId),\n    addedAtBlock: event.blockNumber,\n    addedAtTimestamp: BigInt(0), // Would need to fetch block for timestamp\n    transactionHash: event.transactionHash,\n  }));\n\n  const filesFromV1 = fileAddedEvents.map((event) => ({\n    id: Number(event.args.fileId),\n    url: event.args.url as string,\n    ownerAddress: event.args.ownerAddress as Address,\n    schemaId: 0, // No schema in V1\n    addedAtBlock: event.blockNumber,\n    addedAtTimestamp: BigInt(0), // Would need to fetch block for timestamp\n    transactionHash: event.transactionHash,\n  }));\n\n  // Combine and deduplicate (V2 takes precedence)\n  const allFiles = [...filesFromV2];\n  const v2FileIds = new Set(filesFromV2.map((f) => f.id));\n\n  for (const v1File of filesFromV1) {\n    if (!v2FileIds.has(v1File.id)) {\n      allFiles.push(v1File);\n    }\n  }\n\n  // Sort by block number descending (most recent first)\n  allFiles.sort((a, b) => {\n    if (a.addedAtBlock > b.addedAtBlock) return -1;\n    if (a.addedAtBlock < b.addedAtBlock) return 1;\n    return 0;\n  });\n\n  return allFiles;\n}\n\n/**\n * Determine optimal data source based on requirements\n *\n * @param source - Explicitly requested source\n * @param minBlock - Minimum required block\n * @param currentBlock - Current chain block\n * @param subgraphBlock - Current subgraph block\n * @returns The data source to use\n */\nexport function determineDataSource(\n  source: \"subgraph\" | \"chain\" | \"auto\" | undefined,\n  minBlock: number | undefined,\n  currentBlock: bigint,\n  subgraphBlock: number | undefined,\n): \"subgraph\" | \"chain\" {\n  // If explicitly specified, use that\n  if (source === \"subgraph\" || source === \"chain\") {\n    return source;\n  }\n\n  // Auto mode or unspecified\n  if (source === \"auto\" || source === undefined) {\n    // If no consistency requirement, use subgraph (faster)\n    if (!minBlock) {\n      return \"subgraph\";\n    }\n\n    // If subgraph is unknown or too far behind, use chain\n    if (!subgraphBlock || subgraphBlock < minBlock) {\n      // Calculate staleness\n      const staleness = Number(currentBlock) - (subgraphBlock ?? 0);\n\n      // If more than 100 blocks behind, use chain\n      if (staleness > 100) {\n        return \"chain\";\n      }\n    }\n\n    // Default to subgraph\n    return \"subgraph\";\n  }\n\n  // Default fallback\n  return \"subgraph\";\n}\n"],"mappings":"AAMA,SAAS,oBAAoB;AAiB7B,eAAsB,sBACpB,cACA,iBACA,OACA,WACA,SACqB;AAErB,QAAM,oBAAoB,MAAM,aAAa,QAAQ;AAAA,IACnD,SAAS;AAAA,IACT,OAAO;AAAA,MACL;AAAA,IACF;AAAA,IACA,MAAM;AAAA,MACJ,cAAc;AAAA,IAChB;AAAA,IACA,WAAW,aAAa;AAAA,IACxB,SAAS,WAAW;AAAA,EACtB,CAAC;AAGD,QAAM,kBAAkB,MAAM,aAAa,QAAQ;AAAA,IACjD,SAAS;AAAA,IACT,OAAO;AAAA,MACL;AAAA,IACF;AAAA,IACA,MAAM;AAAA,MACJ,cAAc;AAAA,IAChB;AAAA,IACA,WAAW,aAAa;AAAA,IACxB,SAAS,WAAW;AAAA,EACtB,CAAC;AAGD,QAAM,cAAc,kBAAkB,IAAI,CAAC,WAAW;AAAA,IACpD,IAAI,OAAO,MAAM,KAAK,MAAM;AAAA,IAC5B,KAAK,MAAM,KAAK;AAAA,IAChB,cAAc,MAAM,KAAK;AAAA,IACzB,UAAU,OAAO,MAAM,KAAK,QAAQ;AAAA,IACpC,cAAc,MAAM;AAAA,IACpB,kBAAkB,OAAO,CAAC;AAAA;AAAA,IAC1B,iBAAiB,MAAM;AAAA,EACzB,EAAE;AAEF,QAAM,cAAc,gBAAgB,IAAI,CAAC,WAAW;AAAA,IAClD,IAAI,OAAO,MAAM,KAAK,MAAM;AAAA,IAC5B,KAAK,MAAM,KAAK;AAAA,IAChB,cAAc,MAAM,KAAK;AAAA,IACzB,UAAU;AAAA;AAAA,IACV,cAAc,MAAM;AAAA,IACpB,kBAAkB,OAAO,CAAC;AAAA;AAAA,IAC1B,iBAAiB,MAAM;AAAA,EACzB,EAAE;AAGF,QAAM,WAAW,CAAC,GAAG,WAAW;AAChC,QAAM,YAAY,IAAI,IAAI,YAAY,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AAEtD,aAAW,UAAU,aAAa;AAChC,QAAI,CAAC,UAAU,IAAI,OAAO,EAAE,GAAG;AAC7B,eAAS,KAAK,MAAM;AAAA,IACtB;AAAA,EACF;AAGA,WAAS,KAAK,CAAC,GAAG,MAAM;AACtB,QAAI,EAAE,eAAe,EAAE,aAAc,QAAO;AAC5C,QAAI,EAAE,eAAe,EAAE,aAAc,QAAO;AAC5C,WAAO;AAAA,EACT,CAAC;AAED,SAAO;AACT;AAWO,SAAS,oBACd,QACA,UACA,cACA,eACsB;AAEtB,MAAI,WAAW,cAAc,WAAW,SAAS;AAC/C,WAAO;AAAA,EACT;AAGA,MAAI,WAAW,UAAU,WAAW,QAAW;AAE7C,QAAI,CAAC,UAAU;AACb,aAAO;AAAA,IACT;AAGA,QAAI,CAAC,iBAAiB,gBAAgB,UAAU;AAE9C,YAAM,YAAY,OAAO,YAAY,KAAK,iBAAiB;AAG3D,UAAI,YAAY,KAAK;AACnB,eAAO;AAAA,MACT;AAAA,IACF;AAGA,WAAO;AAAA,EACT;AAGA,SAAO;AACT;","names":[]}

package/dist/utils/grantFiles.cjs

@@ -41,8 +41,11 @@ function createGrantFile(params) {
   const grantFile = {
     grantee: params.grantee,
     operation: params.operation,
-    parameters: params.parameters
+    parameters: { ...params.parameters }
   };
+  if (params.filters) {
+    grantFile.parameters.filters = params.filters;
+  }
   if (params.expiresAt) {
     grantFile.expires = params.expiresAt;
   }

package/dist/utils/grantFiles.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/grantFiles.ts"],"sourcesContent":["import { keccak256, toHex } from \"viem\";\nimport type { GrantFile, GrantPermissionParams } from \"../types/permissions\";\nimport { SerializationError, NetworkError } from \"../errors\";\n\ninterface GrantFileStorageResponse {\n  success: boolean;\n  error?: string;\n  url?: string;\n}\n\n/**\n * Creates a grant file structure from permission parameters.\n *\n * @remarks\n * This function constructs the JSON structure that represents a permission grant\n * in the Vana protocol. The grant file contains all necessary information for\n * a grantee to perform operations on behalf of the grantor.\n *\n * @param params - The permission parameters to create the grant file from\n * @returns The constructed grant file object\n * @example\n * ```typescript\n * const grantFile = createGrantFile({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'llm_inference',\n *   parameters: {\n *     model: 'gpt-4',\n *     maxTokens: 1000\n *   },\n *   expiresAt: Date.now() + 86400000 // 24 hours\n * });\n *\n * console.log(grantFile);\n * // {\n * //   grantee: '0x742d...',\n * //   operation: 'llm_inference',\n * //   parameters: { model: 'gpt-4', maxTokens: 1000 },\n * //   expires: 1234567890\n * // }\n * ```\n */\nexport function createGrantFile(params: GrantPermissionParams): GrantFile {\n  const grantFile: GrantFile = {\n    grantee: params.grantee,\n    operation: params.operation,\n    parameters: params.parameters,\n  };\n\n  // Add expiration if provided\n  if (params.expiresAt) {\n    grantFile.expires = params.expiresAt;\n  }\n\n  return grantFile;\n}\n\n/**\n * Stores a grant file in IPFS via the relayer service.\n *\n * @remarks\n * This function uploads the grant file to IPFS through the relayer's upload endpoint.\n * The returned URL can be stored on-chain as part of the permission grant, allowing\n * anyone to retrieve the detailed permission parameters later.\n *\n * @param grantFile - The grant file to store\n * @param relayerUrl - URL of the relayer service\n * @returns Promise resolving to the IPFS URL\n * @throws {NetworkError} When the upload fails or relayer is unavailable\n * @example\n * ```typescript\n * const grantFile = createGrantFile(params);\n *\n * try {\n *   const ipfsUrl = await storeGrantFile(grantFile, 'https://relayer.vana.com');\n *   console.log(`Grant file stored at: ${ipfsUrl}`);\n *   // ipfsUrl: \"ipfs://QmHash123...\"\n * } catch (error) {\n *   console.error('Failed to store grant file:', error);\n * }\n * ```\n */\nexport async function storeGrantFile(\n  grantFile: GrantFile,\n  relayerUrl: string,\n): Promise<string> {\n  try {\n    // Convert grant file to blob and use IPFS upload endpoint\n    const grantFileBlob = new Blob([JSON.stringify(grantFile, null, 2)], {\n      type: \"application/json\",\n    });\n\n    const formData = new FormData();\n    formData.append(\"file\", grantFileBlob, \"grant-file.json\");\n\n    const response = await fetch(`${relayerUrl}/api/ipfs/upload`, {\n      method: \"POST\",\n      body: formData,\n    });\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to store grant file: ${response.statusText}`,\n        new Error(`HTTP ${response.status}`),\n      );\n    }\n\n    const responseData: unknown = await response.json();\n    const data = responseData as GrantFileStorageResponse;\n\n    if (!data.success) {\n      throw new NetworkError(data.error ?? \"Failed to store grant file\");\n    }\n\n    if (!data.url) {\n      throw new NetworkError(\"Upload succeeded but no URL was returned\");\n    }\n    return data.url; // The IPFS URL from the upload response\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Network error while storing grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Retrieves detailed grant file data from IPFS or HTTP storage.\n *\n * @remarks\n * **This is Step 2 of the performant two-step permission API.**\n *\n * Use this method to resolve detailed permission data (operation, parameters, etc.)\n * for specific grants after first getting the fast on-chain data using\n * `getUserPermissionGrantsOnChain()`. This design eliminates N+1 query problems\n * by allowing selective lazy-loading of expensive off-chain data.\n *\n * **Performance**: Single network request per grant file (typically 100-500ms).\n * **Reliability**: Tries multiple IPFS gateways as fallbacks if primary URL fails.\n *\n * @param grantUrl - The grant file URL from OnChainPermissionGrant.grantUrl\n * @param _relayerUrl - URL of the relayer service (optional, unused)\n * @param downloadRelayer - Optional download relayer for proxying CORS-restricted downloads\n * @param downloadRelayer.proxyDownload - Function to proxy download requests through application server\n * @returns Promise resolving to the complete grant file with operation details\n * @throws {NetworkError} When all retrieval attempts fail\n * @throws {SerializationError} When grant file format is invalid\n * @example\n * ```typescript\n * // Step 1: Fast on-chain data (no N+1 queries)\n * const grants = await vana.permissions.getUserPermissionGrantsOnChain();\n *\n * // Step 2: Lazy-load details for specific grant when needed\n * const grantFile = await retrieveGrantFile(grants[0].grantUrl);\n *\n * console.log(`Operation: ${grantFile.operation}`);\n * console.log(`Grantee: ${grantFile.grantee}`);\n * console.log(`Parameters:`, grantFile.parameters);\n *\n * // Only fetch details for grants user actually wants to see\n * for (const grant of selectedGrants) {\n *   const details = await retrieveGrantFile(grant.grantUrl);\n *   displayGrantDetails(details);\n * }\n * ```\n */\nexport async function retrieveGrantFile(\n  grantUrl: string,\n  _relayerUrl?: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<GrantFile> {\n  try {\n    // Check if the URL is a gateway URL instead of ipfs:// protocol\n    if (grantUrl.startsWith(\"http\") && grantUrl.includes(\"/ipfs/\")) {\n      console.warn(\n        `⚠️  Grant URL uses HTTP gateway format instead of ipfs:// protocol. ` +\n          `Found: ${grantUrl}. ` +\n          `Consider using ipfs:// format for better protocol-agnostic storage.`,\n      );\n    }\n\n    // Use the unified download utility\n    const { universalFetch } = await import(\"./download\");\n    const response = await universalFetch(grantUrl, downloadRelayer);\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to retrieve grant file: HTTP ${response.status}`,\n      );\n    }\n\n    const text = await response.text();\n    const grantFile = JSON.parse(text);\n\n    if (!validateGrantFile(grantFile)) {\n      throw new NetworkError(`Invalid grant file format from ${grantUrl}`);\n    }\n\n    return grantFile;\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Error retrieving grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Generates a content hash for a grant file.\n * This can be used for integrity verification.\n *\n * @remarks\n * Creates a deterministic keccak256 hash of the grant file by first sorting\n * all object keys recursively to ensure consistent hashing regardless of\n * property order. This hash can be used to verify grant file integrity\n * or as a unique identifier.\n *\n * @param grantFile - The grant file to generate a hash for\n * @returns The keccak256 hash of the grant file as a hex string\n * @throws {SerializationError} When the grant file cannot be serialized\n * @example\n * ```typescript\n * const grantFile = {\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: { version: '1.0', mode: 'full' }\n * };\n *\n * const hash = getGrantFileHash(grantFile);\n * console.log(`Grant file hash: ${hash}`);\n * // \"0x1234567890abcdef...\"\n *\n * // Same grant file with different property order produces same hash\n * const grantFile2 = {\n *   operation: 'read',\n *   parameters: { mode: 'full', version: '1.0' },\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36'\n * };\n *\n * const hash2 = getGrantFileHash(grantFile2);\n * console.log(hash === hash2); // true\n * ```\n */\nexport function getGrantFileHash(grantFile: GrantFile): string {\n  try {\n    // Create a stable JSON representation\n    const sortedFile: GrantFile = {\n      grantee: grantFile.grantee,\n      operation: grantFile.operation,\n      parameters: sortObjectKeys(grantFile.parameters) as Record<\n        string,\n        unknown\n      >,\n    };\n\n    // Add expires if present\n    if (grantFile.expires !== undefined) {\n      sortedFile.expires = grantFile.expires;\n    }\n\n    const jsonString = JSON.stringify(sortedFile);\n    console.info(`Hash: ${keccak256(toHex(jsonString))}`);\n    return keccak256(toHex(jsonString));\n  } catch (error) {\n    throw new SerializationError(\n      `Failed to generate grant file hash: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n\n/**\n * Recursively sorts object keys for stable serialization.\n *\n * @param obj - The object to sort keys recursively\n * @returns The object with all keys sorted recursively\n */\nfunction sortObjectKeys(obj: unknown): unknown {\n  if (obj === null || typeof obj !== \"object\") {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => sortObjectKeys(item));\n  }\n\n  const sortedObj: Record<string, unknown> = {};\n  Object.keys(obj as Record<string, unknown>)\n    .sort()\n    .forEach((key) => {\n      sortedObj[key] = sortObjectKeys((obj as Record<string, unknown>)[key]);\n    });\n\n  return sortedObj;\n}\n\n/**\n * Validates that a grant file has the required structure.\n *\n * @remarks\n * Performs runtime validation to ensure data conforms to the GrantFile interface.\n * Checks for required fields (grantee, operation, parameters) and validates their\n * types and formats. This is a type guard function that enables TypeScript to\n * narrow the type when it returns true.\n *\n * @param data - The data to validate as a grant file\n * @returns True if the data is a valid grant file, false otherwise\n * @example\n * ```typescript\n * const unknownData = await fetch(url).then(r => r.json());\n *\n * if (validateGrantFile(unknownData)) {\n *   // TypeScript now knows unknownData is a GrantFile\n *   console.log(`Grant for operation: ${unknownData.operation}`);\n *   console.log(`Grantee: ${unknownData.grantee}`);\n * } else {\n *   throw new Error('Invalid grant file format');\n * }\n *\n * // Validation examples:\n * validateGrantFile({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: {}\n * }); // true\n *\n * validateGrantFile({\n *   grantee: 'invalid-address',\n *   operation: 'read',\n *   parameters: {}\n * }); // false (invalid address format)\n *\n * validateGrantFile({\n *   operation: 'read',\n *   parameters: {}\n * }); // false (missing grantee)\n * ```\n */\nexport function validateGrantFile(data: unknown): data is GrantFile {\n  if (!data || typeof data !== \"object\") {\n    return false;\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  // Validate required fields\n  // Validate grantee address\n  if (\n    typeof obj.grantee !== \"string\" ||\n    !obj.grantee.match(/^0x[a-fA-F0-9]{40}$/)\n  ) {\n    return false;\n  }\n\n  if (typeof obj.operation !== \"string\" || obj.operation.length === 0) {\n    return false;\n  }\n\n  // Files are no longer stored in grant files - they're tracked in the contract\n\n  if (!obj.parameters || typeof obj.parameters !== \"object\") {\n    return false;\n  }\n\n  // Validate optional expires field\n  if (obj.expires !== undefined) {\n    if (\n      typeof obj.expires !== \"number\" ||\n      obj.expires < 0 ||\n      !Number.isInteger(obj.expires)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/utils/grantFiles.ts"],"sourcesContent":["import { keccak256, toHex } from \"viem\";\nimport type { GrantFile, GrantPermissionParams } from \"../types/permissions\";\nimport { SerializationError, NetworkError } from \"../errors\";\n\ninterface GrantFileStorageResponse {\n  success: boolean;\n  error?: string;\n  url?: string;\n}\n\n/**\n * Creates grant file structure for permission storage.\n *\n * @remarks\n * Constructs JSON structure that represents a permission grant\n * in the Vana protocol. The grant file contains all necessary information\n * for a grantee to perform operations on behalf of the grantor.\n *\n * @param params - Permission parameters to create the grant file from\n * @returns Grant file object for IPFS storage\n *\n * @example\n * ```typescript\n * const grant = createGrantFile({\n *   grantee: '0x742d35Cc...',\n *   operation: 'llm_inference',\n *   parameters: { model: 'gpt-4' },\n *   expiresAt: Date.now() + 86400000 // 24 hours\n * });\n * ```\n */\nexport function createGrantFile(params: GrantPermissionParams): GrantFile {\n  const grantFile: GrantFile = {\n    grantee: params.grantee,\n    operation: params.operation,\n    parameters: { ...params.parameters },\n  };\n\n  // Add filters to parameters if provided\n  if (params.filters) {\n    grantFile.parameters.filters = params.filters;\n  }\n\n  // Add expiration if provided\n  if (params.expiresAt) {\n    grantFile.expires = params.expiresAt;\n  }\n\n  return grantFile;\n}\n\n/**\n * Stores a grant file in IPFS via the relayer service.\n *\n * @remarks\n * This function uploads the grant file to IPFS through the relayer's upload endpoint.\n * The returned URL can be stored on-chain as part of the permission grant, allowing\n * anyone to retrieve the detailed permission parameters later.\n *\n * @param grantFile - The grant file to store\n * @param relayerUrl - URL of the relayer service\n * @returns Promise resolving to the IPFS URL\n * @throws {NetworkError} When the upload fails or relayer is unavailable\n * @example\n * ```typescript\n * const grantFile = createGrantFile(params);\n *\n * try {\n *   const ipfsUrl = await storeGrantFile(grantFile, 'https://relayer.vana.com');\n *   console.log(`Grant file stored at: ${ipfsUrl}`);\n *   // ipfsUrl: \"ipfs://QmHash123...\"\n * } catch (error) {\n *   console.error('Failed to store grant file:', error);\n * }\n * ```\n */\nexport async function storeGrantFile(\n  grantFile: GrantFile,\n  relayerUrl: string,\n): Promise<string> {\n  try {\n    // Convert grant file to blob and use IPFS upload endpoint\n    const grantFileBlob = new Blob([JSON.stringify(grantFile, null, 2)], {\n      type: \"application/json\",\n    });\n\n    const formData = new FormData();\n    formData.append(\"file\", grantFileBlob, \"grant-file.json\");\n\n    const response = await fetch(`${relayerUrl}/api/ipfs/upload`, {\n      method: \"POST\",\n      body: formData,\n    });\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to store grant file: ${response.statusText}`,\n        new Error(`HTTP ${response.status}`),\n      );\n    }\n\n    const responseData: unknown = await response.json();\n    const data = responseData as GrantFileStorageResponse;\n\n    if (!data.success) {\n      throw new NetworkError(data.error ?? \"Failed to store grant file\");\n    }\n\n    if (!data.url) {\n      throw new NetworkError(\"Upload succeeded but no URL was returned\");\n    }\n    return data.url; // The IPFS URL from the upload response\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Network error while storing grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Retrieves detailed grant file data from IPFS or HTTP storage.\n *\n * @remarks\n * **This is Step 2 of the performant two-step permission API.**\n *\n * Use this method to resolve detailed permission data (operation, parameters, etc.)\n * for specific grants after first getting the fast on-chain data using\n * `getUserPermissionGrantsOnChain()`. This design eliminates N+1 query problems\n * by allowing selective lazy-loading of expensive off-chain data.\n *\n * **Performance**: Single network request per grant file (typically 100-500ms).\n * **Reliability**: Tries multiple IPFS gateways as fallbacks if primary URL fails.\n *\n * @param grantUrl - The grant file URL from OnChainPermissionGrant.grantUrl\n * @param _relayerUrl - URL of the relayer service (optional, unused)\n * @param downloadRelayer - Optional download relayer for proxying CORS-restricted downloads\n * @param downloadRelayer.proxyDownload - Function to proxy download requests through application server\n * @returns Promise resolving to the complete grant file with operation details\n * @throws {NetworkError} When all retrieval attempts fail\n * @throws {SerializationError} When grant file format is invalid\n * @example\n * ```typescript\n * // Step 1: Fast on-chain data (no N+1 queries)\n * const grants = await vana.permissions.getUserPermissionGrantsOnChain();\n *\n * // Step 2: Lazy-load details for specific grant when needed\n * const grantFile = await retrieveGrantFile(grants[0].grantUrl);\n *\n * console.log(`Operation: ${grantFile.operation}`);\n * console.log(`Grantee: ${grantFile.grantee}`);\n * console.log(`Parameters:`, grantFile.parameters);\n *\n * // Only fetch details for grants user actually wants to see\n * for (const grant of selectedGrants) {\n *   const details = await retrieveGrantFile(grant.grantUrl);\n *   displayGrantDetails(details);\n * }\n * ```\n */\nexport async function retrieveGrantFile(\n  grantUrl: string,\n  _relayerUrl?: string,\n  downloadRelayer?: { proxyDownload: (url: string) => Promise<Blob> },\n): Promise<GrantFile> {\n  try {\n    // Check if the URL is a gateway URL instead of ipfs:// protocol\n    if (grantUrl.startsWith(\"http\") && grantUrl.includes(\"/ipfs/\")) {\n      console.warn(\n        `⚠️  Grant URL uses HTTP gateway format instead of ipfs:// protocol. ` +\n          `Found: ${grantUrl}. ` +\n          `Consider using ipfs:// format for better protocol-agnostic storage.`,\n      );\n    }\n\n    // Use the unified download utility\n    const { universalFetch } = await import(\"./download\");\n    const response = await universalFetch(grantUrl, downloadRelayer);\n\n    if (!response.ok) {\n      throw new NetworkError(\n        `Failed to retrieve grant file: HTTP ${response.status}`,\n      );\n    }\n\n    const text = await response.text();\n    const grantFile = JSON.parse(text);\n\n    if (!validateGrantFile(grantFile)) {\n      throw new NetworkError(`Invalid grant file format from ${grantUrl}`);\n    }\n\n    return grantFile;\n  } catch (error) {\n    if (error instanceof NetworkError) {\n      throw error;\n    }\n    throw new NetworkError(\n      `Error retrieving grant file: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      error as Error,\n    );\n  }\n}\n\n/**\n * Generates a content hash for a grant file.\n * This can be used for integrity verification.\n *\n * @remarks\n * Creates a deterministic keccak256 hash of the grant file by first sorting\n * all object keys recursively to ensure consistent hashing regardless of\n * property order. This hash can be used to verify grant file integrity\n * or as a unique identifier.\n *\n * @param grantFile - The grant file to generate a hash for\n * @returns The keccak256 hash of the grant file as a hex string\n * @throws {SerializationError} When the grant file cannot be serialized\n * @example\n * ```typescript\n * const grantFile = {\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: { version: '1.0', mode: 'full' }\n * };\n *\n * const hash = getGrantFileHash(grantFile);\n * console.log(`Grant file hash: ${hash}`);\n * // \"0x1234567890abcdef...\"\n *\n * // Same grant file with different property order produces same hash\n * const grantFile2 = {\n *   operation: 'read',\n *   parameters: { mode: 'full', version: '1.0' },\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36'\n * };\n *\n * const hash2 = getGrantFileHash(grantFile2);\n * console.log(hash === hash2); // true\n * ```\n */\nexport function getGrantFileHash(grantFile: GrantFile): string {\n  try {\n    // Create a stable JSON representation\n    const sortedFile: GrantFile = {\n      grantee: grantFile.grantee,\n      operation: grantFile.operation,\n      parameters: sortObjectKeys(grantFile.parameters) as Record<\n        string,\n        unknown\n      >,\n    };\n\n    // Add expires if present\n    if (grantFile.expires !== undefined) {\n      sortedFile.expires = grantFile.expires;\n    }\n\n    const jsonString = JSON.stringify(sortedFile);\n    console.info(`Hash: ${keccak256(toHex(jsonString))}`);\n    return keccak256(toHex(jsonString));\n  } catch (error) {\n    throw new SerializationError(\n      `Failed to generate grant file hash: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n    );\n  }\n}\n\n/**\n * Recursively sorts object keys for stable serialization.\n *\n * @param obj - The object to sort keys recursively\n * @returns The object with all keys sorted recursively\n */\nfunction sortObjectKeys(obj: unknown): unknown {\n  if (obj === null || typeof obj !== \"object\") {\n    return obj;\n  }\n\n  if (Array.isArray(obj)) {\n    return obj.map((item) => sortObjectKeys(item));\n  }\n\n  const sortedObj: Record<string, unknown> = {};\n  Object.keys(obj as Record<string, unknown>)\n    .sort()\n    .forEach((key) => {\n      sortedObj[key] = sortObjectKeys((obj as Record<string, unknown>)[key]);\n    });\n\n  return sortedObj;\n}\n\n/**\n * Validates that a grant file has the required structure.\n *\n * @remarks\n * Performs runtime validation to ensure data conforms to the GrantFile interface.\n * Checks for required fields (grantee, operation, parameters) and validates their\n * types and formats. This is a type guard function that enables TypeScript to\n * narrow the type when it returns true.\n *\n * @param data - The data to validate as a grant file\n * @returns True if the data is a valid grant file, false otherwise\n * @example\n * ```typescript\n * const unknownData = await fetch(url).then(r => r.json());\n *\n * if (validateGrantFile(unknownData)) {\n *   // TypeScript now knows unknownData is a GrantFile\n *   console.log(`Grant for operation: ${unknownData.operation}`);\n *   console.log(`Grantee: ${unknownData.grantee}`);\n * } else {\n *   throw new Error('Invalid grant file format');\n * }\n *\n * // Validation examples:\n * validateGrantFile({\n *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',\n *   operation: 'read',\n *   parameters: {}\n * }); // true\n *\n * validateGrantFile({\n *   grantee: 'invalid-address',\n *   operation: 'read',\n *   parameters: {}\n * }); // false (invalid address format)\n *\n * validateGrantFile({\n *   operation: 'read',\n *   parameters: {}\n * }); // false (missing grantee)\n * ```\n */\nexport function validateGrantFile(data: unknown): data is GrantFile {\n  if (!data || typeof data !== \"object\") {\n    return false;\n  }\n\n  const obj = data as Record<string, unknown>;\n\n  // Validate required fields\n  // Validate grantee address\n  if (\n    typeof obj.grantee !== \"string\" ||\n    !obj.grantee.match(/^0x[a-fA-F0-9]{40}$/)\n  ) {\n    return false;\n  }\n\n  if (typeof obj.operation !== \"string\" || obj.operation.length === 0) {\n    return false;\n  }\n\n  // Files are no longer stored in grant files - they're tracked in the contract\n\n  if (!obj.parameters || typeof obj.parameters !== \"object\") {\n    return false;\n  }\n\n  // Validate optional expires field\n  if (obj.expires !== undefined) {\n    if (\n      typeof obj.expires !== \"number\" ||\n      obj.expires < 0 ||\n      !Number.isInteger(obj.expires)\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n"],"mappings":"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","names":[]}

package/dist/utils/grantFiles.d.ts

@@ -1,33 +1,23 @@
 import type { GrantFile, GrantPermissionParams } from "../types/permissions";
 /**
- * Creates a grant file structure from permission parameters.
+ * Creates grant file structure for permission storage.
  *
  * @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.
+ * Constructs 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 - Permission parameters to create the grant file from
+ * @returns Grant file object for IPFS storage
  *
- * @param params - The permission parameters to create the grant file from
- * @returns The constructed grant file object
  * @example
  * ```typescript
- * const grantFile = createGrantFile({
- *   grantee: '0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36',
+ * const grant = createGrantFile({
+ *   grantee: '0x742d35Cc...',
  *   operation: 'llm_inference',
- *   parameters: {
- *     model: 'gpt-4',
- *     maxTokens: 1000
- *   },
+ *   parameters: { model: 'gpt-4' },
  *   expiresAt: Date.now() + 86400000 // 24 hours
  * });
- *
- * console.log(grantFile);
- * // {
- * //   grantee: '0x742d...',
- * //   operation: 'llm_inference',
- * //   parameters: { model: 'gpt-4', maxTokens: 1000 },
- * //   expires: 1234567890
- * // }
  * ```
  */
 export declare function createGrantFile(params: GrantPermissionParams): GrantFile;

package/dist/utils/grantFiles.js

@@ -4,8 +4,11 @@ function createGrantFile(params) {
   const grantFile = {
     grantee: params.grantee,
     operation: params.operation,
-    parameters: params.parameters
+    parameters: { ...params.parameters }
   };
+  if (params.filters) {
+    grantFile.parameters.filters = params.filters;
+  }
   if (params.expiresAt) {
     grantFile.expires = params.expiresAt;
   }