@opendatalabs/vana-sdk 0.1.0-alpha.5f8458e → 0.1.0-alpha.606fa2d

package/dist/index.node.d.cts

@@ -1,4 +1,4 @@
-import { Chain, Address, Hash, WalletClient, Account, Abi, GetContractReturnType, PublicClient } from 'viem';
+import { Chain, Address, Hash, WalletClient, Account, Abi, GetContractReturnType, TransactionReceipt as TransactionReceipt$1, PublicClient } from 'viem';
 export { Abi, Account, Address, Chain, GetContractReturnType, Hash, PublicClient, WalletClient } from 'viem';
 import { Abi as Abi$1 } from 'abitype';
 
@@ -984,6 +984,8 @@ interface ServerFilesAndPermissionParams {
     grant: string;
     /** File URLs */
     fileUrls: string[];
+    /** Schema IDs for each file - use 0 for files without schema validation */
+    schemaIds: number[];
     /** Server address */
     serverAddress: Address;
     /** Server URL */
@@ -1009,6 +1011,8 @@ interface ServerFilesAndPermissionTypedData extends GenericTypedData {
         grant: string;
         /** File URLs */
         fileUrls: string[];
+        /** Schema IDs for each file - use 0 for files without schema validation */
+        schemaIds: bigint[];
         /** Server address */
         serverAddress: Address;
         /** Server URL */
@@ -2159,33 +2163,84 @@ interface BatchUploadResult {
     errors?: string[];
 }
 /**
- * Represents a data schema in the refiner registry.
+ * Schema metadata from the blockchain (without fetched definition).
+ *
+ * This represents the on-chain schema registration data before the
+ * definition has been fetched from the storage URL.
+ *
+ * @category Data Management
+ */
+interface SchemaMetadata {
+    /** Schema ID */
+    id: number;
+    /** Schema name */
+    name: string;
+    /** Schema dialect ('json' or 'sqlite') */
+    dialect: "json" | "sqlite";
+    /** URL containing the schema definition */
+    definitionUrl: string;
+}
+/**
+ * Complete schema with all definition fields populated.
+ * This is what schemas.get() returns - a schema with the definition fetched.
+ */
+interface CompleteSchema extends SchemaMetadata {
+    /** Version of the schema */
+    version: string;
+    /** Optional description of the schema */
+    description?: string;
+    /** Optional version of the dialect */
+    dialectVersion?: string;
+    /** The actual schema - JSON Schema object for 'json' dialect, DDL string for 'sqlite' */
+    schema: object | string;
+}
+/**
+ * Schema with optional definition fields.
  *
  * Schemas define the structure and validation rules for user data processed by refiners.
  * They ensure data quality and consistency across the Vana network by specifying how
  * raw user data should be formatted, validated, and processed.
  *
+ * When the definition has been fetched (via schemas.get() or schemas.list() with includeDefinitions),
+ * the version and schema fields will be populated. Otherwise, only the metadata fields are present.
+ *
  * @category Data Management
  * @example
  * ```typescript
- * const socialMediaSchema: Schema = {
+ * // Complete schema from schemas.get()
+ * const completeSchema: Schema = {
+ *   id: 5,
+ *   name: 'Social Media Profile',
+ *   dialect: 'json',
+ *   definitionUrl: 'ipfs://QmSchema...',
+ *   version: '1.0.0',
+ *   description: 'Schema for validating social media profile data',
+ *   schema: { // JSON Schema object
+ *     type: 'object',
+ *     properties: {
+ *       username: { type: 'string' }
+ *     }
+ *   }
+ * };
+ *
+ * // Metadata-only schema from schemas.list() without includeDefinitions
+ * const metadataSchema: Schema = {
  *   id: 5,
  *   name: 'Social Media Profile',
- *   type: 'JSON',
- *   url: 'ipfs://QmSchema...', // Schema definition file
- *   description: 'Schema for validating social media profile data'
+ *   dialect: 'json',
+ *   definitionUrl: 'ipfs://QmSchema...'
  * };
  * ```
  */
-interface Schema {
-    /** Schema ID */
-    id: number;
-    /** Schema name */
-    name: string;
-    /** Schema type */
-    type: string;
-    /** URL containing the schema definition */
-    definitionUrl: string;
+interface Schema extends SchemaMetadata {
+    /** Version of the schema (present when definition is fetched) */
+    version?: string;
+    /** Optional description of the schema */
+    description?: string;
+    /** Optional version of the dialect */
+    dialectVersion?: string;
+    /** The actual schema - JSON Schema object for 'json' dialect, DDL string for 'sqlite' (present when definition is fetched) */
+    schema?: object | string;
 }
 /**
  * Represents a refiner with schema information
@@ -2214,8 +2269,8 @@ interface Refiner {
 interface AddSchemaParams {
     /** Schema name */
     name: string;
-    /** Schema type */
-    type: string;
+    /** Schema dialect */
+    dialect: string;
     /** URL containing the schema definition */
     definitionUrl: string;
 }
@@ -2290,13 +2345,7 @@ interface UpdateSchemaIdResult {
     transactionHash: Hash;
 }
 /**
- * Query mode for trusted server retrieval
- *
- * @category Data Management
- */
-type TrustedServerQueryMode = "subgraph" | "rpc" | "auto";
-/**
- * Trusted server data structure (unified format for both subgraph and RPC modes)
+ * Trusted server data structure
  *
  * @category Data Management
  */
@@ -2315,39 +2364,20 @@ interface TrustedServer {
     trustIndex?: number;
 }
 /**
- * Parameters for getUserTrustedServers with dual-mode support
+ * Parameters for getUserTrustedServers method
  *
  * @category Data Management
  */
 interface GetUserTrustedServersParams {
-    /** User address to query */
+    /** User address to query trusted servers for */
     user: Address;
-    /** Query mode: 'subgraph' (fast, requires subgraph), 'rpc' (direct contract), or 'auto' (tries subgraph first) */
-    mode?: TrustedServerQueryMode;
-    /** Subgraph URL (required for subgraph mode) */
+    /** Optional subgraph URL to override default */
     subgraphUrl?: string;
-    /** Pagination limit (applies to RPC mode) */
+    /** Maximum number of results */
     limit?: number;
-    /** Pagination offset (applies to RPC mode) */
+    /** Number of results to skip */
     offset?: number;
 }
-/**
- * Result of getUserTrustedServers query
- *
- * @category Data Management
- */
-interface GetUserTrustedServersResult {
-    /** Array of trusted servers */
-    servers: TrustedServer[];
-    /** Query mode that was actually used */
-    usedMode: TrustedServerQueryMode;
-    /** Total count (only available in RPC mode) */
-    total?: number;
-    /** Whether there are more servers (pagination info for RPC mode) */
-    hasMore?: boolean;
-    /** Any warnings or fallback information */
-    warnings?: string[];
-}
 
 declare const contractAbis: {
     readonly DataPortabilityPermissions: readonly [{
@@ -2466,6 +2496,18 @@ declare const contractAbis: {
         }];
         readonly name: "InvalidPermissionsLength";
         readonly type: "error";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "filesLength";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "schemaIdsLength";
+            readonly type: "uint256";
+        }];
+        readonly name: "InvalidSchemaIdsLength";
+        readonly type: "error";
     }, {
         readonly inputs: readonly [];
         readonly name: "InvalidSignature";
@@ -2742,6 +2784,10 @@ declare const contractAbis: {
                 readonly internalType: "string[]";
                 readonly name: "fileUrls";
                 readonly type: "string[]";
+            }, {
+                readonly internalType: "uint256[]";
+                readonly name: "schemaIds";
+                readonly type: "uint256[]";
             }, {
                 readonly internalType: "address";
                 readonly name: "serverAddress";
@@ -3724,7 +3770,7 @@ declare const contractAbis: {
             readonly name: "addServerInput";
             readonly type: "tuple";
         }];
-        readonly name: "addAndTrustServerOnBehalf";
+        readonly name: "addAndTrustServerByManager";
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
         readonly type: "function";
@@ -4112,6 +4158,20 @@ declare const contractAbis: {
         readonly outputs: readonly [];
         readonly stateMutability: "nonpayable";
         readonly type: "function";
+    }, {
+        readonly inputs: readonly [{
+            readonly internalType: "address";
+            readonly name: "userAddress";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "serverId";
+            readonly type: "uint256";
+        }];
+        readonly name: "trustServerByManager";
+        readonly outputs: readonly [];
+        readonly stateMutability: "nonpayable";
+        readonly type: "function";
     }, {
         readonly inputs: readonly [{
             readonly components: readonly [{
@@ -28735,6 +28795,95 @@ type VanaContract = keyof ContractAbis;
  */
 declare function getAbi<T extends VanaContract>(contract: T): ContractAbis[T];
 
+/**
+ * Comprehensive mapping of SDK transaction operations to blockchain events.
+ * Used by the generic transaction parser to know which contract and event
+ * to look for when parsing transaction results.
+ */
+declare const EVENT_MAPPINGS: {
+    readonly grant: {
+        readonly contract: "DataPortabilityPermissions";
+        readonly event: "PermissionAdded";
+    };
+    readonly revoke: {
+        readonly contract: "DataPortabilityPermissions";
+        readonly event: "PermissionRevoked";
+    };
+    readonly revokePermission: {
+        readonly contract: "DataPortabilityPermissions";
+        readonly event: "PermissionRevoked";
+    };
+    readonly addServerFilesAndPermissions: {
+        readonly contract: "DataPortabilityPermissions";
+        readonly event: "PermissionAdded";
+    };
+    readonly trustServer: {
+        readonly contract: "DataPortabilityServers";
+        readonly event: "ServerTrusted";
+    };
+    readonly untrustServer: {
+        readonly contract: "DataPortabilityServers";
+        readonly event: "ServerUntrusted";
+    };
+    readonly registerServer: {
+        readonly contract: "DataPortabilityServers";
+        readonly event: "ServerRegistered";
+    };
+    readonly updateServer: {
+        readonly contract: "DataPortabilityServers";
+        readonly event: "ServerUpdated";
+    };
+    readonly addAndTrustServer: {
+        readonly contract: "DataPortabilityServers";
+        readonly event: "ServerTrusted";
+    };
+    readonly addFile: {
+        readonly contract: "DataRegistry";
+        readonly event: "FileAdded";
+    };
+    readonly addFileWithPermissionsAndSchema: {
+        readonly contract: "DataRegistry";
+        readonly event: "FileAdded";
+    };
+    readonly addFileWithSchema: {
+        readonly contract: "DataRegistry";
+        readonly event: "FileAdded";
+    };
+    readonly addFileWithPermissions: {
+        readonly contract: "DataRegistry";
+        readonly event: "FileAdded";
+    };
+    readonly addRefinement: {
+        readonly contract: "DataRegistry";
+        readonly event: "RefinementAdded";
+    };
+    readonly addRefiner: {
+        readonly contract: "DataRefinerRegistry";
+        readonly event: "RefinerAdded";
+    };
+    readonly updateSchemaId: {
+        readonly contract: "DataRefinerRegistry";
+        readonly event: "SchemaAdded";
+    };
+    readonly addSchema: {
+        readonly contract: "DataRefinerRegistry";
+        readonly event: "SchemaAdded";
+    };
+    readonly updateRefinement: {
+        readonly contract: "DataRegistry";
+        readonly event: "RefinementUpdated";
+    };
+    readonly addFilePermission: {
+        readonly contract: "DataRegistry";
+        readonly event: "PermissionGranted";
+    };
+    readonly registerGrantee: {
+        readonly contract: "DataPortabilityGrantees";
+        readonly event: "GranteeRegistered";
+    };
+};
+type TransactionOperation = keyof typeof EVENT_MAPPINGS;
+
 /**
  * Base interface for all transaction results.
  * Contains the event data plus transaction metadata.
@@ -28772,6 +28921,62 @@ interface PermissionRevokeResult extends BaseTransactionResult {
     /** ID of the permission that was revoked */
     permissionId: bigint;
 }
+/**
+ * Result of a successful server trust operation.
+ * Contains data from the ServerTrusted blockchain event.
+ */
+interface ServerTrustResult extends BaseTransactionResult {
+    /** Address of the user who trusted the server */
+    user: Address;
+    /** Address/ID of the trusted server */
+    serverId: Address;
+    /** URL of the trusted server */
+    serverUrl: string;
+}
+/**
+ * Result of a successful server untrust operation.
+ * Contains data from the ServerUntrusted blockchain event.
+ */
+interface ServerUntrustResult extends BaseTransactionResult {
+    /** Address of the user who untrusted the server */
+    user: Address;
+    /** Address/ID of the untrusted server */
+    serverId: Address;
+}
+/**
+ * Result of a successful server update operation.
+ * Contains data from the ServerUpdated blockchain event.
+ */
+interface ServerUpdateResult extends BaseTransactionResult {
+    /** ID of the server that was updated */
+    serverId: bigint;
+    /** New URL of the server */
+    url: string;
+}
+/**
+ * Result of a successful grantee registration operation.
+ * Contains data from the GranteeRegistered blockchain event.
+ */
+interface GranteeRegisterResult extends BaseTransactionResult {
+    /** Unique grantee ID assigned by the registry */
+    granteeId: bigint;
+    /** Address of the registered grantee */
+    granteeAddress: Address;
+    /** Display name of the grantee */
+    name: string;
+}
+/**
+ * Result of a successful file addition operation.
+ * Contains data from the FileAdded blockchain event.
+ */
+interface FileAddedResult extends BaseTransactionResult {
+    /** Unique file ID assigned by the registry */
+    fileId: bigint;
+    /** Address of the file owner */
+    ownerAddress: Address;
+    /** URL where the file is stored */
+    url: string;
+}
 /**
  * Result of a successful file permission addition operation.
  * Contains data from the FilePermissionAdded blockchain event.
@@ -28785,6 +28990,80 @@ interface FilePermissionResult extends BaseTransactionResult {
     encryptedKey: string;
 }
 
+/**
+ * Provides a unified interface for blockchain transaction results with lazy-loaded event parsing.
+ *
+ * @remarks
+ * TransactionHandle enables immediate access to transaction hashes while providing optional
+ * lazy-loaded access to receipts and parsed event data. All transaction-submitting methods
+ * in the SDK return this handle, allowing developers to choose between immediate hash access
+ * or waiting for event data. Results are memoized to prevent redundant network calls.
+ *
+ * @category Transactions
+ * @example
+ * ```typescript
+ * // Immediate hash access
+ * const tx = await sdk.permissions.submitSignedGrant(typedData, signature);
+ * console.log(`Transaction submitted: ${tx.hash}`);
+ *
+ * // Wait for and parse events
+ * const eventData = await tx.waitForEvents();
+ * console.log(`Permission ID: ${eventData.permissionId}`);
+ *
+ * // Check receipt for gas usage
+ * const receipt = await tx.waitForReceipt();
+ * console.log(`Gas used: ${receipt.gasUsed}`);
+ * ```
+ */
+declare class TransactionHandle<TEventData = unknown> {
+    private readonly context;
+    readonly hash: Hash;
+    private readonly operation?;
+    private _receipt?;
+    private _eventData?;
+    private _receiptPromise?;
+    private _eventPromise?;
+    constructor(context: ControllerContext$1, hash: Hash, operation?: TransactionOperation | undefined);
+    /**
+     * Waits for transaction confirmation and returns the receipt.
+     * Results are memoized - multiple calls return the same promise.
+     *
+     * @param options Optional timeout configuration
+     * @param options.timeout Timeout in milliseconds (default: 30000)
+     * @returns Transaction receipt with gas usage, logs, and status
+     */
+    waitForReceipt(options?: {
+        timeout?: number;
+    }): Promise<TransactionReceipt$1>;
+    /**
+     * Waits for transaction confirmation and parses emitted events.
+     * Results are memoized - multiple calls return the same promise.
+     *
+     * @returns Parsed event data with transaction metadata
+     * @throws {Error} If no operation was specified for event parsing
+     */
+    waitForEvents(): Promise<TEventData>;
+    /**
+     * Enables string coercion for backwards compatibility.
+     * Allows TransactionHandle to be used anywhere a Hash is expected.
+     *
+     * @example
+     * ```typescript
+     * const hash: Hash = tx; // Works via toString()
+     * console.log(`Transaction: ${tx}`); // Prints hash
+     * ```
+     * @returns The transaction hash as a string
+     */
+    toString(): string;
+    /**
+     * JSON serialization support.
+     * Returns the hash when serialized to JSON.
+     *
+     * @returns The transaction hash for JSON serialization
+     */
+    toJSON(): string;
+}
+
 /**
  * Google Drive Storage Provider for Vana SDK
  *
@@ -29823,30 +30102,31 @@ declare class PermissionsController {
      */
     grant(params: GrantPermissionParams$1): Promise<PermissionGrantResult>;
     /**
-     * Submits a permission grant transaction and returns the transaction hash immediately.
+     * Submits a permission grant transaction and returns a handle for flexible result access.
      *
-     * This is the lower-level method that provides maximum control over transaction timing.
-     * Use this when you want to handle transaction confirmation and event parsing separately,
-     * or when submitting multiple transactions in batch.
+     * @remarks
+     * This lower-level method provides maximum control over transaction timing.
+     * Returns a TransactionHandle that allows immediate hash access or optional event parsing.
+     * Use this when handling multiple transactions or when you need granular control.
      *
      * @param params - The permission grant configuration object
-     * @returns Promise that resolves to the transaction hash when successfully submitted
+     * @returns Promise resolving to TransactionHandle with hash and event parsing capabilities
      * @throws {RelayerError} When gasless transaction submission fails
      * @throws {SignatureError} When user rejects the signature request
      * @throws {SerializationError} When grant data cannot be serialized
      * @throws {BlockchainError} When permission grant preparation fails
      * @example
      * ```typescript
-     * // Submit transaction and handle confirmation later
-     * const txHash = await vana.permissions.submitPermissionGrant(params);
-     * console.log(`Transaction submitted: ${txHash}`);
+     * // Submit transaction and get immediate hash access
+     * const tx = await vana.permissions.submitPermissionGrant(params);
+     * console.log(`Transaction submitted: ${tx.hash}`);
      *
-     * // Later, when you need the permission data:
-     * const result = await parseTransactionResult(context, txHash, 'grant');
-     * console.log(`Permission ID: ${result.permissionId}`);
+     * // Optionally wait for and parse events
+     * const eventData = await tx.waitForEvents();
+     * console.log(`Permission ID: ${eventData.permissionId}`);
      * ```
      */
-    submitPermissionGrant(params: GrantPermissionParams$1): Promise<Hash>;
+    submitPermissionGrant(params: GrantPermissionParams$1): Promise<TransactionHandle<PermissionGrantResult>>;
     /**
      * Prepares a permission grant with preview before signing.
      *
@@ -29874,15 +30154,21 @@ declare class PermissionsController {
      */
     prepareGrant(params: GrantPermissionParams$1): Promise<{
         preview: GrantFile;
-        confirm: () => Promise<Hash>;
+        confirm: () => Promise<TransactionHandle<PermissionGrantResult>>;
     }>;
     /**
-     * Internal method to complete the grant process after user confirmation.
-     * This is called by the confirm() function returned from prepareGrant().
+     * Completes the grant process after user confirmation.
+     *
+     * @remarks
+     * This internal method is called by the confirm() function returned from prepareGrant().
+     * It handles IPFS upload, signature creation, and transaction submission.
      *
      * @param params - The permission grant parameters containing user and operation details
      * @param grantFile - The prepared grant file with permissions and metadata
-     * @returns Promise resolving to the transaction hash
+     * @returns Promise resolving to TransactionHandle for flexible result access
+     * @throws {BlockchainError} When permission grant confirmation fails
+     * @throws {NetworkError} When IPFS upload fails
+     * @throws {SignatureError} When user rejects the signature
      */
     private confirmGrantInternal;
     /**
@@ -29938,49 +30224,106 @@ declare class PermissionsController {
      * );
      * ```
      */
-    submitSignedGrant(typedData: PermissionGrantTypedData, signature: Hash): Promise<Hash>;
+    submitSignedGrant(typedData: PermissionGrantTypedData, signature: Hash): Promise<TransactionHandle<PermissionGrantResult>>;
     /**
      * Submits an already-signed trust server transaction to the blockchain.
+     *
+     * @remarks
      * This method extracts the trust server input from typed data and submits it directly.
+     * Used internally by trust server methods after signature collection.
      *
      * @param typedData - The EIP-712 typed data for TrustServer
-     * @param signature - The user's signature
-     * @returns Promise resolving to the transaction hash
+     * @param signature - The user's signature obtained via `signTypedData()`
+     * @returns Promise resolving to TransactionHandle for transaction tracking
+     * @throws {BlockchainError} When contract submission fails
+     * @throws {NetworkError} When blockchain communication fails
+     * @example
+     * ```typescript
+     * const txHandle = await vana.permissions.submitSignedTrustServer(
+     *   typedData,
+     *   "0x1234..."
+     * );
+     * const result = await txHandle.waitForEvents();
+     * ```
      */
-    submitSignedTrustServer(typedData: TrustServerTypedData, signature: Hash): Promise<Hash>;
+    submitSignedTrustServer(typedData: TrustServerTypedData, signature: Hash): Promise<TransactionHandle<ServerTrustResult>>;
     /**
      * Submits an already-signed add and trust server transaction to the blockchain.
+     *
+     * @remarks
      * This method extracts the add and trust server input from typed data and submits it directly.
+     * Combines server registration and trust operations in a single transaction.
      *
      * @param typedData - The EIP-712 typed data for AddAndTrustServer
-     * @param signature - The user's signature
-     * @returns Promise resolving to the transaction hash
+     * @param signature - The user's signature obtained via `signTypedData()`
+     * @returns Promise resolving to TransactionHandle for transaction tracking
+     * @throws {BlockchainError} When contract submission fails
+     * @throws {NetworkError} When blockchain communication fails
+     * @example
+     * ```typescript
+     * const txHandle = await vana.permissions.submitSignedAddAndTrustServer(
+     *   typedData,
+     *   "0x1234..."
+     * );
+     * const result = await txHandle.waitForEvents();
+     * ```
      */
-    submitSignedAddAndTrustServer(typedData: AddAndTrustServerTypedData, signature: Hash): Promise<Hash>;
+    submitSignedAddAndTrustServer(typedData: AddAndTrustServerTypedData, signature: Hash): Promise<TransactionHandle<ServerTrustResult>>;
     /**
      * Submits an already-signed permission revoke transaction to the blockchain.
+     *
+     * @remarks
      * This method handles the revocation of previously granted permissions.
+     * Used internally by revocation methods after signature collection.
      *
      * @param typedData - The EIP-712 typed data for PermissionRevoke
-     * @param signature - The user's signature
-     * @returns Promise resolving to the transaction hash
+     * @param signature - The user's signature obtained via `signTypedData()`
+     * @returns Promise resolving to TransactionHandle for transaction tracking
+     * @throws {BlockchainError} When contract submission fails
+     * @throws {NetworkError} When blockchain communication fails
+     * @example
+     * ```typescript
+     * const txHandle = await vana.permissions.submitSignedRevoke(
+     *   typedData,
+     *   "0x1234..."
+     * );
+     * const result = await txHandle.waitForEvents();
+     * ```
      */
-    submitSignedRevoke(typedData: GenericTypedData, signature: Hash): Promise<Hash>;
+    submitSignedRevoke(typedData: GenericTypedData, signature: Hash): Promise<TransactionHandle<PermissionRevokeResult>>;
     /**
      * Submits an already-signed untrust server transaction to the blockchain.
+     *
+     * @remarks
      * This method handles the removal of trusted servers.
+     * Used internally by untrust server methods after signature collection.
      *
      * @param typedData - The EIP-712 typed data for UntrustServer
-     * @param signature - The user's signature
-     * @returns Promise resolving to the transaction hash
+     * @param signature - The user's signature obtained via `signTypedData()`
+     * @returns Promise resolving to TransactionHandle for transaction tracking
+     * @throws {BlockchainError} When contract submission fails
+     * @throws {NetworkError} When blockchain communication fails
+     * @example
+     * ```typescript
+     * const txHandle = await vana.permissions.submitSignedUntrustServer(
+     *   typedData,
+     *   "0x1234..."
+     * );
+     * const result = await txHandle.waitForEvents();
+     * ```
      */
-    submitSignedUntrustServer(typedData: GenericTypedData, signature: Hash): Promise<Hash>;
+    submitSignedUntrustServer(typedData: GenericTypedData, signature: Hash): Promise<TransactionHandle<ServerUntrustResult>>;
     /**
      * Submits a signed transaction directly to the blockchain.
      *
+     * @remarks
+     * Internal method used when relayer callbacks are not available. Formats the signature
+     * and submits the permission grant directly to the smart contract.
+     *
      * @param typedData - The typed data structure for the permission grant
      * @param signature - The cryptographic signature authorizing the transaction
      * @returns Promise resolving to the transaction hash
+     * @throws {BlockchainError} When contract submission fails
      */
     private submitDirectTransaction;
     /**
@@ -30027,19 +30370,33 @@ declare class PermissionsController {
      * console.log(`Revocation submitted: ${txHash}`);
      * ```
      */
-    submitPermissionRevoke(params: RevokePermissionParams): Promise<Hash>;
+    submitPermissionRevoke(params: RevokePermissionParams): Promise<TransactionHandle<PermissionRevokeResult>>;
     /**
-     * Revokes a permission with a signature (gasless transaction).
+     * Revokes a permission with a signature for gasless transactions.
+     *
+     * @remarks
+     * This method creates an EIP-712 signature for permission revocation and submits
+     * it either through relayer callbacks or directly to the blockchain. Provides
+     * gasless revocation when relayer is configured.
      *
      * @param params - Parameters for revoking the permission
-     * @returns Promise resolving to transaction hash
+     * @param params.permissionId - Permission identifier to revoke (accepts bigint, number, or string)
+     * @returns Promise resolving to TransactionHandle for transaction tracking
      * @throws {BlockchainError} When chain ID is not available
      * @throws {NonceError} When retrieving user nonce fails
      * @throws {SignatureError} When user rejects the signature request
      * @throws {RelayerError} When gasless submission fails
      * @throws {PermissionError} When revocation fails for any other reason
+     * @example
+     * ```typescript
+     * const txHandle = await vana.permissions.submitRevokeWithSignature({
+     *   permissionId: 123n
+     * });
+     * const result = await txHandle.waitForEvents();
+     * console.log(`Permission ${result.permissionId} revoked`);
+     * ```
      */
-    submitRevokeWithSignature(params: RevokePermissionParams): Promise<Hash>;
+    submitRevokeWithSignature(params: RevokePermissionParams): Promise<TransactionHandle<PermissionRevokeResult>>;
     /**
      * @deprecated Use getPermissionsUserNonce() for permission operations or getServersUserNonce() for server operations
      *
@@ -30064,6 +30421,18 @@ declare class PermissionsController {
      * const serversNonce = await this.getServersUserNonce();
      * ```
      */
+    /**
+     * @deprecated Use getPermissionsUserNonce() for permission operations or getServersUserNonce() for server operations
+     *
+     * Retrieves the user's current nonce from the DataPortabilityServers contract.
+     *
+     * @remarks
+     * This method is deprecated in favor of more specific nonce methods that target
+     * the appropriate contract for the operation being performed.
+     *
+     * @returns Promise resolving to the user's current nonce as a bigint
+     * @throws {NonceError} When retrieving the nonce fails
+     */
     private getUserNonce;
     /**
      * Retrieves the user's current nonce from the DataPortabilityServers contract.
@@ -30079,6 +30448,16 @@ declare class PermissionsController {
      * console.log(`Current servers nonce: ${nonce}`);
      * ```
      */
+    /**
+     * Retrieves the user's current nonce from the DataPortabilityServers contract.
+     *
+     * @remarks
+     * Used for server-related operations (trust/untrust) to prevent replay attacks.
+     * The nonce must be incremented with each server operation.
+     *
+     * @returns Promise resolving to the user's current nonce as a bigint
+     * @throws {NonceError} When retrieving the nonce fails
+     */
     private getServersUserNonce;
     /**
      * Retrieves the user's current nonce from the DataPortabilityPermissions contract.
@@ -30094,6 +30473,16 @@ declare class PermissionsController {
      * console.log(`Current permissions nonce: ${nonce}`);
      * ```
      */
+    /**
+     * Retrieves the user's current nonce from the DataPortabilityPermissions contract.
+     *
+     * @remarks
+     * Used for permission-related operations (grant/revoke) to prevent replay attacks.
+     * The nonce must be incremented with each permission operation.
+     *
+     * @returns Promise resolving to the user's current nonce as a bigint
+     * @throws {NonceError} When retrieving the nonce fails
+     */
     private getPermissionsUserNonce;
     /**
      * Composes the EIP-712 typed data for PermissionGrant (new simplified format).
@@ -30115,6 +30504,7 @@ declare class PermissionsController {
      * @param params.granteeId - Grantee ID
      * @param params.grant - Grant URL or grant data
      * @param params.fileUrls - Array of file URLs
+     * @param params.schemaIds - Schema IDs for each file
      * @param params.serverAddress - Server address
      * @param params.serverUrl - Server URL
      * @param params.serverPublicKey - Server public key
@@ -30220,7 +30610,7 @@ declare class PermissionsController {
      * console.log('Now trusting servers:', trustedServers);
      * ```
      */
-    addAndTrustServer(params: AddAndTrustServerParams): Promise<Hash>;
+    addAndTrustServer(params: AddAndTrustServerParams): Promise<TransactionHandle<ServerTrustResult>>;
     /**
      * Trusts a server for data processing (legacy method).
      *
@@ -30228,14 +30618,14 @@ declare class PermissionsController {
      * @returns Promise resolving to transaction hash
      * @deprecated Use addAndTrustServer instead
      */
-    submitTrustServer(params: TrustServerParams): Promise<Hash>;
+    submitTrustServer(params: TrustServerParams): Promise<TransactionHandle<ServerTrustResult>>;
     /**
      * Adds and trusts a server using a signature (gasless transaction).
      *
      * @param params - Parameters for adding and trusting the server
-     * @returns Promise resolving to transaction hash
+     * @returns Promise resolving to TransactionHandle with ServerTrustResult event data
      */
-    submitAddAndTrustServerWithSignature(params: AddAndTrustServerParams): Promise<Hash>;
+    submitAddAndTrustServerWithSignature(params: AddAndTrustServerParams): Promise<TransactionHandle<ServerTrustResult>>;
     /**
      * Trusts a server using a signature (gasless transaction - legacy method).
      *
@@ -30249,13 +30639,24 @@ declare class PermissionsController {
      * @throws {ServerUrlMismatchError} When server URL doesn't match existing registration
      * @throws {BlockchainError} When trust operation fails for any other reason
      */
-    submitTrustServerWithSignature(params: TrustServerParams): Promise<Hash>;
+    submitTrustServerWithSignature(params: TrustServerParams): Promise<TransactionHandle<ServerTrustResult>>;
     /**
      * Submits a direct untrust server transaction (without signature).
      *
      * @param params - The untrust server parameters containing server details
      * @returns Promise resolving to the transaction hash
      */
+    /**
+     * Submits an untrust server transaction directly to the blockchain.
+     *
+     * @remarks
+     * Internal method used for direct blockchain submission of untrust server operations
+     * when relayer callbacks are not available.
+     *
+     * @param params - The untrust server parameters
+     * @returns Promise resolving to TransactionHandle for transaction tracking
+     * @throws {BlockchainError} When contract submission fails
+     */
     private submitDirectUntrustTransaction;
     /**
      * Removes a server from the user's trusted servers list in the DataPortabilityServers contract.
@@ -30285,7 +30686,7 @@ declare class PermissionsController {
      * console.log('Still trusting servers:', trustedServers);
      * ```
      */
-    submitUntrustServer(params: UntrustServerParams): Promise<Hash>;
+    submitUntrustServer(params: UntrustServerParams): Promise<TransactionHandle<ServerUntrustResult>>;
     /**
      * Untrusts a server using a signature (gasless transaction).
      *
@@ -30298,7 +30699,7 @@ declare class PermissionsController {
      * @throws {RelayerError} When gasless submission fails
      * @throws {BlockchainError} When untrust transaction fails
      */
-    submitUntrustServerWithSignature(params: UntrustServerParams): Promise<Hash>;
+    submitUntrustServerWithSignature(params: UntrustServerParams): Promise<TransactionHandle<ServerUntrustResult>>;
     /**
      * Retrieves all servers trusted by a user from the DataPortabilityServers contract.
      *
@@ -30349,22 +30750,60 @@ declare class PermissionsController {
     /**
      * Gets server information for multiple servers efficiently.
      *
-     * @param serverIds - Array of server IDs to query
-     * @returns Promise resolving to batch result with successes and failures
+     * @remarks
+     * This method uses multicall to fetch information for multiple servers in a single
+     * blockchain call, improving performance when querying many servers. Failed lookups
+     * are returned separately for error handling.
+     *
+     * @param serverIds - Array of numeric server IDs to query
+     * @returns Promise resolving to batch result containing successful lookups and failed IDs
      * @throws {BlockchainError} When reading from contract fails or chain is unavailable
+     * @example
+     * ```typescript
+     * const result = await vana.permissions.getServerInfoBatch([1, 2, 3, 999]);
+     *
+     * // Process successful lookups
+     * result.servers.forEach((server, id) => {
+     *   console.log(`Server ${id}: ${server.url}`);
+     * });
+     *
+     * // Handle failed lookups
+     * if (result.failed.length > 0) {
+     *   console.log(`Failed to fetch: ${result.failed.join(', ')}`);
+     * }
+     * ```
      */
     getServerInfoBatch(serverIds: number[]): Promise<BatchServerInfoResult>;
     /**
      * Checks whether a specific server is trusted by a user.
      *
-     * @param serverId - Server ID to check (numeric)
+     * @remarks
+     * This method queries the user's trusted server list and checks if the specified
+     * server is present. Returns both the trust status and the index in the trust list
+     * if trusted.
+     *
+     * @param serverId - Numeric server ID to check
      * @param userAddress - Optional user address (defaults to current user)
-     * @returns Promise resolving to server trust status
+     * @returns Promise resolving to server trust status with trust index if applicable
+     * @throws {BlockchainError} When reading from contract fails
+     * @example
+     * ```typescript
+     * const status = await vana.permissions.checkServerTrustStatus(1);
+     * if (status.isTrusted) {
+     *   console.log(`Server is trusted at index ${status.trustIndex}`);
+     * } else {
+     *   console.log('Server is not trusted');
+     * }
+     * ```
      */
     checkServerTrustStatus(serverId: number, userAddress?: Address): Promise<ServerTrustStatus>;
     /**
      * Composes EIP-712 typed data for AddAndTrustServer.
      *
+     * @remarks
+     * Creates the complete typed data structure required for EIP-712 signature generation
+     * when adding and trusting a new server in a single transaction.
+     *
      * @param input - The add and trust server input data containing server details
      * @returns Promise resolving to the typed data structure for server add and trust
      */
@@ -30446,7 +30885,7 @@ declare class PermissionsController {
      * console.log(`Grantee registered in transaction: ${txHash}`);
      * ```
      */
-    submitRegisterGrantee(params: RegisterGranteeParams): Promise<Hash>;
+    submitRegisterGrantee(params: RegisterGranteeParams): Promise<TransactionHandle<GranteeRegisterResult>>;
     /**
      * Registers a grantee with a signature (gasless transaction)
      *
@@ -30462,7 +30901,7 @@ declare class PermissionsController {
      * });
      * ```
      */
-    submitRegisterGranteeWithSignature(params: RegisterGranteeParams): Promise<Hash>;
+    submitRegisterGranteeWithSignature(params: RegisterGranteeParams): Promise<TransactionHandle<GranteeRegisterResult>>;
     /**
      * Submits a signed register grantee transaction via relayer
      *
@@ -30475,7 +30914,7 @@ declare class PermissionsController {
      * const result = await vana.permissions.submitSignedRegisterGrantee(typedData, signature);
      * ```
      */
-    submitSignedRegisterGrantee(typedData: RegisterGranteeTypedData, signature: Hash): Promise<Hash>;
+    submitSignedRegisterGrantee(typedData: RegisterGranteeTypedData, signature: Hash): Promise<TransactionHandle<GranteeRegisterResult>>;
     /**
      * Retrieves all registered grantees from the DataPortabilityGrantees contract.
      *
@@ -30762,7 +31201,7 @@ declare class PermissionsController {
      * @param url - New URL for the server
      * @returns Promise resolving to transaction hash
      */
-    submitUpdateServer(serverId: bigint, url: string): Promise<Hash>;
+    submitUpdateServer(serverId: bigint, url: string): Promise<TransactionHandle<ServerUpdateResult>>;
     /**
      * Get all permission IDs for a user
      *
@@ -30802,49 +31241,106 @@ declare class PermissionsController {
      * @throws {BlockchainError} When permission addition fails
      * @throws {NetworkError} When network communication fails
      */
-    submitAddPermission(params: ServerFilesAndPermissionParams): Promise<Hash>;
+    submitAddPermission(params: ServerFilesAndPermissionParams): Promise<TransactionHandle<PermissionGrantResult>>;
     /**
      * Submits an already-signed add permission transaction to the blockchain.
      * This method supports both relayer-based gasless transactions and direct transactions.
      *
      * @param typedData - The EIP-712 typed data for AddPermission
      * @param signature - The user's signature
-     * @returns Promise resolving to the transaction hash
+     * @returns Promise resolving to TransactionHandle with PermissionGrantResult event data
      * @throws {RelayerError} When gasless transaction submission fails
      * @throws {BlockchainError} When permission addition fails
      * @throws {NetworkError} When network communication fails
      */
-    submitSignedAddPermission(typedData: GenericTypedData, signature: Hash): Promise<Hash>;
+    submitSignedAddPermission(typedData: GenericTypedData, signature: Hash): Promise<TransactionHandle<PermissionGrantResult>>;
     /**
-     * Submit server files and permissions with signature to the blockchain (supports gasless transactions)
+     * Submits server files and permissions with signature to the blockchain, supporting schema validation and gasless transactions.
+     *
+     * @remarks
+     * This method validates files against their specified schemas before submission.
+     * Schema validation ensures data conforms to expected formats before on-chain registration.
+     * Files with schemaId = 0 bypass validation. The method supports atomic batch operations
+     * where all files and permissions are registered in a single transaction.
      *
      * @param params - Parameters for adding server files and permissions
-     * @returns Promise resolving to transaction hash
-     * @throws {RelayerError} When gasless transaction submission fails
+     * @param params.granteeId - The ID of the permission grantee
+     * @param params.grant - Grant URL containing permission parameters (typically IPFS)
+     * @param params.fileUrls - Array of file URLs to register
+     * @param params.schemaIds - Schema IDs for each file. Use 0 for files without schema validation.
+     *   Array length must match fileUrls length.
+     * @param params.serverAddress - Server wallet address for decryption permissions
+     * @param params.serverUrl - Server endpoint URL
+     * @param params.serverPublicKey - Server's public key for encryption.
+     *   Obtain via `vana.server.getIdentity(userAddress).public_key`.
+     * @param params.filePermissions - Nested array of permissions for each file
+     * @returns TransactionHandle with immediate hash access and event parsing capability
+     * @throws {Error} When schemaIds array length doesn't match fileUrls array length
+     * @throws {SchemaValidationError} When file data doesn't match the specified schema.
+     *   Verify data structure matches schema definition from `vana.schemas.get(schemaId)`.
+     * @throws {RelayerError} When gasless transaction submission fails.
+     *   Retry without relayer configuration to submit direct transaction.
      * @throws {SignatureError} When user rejects the signature request
      * @throws {BlockchainError} When server files and permissions addition fails
-     * @throws {NetworkError} When network communication fails
+     * @throws {NetworkError} When network communication fails.
+     *   Check network connection or configure alternative gateways.
+     *
+     * @example
+     * ```typescript
+     * const result = await vana.permissions.submitAddServerFilesAndPermissions({
+     *   granteeId: BigInt(1),
+     *   grant: "ipfs://QmXxx...",
+     *   fileUrls: ["https://storage.example.com/data.json"],
+     *   schemaIds: [123], // LinkedIn profile schema ID
+     *   serverAddress: "0x742d35Cc6634C0532925a3b844Bc9e7595f0b0Bb",
+     *   serverUrl: "https://server.example.com",
+     *   serverPublicKey: serverInfo.public_key,
+     *   filePermissions: [[{
+     *     account: "0x742d35Cc6634C0532925a3b844Bc9e7595f0b0Bb",
+     *     key: encryptedKey
+     *   }]]
+     * });
+     * const events = await result.waitForEvents();
+     * console.log(`Permission ID: ${events.permissionId}`);
+     * ```
      */
-    submitAddServerFilesAndPermissions(params: ServerFilesAndPermissionParams): Promise<Hash>;
+    submitAddServerFilesAndPermissions(params: ServerFilesAndPermissionParams): Promise<TransactionHandle<PermissionGrantResult>>;
     /**
      * Submits an already-signed add server files and permissions transaction to the blockchain.
-     * This method supports both relayer-based gasless transactions and direct transactions.
+     *
+     * @remarks
+     * This method returns a TransactionHandle that provides immediate access to the transaction hash
+     * while allowing lazy-loaded access to parsed event data. Use `waitForEvents()` to retrieve
+     * the permission ID and other event details after transaction confirmation.
      *
      * @param typedData - The EIP-712 typed data for AddServerFilesAndPermissions
      * @param signature - The user's signature
-     * @returns Promise resolving to the transaction hash
+     * @returns TransactionHandle with immediate hash access and optional event parsing
      * @throws {RelayerError} When gasless transaction submission fails
      * @throws {BlockchainError} When server files and permissions addition fails
      * @throws {NetworkError} When network communication fails
+     *
+     * @example
+     * ```typescript
+     * const tx = await vana.permissions.submitSignedAddServerFilesAndPermissions(
+     *   typedData,
+     *   signature
+     * );
+     * console.log(`Transaction submitted: ${tx.hash}`);
+     *
+     * // Wait for confirmation and get the permission ID
+     * const { permissionId } = await tx.waitForEvents();
+     * console.log(`Permission created with ID: ${permissionId}`);
+     * ```
      */
-    submitSignedAddServerFilesAndPermissions(typedData: ServerFilesAndPermissionTypedData, signature: Hash): Promise<Hash>;
+    submitSignedAddServerFilesAndPermissions(typedData: ServerFilesAndPermissionTypedData, signature: Hash): Promise<TransactionHandle<PermissionGrantResult>>;
     /**
      * Submit permission revocation with signature to the blockchain
      *
      * @param permissionId - Permission ID to revoke
      * @returns Promise resolving to transaction hash
      */
-    submitRevokePermission(permissionId: bigint): Promise<Hash>;
+    submitRevokePermission(permissionId: bigint): Promise<TransactionHandle<PermissionRevokeResult>>;
     /**
      * Submits a signed add permission transaction directly to the blockchain.
      *
@@ -30874,10 +31370,10 @@ declare class PermissionsController {
 interface CreateSchemaParams {
     /** The name of the schema */
     name: string;
-    /** The type/category of the schema */
-    type: string;
+    /** The dialect of the schema (e.g., 'json' or 'sqlite') */
+    dialect: "json" | "sqlite";
     /** The schema definition object or JSON string */
-    definition: object | string;
+    schema: object | string;
 }
 /**
  * Result of creating a new schema.
@@ -30922,8 +31418,8 @@ interface CreateSchemaResult {
  * // Create a new schema with automatic IPFS upload
  * const result = await vana.schemas.create({
  *   name: "User Profile",
- *   type: "personal",
- *   definition: {
+ *   dialect: "json",
+ *   schema: {
  *     type: "object",
  *     properties: {
  *       name: { type: "string" },
@@ -30958,7 +31454,7 @@ declare class SchemaController {
      * - Uploads the definition to IPFS to generate a permanent URL
      * - Registers the schema on the blockchain with the generated URL
      *
-     * @param params - Schema creation parameters including name, type, and definition
+     * @param params - Schema creation parameters including name, dialect, and definition
      * @returns Promise resolving to creation results with schema ID and transaction hash
      * @throws {SchemaValidationError} When the schema definition is invalid
      * @throws {Error} When IPFS upload or blockchain registration fails
@@ -30967,8 +31463,8 @@ declare class SchemaController {
      * // Create a JSON schema for user profiles
      * const result = await vana.schemas.create({
      *   name: "User Profile",
-     *   type: "personal",
-     *   definition: {
+     *   dialect: "json",
+     *   schema: {
      *     type: "object",
      *     properties: {
      *       name: { type: "string" },
@@ -30983,42 +31479,66 @@ declare class SchemaController {
      */
     create(params: CreateSchemaParams): Promise<CreateSchemaResult>;
     /**
-     * Retrieves a schema by its ID.
+     * Retrieves a complete schema by its ID with definition fetched and flattened.
      *
      * @param schemaId - The ID of the schema to retrieve
-     * @returns Promise resolving to the schema object
-     * @throws {Error} When the schema is not found or chain is unavailable
+     * @param options - Optional parameters
+     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
+     * @returns Promise resolving to the complete schema object with all fields populated
+     * @throws {Error} When the schema is not found, definition cannot be fetched, or chain is unavailable
      * @example
      * ```typescript
      * const schema = await vana.schemas.get(1);
-     * console.log(`Schema: ${schema.name} (${schema.type})`);
+     * console.log(`Schema: ${schema.name} (${schema.dialect})`);
+     * console.log(`Version: ${schema.version}`);
+     * console.log(`Description: ${schema.description}`);
+     * console.log('Schema:', schema.schema);
+     *
+     * // Use directly with validator (schema has all required fields)
+     * validator.validateDataAgainstSchema(data, schema);
      * ```
      */
-    get(schemaId: number): Promise<Schema>;
+    get(schemaId: number, options?: {
+        subgraphUrl?: string;
+    }): Promise<CompleteSchema>;
     /**
      * Gets the total number of schemas registered on the network.
      *
+     * @param options - Optional parameters
+     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
      * @returns Promise resolving to the total schema count
      * @throws {Error} When the count cannot be retrieved
      * @example
      * ```typescript
      * const count = await vana.schemas.count();
      * console.log(`Total schemas: ${count}`);
+     *
+     * // With custom subgraph
+     * const count = await vana.schemas.count({
+     *   subgraphUrl: 'https://custom-subgraph.com/graphql'
+     * });
      * ```
      */
-    count(): Promise<number>;
+    count(options?: {
+        subgraphUrl?: string;
+    }): Promise<number>;
     /**
      * Lists all schemas with pagination.
      *
      * @param options - Optional parameters for listing schemas
      * @param options.limit - Maximum number of schemas to return
      * @param options.offset - Number of schemas to skip
+     * @param options.subgraphUrl - Custom subgraph URL to use instead of default
+     * @param options.includeDefinitions - Whether to fetch and include schema definitions (default: false for performance)
      * @returns Promise resolving to an array of schemas
      * @example
      * ```typescript
-     * // Get all schemas
+     * // Get all schemas (without definitions for performance)
      * const schemas = await vana.schemas.list();
      *
+     * // Get schemas with definitions
+     * const schemas = await vana.schemas.list({ includeDefinitions: true });
+     *
      * // Get schemas with pagination
      * const schemas = await vana.schemas.list({ limit: 10, offset: 0 });
      * ```
@@ -31026,6 +31546,8 @@ declare class SchemaController {
     list(options?: {
         limit?: number;
         offset?: number;
+        subgraphUrl?: string;
+        includeDefinitions?: boolean;
     }): Promise<Schema[]>;
     /**
      * Adds a schema using the legacy method (low-level API).
@@ -31035,6 +31557,36 @@ declare class SchemaController {
      * @returns Promise resolving to the add schema result
      */
     addSchema(params: AddSchemaParams): Promise<AddSchemaResult>;
+    /**
+     * Internal method: Query schema via subgraph
+     *
+     * @param params - Query parameters
+     * @param params.schemaId - The ID of the schema to retrieve
+     * @param params.subgraphUrl - The subgraph URL to query
+     * @returns Promise resolving to the schema object
+     * @private
+     */
+    private _getSchemaViaSubgraph;
+    /**
+     * Internal method: List schemas via subgraph
+     *
+     * @param params - Query parameters
+     * @param params.limit - Maximum number of schemas to return
+     * @param params.offset - Number of schemas to skip
+     * @param params.subgraphUrl - The subgraph URL to query
+     * @returns Promise resolving to an array of schemas
+     * @private
+     */
+    private _listSchemasViaSubgraph;
+    /**
+     * Internal method: Count schemas via subgraph
+     *
+     * @param params - Query parameters
+     * @param params.subgraphUrl - The subgraph URL to query
+     * @returns Promise resolving to the total schema count
+     * @private
+     */
+    private _countSchemasViaSubgraph;
     /**
      * Gets the user's wallet address.
      *
@@ -31042,6 +31594,13 @@ declare class SchemaController {
      * @returns Promise resolving to the user's address
      */
     private getUserAddress;
+    /**
+     * Fetches and attaches definitions to an array of schemas.
+     *
+     * @param schemas - Array of schemas to fetch definitions for
+     * @private
+     */
+    private _fetchDefinitionsForSchemas;
 }
 
 /**
@@ -31116,34 +31675,30 @@ declare class SchemaValidator {
      */
     validateDataSchema(schema: unknown): asserts schema is DataSchema;
     /**
-     * Validates data against a JSON Schema from a data schema
+     * Validates data against a JSON Schema from a schema
      *
      * @param data - The data to validate
-     * @param schema - The data schema containing the schema
+     * @param schema - The schema containing the validation rules (DataSchema or Schema)
      * @throws SchemaValidationError if invalid
      * @example
      * ```typescript
      * const validator = new SchemaValidator();
      *
-     * const schema = {
+     * // Works with Schema from schemas.get()
+     * const schema = await vana.schemas.get(1);
+     * validator.validateDataAgainstSchema(userData, schema);
+     *
+     * // Also works with DataSchema object
+     * const dataSchema: DataSchema = {
      *   name: "User Profile",
      *   version: "1.0.0",
      *   dialect: "json",
-     *   schema: {
-     *     type: "object",
-     *     properties: {
-     *       name: { type: "string" },
-     *       age: { type: "number" }
-     *     },
-     *     required: ["name"]
-     *   }
+     *   schema: { type: "object", properties: { name: { type: "string" } } }
      * };
-     *
-     * const userData = { name: "Alice", age: 30 };
-     * validator.validateDataAgainstSchema(userData, schema);
+     * validator.validateDataAgainstSchema(userData, dataSchema);
      * ```
      */
-    validateDataAgainstSchema(data: unknown, schema: DataSchema): void;
+    validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void;
     /**
      * Validates a SQLite DDL string for basic syntax
      * Note: This is a basic validation, full SQL parsing would require a proper SQL parser
@@ -31187,7 +31742,7 @@ declare function validateDataSchema(schema: unknown): asserts schema is DataSche
  * @returns void - Function doesn't return a value
  * @throws SchemaValidationError if invalid
  */
-declare function validateDataAgainstSchema(data: unknown, schema: DataSchema): void;
+declare function validateDataAgainstSchema(data: unknown, schema: DataSchema | Schema): void;
 /**
  * Convenience function to fetch and validate a schema from a URL
  *
@@ -33683,19 +34238,18 @@ declare class DataController {
         subgraphUrl?: string;
     }): Promise<UserFile$1[]>;
     /**
-     * Retrieves a list of permissions granted by a user using the new subgraph entities.
+     * Retrieves a list of permissions granted by a user.
      *
-     * This method queries the Vana subgraph to find permissions directly granted by the user
-     * using the new Permission entity. It efficiently handles millions of permissions by:
-     * 1. Querying the subgraph for user's directly granted permissions
-     * 2. Returning complete permission information from subgraph
-     * 3. No need for additional contract calls as all data comes from subgraph
+     * This method supports automatic fallback between subgraph and RPC modes:
+     * - If subgraph URL is available, tries subgraph query first
+     * - Falls back to direct contract queries via RPC if subgraph fails
+     * - RPC mode uses gasAwareMulticall for efficient batch queries
      *
      * @param params - Object containing the user address and optional subgraph URL
      * @param params.user - The wallet address of the user to query permissions for
      * @param params.subgraphUrl - Optional subgraph URL to override the default
      * @returns Promise resolving to an array of permission objects
-     * @throws Error if subgraph is unavailable or returns invalid data
+     * @throws Error if both subgraph and RPC queries fail
      */
     getUserPermissions(params: {
         user: Address;
@@ -33711,43 +34265,59 @@ declare class DataController {
         user: Address;
     }>>;
     /**
-     * Retrieves a list of trusted servers for a user using the new subgraph entities.
+     * Internal method: Query user permissions via subgraph
+     *
+     * @param params - Query parameters object
+     * @param params.user - The user address to query permissions for
+     * @param params.subgraphUrl - The subgraph URL endpoint to query
+     * @returns Promise resolving to an array of permission objects
+     */
+    private _getUserPermissionsViaSubgraph;
+    /**
+     * Internal method: Query user permissions via direct RPC
      *
-     * This method queries the Vana subgraph to find trusted servers directly associated with the user
-     * with support for both subgraph and direct RPC queries.
+     * @param params - Query parameters object
+     * @param params.user - The user address to query permissions for
+     * @returns Promise resolving to an array of permission objects
+     */
+    private _getUserPermissionsViaRpc;
+    /**
+     * Retrieves a list of trusted servers for a user.
      *
-     * This method supports multiple query modes:
-     * - 'subgraph': Fast query via subgraph (requires subgraphUrl)
-     * - 'rpc': Direct contract queries (slower but no external dependencies)
-     * - 'auto': Try subgraph first, fallback to RPC if unavailable
+     * This method supports automatic fallback between subgraph and RPC modes:
+     * - If subgraph URL is available, tries subgraph query first for fast results
+     * - Falls back to direct contract queries via RPC if subgraph fails
+     * - RPC mode uses gasAwareMulticall for efficient batch queries
      *
-     * @param params - Query parameters including user address and mode selection
-     * @returns Promise resolving to trusted servers with metadata about the query
-     * @throws Error if query fails in both modes (when using 'auto')
+     * @param params - Query parameters including user address and optional pagination
+     * @param params.user - The wallet address of the user to query trusted servers for
+     * @param params.subgraphUrl - Optional subgraph URL to override the default
+     * @param params.limit - Maximum number of results to return (default: 50)
+     * @param params.offset - Number of results to skip for pagination (default: 0)
+     * @returns Promise resolving to an array of trusted server objects
+     * @throws Error if both subgraph and RPC queries fail
      * @example
      * ```typescript
-     * // Use subgraph for fast queries
-     * const result = await vana.data.getUserTrustedServers({
-     *   user: '0x...',
-     *   mode: 'subgraph',
-     *   subgraphUrl: 'https://...'
+     * // Basic usage with automatic fallback
+     * const servers = await vana.data.getUserTrustedServers({
+     *   user: '0x...'
      * });
      *
-     * // Use direct RPC (no external dependencies)
-     * const result = await vana.data.getUserTrustedServers({
+     * // With pagination
+     * const servers = await vana.data.getUserTrustedServers({
      *   user: '0x...',
-     *   mode: 'rpc',
-     *   limit: 10
+     *   limit: 10,
+     *   offset: 20
      * });
      *
-     * // Auto-fallback mode
-     * const result = await vana.data.getUserTrustedServers({
+     * // With custom subgraph URL
+     * const servers = await vana.data.getUserTrustedServers({
      *   user: '0x...',
-     *   mode: 'auto' // tries subgraph first, falls back to RPC
+     *   subgraphUrl: 'https://custom-subgraph.com/graphql'
      * });
      * ```
      */
-    getUserTrustedServers(params: GetUserTrustedServersParams): Promise<GetUserTrustedServersResult>;
+    getUserTrustedServers(params: GetUserTrustedServersParams): Promise<TrustedServer[]>;
     /**
      * Internal method: Query trusted servers via subgraph
      *
@@ -33815,12 +34385,25 @@ declare class DataController {
     /**
      * Registers a file URL directly on the blockchain with a schema ID.
      *
-     * @param url - The URL of the file to register
+     * @remarks
+     * This method registers an existing file URL on the DataRegistry contract
+     * with a schema ID, without uploading any data. Useful when you have already
+     * uploaded content to storage and just need to register it on-chain.
+     *
+     * @param url - The URL of the file to register (IPFS or HTTP/HTTPS)
      * @param schemaId - The schema ID to associate with the file
      * @returns Promise resolving to the file ID and transaction hash
-     *
-     * This method registers an existing file URL on the DataRegistry
-     * contract with a schema ID, without uploading any data.
+     * @throws {Error} When chain ID is not available - "Chain ID not available"
+     * @throws {Error} When wallet address is unavailable - "No addresses available"
+     * @throws {Error} When transaction fails - "Failed to register file with schema"
+     * @example
+     * ```typescript
+     * const { fileId, transactionHash } = await vana.data.registerFileWithSchema(
+     *   "ipfs://QmXxx...",
+     *   1
+     * );
+     * console.log(`File ${fileId} registered with schema in tx ${transactionHash}`);
+     * ```
      */
     registerFileWithSchema(url: string, schemaId: number): Promise<{
         fileId: number;
@@ -33880,35 +34463,112 @@ declare class DataController {
     /**
      * Adds a new refiner to the DataRefinerRegistry.
      *
-     * @param params - Refiner parameters including DLP ID, name, schema ID, and instruction URL
+     * @remarks
+     * Refiners are data processing templates that define how raw data should be
+     * transformed into structured formats. Each refiner is associated with a DLP
+     * (Data Liquidity Pool), has a specific schema for output, and includes
+     * instructions for the refinement process.
+     *
+     * @param params - Refiner configuration parameters
+     * @param params.dlpId - The Data Liquidity Pool ID this refiner belongs to
+     * @param params.name - Human-readable name for the refiner
+     * @param params.schemaId - Schema ID that defines the output format
+     * @param params.refinementInstructionUrl - URL containing processing instructions
      * @returns Promise resolving to the new refiner ID and transaction hash
+     * @throws {Error} When chain ID is not available - "Chain ID not available"
+     * @throws {Error} When transaction fails - "Failed to add refiner: {error}"
+     * @example
+     * ```typescript
+     * const result = await vana.data.addRefiner({
+     *   dlpId: 1,
+     *   name: "Social Media Sentiment Analyzer",
+     *   schemaId: 42,
+     *   refinementInstructionUrl: "ipfs://QmXxx..."
+     * });
+     * console.log(`Created refiner ${result.refinerId} in tx ${result.transactionHash}`);
+     * ```
      */
     addRefiner(params: AddRefinerParams): Promise<AddRefinerResult>;
     /**
      * Retrieves a refiner by its ID.
      *
-     * @param refinerId - The refiner ID to retrieve
-     * @returns Promise resolving to the refiner information
+     * @remarks
+     * Queries the DataRefinerRegistry contract to get complete information about
+     * a specific refiner including its DLP association, schema, and instructions.
+     *
+     * @param refinerId - The numeric refiner ID to retrieve
+     * @returns Promise resolving to the refiner information object
+     * @throws {Error} When chain ID is not available - "Chain ID not available"
+     * @throws {Error} When refiner doesn't exist - "Refiner with ID {refinerId} does not exist"
+     * @throws {Error} When contract read fails - "Failed to fetch refiner: {error}"
+     * @example
+     * ```typescript
+     * const refiner = await vana.data.getRefiner(1);
+     * console.log({
+     *   name: refiner.name,
+     *   dlp: refiner.dlpId,
+     *   schema: refiner.schemaId,
+     *   instructions: refiner.refinementInstructionUrl
+     * });
+     * ```
      */
     getRefiner(refinerId: number): Promise<Refiner>;
     /**
      * Validates if a schema ID exists in the registry.
      *
-     * @param schemaId - The schema ID to validate
-     * @returns Promise resolving to boolean indicating if the schema ID is valid
+     * @remarks
+     * Checks the DataRefinerRegistry contract to determine if a given schema ID
+     * has been registered and is available for use.
+     *
+     * @param schemaId - The numeric schema ID to validate
+     * @returns Promise resolving to true if schema exists, false otherwise
+     * @example
+     * ```typescript
+     * const isValid = await vana.data.isValidSchemaId(42);
+     * if (isValid) {
+     *   console.log('Schema 42 is available for use');
+     * } else {
+     *   console.log('Schema 42 does not exist');
+     * }
+     * ```
      */
     isValidSchemaId(schemaId: number): Promise<boolean>;
     /**
      * Gets the total number of refiners in the registry.
      *
+     * @remarks
+     * Queries the DataRefinerRegistry contract to get the total count of all
+     * registered refiners across all DLPs.
+     *
      * @returns Promise resolving to the total refiner count
+     * @example
+     * ```typescript
+     * const count = await vana.data.getRefinersCount();
+     * console.log(`Total refiners registered: ${count}`);
+     * ```
      */
     getRefinersCount(): Promise<number>;
     /**
      * Updates the schema ID for an existing refiner.
      *
-     * @param params - Parameters including refiner ID and new schema ID
+     * @remarks
+     * Allows the owner of a refiner to update its associated schema ID.
+     * This is useful when refiner output format needs to change.
+     *
+     * @param params - Update parameters
+     * @param params.refinerId - The refiner ID to update
+     * @param params.newSchemaId - The new schema ID to set
      * @returns Promise resolving to the transaction hash
+     * @throws {Error} When chain ID is not available - "Chain ID not available"
+     * @throws {Error} When transaction fails - "Failed to update schema ID: {error}"
+     * @example
+     * ```typescript
+     * const result = await vana.data.updateSchemaId({
+     *   refinerId: 1,
+     *   newSchemaId: 55
+     * });
+     * console.log(`Schema updated in tx ${result.transactionHash}`);
+     * ```
      */
     updateSchemaId(params: UpdateSchemaIdParams): Promise<UpdateSchemaIdResult>;
     /**
@@ -33967,7 +34627,7 @@ declare class DataController {
      * console.log(`Transaction: ${result.transactionHash}`);
      * ```
      */
-    addPermissionToFile(fileId: number, account: Address, publicKey: string): Promise<FilePermissionResult>;
+    addPermissionToFile(fileId: number, account: Address, publicKey: string): Promise<TransactionHandle<FilePermissionResult>>;
     /**
      * Submits a file permission transaction and returns the transaction hash immediately.
      *
@@ -33984,7 +34644,7 @@ declare class DataController {
      * console.log(`Transaction submitted: ${txHash}`);
      * ```
      */
-    submitFilePermission(fileId: number, account: Address, publicKey: string): Promise<Hash>;
+    submitFilePermission(fileId: number, account: Address, publicKey: string): Promise<TransactionHandle<FilePermissionResult>>;
     /**
      * Gets the encrypted key for a specific account's permission to access a file.
      *
@@ -34151,24 +34811,6 @@ declare class DataController {
      * ```
      */
     fetchAndValidateSchema(url: string): Promise<DataSchema>;
-    /**
-     * Retrieves a schema by ID and fetches its definition URL to get the full data schema.
-     *
-     * @param schemaId - The schema ID to retrieve and validate
-     * @returns The validated data schema
-     * @throws SchemaValidationError if schema is invalid
-     * @example
-     * ```typescript
-     * // Get schema from registry and validate its schema
-     * const schema = await vana.data.getValidatedSchema(123);
-     *
-     * // Use it to validate user data
-     * if (schema.dialect === "json") {
-     *   vana.data.validateDataAgainstSchema(userData, schema);
-     * }
-     * ```
-     */
-    getValidatedSchema(schemaId: number): Promise<DataSchema>;
 }
 
 /**
@@ -34371,6 +35013,31 @@ interface Chains {
 }
 declare const chains: Chains;
 
+/**
+ * Creates or retrieves a cached public client for blockchain read operations.
+ *
+ * @remarks
+ * This function provides an optimized way to access blockchain data by maintaining
+ * a cached client instance per chain. The client is used for reading contract state,
+ * querying events, and other read-only blockchain operations. It automatically
+ * handles HTTP transport configuration and chain switching.
+ *
+ * @param chainId - The chain ID to connect to (defaults to Moksha testnet)
+ * @returns A public client configured for the specified chain with caching optimization
+ * @throws {Error} When the specified chain ID is not supported by the SDK
+ * @example
+ * ```typescript
+ * // Get client for default chain (Moksha testnet)
+ * const client = createClient();
+ *
+ * // Get client for specific chain
+ * const mainnetClient = createClient(14800);
+ *
+ * // Use client for blockchain reads
+ * const blockNumber = await client.getBlockNumber();
+ * ```
+ * @category Blockchain
+ */
 declare const createClient: (chainId?: keyof typeof chains) => PublicClient & {
     chain: Chain;
 };
@@ -35089,51 +35756,157 @@ declare class SerializationError extends VanaError {
     constructor(message: string);
 }
 /**
- * Error thrown when a signature operation fails.
+ * Thrown when a signature operation fails or cannot be completed.
  *
  * @remarks
- * Recovery strategies: Check wallet connection and account unlock status,
- * retry operation with explicit user interaction, or for gasless operations
- * consider switching to direct transactions.
+ * This error occurs when wallet signature operations fail due to disconnection,
+ * locked accounts, or other wallet-related issues. It preserves the original
+ * error for debugging while providing consistent error handling across the SDK.
+ *
+ * Recovery strategies:
+ * - Check wallet connection and account unlock status
+ * - Retry operation with explicit user interaction
+ * - For gasless operations, consider switching to direct transactions
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await vana.permissions.grant({ grantee: '0x...' });
+ * } catch (error) {
+ *   if (error instanceof SignatureError) {
+ *     // Prompt user to unlock wallet
+ *     await promptWalletUnlock();
+ *     // Retry operation
+ *   }
+ * }
+ * ```
+ * @category Error Handling
  */
 declare class SignatureError extends VanaError {
     readonly originalError?: Error | undefined;
     constructor(message: string, originalError?: Error | undefined);
 }
 /**
- * Error thrown when a network operation fails.
+ * Thrown when network communication fails during API calls or blockchain interactions.
  *
  * @remarks
- * Recovery strategies: Check network connectivity, retry with exponential backoff,
- * verify API endpoints are accessible, or switch to alternative network providers.
+ * This error encompasses network connectivity issues, API unavailability,
+ * timeout errors, and CORS restrictions. It's commonly encountered during
+ * IPFS operations, subgraph queries, or RPC calls.
+ *
+ * Recovery strategies:
+ * - Check network connectivity
+ * - Retry with exponential backoff
+ * - Verify API endpoints are accessible
+ * - Switch to alternative network providers or gateways
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const files = await vana.data.getUserFiles({ owner: '0x...' });
+ * } catch (error) {
+ *   if (error instanceof NetworkError) {
+ *     // Implement retry with exponential backoff
+ *     await retryWithBackoff(() => vana.data.getUserFiles({ owner: '0x...' }));
+ *   }
+ * }
+ * ```
+ * @category Error Handling
  */
 declare class NetworkError extends VanaError {
     readonly originalError?: Error | undefined;
     constructor(message: string, originalError?: Error | undefined);
 }
 /**
- * Error thrown when the nonce retrieval fails.
+ * Thrown when transaction nonce retrieval fails during gasless operations.
  *
  * @remarks
- * Recovery strategies: Retry nonce retrieval after brief delay, check wallet connection
- * and account status, or use manual nonce specification if supported by the operation.
+ * This error occurs when the SDK cannot retrieve the user's current nonce from
+ * smart contracts, preventing gasless transaction submission. Nonces are critical
+ * for preventing replay attacks in signed transactions.
+ *
+ * Recovery strategies:
+ * - Retry nonce retrieval after brief delay
+ * - Check wallet connection and account status
+ * - Use manual nonce specification if supported by the operation
+ * - Switch to direct transactions as fallback
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await vana.permissions.grant({ grantee: '0x...' });
+ * } catch (error) {
+ *   if (error instanceof NonceError) {
+ *     // Wait and retry
+ *     await delay(1000);
+ *     await vana.permissions.grant({ grantee: '0x...' });
+ *   }
+ * }
+ * ```
+ * @category Error Handling
  */
 declare class NonceError extends VanaError {
     constructor(message: string);
 }
 /**
- * Error thrown when a personal server operation fails.
+ * Thrown when personal server operations fail or cannot be completed.
  *
  * @remarks
- * Recovery strategies: Verify server URL accessibility, check server trust status via
- * `vana.permissions.getUserTrustedServers()`, or retry after server becomes available.
+ * This error occurs during interactions with personal servers for computation
+ * requests, identity retrieval, or operation status checks. Common causes include
+ * server unavailability, untrusted server status, or invalid permission grants.
+ *
+ * Recovery strategies:
+ * - Verify server URL accessibility
+ * - Check server trust status via `vana.permissions.getTrustedServers()`
+ * - Ensure valid permissions exist for the operation
+ * - Retry after server becomes available
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const result = await vana.server.createOperation({ permissionId: 123 });
+ * } catch (error) {
+ *   if (error instanceof PersonalServerError) {
+ *     // Check if server is trusted
+ *     const trustedServers = await vana.permissions.getTrustedServers();
+ *     if (!trustedServers.includes(serverId)) {
+ *       await vana.permissions.trustServer({ serverId });
+ *     }
+ *   }
+ * }
+ * ```
+ * @category Error Handling
  */
 declare class PersonalServerError extends VanaError {
     readonly originalError?: Error | undefined;
     constructor(message: string, originalError?: Error | undefined);
 }
 /**
- * Error thrown when trying to register a server with a URL that doesn't match the existing registration.
+ * Thrown when attempting to register a server with a URL different from its existing registration.
+ *
+ * @remarks
+ * This error occurs when trying to add or trust a server that's already registered
+ * on-chain with a different URL. Server URLs are immutable once registered to
+ * maintain consistency and security. Applications should use the existing URL
+ * or register a new server with a different ID.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await vana.permissions.addAndTrustServer({
+ *     serverId: 1,
+ *     serverUrl: 'https://new-url.com',
+ *     publicKey: '0x...'
+ *   });
+ * } catch (error) {
+ *   if (error instanceof ServerUrlMismatchError) {
+ *     console.log(`Server already registered with: ${error.existingUrl}`);
+ *     // Use existing URL or register new server
+ *   }
+ * }
+ * ```
+ * @category Error Handling
  */
 declare class ServerUrlMismatchError extends VanaError {
     constructor(existingUrl: string, providedUrl: string, serverId: string);
@@ -35142,7 +35915,25 @@ declare class ServerUrlMismatchError extends VanaError {
     readonly serverId: string;
 }
 /**
- * Error thrown when a permission operation fails.
+ * Thrown when permission grant, revoke, or validation operations fail.
+ *
+ * @remarks
+ * This error occurs during permission management operations including grants,
+ * revocations, and permission validation checks. Common causes include invalid
+ * grantee addresses, expired permissions, or insufficient privileges.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await vana.permissions.revoke({ permissionId: 999999 });
+ * } catch (error) {
+ *   if (error instanceof PermissionError) {
+ *     console.error('Permission operation failed:', error.message);
+ *     // Permission may not exist or user may not be owner
+ *   }
+ * }
+ * ```
+ * @category Error Handling
  */
 declare class PermissionError extends VanaError {
     readonly originalError?: Error | undefined;
@@ -36108,12 +36899,12 @@ declare class SignatureCache {
      * Generate a deterministic hash of a message object for cache key generation
      *
      * @remarks
-     * Creates a consistent hash from complex objects including EIP-712 typed data.
-     * Handles BigInt serialization and produces a 32-character hash that balances
-     * uniqueness with key length constraints.
+     * Creates a cryptographically secure hash from complex objects including EIP-712 typed data.
+     * Uses SHA-256 for collision resistance and deterministic key generation.
+     * Handles BigInt serialization and sorts object keys for consistency.
      *
      * @param message - The message object to hash (typically EIP-712 typed data)
-     * @returns A 32-character hash string suitable for cache keys
+     * @returns A hex string hash (SHA-256) suitable for cache keys
      * @example
      * ```typescript
      * const typedData = {
@@ -36122,19 +36913,19 @@ declare class SignatureCache {
      * };
      *
      * const hash = SignatureCache.hashMessage(typedData);
-     * // Returns something like: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+     * // Returns SHA-256 hash like: "a1b2c3d4e5f6..."
      * ```
      */
     static hashMessage(message: object): string;
     /**
-     * Custom JSON replacer that converts BigInt values to strings for serialization
-     * This ensures deterministic cache key generation for EIP-712 typed data
+     * Deterministic JSON replacer that handles BigInt values and sorts object keys
+     * This ensures consistent cache key generation for EIP-712 typed data
      *
      * @param _key - The object key being serialized (unused)
      * @param value - The value to serialize
-     * @returns The serialized value
+     * @returns The serialized value with sorted keys for objects
      */
-    private static bigIntReplacer;
+    private static deterministicReplacer;
 }
 /**
  * Wrapper function to cache signature operations
@@ -36150,21 +36941,53 @@ declare function withSignatureCache(cache: VanaCacheAdapter, walletAddress: stri
 
 declare const CONTRACT_ADDRESSES: Record<number, Record<string, string>>;
 /**
- * Retrieves the deployed contract address for a specific contract on a given chain.
+ * Retrieves the deployed contract address for a specific Vana protocol contract on a given chain.
  *
- * @param chainId - The chain ID to look up the contract on
- * @param contract - The contract name to get the address for
- * @returns The contract address as a hex string
- * @throws {Error} When contract address not found for the specified contract and chain
+ * @remarks
+ * This function provides type-safe access to contract addresses across all supported Vana networks.
+ * It automatically searches both current and legacy contract registries to ensure backwards
+ * compatibility while providing clear error messages for unsupported combinations.
+ *
+ * The function validates that both the chain ID and contract name are supported before
+ * attempting address lookup, helping developers identify deployment or configuration issues
+ * early in the development process.
+ *
+ * **Supported Chains:**
+ * - 14800: Vana Mainnet
+ * - 1480: Moksha Testnet
+ *
+ * **Contract Categories:**
+ * - Data Management: DataRegistry, DataRefinerRegistry
+ * - Permissions: DataPortabilityPermissions, DataPortabilityServers, DataPortabilityGrantees
+ * - Computing: TeePoolPhala, TeePoolDedicatedGpu, etc.
+ * - Token & Governance: DATImplementation, VanaPoolStaking, etc.
+ *
+ * @param chainId - The chain ID to look up the contract on (14800 for mainnet, 1480 for testnet)
+ * @param contract - The contract name to get the address for (use TypeScript autocomplete for available options)
+ * @returns The contract address as a checksummed hex string (0x...)
+ * @throws {Error} When contract address not found for the specified contract and chain combination.
+ *   This typically indicates the contract is not deployed on the requested network.
  * @example
  * ```typescript
+ * // Get core protocol contract addresses
+ * const dataRegistry = getContractAddress(14800, 'DataRegistry');
+ * const permissions = getContractAddress(14800, 'DataPortabilityPermissions');
+ * const trustedServers = getContractAddress(14800, 'DataPortabilityServers');
+ *
+ * // Handle unsupported combinations gracefully
  * try {
- *   const dataRegistryAddress = getContractAddress(1480, 'DataRegistry');
- *   console.log('DataRegistry address:', dataRegistryAddress);
+ *   const address = getContractAddress(1480, 'DataRegistry');
+ *   console.log('DataRegistry testnet address:', address);
  * } catch (error) {
- *   console.error('Contract not deployed on this chain:', error.message);
+ *   console.error('Contract not available on testnet:', error.message);
+ *   // Fallback to mainnet or show user-friendly error
  * }
+ *
+ * // TypeScript provides autocomplete for contract names
+ * const poolAddress = getContractAddress(14800, 'TeePoolPhala'); // ✅ Valid
+ * // const invalid = getContractAddress(14800, 'InvalidContract'); // ❌ TypeScript error
  * ```
+ * @category Configuration
  */
 declare const getContractAddress: (chainId: keyof typeof CONTRACT_ADDRESSES, contract: VanaContract) => `0x${string}`;
 
@@ -36334,6 +37157,8 @@ declare class CircuitBreaker {
     reset(): void;
 }
 
+/** Union type of all possible transaction results from relayer operations */
+type RelayerTransactionResult = PermissionGrantResult | PermissionRevokeResult | ServerTrustResult | ServerUntrustResult | GranteeRegisterResult | FileAddedResult;
 /**
  * Payload structure for relayer requests.
  * Contains the EIP-712 typed data, signature, and optional expected user address for security verification.
@@ -36355,7 +37180,7 @@ interface RelayerRequestPayload {
  * 1. Verifies the signature against the typed data
  * 2. Optionally checks the signer matches the expected user address
  * 3. Routes to the appropriate SDK method based on primaryType
- * 4. Returns the resulting transaction hash
+ * 4. Returns the transaction handle with hash and event parsing capability
  *
  * Supported transaction types:
  * - Permission: Permission grants
@@ -36368,7 +37193,7 @@ interface RelayerRequestPayload {
  *
  * @param sdk - Initialized Vana SDK instance
  * @param payload - Request payload containing typed data, signature, and optional security check
- * @returns Promise resolving to the transaction hash
+ * @returns Promise resolving to TransactionHandle with hash and event parsing capability
  * @throws {SignatureError} When signature verification fails or signer mismatch occurs
  * @throws {Error} When primaryType is unsupported or SDK operations fail
  * @category Server
@@ -36382,15 +37207,24 @@ interface RelayerRequestPayload {
  *     const body = await request.json();
  *     const vana = await createRelayerVana();
  *
- *     const txHash = await handleRelayerRequest(vana, {
+ *     const tx = await handleRelayerRequest(vana, {
  *       typedData: body.typedData,
  *       signature: body.signature,
  *       expectedUserAddress: body.expectedUserAddress
  *     });
  *
+ *     // Option 1: Return just the hash immediately
+ *     return NextResponse.json({
+ *       success: true,
+ *       transactionHash: tx.hash
+ *     });
+ *
+ *     // Option 2: Wait for transaction confirmation and return event data
+ *     const eventData = await tx.waitForEvents();
  *     return NextResponse.json({
  *       success: true,
- *       transactionHash: txHash
+ *       transactionHash: tx.hash,
+ *       ...eventData // Include parsed event data like permissionId, fileId, etc.
  *     });
  *   } catch (error) {
  *     return NextResponse.json({
@@ -36401,13 +37235,14 @@ interface RelayerRequestPayload {
  * }
  * ```
  */
-declare function handleRelayerRequest(sdk: VanaInstance, payload: RelayerRequestPayload): Promise<Hash>;
+declare function handleRelayerRequest(sdk: VanaInstance, payload: RelayerRequestPayload): Promise<TransactionHandle<RelayerTransactionResult>>;
 
 /**
  * Node.js implementation of the Vana Platform Adapter
  *
- * This implementation uses Node.js-specific libraries and configurations
- * to provide crypto, PGP, and HTTP functionality.
+ * WARNING: Dependencies that access globals during init
+ * MUST be dynamically imported to support Turbopack.
+ * See: https://github.com/vercel/next.js/issues/82632
  */
 
 /**
@@ -36423,22 +37258,73 @@ declare class NodePlatformAdapter implements VanaPlatformAdapter {
 }
 
 /**
- * Browser implementation of the Vana Platform Adapter
+ * Browser implementation of the Vana Platform Adapter using Uint8Array
  *
- * This implementation uses browser-compatible libraries and configurations
- * to provide crypto, PGP, and HTTP functionality without Node.js dependencies.
+ * This implementation uses browser-compatible libraries and native APIs
+ * without requiring Buffer or other Node.js polyfills.
  */
 
 /**
- * Complete browser platform adapter implementation
+ * Browser implementation of crypto operations using Uint8Array
+ */
+declare class BrowserCryptoAdapter implements VanaCryptoAdapter {
+    private eciesProvider;
+    private walletKeyEncryptionService;
+    encryptWithPublicKey(data: string, publicKeyHex: string): Promise<string>;
+    decryptWithPrivateKey(encryptedData: string, privateKeyHex: string): Promise<string>;
+    encryptWithWalletPublicKey(data: string, publicKey: string): Promise<string>;
+    decryptWithWalletPrivateKey(encryptedData: string, privateKey: string): Promise<string>;
+    generateKeyPair(): Promise<{
+        privateKey: string;
+        publicKey: string;
+    }>;
+    encryptWithPassword(data: Uint8Array, password: string): Promise<Uint8Array>;
+    decryptWithPassword(encryptedData: Uint8Array, password: string): Promise<Uint8Array>;
+}
+/**
+ * Browser implementation of PGP operations
+ */
+declare class BrowserPGPAdapter implements VanaPGPAdapter {
+    encrypt(data: string, publicKeyArmored: string): Promise<string>;
+    decrypt(encryptedData: string, privateKeyArmored: string): Promise<string>;
+    generateKeyPair(options?: {
+        name?: string;
+        email?: string;
+        passphrase?: string;
+    }): Promise<{
+        publicKey: string;
+        privateKey: string;
+    }>;
+}
+/**
+ * Browser implementation of HTTP operations using Fetch API
+ */
+declare class BrowserHttpAdapter implements VanaHttpAdapter {
+    fetch(url: string, options?: RequestInit): Promise<Response>;
+}
+/**
+ * Browser implementation of caching using sessionStorage for security
+ * SessionStorage is cleared when the tab closes, making it more secure for signature caching
+ */
+declare class BrowserCacheAdapter implements VanaCacheAdapter {
+    private readonly prefix;
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+    delete(key: string): void;
+    clear(): void;
+}
+/**
+ * Browser implementation of the Vana Platform Adapter
+ *
+ * This adapter provides all platform-specific functionality for browser environments
+ * without requiring any Node.js polyfills.
  */
 declare class BrowserPlatformAdapter implements VanaPlatformAdapter {
-    crypto: VanaCryptoAdapter;
-    pgp: VanaPGPAdapter;
-    http: VanaHttpAdapter;
-    cache: VanaCacheAdapter;
-    platform: "browser";
-    constructor();
+    readonly crypto: BrowserCryptoAdapter;
+    readonly pgp: BrowserPGPAdapter;
+    readonly http: BrowserHttpAdapter;
+    readonly cache: BrowserCacheAdapter;
+    readonly platform: "browser";
 }
 
 /**
@@ -36815,4 +37701,4 @@ declare function Vana(config: VanaConfig): VanaNodeImpl;
  */
 type VanaInstance = VanaNodeImpl;
 
-export { type $defs, type APIResponse, type AddAndTrustServerInput, type AddAndTrustServerParams, type AddAndTrustServerTypedData, type AddRefinerParams, type AddRefinerResult, type AddSchemaParams, type AddSchemaResult, type AllKeys, ApiClient, type ApiClientConfig, type ApiResponse, AsyncQueue, type AsyncResult, type AuthenticationErrorResponse, type Awaited, type BaseConfig, type BaseConfigWithStorage, BaseController, type BatchServerInfoResult, type BatchUploadParams, type BatchUploadResult, type BlockRange, BlockchainError, type BlockchainErrorResponse, type Brand, BrowserPlatformAdapter, type Cache, type CacheConfig, CallbackStorage, type ChainConfig, type ChainConfigWithStorage, type CheckPermissionParams, CircuitBreaker, type ComputeErrorResponse, type ConditionalOptional, type ConfigValidationOptions, type ConfigValidationResult, type ContractAddresses, type ContractCall, type ContractDeployment, ContractFactory, type ContractInfo, type ContractMethodParams, type ContractMethodReturnType, ContractNotFoundError, type Controller, type ControllerContext, type CreateOperationParams, type CreateOperationRequest, type CreateOperationResponse, type CreateSchemaParams, type CreateSchemaResult, DEFAULT_ENCRYPTION_SEED, DEFAULT_IPFS_GATEWAY, DataController, type DataSchema, type DecryptionErrorResponse, type DeepPartial, type DeepReadonly, type DeleteFileParams, type DeleteFileResult, type DownloadFileParams, type DownloadFileResult, type EncryptedUploadParams, type EncryptionInfo, type ErrorResponse, EventEmitter, type EventFilter, type EventLog, type Factory, type FileAccessErrorResponse, type FileAccessPermissions, type FileMetadata, type FilePermissionParams, type FileSharingConfig, type GasEstimate, type GenericRequest, type GenericResponse, type GenericTypedData, type GetFileParams, type GetOperationResponse, type GetUserFilesParams, type GetUserPermissionsOptions, type GetUserTrustedServersParams, type GetUserTrustedServersResult, GoogleDriveStorage, GrantExpiredError, type GrantFile, type GrantPermissionParams, GrantSchemaError, GrantValidationError, type GrantValidationErrorResponse, type GrantValidationOptions, type GrantValidationResult, type GrantedPermission, type Grantee, type GranteeInfo, GranteeMismatchError, type GranteeQueryOptions, type HttpMethod, IPFS_GATEWAYS, type IdentityResponseModel, type InitPersonalServerParams, type InternalServerErrorResponse, InvalidConfigurationError, IpfsStorage, type LegacyPermissionParams, type MaybeArray, type MaybePromise, MemoryCache, type Middleware, MiddlewarePipeline, NetworkError, type NetworkInfo, NodePlatformAdapter, type Nominal, type NonNullable, NonceError, type NotFoundErrorResponse, type Observable, type Observer, type OmitByType, type OnChainPermissionGrant, type OperationErrorResponse, OperationNotAllowedError, type OptionalKeys, type PaginatedGrantees, type PaginatedTrustedServers, type PaginationParams, type PaginationResult, type PartialExcept, type Permission, type PermissionAnalytics, type PermissionCheckResult, PermissionError, type PermissionEvent, type PermissionGrantDomain, type PermissionGrantMessage, type PermissionGrantTypedData, type PermissionInfo, type PermissionInputMessage, type PermissionOperation, type PermissionQueryResult, type PermissionStatus, PermissionsController, PersonalServerError, type PersonalServerIdentity, type PersonalServerModel, type PickByType, type PinataListResponse, type PinataPin, PinataStorage, type PinataUploadResponse, type Plugin, type PostRequestParams, type PromiseResult, ProtocolController, type QueryPermissionsParams, type RateLimitInfo, RateLimiter, type RateLimiterConfig, type Refiner, type RegisterGranteeInput, type RegisterGranteeParams, type RegisterGranteeTypedData, type RelayerCallbacks, type RelayerConfig, RelayerError, type RelayerErrorResponse, type RelayerMetrics, type RelayerQueueInfo, type RelayerRequestOptions, type RelayerRequestPayload, type RelayerStatus, type RelayerStorageResponse, type RelayerStoreParams, type RelayerSubmitParams, type RelayerTransactionResponse, type RelayerTransactionStatus, type RelayerWebhookConfig, type RelayerWebhookPayload, type ReplicateAPIResponse, type ReplicateStatus, type Repository, type RequestOptions, type RequireKeys, type RequiredExcept, type RetryConfig, RetryUtility, type RevokePermissionInput, type RevokePermissionParams, type RuntimeConfig, type Schema, SchemaController, SchemaValidationError, SchemaValidator, SerializationError, type Server, type components as ServerComponents, ServerController, type $defs as ServerDefs, type ServerFilesAndPermissionParams, type ServerFilesAndPermissionTypedData, type ServerInfo, type operations as ServerOperations, type paths as ServerPaths, type ServerTrustStatus, ServerUrlMismatchError, type webhooks as ServerWebhooks, type Service, SignatureCache, SignatureError, type SimplifiedPermissionMessage, type StateMachine, type StatusInfo, type StorageCallbacks, type StorageConfig, type StorageDownloadOptions, StorageError, type StorageFile, type StorageListOptions, type StorageListResult, StorageManager, type StorageProvider, type StorageProviderConfig, type StorageRequiredMarker, type StorageUploadResult, type TimeRange, type TransactionOptions, type TransactionReceipt, type Transformer, type TrustServerInput, type TrustServerParams, type TrustServerTypedData, type TrustedServer, type TrustedServerInfo, type TrustedServerQueryMode, type TrustedServerQueryOptions, type UnencryptedUploadParams, type UntrustServerInput, type UntrustServerParams, type UntrustServerTypedData, type UpdateSchemaIdParams, type UpdateSchemaIdResult, type UploadEncryptedFileResult, type UploadFileParams, type UploadFileResult, type UploadParams, type UploadProgress, type UploadResult, type UserFile, UserRejectedRequestError, type ValidationErrorResponse, type ValidationResult, type Validator, Vana, type VanaChain, type VanaChainConfig, type VanaChainId, type VanaConfig, type VanaConfigWithStorage, type VanaContract, type VanaContract as VanaContractAbi, type VanaContractInstance, type VanaContractName, VanaCore, VanaCoreFactory, VanaError, type VanaInstance, VanaNodeImpl, type VanaPlatformAdapter, type WalletConfig, type WalletConfigWithStorage, __contractCache, chains, checkGrantAccess, clearContractCache, type components, convertIpfsUrl, convertIpfsUrlWithFallbacks, createAndStoreGrant, createBrowserPlatformAdapter, createGrantFile, createNodePlatformAdapter, createPlatformAdapter, createPlatformAdapterFor, createPlatformAdapterSafe, createValidatedGrant, decryptBlobWithSignedKey, decryptWithPrivateKey, decryptWithWalletPrivateKey, Vana as default, detectPlatform, encryptBlobWithSignedKey, encryptFileKey, encryptWithWalletPublicKey, extractIpfsHash, fetchAndValidateSchema, fetchWithFallbacks, formatEth, formatNumber, formatToken, generateEncryptionKey, generateEncryptionKeyPair, generatePGPKeyPair, getAbi, getAllChains, getChainConfig, getContractAddress, getContractController, getContractInfo, getEncryptionParameters, getGatewayUrls, getGrantFileHash, getGrantTimeRemaining, getPlatformCapabilities, handleRelayerRequest, hasStorageConfig, isAPIResponse, isChainConfig, isGrantExpired, isIpfsUrl, isPlatformSupported, isReplicateAPIResponse, isVanaChain, isVanaChainId, isWalletConfig, moksha, mokshaTestnet, type operations, parseReplicateOutput, type paths, retrieveAndValidateGrant, retrieveGrantFile, safeParseJSON, schemaValidator, shortenAddress, storeGrantFile, summarizeGrant, validateDataAgainstSchema, validateDataSchema, validateGrant, validateGrantExpiry, validateGrantFile, validateGranteeAccess, validateOperationAccess, vanaMainnet, type webhooks, withSignatureCache };
+export { type $defs, type APIResponse, type AddAndTrustServerInput, type AddAndTrustServerParams, type AddAndTrustServerTypedData, type AddRefinerParams, type AddRefinerResult, type AddSchemaParams, type AddSchemaResult, type AllKeys, ApiClient, type ApiClientConfig, type ApiResponse, AsyncQueue, type AsyncResult, type AuthenticationErrorResponse, type Awaited, type BaseConfig, type BaseConfigWithStorage, BaseController, type BatchServerInfoResult, type BatchUploadParams, type BatchUploadResult, type BlockRange, BlockchainError, type BlockchainErrorResponse, type Brand, BrowserPlatformAdapter, type Cache, type CacheConfig, CallbackStorage, type ChainConfig, type ChainConfigWithStorage, type CheckPermissionParams, CircuitBreaker, type CompleteSchema, type ComputeErrorResponse, type ConditionalOptional, type ConfigValidationOptions, type ConfigValidationResult, type ContractAddresses, type ContractCall, type ContractDeployment, ContractFactory, type ContractInfo, type ContractMethodParams, type ContractMethodReturnType, ContractNotFoundError, type Controller, type ControllerContext, type CreateOperationParams, type CreateOperationRequest, type CreateOperationResponse, type CreateSchemaParams, type CreateSchemaResult, DEFAULT_ENCRYPTION_SEED, DEFAULT_IPFS_GATEWAY, DataController, type DataSchema, type DecryptionErrorResponse, type DeepPartial, type DeepReadonly, type DeleteFileParams, type DeleteFileResult, type DownloadFileParams, type DownloadFileResult, type EncryptedUploadParams, type EncryptionInfo, type ErrorResponse, EventEmitter, type EventFilter, type EventLog, type Factory, type FileAccessErrorResponse, type FileAccessPermissions, type FileMetadata, type FilePermissionParams, type FileSharingConfig, type GasEstimate, type GenericRequest, type GenericResponse, type GenericTypedData, type GetFileParams, type GetOperationResponse, type GetUserFilesParams, type GetUserPermissionsOptions, type GetUserTrustedServersParams, GoogleDriveStorage, GrantExpiredError, type GrantFile, type GrantPermissionParams, GrantSchemaError, GrantValidationError, type GrantValidationErrorResponse, type GrantValidationOptions, type GrantValidationResult, type GrantedPermission, type Grantee, type GranteeInfo, GranteeMismatchError, type GranteeQueryOptions, type HttpMethod, IPFS_GATEWAYS, type IdentityResponseModel, type InitPersonalServerParams, type InternalServerErrorResponse, InvalidConfigurationError, IpfsStorage, type LegacyPermissionParams, type MaybeArray, type MaybePromise, MemoryCache, type Middleware, MiddlewarePipeline, NetworkError, type NetworkInfo, NodePlatformAdapter, type Nominal, type NonNullable, NonceError, type NotFoundErrorResponse, type Observable, type Observer, type OmitByType, type OnChainPermissionGrant, type OperationErrorResponse, OperationNotAllowedError, type OptionalKeys, type PaginatedGrantees, type PaginatedTrustedServers, type PaginationParams, type PaginationResult, type PartialExcept, type Permission, type PermissionAnalytics, type PermissionCheckResult, PermissionError, type PermissionEvent, type PermissionGrantDomain, type PermissionGrantMessage, type PermissionGrantTypedData, type PermissionInfo, type PermissionInputMessage, type PermissionOperation, type PermissionQueryResult, type PermissionStatus, PermissionsController, PersonalServerError, type PersonalServerIdentity, type PersonalServerModel, type PickByType, type PinataListResponse, type PinataPin, PinataStorage, type PinataUploadResponse, type Plugin, type PostRequestParams, type PromiseResult, ProtocolController, type QueryPermissionsParams, type RateLimitInfo, RateLimiter, type RateLimiterConfig, type Refiner, type RegisterGranteeInput, type RegisterGranteeParams, type RegisterGranteeTypedData, type RelayerCallbacks, type RelayerConfig, RelayerError, type RelayerErrorResponse, type RelayerMetrics, type RelayerQueueInfo, type RelayerRequestOptions, type RelayerRequestPayload, type RelayerStatus, type RelayerStorageResponse, type RelayerStoreParams, type RelayerSubmitParams, type RelayerTransactionResponse, type RelayerTransactionStatus, type RelayerWebhookConfig, type RelayerWebhookPayload, type ReplicateAPIResponse, type ReplicateStatus, type Repository, type RequestOptions, type RequireKeys, type RequiredExcept, type RetryConfig, RetryUtility, type RevokePermissionInput, type RevokePermissionParams, type RuntimeConfig, type Schema, SchemaController, type SchemaMetadata, SchemaValidationError, SchemaValidator, SerializationError, type Server, type components as ServerComponents, ServerController, type $defs as ServerDefs, type ServerFilesAndPermissionParams, type ServerFilesAndPermissionTypedData, type ServerInfo, type operations as ServerOperations, type paths as ServerPaths, type ServerTrustStatus, ServerUrlMismatchError, type webhooks as ServerWebhooks, type Service, SignatureCache, SignatureError, type SimplifiedPermissionMessage, type StateMachine, type StatusInfo, type StorageCallbacks, type StorageConfig, type StorageDownloadOptions, StorageError, type StorageFile, type StorageListOptions, type StorageListResult, StorageManager, type StorageProvider, type StorageProviderConfig, type StorageRequiredMarker, type StorageUploadResult, type TimeRange, TransactionHandle, type TransactionOptions, type TransactionReceipt, type Transformer, type TrustServerInput, type TrustServerParams, type TrustServerTypedData, type TrustedServer, type TrustedServerInfo, type TrustedServerQueryOptions, type UnencryptedUploadParams, type UntrustServerInput, type UntrustServerParams, type UntrustServerTypedData, type UpdateSchemaIdParams, type UpdateSchemaIdResult, type UploadEncryptedFileResult, type UploadFileParams, type UploadFileResult, type UploadParams, type UploadProgress, type UploadResult, type UserFile, UserRejectedRequestError, type ValidationErrorResponse, type ValidationResult, type Validator, Vana, type VanaChain, type VanaChainConfig, type VanaChainId, type VanaConfig, type VanaConfigWithStorage, type VanaContract, type VanaContract as VanaContractAbi, type VanaContractInstance, type VanaContractName, VanaCore, VanaCoreFactory, VanaError, type VanaInstance, VanaNodeImpl, type VanaPlatformAdapter, type WalletConfig, type WalletConfigWithStorage, __contractCache, chains, checkGrantAccess, clearContractCache, type components, convertIpfsUrl, convertIpfsUrlWithFallbacks, createAndStoreGrant, createBrowserPlatformAdapter, createGrantFile, createNodePlatformAdapter, createPlatformAdapter, createPlatformAdapterFor, createPlatformAdapterSafe, createValidatedGrant, decryptBlobWithSignedKey, decryptWithPrivateKey, decryptWithWalletPrivateKey, Vana as default, detectPlatform, encryptBlobWithSignedKey, encryptFileKey, encryptWithWalletPublicKey, extractIpfsHash, fetchAndValidateSchema, fetchWithFallbacks, formatEth, formatNumber, formatToken, generateEncryptionKey, generateEncryptionKeyPair, generatePGPKeyPair, getAbi, getAllChains, getChainConfig, getContractAddress, getContractController, getContractInfo, getEncryptionParameters, getGatewayUrls, getGrantFileHash, getGrantTimeRemaining, getPlatformCapabilities, handleRelayerRequest, hasStorageConfig, isAPIResponse, isChainConfig, isGrantExpired, isIpfsUrl, isPlatformSupported, isReplicateAPIResponse, isVanaChain, isVanaChainId, isWalletConfig, moksha, mokshaTestnet, type operations, parseReplicateOutput, type paths, retrieveAndValidateGrant, retrieveGrantFile, safeParseJSON, schemaValidator, shortenAddress, storeGrantFile, summarizeGrant, validateDataAgainstSchema, validateDataSchema, validateGrant, validateGrantExpiry, validateGrantFile, validateGranteeAccess, validateOperationAccess, vanaMainnet, type webhooks, withSignatureCache };