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

package/dist/controllers/data.js

@@ -0,0 +1,2620 @@
+import { getContract } from "viem";
+import { PollingManager } from "../core/pollingManager";
+import { BaseController } from "./base";
+import { getContractAddress } from "../config/addresses";
+import { getAbi } from "../generated/abi";
+import {
+  GetUserFilesPaginatedDocument,
+  GetFileProofsDocument,
+  GetDlpDocument,
+  GetUserPermissionsPaginatedDocument,
+  GetUserTrustedServersPaginatedDocument
+} from "../generated/subgraph";
+import { print } from "graphql";
+import {
+  checkSubgraphConsistency,
+  fetchSubgraphMeta
+} from "../utils/subgraphConsistency";
+import {
+  executePaginatedQuery,
+  mapOrderByToEnum,
+  mapOrderDirection
+} from "../utils/subgraphPagination";
+import {
+  getUserFilesFromChain,
+  determineDataSource
+} from "../utils/chainQuery";
+import {
+  generateEncryptionKey,
+  decryptBlobWithSignedKey,
+  DEFAULT_ENCRYPTION_SEED,
+  encryptBlobWithSignedKey,
+  encryptWithWalletPublicKey,
+  decryptWithWalletPrivateKey
+} from "../utils/encryption";
+import {
+  validateDataSchemaAgainstMetaSchema,
+  validateDataAgainstSchema,
+  fetchAndValidateSchema
+} from "../utils/schemaValidation";
+import { gasAwareMulticall } from "../utils/multicall";
+class DataController extends BaseController {
+  constructor(context) {
+    super(context);
+  }
+  async upload(params) {
+    this.assertWallet();
+    const {
+      content,
+      filename,
+      schemaId,
+      permissions = [],
+      encrypt = true,
+      providerName,
+      owner,
+      schemaValidation = "strict"
+    } = params;
+    try {
+      let isValid = true;
+      let validationErrors = [];
+      if (schemaId !== void 0 && schemaValidation !== "skip") {
+        try {
+          const { SchemaController } = await import("./schemas");
+          const schemaController = new SchemaController(this.context);
+          const schema = await schemaController.get(schemaId);
+          let parsedContent;
+          if (typeof content === "string") {
+            try {
+              parsedContent = JSON.parse(content);
+            } catch {
+              parsedContent = content;
+            }
+          } else if (content instanceof Blob) {
+            const text = await content.text();
+            try {
+              parsedContent = JSON.parse(text);
+            } catch {
+              parsedContent = text;
+            }
+          } else {
+            parsedContent = content;
+          }
+          validateDataAgainstSchema(parsedContent, schema);
+        } catch (error) {
+          if (schemaValidation === "strict") {
+            throw error;
+          } else if (schemaValidation === "warn") {
+            console.warn(
+              '[Vana SDK] Schema validation failed, but continuing due to validation mode "warn"'
+            );
+            if (error instanceof Error) {
+              console.warn("  Validation error:", error.message);
+              if (typeof error === "object" && "errors" in error && Array.isArray(error.errors)) {
+                console.warn("  Detailed errors:", error.errors);
+              }
+            }
+            isValid = false;
+            validationErrors = error instanceof Error ? [error.message] : ["Schema validation failed"];
+          }
+        }
+      }
+      const uploadResult = await this.uploadToStorage(
+        content,
+        filename,
+        encrypt,
+        providerName
+      );
+      const userAddress = owner ?? this.context.userAddress;
+      let encryptedPermissions = [];
+      if (permissions.length > 0 && encrypt) {
+        this.assertWallet();
+        const userEncryptionKey = await generateEncryptionKey(
+          this.context.walletClient,
+          this.context.platform,
+          DEFAULT_ENCRYPTION_SEED
+        );
+        encryptedPermissions = await Promise.all(
+          permissions.map(async (permission) => {
+            const encryptedKey = await encryptWithWalletPublicKey(
+              userEncryptionKey,
+              permission.publicKey,
+              this.context.platform
+            );
+            return {
+              account: permission.account,
+              key: encryptedKey
+            };
+          })
+        );
+      }
+      let result;
+      if (this.context.relayer) {
+        const request = {
+          type: "direct",
+          operation: "submitFileAdditionComplete",
+          params: {
+            url: uploadResult.url,
+            userAddress,
+            permissions: encryptedPermissions,
+            schemaId: schemaId ?? 0,
+            ownerAddress: owner
+          }
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new Error(response.error);
+        }
+        if (response.type === "pending") {
+          result = await this.pollRelayerForConfirmation(
+            response.operationId,
+            void 0
+            // TODO: Add TransactionOptions to upload method signature
+          );
+        } else if (response.type === "direct" && typeof response.result === "object" && response.result !== null && "fileId" in response.result) {
+          result = response.result;
+        } else {
+          throw new Error("Invalid response from relayer");
+        }
+      } else {
+        const txResult = await this.addFileWithEncryptedPermissionsAndSchema(
+          uploadResult.url,
+          userAddress,
+          encryptedPermissions,
+          schemaId ?? 0
+        );
+        if (!this.context.waitForTransactionEvents) {
+          throw new Error(
+            "Cannot upload without relay: waitForTransactionEvents not configured"
+          );
+        }
+        const eventResult = await this.context.waitForTransactionEvents(txResult);
+        const fileAddedEvent = eventResult.expectedEvents.FileAdded;
+        if (!fileAddedEvent) {
+          throw new Error("FileAdded event not found in transaction");
+        }
+        result = {
+          fileId: Number(fileAddedEvent.fileId),
+          transactionHash: txResult.hash
+        };
+      }
+      return {
+        fileId: result.fileId,
+        url: uploadResult.url,
+        transactionHash: result.transactionHash,
+        size: uploadResult.size,
+        isValid,
+        validationErrors: validationErrors.length > 0 ? validationErrors : void 0
+      };
+    } catch (error) {
+      throw new Error(
+        `Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Encrypts data using wallet-derived encryption.
+   *
+   * @remarks
+   * This method provides secure, wallet-based encryption for data before uploading
+   * to the Vana network. It's the counterpart to decryptFile for preparing data
+   * for secure storage.
+   *
+   * The method automatically:
+   * - Generates an encryption key from the user's wallet signature
+   * - Converts the input data to a Blob if necessary
+   * - Encrypts the data using the generated key
+   * - Returns both the encrypted data and the encryption key
+   *
+   * The encryption key returned can be stored and later used for decryption,
+   * or shared with others to grant them decryption access.
+   *
+   * @param data - The data to encrypt (Blob, string, or object)
+   * @param options - Optional encryption configuration
+   * @returns Promise resolving to encrypted data and the encryption key used
+   * @throws {Error} When wallet is not connected or encryption fails
+   * @example
+   * ```typescript
+   * // Encrypt a string
+   * const { encryptedData, encryptionKey } = await vana.data.encryptFile(
+   *   "My secret data"
+   * );
+   *
+   * // Encrypt JSON with custom MIME type
+   * const { encryptedData, encryptionKey } = await vana.data.encryptFile(
+   *   { name: "Alice", age: 30 },
+   *   { mimeType: "application/json" }
+   * );
+   *
+   * // With custom encryption seed
+   * const { encryptedData, encryptionKey } = await vana.data.encryptFile(
+   *   "Secret message",
+   *   { seed: "My custom encryption seed" }
+   * );
+   *
+   * // Upload the encrypted data
+   * const result = await vana.data.uploadToStorage(encryptedData);
+   * ```
+   */
+  async encryptFile(data, options) {
+    this.assertWallet();
+    try {
+      const encryptionKey = await generateEncryptionKey(
+        this.context.walletClient,
+        this.context.platform,
+        options?.seed ?? DEFAULT_ENCRYPTION_SEED
+      );
+      let blob;
+      if (data instanceof Blob) {
+        blob = data;
+      } else if (typeof data === "string") {
+        blob = new Blob([data], { type: options?.mimeType ?? "text/plain" });
+      } else {
+        blob = new Blob([JSON.stringify(data)], {
+          type: options?.mimeType ?? "application/json"
+        });
+      }
+      const encryptedData = await encryptBlobWithSignedKey(
+        blob,
+        encryptionKey,
+        this.context.platform
+      );
+      return {
+        encryptedData,
+        encryptionKey
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to encrypt file: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Decrypts a file using wallet-derived decryption key.
+   *
+   * @remarks
+   * Counterpart to `upload()` for decrypting user files. Automatically
+   * generates decryption key from wallet, fetches encrypted content,
+   * and decrypts. Supports IPFS (with gateway fallback) and HTTP URLs.
+   *
+   * @param file - UserFile object from `getUserFiles()`
+   * @param options - Decryption options
+   * @param options.seed - Custom encryption seed.
+   *   Defaults to standard Vana seed.
+   *
+   * @returns Decrypted content as Blob
+   *
+   * @throws {Error} No wallet connected.
+   *   Connect wallet before decrypting.
+   * @throws {Error} Network error accessing file.
+   *   Check CORS settings or server availability.
+   * @throws {Error} File not found (404).
+   *   File no longer available at stored URL.
+   * @throws {Error} Access denied (403).
+   *   No permission to access file.
+   * @throws {Error} Invalid file format.
+   *   File not encrypted with Vana protocol.
+   * @throws {Error} Wrong encryption key.
+   *   Verify seed matches upload or use default.
+   *
+   * @example
+   * ```typescript
+   * // Basic file decryption
+   * const files = await vana.data.getUserFiles({ owner: userAddress });
+   * const decryptedBlob = await vana.data.decryptFile(files[0]);
+   *
+   * // Convert to text
+   * const text = await decryptedBlob.text();
+   * console.log('Decrypted content:', text);
+   *
+   * // Convert to JSON
+   * const json = JSON.parse(await decryptedBlob.text());
+   * console.log('Decrypted data:', json);
+   *
+   * // With custom encryption seed
+   * const decryptedBlob = await vana.data.decryptFile(
+   *   files[0],
+   *   "My custom encryption seed"
+   * );
+   *
+   * // Save to file (in Node.js)
+   * const buffer = await decryptedBlob.arrayBuffer();
+   * fs.writeFileSync('decrypted-file.txt', Buffer.from(buffer));
+   * ```
+   */
+  async decryptFile(file, options) {
+    this.assertWallet();
+    try {
+      this.assertWallet();
+      const encryptionKey = await generateEncryptionKey(
+        this.context.walletClient,
+        this.context.platform,
+        options?.seed ?? DEFAULT_ENCRYPTION_SEED
+      );
+      let encryptedBlob;
+      try {
+        if (file.url.startsWith("ipfs://")) {
+          encryptedBlob = await this.fetchFromIPFS(file.url);
+        } else {
+          encryptedBlob = await this.fetch(file.url);
+        }
+      } catch (fetchError) {
+        const errorMessage = fetchError instanceof Error ? fetchError.message : "Unknown error";
+        if (errorMessage.includes("Failed to fetch IPFS content") && errorMessage.includes("from all gateways")) {
+          throw new Error(
+            "Network error: Cannot access the file URL. The file may be stored on a server that's not accessible or has CORS restrictions."
+          );
+        } else if (errorMessage.includes("Empty response")) {
+          throw new Error("File is empty or could not be retrieved");
+        } else if (errorMessage.includes("Network error:") || errorMessage.includes("Failed to fetch")) {
+          throw new Error(
+            "Network error: Cannot access the file URL. The file may be stored on a server that's not accessible or has CORS restrictions."
+          );
+        } else if (errorMessage.includes("HTTP error!")) {
+          const statusMatch = errorMessage.match(/status: (\d+)/);
+          const status = statusMatch ? statusMatch[1] : "unknown";
+          if (status === "500") {
+            throw new Error(
+              "Network error: Cannot access the file URL. The file may be stored on a server that's not accessible or has CORS restrictions."
+            );
+          } else if (status === "403") {
+            throw new Error(
+              "Access denied. You may not have permission to access this file"
+            );
+          } else if (status === "404") {
+            throw new Error(
+              "File not found: The encrypted file is no longer available at the stored URL."
+            );
+          } else {
+            throw new Error(
+              "Network error: Cannot access the file URL. The file may be stored on a server that's not accessible or has CORS restrictions."
+            );
+          }
+        }
+        throw fetchError;
+      }
+      if (encryptedBlob.size === 0) {
+        throw new Error("File is empty or could not be retrieved");
+      }
+      let decryptedBlob;
+      try {
+        decryptedBlob = await decryptBlobWithSignedKey(
+          encryptedBlob,
+          encryptionKey,
+          this.context.platform
+        );
+      } catch (decryptError) {
+        const errorMessage = decryptError instanceof Error ? decryptError.message : "Unknown error";
+        if (errorMessage.includes("not a valid OpenPGP message")) {
+          throw new Error(
+            "Invalid file format: This file doesn't appear to be encrypted with the Vana protocol"
+          );
+        } else if (errorMessage.includes("Session key decryption failed")) {
+          throw new Error("Wrong encryption key");
+        } else if (errorMessage.includes("Error decrypting message")) {
+          throw new Error("Wrong encryption key");
+        } else if (errorMessage.includes("File not found")) {
+          throw new Error(
+            "File not found: The encrypted file is no longer available"
+          );
+        } else {
+          throw decryptError;
+        }
+      }
+      return decryptedBlob;
+    } catch (error) {
+      if (error instanceof Error && (error.message.includes("Network error:") || error.message.includes("Invalid file format:") || error.message.includes("Wrong encryption key") || error.message.includes("Access denied") || error.message.includes("File not found:") || error.message.includes("File is empty"))) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to decrypt file: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Retrieves all files owned by a specific user address.
+   *
+   * @remarks
+   * Queries the Vana subgraph for files owned by the specified address.
+   * Automatically deduplicates by file ID, keeping the latest version
+   * when duplicates exist from re-indexing or chain reorganizations.
+   * Enriches results with DLP proof data when available.
+   *
+   * @param params - Query configuration
+   * @param params.owner - Wallet address of the file owner
+   * @param params.subgraphUrl - Subgraph endpoint override.
+   *   Defaults to context configuration.
+   *
+   * @returns Array of UserFile objects sorted by timestamp (newest first)
+   *
+   * @throws {Error} Subgraph URL not configured.
+   *   Provide `subgraphUrl` parameter or configure in Vana constructor.
+   * @throws {Error} Subgraph request failed.
+   *   Check network connectivity and subgraph availability.
+   * @throws {Error} Subgraph returned errors.
+   *   Review query parameters and subgraph logs.
+   *
+   * @example
+   * ```typescript
+   * const files = await vana.data.getUserFiles({
+   *   owner: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36"
+   * });
+   *
+   * files.forEach(file => {
+   *   console.log(`File ${file.id}: ${file.url}`);
+   *   console.log(`  Schema: ${file.schemaId}`);
+   *   console.log(`  DLPs: ${file.dlpIds?.join(", ") || "none"}`);
+   * });
+   * ```
+   */
+  async getUserFiles(params, options) {
+    const { owner, subgraphUrl } = params;
+    let dataSource = options?.source === "chain" ? "chain" : "subgraph";
+    if (options?.source === "auto" || !options?.source && options?.minBlock) {
+      const endpoint2 = subgraphUrl ?? this.context.subgraphUrl;
+      const currentBlock = await this.context.publicClient.getBlockNumber();
+      let subgraphBlock;
+      if (endpoint2) {
+        try {
+          const meta = await fetchSubgraphMeta(endpoint2);
+          subgraphBlock = meta.blockNumber;
+        } catch {
+          subgraphBlock = void 0;
+        }
+      }
+      dataSource = determineDataSource(
+        options?.source,
+        options?.minBlock,
+        currentBlock,
+        subgraphBlock
+      );
+    }
+    if (dataSource === "chain") {
+      const publicClient = this.context.publicClient;
+      const chainId = await publicClient.getChainId();
+      const contractAddress = getContractAddress(chainId, "DataRegistry");
+      const files = await getUserFilesFromChain(
+        publicClient,
+        contractAddress,
+        owner,
+        options?.minBlock ? BigInt(options.minBlock) : void 0
+      );
+      const limit = options?.fetchAll ? files.length : options?.limit ?? 100;
+      const offset = options?.offset ?? 0;
+      return files.slice(offset, offset + limit);
+    }
+    const endpoint = subgraphUrl ?? this.context.subgraphUrl;
+    if (!endpoint) {
+      throw new Error(
+        "subgraphUrl is required. Please provide a valid subgraph endpoint or configure it in Vana constructor."
+      );
+    }
+    if (options?.minBlock || options?.waitForSync) {
+      await checkSubgraphConsistency(endpoint, options);
+    }
+    try {
+      const orderByMap = {
+        id: "id",
+        addedAtBlock: "addedAtBlock",
+        addedAtTimestamp: "addedAtTimestamp",
+        url: "url",
+        schemaId: "schemaId"
+      };
+      const allFiles = await executePaginatedQuery({
+        endpoint,
+        document: GetUserFilesPaginatedDocument,
+        baseVariables: {
+          userId: owner.toLowerCase(),
+          // Subgraph requires lowercase addresses
+          orderBy: mapOrderByToEnum(
+            options?.orderBy,
+            orderByMap,
+            "addedAtBlock"
+          ),
+          orderDirection: mapOrderDirection(
+            options?.orderDirection,
+            "asc",
+            "desc"
+          )
+        },
+        options,
+        extractItems: (data) => data?.user?.files,
+        transformItem: (file) => ({
+          id: parseInt(file.id),
+          url: file.url,
+          ownerAddress: file.owner.id,
+          addedAtBlock: BigInt(file.addedAtBlock),
+          schemaId: parseInt(file.schemaId),
+          addedAtTimestamp: BigInt(file.addedAtTimestamp),
+          transactionHash: file.transactionHash
+        })
+      });
+      if (allFiles.length > 0) {
+        try {
+          const fileIds = allFiles.map((f) => f.id);
+          let proofMap;
+          try {
+            proofMap = await this._fetchProofsFromSubgraph(fileIds, endpoint);
+          } catch (subgraphError) {
+            console.debug(
+              "Failed to fetch proofs from subgraph, trying chain:",
+              subgraphError
+            );
+            proofMap = await this._fetchProofsFromChain(fileIds);
+          }
+          for (const file of allFiles) {
+            const dlpIds = proofMap.get(file.id);
+            if (dlpIds && dlpIds.length > 0) {
+              file.dlpIds = dlpIds;
+            }
+          }
+        } catch (error) {
+          console.warn("Failed to fetch proof data for files:", error);
+        }
+      }
+      return allFiles;
+    } catch (error) {
+      console.error("Failed to fetch user files from subgraph:", error);
+      throw new Error(
+        `Failed to fetch user files from subgraph: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Fetches proof data for multiple files from the subgraph.
+   *
+   * @private
+   * @param fileIds - Array of file IDs to fetch proofs for
+   * @param subgraphUrl - The subgraph endpoint URL
+   * @returns Map of file IDs to their associated DLP IDs
+   */
+  async _fetchProofsFromSubgraph(fileIds, subgraphUrl) {
+    const response = await fetch(subgraphUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query: print(GetFileProofsDocument),
+        variables: {
+          fileIds: fileIds.map((id) => id.toString())
+        }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Subgraph request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const result = await response.json();
+    if (result.errors) {
+      throw new Error(
+        `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+      );
+    }
+    const proofMap = /* @__PURE__ */ new Map();
+    if (result.data?.dataRegistryProofs) {
+      for (const proof of result.data.dataRegistryProofs) {
+        if (proof.dlp?.id) {
+          const fileId = parseInt(proof.fileId);
+          const dlpId = parseInt(proof.dlp.id);
+          let dlpIds = proofMap.get(fileId);
+          if (!dlpIds) {
+            dlpIds = [];
+            proofMap.set(fileId, dlpIds);
+          }
+          if (!dlpIds.includes(dlpId)) {
+            dlpIds.push(dlpId);
+          }
+        }
+      }
+    }
+    return proofMap;
+  }
+  /**
+   * Fetches proof data for multiple files from the blockchain.
+   * Falls back to this when subgraph is unavailable.
+   *
+   * @private
+   * @param fileIds - Array of file IDs to fetch proofs for
+   * @returns Map of file IDs to their associated DLP IDs
+   */
+  async _fetchProofsFromChain(fileIds) {
+    const chainId = this.context.publicClient.chain?.id;
+    if (!chainId) {
+      throw new Error("Chain ID not available");
+    }
+    const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+    const dataRegistryAbi = getAbi("DataRegistry");
+    const proofMap = /* @__PURE__ */ new Map();
+    for (const fileId of fileIds) {
+      const dlpIds = [];
+      let proofIndex = 0;
+      let hasMoreProofs = true;
+      while (hasMoreProofs) {
+        try {
+          const proof = await this.context.publicClient.readContract({
+            address: dataRegistryAddress,
+            abi: dataRegistryAbi,
+            functionName: "fileProofs",
+            args: [BigInt(fileId), BigInt(proofIndex)]
+          });
+          if (proof?.data?.dlpId) {
+            const dlpId = Number(proof.data.dlpId);
+            if (!dlpIds.includes(dlpId)) {
+              dlpIds.push(dlpId);
+            }
+          }
+          proofIndex++;
+        } catch {
+          hasMoreProofs = false;
+        }
+      }
+      if (dlpIds.length > 0) {
+        proofMap.set(fileId, dlpIds);
+      }
+    }
+    return proofMap;
+  }
+  /**
+   * Retrieves information about a specific Data Liquidity Pool (DLP).
+   *
+   * @remarks
+   * DLPs are entities that process and verify data files in the Vana network.
+   * This method fetches DLP metadata including name, status, and performance rating.
+   * Uses subgraph first for efficiency, falls back to chain if unavailable.
+   *
+   * @param dlpId - The unique identifier of the DLP
+   * @param options - Optional parameters
+   * @param options.subgraphUrl - Custom subgraph URL to override default
+   * @returns Promise resolving to DLP information
+   * @throws {Error} When DLP cannot be found - "DLP not found: {dlpId}"
+   * @throws {Error} When query fails - "Failed to fetch DLP: {error}"
+   * @example
+   * ```typescript
+   * const dlp = await vana.data.getDLP(26);
+   * console.log(`DLP ${dlp.name}: ${dlp.status}`);
+   * ```
+   */
+  async getDLP(dlpId, options = {}) {
+    const subgraphUrl = options.subgraphUrl ?? this.context.subgraphUrl;
+    if (subgraphUrl && (options.minBlock || options.waitForSync)) {
+      await checkSubgraphConsistency(subgraphUrl, options);
+    }
+    if (subgraphUrl) {
+      try {
+        const response = await fetch(subgraphUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            query: print(GetDlpDocument),
+            variables: {
+              id: dlpId.toString()
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Subgraph request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        const result = await response.json();
+        if (result.errors) {
+          throw new Error(
+            `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        if (!result.data?.dlp) {
+          throw new Error(`DLP not found: ${dlpId}`);
+        }
+        return {
+          id: parseInt(result.data.dlp.id),
+          name: result.data.dlp.name ?? "",
+          metadata: result.data.dlp.metadata ?? void 0,
+          status: result.data.dlp.status ? parseInt(result.data.dlp.status) : void 0,
+          address: result.data.dlp.address ? result.data.dlp.address : void 0,
+          owner: result.data.dlp.owner ? result.data.dlp.owner : void 0
+        };
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to chain:", error);
+      }
+    }
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dlpRegistryAddress = getContractAddress(chainId, "DLPRegistry");
+      const dlpRegistryAbi = getAbi("DLPRegistry");
+      const dlpData = await this.context.publicClient.readContract({
+        address: dlpRegistryAddress,
+        abi: dlpRegistryAbi,
+        functionName: "dlps",
+        args: [BigInt(dlpId)]
+      });
+      if (!dlpData?.name) {
+        throw new Error(`DLP not found: ${dlpId}`);
+      }
+      return {
+        id: dlpId,
+        name: dlpData.name,
+        metadata: dlpData.metadata,
+        status: dlpData.status,
+        address: dlpData.dlpAddress,
+        owner: dlpData.ownerAddress
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch DLP: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Lists all Data Liquidity Pools (DLPs) with optional pagination.
+   *
+   * @remarks
+   * Fetches a paginated list of all DLPs registered in the network.
+   * Uses subgraph for efficient querying with fallback to chain multicall.
+   *
+   * @param options - Optional parameters for pagination and filtering
+   * @param options.limit - Maximum number of DLPs to return (default: 100)
+   * @param options.offset - Number of DLPs to skip (default: 0)
+   * @param options.subgraphUrl - Custom subgraph URL to override default
+   * @returns Promise resolving to array of DLP information
+   * @throws {Error} When query fails - "Failed to list DLPs: {error}"
+   * @example
+   * ```typescript
+   * // Get first 10 DLPs
+   * const dlps = await vana.data.listDLPs({ limit: 10 });
+   * dlps.forEach(dlp => console.log(`${dlp.id}: ${dlp.name}`));
+   *
+   * // Get next page
+   * const nextPage = await vana.data.listDLPs({ limit: 10, offset: 10 });
+   * ```
+   */
+  async listDLPs(options = {}) {
+    const { limit = 100, offset = 0 } = options;
+    const subgraphUrl = options.subgraphUrl ?? this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        const query = `
+          query ListDLPs($first: Int!, $skip: Int!) {
+            dlps(first: $first, skip: $skip, orderBy: id) {
+              id
+              name
+              metadata
+              status
+              address
+              owner
+            }
+          }
+        `;
+        const response = await fetch(subgraphUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            query,
+            variables: {
+              first: limit,
+              skip: offset
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(
+            `Subgraph request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        const result = await response.json();
+        if (result.errors) {
+          throw new Error(
+            `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        const dlps = result.data?.dlps ?? [];
+        return dlps.map((dlp) => ({
+          id: parseInt(dlp.id),
+          name: dlp.name ?? "",
+          metadata: dlp.metadata,
+          status: dlp.status ? parseInt(dlp.status) : void 0,
+          address: dlp.address ? dlp.address : void 0,
+          owner: dlp.owner ? dlp.owner : void 0
+        }));
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to chain:", error);
+      }
+    }
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dlpRegistryAddress = getContractAddress(chainId, "DLPRegistry");
+      const dlpRegistryAbi = getAbi("DLPRegistry");
+      const dlpCount = await this.context.publicClient.readContract({
+        address: dlpRegistryAddress,
+        abi: dlpRegistryAbi,
+        functionName: "dlpsCount",
+        args: []
+      });
+      const totalCount = Number(dlpCount);
+      const start = offset;
+      const end = Math.min(start + limit, totalCount);
+      if (end <= start) {
+        return [];
+      }
+      const calls = [];
+      for (let i = start + 1; i <= end; i++) {
+        calls.push({
+          address: dlpRegistryAddress,
+          abi: dlpRegistryAbi,
+          functionName: "dlps",
+          args: [BigInt(i)]
+        });
+      }
+      const results = await gasAwareMulticall(this.context.publicClient, {
+        contracts: calls,
+        allowFailure: true,
+        batchSize: 50
+      });
+      const dlps = [];
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "success" && result.result) {
+          const dlpData = result.result;
+          if (dlpData.name) {
+            dlps.push({
+              id: start + i + 1,
+              name: dlpData.name,
+              metadata: dlpData.metadata,
+              status: dlpData.status,
+              address: dlpData.dlpAddress,
+              owner: dlpData.ownerAddress
+            });
+          }
+        }
+      }
+      return dlps;
+    } catch (error) {
+      throw new Error(
+        `Failed to list DLPs: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Retrieves a list of permissions granted by a user.
+   *
+   * 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 both subgraph and RPC queries fail
+   */
+  async getUserPermissions(params, options) {
+    const { user, subgraphUrl } = params;
+    const endpoint = subgraphUrl ?? this.context.subgraphUrl;
+    if (endpoint && (options?.minBlock || options?.waitForSync)) {
+      await checkSubgraphConsistency(endpoint, options);
+    }
+    if (endpoint) {
+      try {
+        const permissions = await this._getUserPermissionsViaSubgraph(
+          {
+            user,
+            subgraphUrl: endpoint
+          },
+          options
+        );
+        return permissions;
+      } catch (error) {
+        console.warn("Subgraph query failed, falling back to RPC:", error);
+      }
+    }
+    const allPermissions = await this._getUserPermissionsViaRpc({ user });
+    if (options && !options.fetchAll) {
+      const limit = options.limit ?? 100;
+      const offset = options.offset ?? 0;
+      return allPermissions.slice(offset, offset + limit);
+    }
+    return allPermissions;
+  }
+  /**
+   * 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
+   */
+  async _getUserPermissionsViaSubgraph(params, options) {
+    const { user, subgraphUrl } = params;
+    try {
+      const orderByMap = {
+        id: "id",
+        addedAtBlock: "addedAtBlock",
+        addedAtTimestamp: "addedAtTimestamp",
+        grant: "grant",
+        nonce: "nonce",
+        startBlock: "startBlock",
+        endBlock: "endBlock"
+      };
+      const permissions = await executePaginatedQuery({
+        endpoint: subgraphUrl,
+        document: GetUserPermissionsPaginatedDocument,
+        baseVariables: {
+          userId: user.toLowerCase(),
+          orderBy: mapOrderByToEnum(
+            options?.orderBy,
+            orderByMap,
+            "addedAtTimestamp"
+          ),
+          orderDirection: mapOrderDirection(
+            options?.orderDirection,
+            "desc",
+            "asc"
+          )
+        },
+        options,
+        extractItems: (data) => data?.user?.permissions,
+        transformItem: (permission) => ({
+          id: permission.id,
+          grant: permission.grant,
+          nonce: BigInt(permission.nonce),
+          signature: permission.signature,
+          addedAtBlock: BigInt(permission.addedAtBlock),
+          addedAtTimestamp: BigInt(permission.addedAtTimestamp),
+          transactionHash: permission.transactionHash,
+          user
+        })
+      });
+      return permissions;
+    } catch (error) {
+      console.error("Failed to query user permissions from subgraph:", error);
+      throw error;
+    }
+  }
+  /**
+   * Internal method: Query user permissions via direct RPC
+   *
+   * @param params - Query parameters object
+   * @param params.user - The user address to query permissions for
+   * @returns Promise resolving to an array of permission objects
+   */
+  async _getUserPermissionsViaRpc(params) {
+    const { user } = params;
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const permissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const permissionsAbi = getAbi("DataPortabilityPermissions");
+      const totalCount = await this.context.publicClient.readContract({
+        address: permissionsAddress,
+        abi: permissionsAbi,
+        functionName: "userPermissionIdsLength",
+        args: [user]
+      });
+      const total = Number(totalCount);
+      if (total === 0) {
+        return [];
+      }
+      const permissionIdCalls = [];
+      for (let i = 0; i < total; i++) {
+        permissionIdCalls.push({
+          address: permissionsAddress,
+          abi: permissionsAbi,
+          functionName: "userPermissionIdsAt",
+          args: [user, BigInt(i)]
+        });
+      }
+      const permissionIdResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: permissionIdCalls
+      });
+      const permissionIds = permissionIdResults.map((result) => result).filter((id) => id && id > 0n);
+      const permissionInfoCalls = permissionIds.map(
+        (permissionId) => ({
+          address: permissionsAddress,
+          abi: permissionsAbi,
+          functionName: "permissions",
+          args: [permissionId]
+        })
+      );
+      const permissionInfoResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: permissionInfoCalls,
+        allowFailure: true
+      });
+      const permissions = permissionInfoResults.map((result, index) => {
+        const permissionId = permissionIds[index];
+        if (result.status === "success" && result.result) {
+          const permissionInfo = result.result;
+          return {
+            id: permissionId.toString(),
+            grant: permissionInfo.grant,
+            nonce: permissionInfo.nonce,
+            signature: "",
+            // Not available from RPC, will be empty
+            addedAtBlock: permissionInfo.startBlock,
+            addedAtTimestamp: BigInt(0),
+            // Not available from RPC
+            transactionHash: "0x0000000000000000000000000000000000000000",
+            // Not available from RPC
+            user
+          };
+        } else {
+          return {
+            id: permissionId.toString(),
+            grant: "",
+            nonce: BigInt(0),
+            signature: "",
+            addedAtBlock: BigInt(0),
+            addedAtTimestamp: BigInt(0),
+            transactionHash: "0x0000000000000000000000000000000000000000",
+            user
+          };
+        }
+      }).filter((permission) => permission.grant !== "");
+      return permissions;
+    } catch (error) {
+      throw new Error(
+        `RPC query failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Retrieves a list of trusted servers for a user.
+   *
+   * 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 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
+   * // Basic usage with automatic fallback
+   * const servers = await vana.data.getUserTrustedServers({
+   *   user: '0x...'
+   * });
+   *
+   * // With pagination
+   * const servers = await vana.data.getUserTrustedServers({
+   *   user: '0x...',
+   *   limit: 10,
+   *   offset: 20
+   * });
+   *
+   * // With custom subgraph URL
+   * const servers = await vana.data.getUserTrustedServers({
+   *   user: '0x...',
+   *   subgraphUrl: 'https://custom-subgraph.com/graphql'
+   * });
+   * ```
+   */
+  async getUserTrustedServers(params, options) {
+    const { user } = params;
+    const subgraphUrl = params.subgraphUrl ?? this.context.subgraphUrl;
+    if (subgraphUrl && (options?.minBlock || options?.waitForSync)) {
+      await checkSubgraphConsistency(subgraphUrl, options);
+    }
+    if (subgraphUrl) {
+      try {
+        const servers = await this._getUserTrustedServersViaSubgraph(
+          {
+            user,
+            subgraphUrl
+          },
+          options
+        );
+        return servers;
+      } catch (error) {
+        console.warn("Subgraph query failed, falling back to RPC:", error);
+      }
+    }
+    const limit = options?.fetchAll ? Number.MAX_SAFE_INTEGER : options?.limit ?? 100;
+    const offset = options?.offset ?? 0;
+    const rpcResult = await this._getUserTrustedServersViaRpc({
+      user,
+      limit,
+      offset
+    });
+    return rpcResult.servers;
+  }
+  /**
+   * Internal method: Query trusted servers via subgraph
+   *
+   * @param params - Query parameters object
+   * @param params.user - The user address to query trusted servers for
+   * @param params.subgraphUrl - The subgraph URL endpoint to query
+   * @returns Promise resolving to an array of trusted server objects
+   */
+  async _getUserTrustedServersViaSubgraph(params, options) {
+    const { user, subgraphUrl } = params;
+    const graphqlEndpoint = subgraphUrl;
+    if (!graphqlEndpoint) {
+      throw new Error(
+        "subgraphUrl is required for subgraph mode. Please provide a valid subgraph endpoint or configure it in Vana constructor."
+      );
+    }
+    try {
+      const orderByMap = {
+        id: "id",
+        trustedAt: "trustedAt",
+        trustedAtBlock: "trustedAtBlock",
+        server: "server",
+        user: "user"
+      };
+      const serverTrusts = await executePaginatedQuery({
+        endpoint: graphqlEndpoint,
+        document: GetUserTrustedServersPaginatedDocument,
+        baseVariables: {
+          userId: user.toLowerCase(),
+          // Subgraph requires lowercase addresses
+          orderBy: mapOrderByToEnum(
+            options?.orderBy,
+            orderByMap,
+            "trustedAtBlock"
+          ),
+          orderDirection: mapOrderDirection(
+            options?.orderDirection,
+            "desc",
+            "asc"
+          )
+        },
+        options,
+        extractItems: (data) => {
+          const trusts = data?.user?.serverTrusts ?? [];
+          return trusts.filter((trust) => !trust.untrustedAtBlock);
+        },
+        transformItem: (trust) => ({
+          id: trust.server.id,
+          serverAddress: trust.server.serverAddress,
+          serverUrl: trust.server.url,
+          trustedAt: BigInt(trust.trustedAt),
+          user,
+          name: ""
+          // Not available in new schema, will be empty
+        })
+      });
+      return serverTrusts;
+    } catch (error) {
+      console.error("Failed to query trusted servers from subgraph:", error);
+      throw error;
+    }
+  }
+  /**
+   * Internal method: Query trusted servers via direct RPC
+   *
+   * @param params - Query parameters object
+   * @param params.user - The user address to query trusted servers for
+   * @param params.limit - Maximum number of results to return
+   * @param params.offset - Number of results to skip for pagination
+   * @returns Promise resolving to pagination result with servers, total count, and hasMore flag
+   */
+  async _getUserTrustedServersViaRpc(params) {
+    const { user, limit, offset } = params;
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const totalCount = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerIdsLength",
+        args: [user]
+      });
+      const total = Number(totalCount);
+      if (total === 0 || offset >= total) {
+        return {
+          servers: [],
+          total,
+          hasMore: false
+        };
+      }
+      const endIndex = Math.min(offset + limit, total);
+      const serverIdCalls = [];
+      for (let i = offset; i < endIndex; i++) {
+        serverIdCalls.push({
+          address: DataPortabilityServersAddress,
+          abi: DataPortabilityServersAbi,
+          functionName: "userServerIdsAt",
+          args: [user, BigInt(i)]
+        });
+      }
+      const serverIdResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: serverIdCalls
+      });
+      const serverIds = serverIdResults.map((result) => result).filter((id) => id && id > 0n);
+      const serverInfoCalls = serverIds.map(
+        (serverId) => ({
+          address: DataPortabilityServersAddress,
+          abi: DataPortabilityServersAbi,
+          functionName: "servers",
+          args: [serverId]
+        })
+      );
+      const serverInfoResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: serverInfoCalls,
+        allowFailure: true
+      });
+      const servers = serverInfoResults.map((result, index) => {
+        const serverId = serverIds[index];
+        if (result.status === "success" && result.result) {
+          const serverInfo = result.result;
+          return {
+            id: `${user.toLowerCase()}-${serverId.toString()}`,
+            serverAddress: serverInfo.serverAddress,
+            serverUrl: serverInfo.url,
+            trustedAt: BigInt(Date.now()),
+            user,
+            trustIndex: offset + index
+          };
+        } else {
+          return {
+            id: `${user.toLowerCase()}-${serverId.toString()}`,
+            serverAddress: "0x0000000000000000000000000000000000000000",
+            serverUrl: "",
+            trustedAt: BigInt(Date.now()),
+            user,
+            trustIndex: offset + index
+          };
+        }
+      });
+      return {
+        servers,
+        total,
+        hasMore: offset + limit < total
+      };
+    } catch (error) {
+      throw new Error(
+        `RPC query failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Retrieves total file count from Data Registry.
+   *
+   * @remarks
+   * Queries blockchain for complete file count across all users.
+   * Useful for pagination and network statistics.
+   *
+   * @returns Total number of registered files
+   *
+   * @throws {Error} Chain ID not available.
+   *   Ensure network connection.
+   * @throws {Error} Contract read failed.
+   *   Check RPC availability.
+   *
+   * @example
+   * ```typescript
+   * const total = await vana.data.getTotalFilesCount();
+   * console.log(`Total files: ${total}`);
+   *
+   * // Calculate pagination
+   * const pages = Math.ceil(total / 20);
+   * ```
+   */
+  async getTotalFilesCount() {
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const dataRegistry = getContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        client: this.context.publicClient
+      });
+      const count = await dataRegistry.read.filesCount();
+      return Number(count);
+    } catch (error) {
+      if (error instanceof Error && error.message === "Chain ID not available") {
+        throw error;
+      }
+      console.error("Failed to fetch total files count:", error);
+      return 0;
+    }
+  }
+  /**
+   * Retrieves file metadata by ID from the blockchain.
+   *
+   * @remarks
+   * Queries DataRegistry contract directly for file details.
+   * Works for any file ID regardless of ownership, enabling
+   * cross-user file discovery and verification.
+   *
+   * @param fileId - Numeric file ID to retrieve
+   *
+   * @returns UserFile object with metadata
+   *
+   * @throws {Error} Chain ID not available.
+   *   Ensure proper network connection.
+   * @throws {Error} File not found.
+   *   Verify file ID exists on-chain.
+   * @throws {Error} Contract call failed.
+   *   Check network and RPC availability.
+   *
+   * @example
+   * ```typescript
+   * const file = await vana.data.getFileById(123);
+   * console.log(`File ${file.id}:`);
+   * console.log(`  URL: ${file.url}`);
+   * console.log(`  Owner: ${file.ownerAddress}`);
+   * console.log(`  Block: ${file.addedAtBlock}`);
+   * ```
+   */
+  async getFileById(fileId) {
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const dataRegistry = getContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        client: this.context.publicClient
+      });
+      const fileDetails = await dataRegistry.read.files([BigInt(fileId)]);
+      if (!fileDetails) {
+        throw new Error("File not found");
+      }
+      if (Array.isArray(fileDetails)) {
+        const [id, url, ownerAddress, addedAtBlock] = fileDetails;
+        if (id === BigInt(0)) {
+          throw new Error("File not found");
+        }
+        return {
+          id: Number(id),
+          url,
+          ownerAddress,
+          addedAtBlock: BigInt(addedAtBlock)
+        };
+      } else {
+        if (!fileDetails.id || fileDetails.id === BigInt(0)) {
+          throw new Error("File not found");
+        }
+        return {
+          id: Number(fileDetails.id),
+          ownerAddress: fileDetails.ownerAddress,
+          url: fileDetails.url,
+          addedAtBlock: BigInt(fileDetails.addedAtBlock)
+        };
+      }
+    } catch (error) {
+      console.error("Failed to fetch file by ID:", error);
+      throw new Error(
+        `Failed to fetch file ${fileId}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Registers a file URL directly on the blockchain with a schema ID.
+   *
+   * @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
+   * @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}`);
+   * ```
+   */
+  async registerFileWithSchema(url, schemaId, options) {
+    this.assertWallet();
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      this.assertWallet();
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const account = this.context.walletClient.account ?? this.context.userAddress;
+      const from = typeof account === "string" ? account : account.address;
+      const hash = await this.context.walletClient.writeContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        functionName: "addFileWithSchema",
+        args: [url, BigInt(schemaId)],
+        account,
+        chain: this.context.walletClient.chain ?? null,
+        ...this.spreadTransactionOptions(options)
+      });
+      const { tx } = await import("../utils/transactionHelpers");
+      return tx({
+        hash,
+        from,
+        contract: "DataRegistry",
+        fn: "addFileWithSchema"
+      });
+    } catch (error) {
+      console.error("Failed to register file with schema:", error);
+      throw new Error(
+        `Registration failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Gets the user's address from the wallet client.
+   *
+   * @returns Promise resolving to the user's wallet address
+   * @throws {Error} When no addresses are available in wallet client
+   */
+  /**
+   * Adds a file with permissions to the DataRegistry contract.
+   *
+   * @param url - The file URL to register
+   * @param ownerAddress - The address of the file owner
+   * @param permissions - Array of permissions to set for the file
+   * @returns Promise resolving to file ID and transaction hash
+   * @throws {Error} When chain ID is not available
+   * @throws {ContractError} When contract execution fails
+   * @throws {Error} When transaction receipt is not available
+   * @throws {Error} When FileAdded event cannot be parsed
+   *
+   * This method handles the core logic of registering a file
+   * with specific permissions on the DataRegistry contract. It can be used
+   * by both direct transactions and relayer services.
+   */
+  async addFileWithPermissions(url, ownerAddress, permissions = [], options) {
+    this.assertWallet();
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      this.assertWallet();
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const account = this.context.walletClient.account ?? ownerAddress;
+      const from = typeof account === "string" ? account : account.address;
+      const hash = await this.context.walletClient.writeContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        functionName: "addFileWithPermissions",
+        args: [url, ownerAddress, permissions],
+        account,
+        chain: this.context.walletClient.chain ?? null,
+        ...this.spreadTransactionOptions(options)
+      });
+      const { tx } = await import("../utils/transactionHelpers");
+      return tx({
+        hash,
+        from,
+        contract: "DataRegistry",
+        fn: "addFileWithPermissions"
+      });
+    } catch (error) {
+      console.error("Failed to add file with permissions:", error);
+      throw new Error(
+        `Failed to add file with permissions: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Adds a file to the registry with permissions and schema.
+   * This combines the functionality of addFileWithPermissions and schema validation.
+   *
+   * @remarks
+   * This method automatically encrypts permissions when a publicKey is provided.
+   * It generates the user's encryption key and encrypts it with each recipient's
+   * public key before registering on the blockchain.
+   *
+   * @param url - The URL of the file to register
+   * @param ownerAddress - The address of the file owner
+   * @param permissions - Array of permissions to grant, each with account and publicKey properties
+   * @param schemaId - The schema ID to associate with the file (0 for no schema)
+   * @returns Promise resolving to TransactionResult with fileId and transactionHash
+   * @throws {Error} "Chain ID not available" - When wallet chain is not configured
+   * @throws {Error} "Failed to generate encryption key" - When encryption key generation fails
+   * @throws {Error} "Permission for {account} must include 'publicKey'" - When publicKey is missing
+   * @throws {Error} "Failed to add file with permissions and schema: {error}" - When transaction fails
+   * @example
+   * ```typescript
+   * // Get server's public key
+   * const serverIdentity = await vana.server.getIdentity({
+   *   userAddress: "0x..."
+   * });
+   *
+   * // Add file with permissions and schema
+   * const result = await vana.data.addFileWithPermissionsAndSchema(
+   *   "ipfs://QmXxx...",
+   *   ownerAddress,
+   *   [{
+   *     account: serverIdentity.address,
+   *     publicKey: serverIdentity.publicKey
+   *   }],
+   *   schemaId
+   * );
+   *
+   * console.log(`File ${result.fileId} registered in tx ${result.hash}`);
+   * ```
+   */
+  async addFileWithPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0, options) {
+    this.assertWallet();
+    try {
+      let encryptedPermissions = [];
+      if (permissions.length > 0) {
+        this.assertWallet();
+        const userEncryptionKey = await generateEncryptionKey(
+          this.context.walletClient,
+          this.context.platform,
+          DEFAULT_ENCRYPTION_SEED
+        );
+        encryptedPermissions = await Promise.all(
+          permissions.map(async (permission) => {
+            if (!permission.publicKey) {
+              throw new Error(
+                `Permission for ${permission.account} must include 'publicKey'`
+              );
+            }
+            const encryptedKey = await encryptWithWalletPublicKey(
+              userEncryptionKey,
+              permission.publicKey,
+              this.context.platform
+            );
+            return {
+              account: permission.account,
+              key: encryptedKey
+            };
+          })
+        );
+      }
+      return await this.addFileWithEncryptedPermissionsAndSchema(
+        url,
+        ownerAddress,
+        encryptedPermissions,
+        schemaId,
+        options
+      );
+    } catch (error) {
+      console.error("Failed to add file with permissions and schema:", error);
+      throw new Error(
+        `Failed to add file with permissions and schema: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Adds a file with pre-encrypted permissions and schema to the DataRegistry.
+   *
+   * @remarks
+   * This method is designed for relay services and advanced use cases where permissions
+   * have already been encrypted client-side. Unlike `addFileWithPermissionsAndSchema()`,
+   * this method expects permissions in the encrypted format with a 'key' field instead
+   * of 'publicKey'.
+   *
+   * This is typically used by relay endpoints that receive pre-encrypted data from
+   * the client SDK's `upload()` method, avoiding double encryption.
+   *
+   * @param url - The storage URL of the file (e.g., IPFS URL)
+   * @param ownerAddress - The address that will own this file
+   * @param permissions - Array of pre-encrypted permissions with 'account' and 'key' fields
+   * @param schemaId - Optional schema ID for data validation (defaults to 0)
+   * @returns Promise resolving to transaction result with hash and contract details
+   * @throws {Error} When chain ID is not available
+   * @throws {Error} When wallet is not connected
+   * @throws {Error} When transaction fails
+   * @example
+   * ```typescript
+   * // In a relay endpoint that receives pre-encrypted permissions
+   * const result = await vana.data.addFileWithEncryptedPermissionsAndSchema(
+   *   "ipfs://QmXxx...",
+   *   ownerAddress,
+   *   [
+   *     {
+   *       account: "0xServerAddress...",
+   *       key: "encrypted_key_string" // Already encrypted by client
+   *     }
+   *   ],
+   *   schemaId
+   * );
+   *
+   * console.log(`File registered in tx ${result.hash}`);
+   * ```
+   */
+  async addFileWithEncryptedPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0, options) {
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      this.assertWallet();
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const account = this.context.walletClient.account ?? ownerAddress;
+      const from = typeof account === "string" ? account : account.address;
+      const hash = await this.context.walletClient.writeContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        functionName: "addFileWithPermissionsAndSchema",
+        args: [url, ownerAddress, permissions, BigInt(schemaId)],
+        account,
+        chain: this.context.walletClient.chain ?? null,
+        ...this.spreadTransactionOptions(options)
+      });
+      const { tx } = await import("../utils/transactionHelpers");
+      return tx({
+        hash,
+        from,
+        contract: "DataRegistry",
+        fn: "addFileWithPermissionsAndSchema"
+      });
+    } catch (error) {
+      console.error("Failed to add file with permissions and schema:", error);
+      throw new Error(
+        `Failed to add file with permissions and schema: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Registers a data refiner for processing templates.
+   *
+   * @remarks
+   * Refiners define data transformation rules for DLPs.
+   * Associates schema, instructions, and processing logic.
+   *
+   * @param params - Refiner configuration
+   * @param params.dlpId - Data Liquidity Pool ID
+   * @param params.name - Refiner display name
+   * @param params.schemaId - Output schema ID.
+   *   Obtain via `vana.schemas.list()`.
+   * @param params.refinementInstructionUrl - Processing instructions URL
+   *
+   * @returns Refiner ID and transaction hash
+   *
+   * @throws {Error} Chain ID not available.
+   *   Ensure network connection.
+   * @throws {Error} Transaction failed.
+   *   Check wallet balance and network status.
+   *
+   * @example
+   * ```typescript
+   * const result = await vana.data.addRefiner({
+   *   dlpId: 1,
+   *   name: "Sentiment Analyzer",
+   *   schemaId: 42,
+   *   refinementInstructionUrl: "ipfs://QmXxx..."
+   * });
+   * console.log(`Refiner ${result.refinerId} created`);
+   * ```
+   */
+  async addRefiner(params, options) {
+    this.assertWallet();
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      this.assertWallet();
+      const account = this.context.walletClient.account ?? this.context.userAddress;
+      const from = typeof account === "string" ? account : account.address;
+      const hash = await this.context.walletClient.writeContract({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        functionName: "addRefinerWithSchemaId",
+        args: [
+          BigInt(params.dlpId),
+          params.name,
+          BigInt(params.schemaId),
+          params.refinementInstructionUrl
+        ],
+        account,
+        chain: this.context.walletClient.chain ?? null,
+        ...this.spreadTransactionOptions(options)
+      });
+      const { tx } = await import("../utils/transactionHelpers");
+      const txResult = tx({
+        hash,
+        from,
+        contract: "DataRefinerRegistry",
+        fn: "addRefinerWithSchemaId"
+      });
+      if (!this.context.waitForTransactionEvents) {
+        throw new Error("waitForTransactionEvents not configured");
+      }
+      const result = await this.context.waitForTransactionEvents(txResult);
+      const event = result.expectedEvents.RefinerAdded;
+      if (!event) {
+        throw new Error("RefinerAdded event not found in transaction");
+      }
+      return {
+        refinerId: Number(event.refinerId),
+        transactionHash: hash
+      };
+    } catch (error) {
+      console.error("Failed to add refiner:", error);
+      throw new Error(
+        `Failed to add refiner: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Retrieves refiner configuration by ID.
+   *
+   * @remarks
+   * Queries DataRefinerRegistry for refiner details.
+   * Returns DLP association, schema, and processing instructions.
+   *
+   * @param refinerId - Numeric refiner ID
+   *
+   * @returns Refiner configuration object
+   *
+   * @throws {Error} Chain ID not available.
+   *   Ensure network connection.
+   * @throws {Error} Refiner not found.
+   *   Verify refiner ID exists.
+   * @throws {Error} Contract read failed.
+   *   Check network and RPC status.
+   *
+   * @example
+   * ```typescript
+   * const refiner = await vana.data.getRefiner(1);
+   * console.log(`Refiner: ${refiner.name}`);
+   * console.log(`DLP: ${refiner.dlpId}`);
+   * console.log(`Schema: ${refiner.schemaId}`);
+   * ```
+   */
+  async getRefiner(refinerId) {
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const dataRefinerRegistry = getContract({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        client: this.context.publicClient
+      });
+      const refinerData = await dataRefinerRegistry.read.refiners([
+        BigInt(refinerId)
+      ]);
+      if (!refinerData) {
+        throw new Error("Refiner not found");
+      }
+      return {
+        id: refinerId,
+        dlpId: Number(refinerData.dlpId),
+        owner: refinerData.owner,
+        name: refinerData.name,
+        schemaId: Number(refinerData.schemaId),
+        refinementInstructionUrl: refinerData.refinementInstructionUrl
+      };
+    } catch (error) {
+      console.error("Failed to get refiner:", error);
+      throw new Error(
+        `Failed to get refiner ${refinerId}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Validates schema ID existence.
+   *
+   * @remarks
+   * Verifies schema registration in DataRegistry.
+   * Check before using schemas for uploads.
+   *
+   * @param schemaId - Numeric schema ID to validate
+   *
+   * @returns True if schema exists, false otherwise
+   *
+   * @throws {Error} Chain ID not available.
+   *   Ensure network connection.
+   * @throws {Error} Contract read failed.
+   *   Check RPC availability.
+   *
+   * @example
+   * ```typescript
+   * const valid = await vana.data.isValidSchemaId(42);
+   * if (valid) {
+   *   // Safe to use schema 42
+   *   await vana.data.upload({ schemaId: 42, ... });
+   * }
+   * ```
+   */
+  async isValidSchemaId(schemaId) {
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const dataRefinerRegistry = getContract({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        client: this.context.publicClient
+      });
+      const isValid = await dataRefinerRegistry.read.isValidSchemaId([
+        BigInt(schemaId)
+      ]);
+      return isValid;
+    } catch (error) {
+      console.error("Failed to validate schema ID:", error);
+      return false;
+    }
+  }
+  /**
+   * 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}`);
+   * ```
+   */
+  async getRefinersCount() {
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const dataRefinerRegistry = getContract({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        client: this.context.publicClient
+      });
+      const count = await dataRefinerRegistry.read.refinersCount();
+      return Number(count);
+    } catch (error) {
+      console.error("Failed to get refiners count:", error);
+      return 0;
+    }
+  }
+  /**
+   * Updates the schema ID for an existing refiner.
+   *
+   * @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}`);
+   * ```
+   */
+  async updateSchemaId(params, options) {
+    this.assertWallet();
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      this.assertWallet();
+      const account = this.context.walletClient.account ?? this.context.userAddress;
+      const hash = await this.context.walletClient.writeContract({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        functionName: "updateSchemaId",
+        args: [BigInt(params.refinerId), BigInt(params.newSchemaId)],
+        account,
+        chain: this.context.walletClient.chain ?? null,
+        ...this.spreadTransactionOptions(options)
+      });
+      await this.context.publicClient.waitForTransactionReceipt({ hash });
+      return {
+        transactionHash: hash
+      };
+    } catch (error) {
+      console.error("Failed to update schema ID:", error);
+      throw new Error(
+        `Failed to update schema ID: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Uploads an encrypted file and grants permission to a party with a public key.
+   *
+   * This method handles the complete workflow:
+   * 1. Encrypts the file with the user's encryption key
+   * 2. Uploads the encrypted file to storage
+   * 3. Encrypts the user's encryption key with the provided public key
+   * 4. Registers the file with permissions
+   *
+   * @param params - Upload parameters including data, permissions, and options
+   * @returns Promise resolving to upload result with file ID and storage URL
+   */
+  async uploadFileWithPermissions(params) {
+    this.assertWallet();
+    const { data, permissions, filename, providerName } = params;
+    try {
+      const uploadResult = await this.uploadToStorage(
+        data,
+        filename,
+        true,
+        // Always encrypt for uploadFileWithPermissions
+        providerName
+      );
+      const userAddress = this.context.userAddress;
+      const userEncryptionKey = await generateEncryptionKey(
+        this.context.walletClient,
+        this.context.platform,
+        DEFAULT_ENCRYPTION_SEED
+      );
+      const encryptedPermissions = await Promise.all(
+        permissions.map(async (permission) => {
+          const encryptedKey = await encryptWithWalletPublicKey(
+            userEncryptionKey,
+            permission.publicKey,
+            this.context.platform
+          );
+          return {
+            account: permission.account,
+            key: encryptedKey
+          };
+        })
+      );
+      if (this.context.relayer) {
+        const request = {
+          type: "direct",
+          operation: "submitFileAdditionWithPermissions",
+          params: {
+            url: uploadResult.url,
+            userAddress,
+            permissions: encryptedPermissions
+          }
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new Error(response.error);
+        }
+        let result;
+        if (response.type === "pending") {
+          result = await this.pollRelayerForConfirmation(
+            response.operationId,
+            void 0
+            // TODO: Add TransactionOptions to upload method signature
+          );
+        } else if (response.type === "direct" && typeof response.result === "object" && response.result !== null && "fileId" in response.result) {
+          result = response.result;
+        } else {
+          throw new Error("Invalid response from relayer");
+        }
+        return {
+          fileId: result.fileId,
+          url: uploadResult.url,
+          size: uploadResult.size,
+          transactionHash: result.transactionHash
+        };
+      } else {
+        const txResult = await this.addFileWithPermissions(
+          uploadResult.url,
+          userAddress,
+          encryptedPermissions
+        );
+        if (!this.context.waitForTransactionEvents) {
+          throw new Error(
+            "Cannot upload without relay: waitForTransactionEvents not configured"
+          );
+        }
+        const eventResult = await this.context.waitForTransactionEvents(txResult);
+        const fileAddedEvent = eventResult.expectedEvents.FileAdded;
+        if (!fileAddedEvent) {
+          throw new Error("FileAdded event not found in transaction");
+        }
+        return {
+          fileId: Number(fileAddedEvent.fileId),
+          url: uploadResult.url,
+          size: uploadResult.size,
+          transactionHash: txResult.hash
+        };
+      }
+    } catch (error) {
+      console.error("Failed to upload file with permissions:", error);
+      throw new Error(
+        `Failed to upload file with permissions: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Uploads content to storage without registering it on the blockchain.
+   * This method only handles the storage upload and returns the file URL.
+   *
+   * @param content - The content to upload (string, Blob, Buffer, or object - objects will be JSON stringified)
+   * @param filename - Optional filename for the uploaded file (defaults to timestamp-based name)
+   * @param encrypt  - Optional flag to encrypt the content before upload
+   * @param providerName - Optional specific storage provider to use
+   * @returns Promise resolving to the storage upload result with url, size, and contentType
+   */
+  async uploadToStorage(content, filename, encrypt = false, providerName) {
+    try {
+      let blob;
+      if (content instanceof Blob) {
+        blob = content;
+      } else if (typeof content === "string") {
+        blob = new Blob([content], { type: "text/plain" });
+      } else if (content instanceof Buffer) {
+        const arrayBuffer = content.buffer.slice(
+          content.byteOffset,
+          content.byteOffset + content.byteLength
+        );
+        blob = new Blob([arrayBuffer], { type: "application/octet-stream" });
+      } else {
+        blob = new Blob([JSON.stringify(content)], {
+          type: "application/json"
+        });
+      }
+      let finalBlob = blob;
+      if (encrypt) {
+        this.assertWallet();
+        const encryptionKey = await generateEncryptionKey(
+          this.context.walletClient,
+          this.context.platform,
+          DEFAULT_ENCRYPTION_SEED
+        );
+        finalBlob = await encryptBlobWithSignedKey(
+          blob,
+          encryptionKey,
+          this.context.platform
+        );
+      }
+      if (!this.context.storageManager) {
+        if (this.context.validateStorageRequired) {
+          this.context.validateStorageRequired();
+          throw new Error("Storage validation failed");
+        } else {
+          throw new Error(
+            "Storage manager not configured. Please provide storage providers in VanaConfig."
+          );
+        }
+      }
+      const finalFilename = (() => {
+        if (filename) {
+          if (encrypt && !filename.endsWith(".enc")) {
+            return `${filename}.enc`;
+          }
+          return filename;
+        }
+        return encrypt ? `upload-${Date.now()}.enc` : `upload-${Date.now()}.dat`;
+      })();
+      const uploadResult = await this.context.storageManager.upload(
+        finalBlob,
+        finalFilename,
+        providerName
+      );
+      return uploadResult;
+    } catch (error) {
+      throw new Error(
+        `Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Adds a permission for a party to access an existing file.
+   *
+   * This method handles the complete workflow:
+   * 1. Gets the user's encryption key
+   * 2. Encrypts the user's encryption key with the provided public key
+   * 3. Adds the permission to the file
+   * 4. Returns the permission data from the blockchain event
+   *
+   * For advanced users who need more control over transaction timing,
+   * use `submitFilePermission()` instead.
+   *
+   * @param params - Parameters for adding file permission
+   * @param params.fileId - The ID of the file to grant permission for
+   * @param params.account - The recipient's wallet address that will access the file
+   * @param params.publicKey - The recipient's public key for encryption.
+   *   Obtain via `vana.server.getIdentity(account).publicKey`
+   * @returns Promise resolving to permission data from PermissionGranted event
+   * @throws {Error} "No addresses available in wallet client" - When wallet is not connected
+   * @throws {Error} "Chain ID not available" - When wallet chain is not configured
+   * @throws {Error} "Failed to add permission to file: {error}" - When transaction fails or user doesn't own file
+   * @example
+   * ```typescript
+   * const result = await vana.data.addPermissionToFile({
+   *   fileId: 123,
+   *   account: "0xRecipientAddress...",
+   *   publicKey: "0xRecipientPublicKey..."
+   * });
+   * console.log(`Permission granted to ${result.account} for file ${result.fileId}`);
+   * console.log(`Transaction: ${result.transactionHash}`);
+   * ```
+   */
+  async addPermissionToFile(params, options) {
+    this.assertWallet();
+    const { fileId, account, publicKey } = params;
+    return await this.submitFilePermission(fileId, account, publicKey, options);
+  }
+  /**
+   * Submits a file permission transaction to the blockchain.
+   *
+   * @remarks
+   * This method supports gasless transactions via relayer callbacks when configured.
+   * It encrypts the user's encryption key with the recipient's public key before submission.
+   * Use this when you want to handle transaction confirmation and event parsing separately.
+   *
+   * @param fileId - The ID of the file to grant permission for
+   * @param account - The recipient's wallet address that will access the file
+   * @param publicKey - The recipient's public key for encryption.
+   *   Obtain via `vana.server.getIdentity(account).publicKey`
+   * @returns Promise resolving to TransactionResult for tracking the transaction
+   * @throws {Error} When chain ID is not available
+   * @throws {Error} When encryption key generation fails
+   * @throws {Error} When public key encryption fails
+   *
+   * @example
+   * ```typescript
+   * const tx = await vana.data.submitFilePermission(
+   *   fileId,
+   *   "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+   *   recipientPublicKey
+   * );
+   * const result = await tx.waitForEvents();
+   * console.log(`Permission granted with ID: ${result.permissionId}`);
+   * ```
+   */
+  async submitFilePermission(fileId, account, publicKey, options) {
+    this.assertWallet();
+    try {
+      const userEncryptionKey = await generateEncryptionKey(
+        this.context.walletClient,
+        this.context.platform,
+        DEFAULT_ENCRYPTION_SEED
+      );
+      const encryptedKey = await encryptWithWalletPublicKey(
+        userEncryptionKey,
+        publicKey,
+        this.context.platform
+      );
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      this.assertWallet();
+      const walletAccount = this.context.walletClient.account ?? this.context.userAddress;
+      const txHash = await this.context.walletClient.writeContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        functionName: "addFilePermission",
+        args: [BigInt(fileId), account, encryptedKey],
+        account: walletAccount,
+        chain: this.context.walletClient.chain ?? null,
+        ...this.spreadTransactionOptions(options)
+      });
+      const { tx } = await import("../utils/transactionHelpers");
+      return tx({
+        hash: txHash,
+        from: typeof walletAccount === "string" ? walletAccount : walletAccount.address,
+        contract: "DataRegistry",
+        fn: "addFilePermission"
+      });
+    } catch (error) {
+      console.error("Failed to add permission to file:", error);
+      throw new Error(
+        `Failed to add permission to file: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Gets the encrypted key for a specific account's permission to access a file.
+   *
+   * @param fileId - The ID of the file
+   * @param account - The account address to get the permission for
+   * @returns Promise resolving to the encrypted key for that account
+   */
+  async getFilePermission(fileId, account) {
+    try {
+      const chainId = this.context.publicClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const dataRegistry = getContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        client: this.context.publicClient
+      });
+      const encryptedKey = await dataRegistry.read.filePermissions([
+        BigInt(fileId),
+        account
+      ]);
+      return encryptedKey;
+    } catch (error) {
+      console.error("Failed to get file permission:", error);
+      throw new Error(
+        `Failed to get file permission: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Decrypts a file that the user has permission to access using their private key.
+   *
+   * This method handles the complete workflow for servers or other permitted parties:
+   * 1. Gets the encrypted encryption key from file permissions
+   * 2. Decrypts the encryption key using the provided private key
+   * 3. Downloads and decrypts the file data
+   *
+   * @param file - The file to decrypt
+   * @param privateKey - The private key to decrypt the user's encryption key
+   * @param options - Optional decryption configuration
+   * @param options.account - The account address that has permission (defaults to current wallet account)
+   * @returns Promise resolving to the decrypted file data
+   */
+  async decryptFileWithPermission(file, privateKey, options) {
+    try {
+      const permissionAccount = options?.account ?? this.context.userAddress;
+      const encryptedKey = await this.getFilePermission(
+        file.id,
+        permissionAccount
+      );
+      if (!encryptedKey) {
+        throw new Error(
+          `No permission found for account ${permissionAccount} to access file ${file.id}`
+        );
+      }
+      const userEncryptionKey = await decryptWithWalletPrivateKey(
+        encryptedKey,
+        privateKey,
+        this.context.platform
+      );
+      let encryptedData;
+      if (file.url.startsWith("ipfs://")) {
+        encryptedData = await this.fetchFromIPFS(file.url);
+      } else {
+        encryptedData = await this.fetch(file.url);
+      }
+      const decryptedData = await decryptBlobWithSignedKey(
+        encryptedData,
+        userEncryptionKey,
+        this.context.platform
+      );
+      return decryptedData;
+    } catch (error) {
+      console.error("Failed to decrypt file with permission:", error);
+      throw new Error(
+        `Failed to decrypt file with permission: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Simple network-agnostic fetch utility for retrieving file content.
+   *
+   * @remarks
+   * This is a thin wrapper around the global fetch API that returns the response as a Blob.
+   * It provides a consistent interface for fetching encrypted content before decryption.
+   * For IPFS URLs, consider using fetchFromIPFS for better reliability.
+   *
+   * @param url - The URL to fetch content from
+   * @returns Promise resolving to the fetched content as a Blob
+   * @throws {Error} "HTTP error! status: {status} {statusText}" - When server returns error status
+   * @throws {Error} "Empty response" - When server returns no content
+   * @throws {Error} "Network error: Failed to fetch from {url}" - When network request fails
+   *
+   * @example
+   * ```typescript
+   * // Fetch and decrypt a file
+   * const encryptionKey = await generateEncryptionKey(walletClient);
+   * const encryptedBlob = await vana.data.fetch(file.url);
+   * const decryptedBlob = await decryptBlob(encryptedBlob, encryptionKey, platform);
+   *
+   * // With custom headers for authentication
+   * const response = await fetch(file.url, {
+   *   headers: { 'Authorization': 'Bearer token' }
+   * });
+   * const encryptedBlob = await response.blob();
+   * ```
+   */
+  async fetch(url) {
+    try {
+      const { universalFetch } = await import("../utils/download");
+      const response = await universalFetch(url, this.context.downloadRelayer);
+      if (!response.ok) {
+        throw new Error(
+          `HTTP error! status: ${response.status} ${response.statusText}`
+        );
+      }
+      const blob = await response.blob();
+      if (blob.size === 0) {
+        throw new Error("Empty response");
+      }
+      return blob;
+    } catch (error) {
+      if (error instanceof TypeError && error.message.includes("fetch")) {
+        throw new Error(
+          `Network error: Failed to fetch from ${url}. The URL may be invalid or the server may not be accessible.`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Specialized IPFS fetcher with gateway fallback mechanism.
+   *
+   * @remarks
+   * This method provides robust IPFS content fetching by trying multiple gateways
+   * in sequence until one succeeds. It supports both ipfs:// URLs and raw CIDs.
+   *
+   * The default gateway list includes public gateways, but you should provide
+   * your own gateways for production use to ensure reliability and privacy.
+   *
+   * @param url - The IPFS URL (ipfs://...) or CID to fetch
+   * @param options - Optional configuration
+   * @param options.gateways - Array of IPFS gateway URLs to try (must end with /)
+   * @returns Promise resolving to the fetched content as a Blob
+   * @throws {Error} "Invalid IPFS URL format" - When URL is not ipfs:// or valid CID
+   * @throws {Error} "Empty response" - When gateway returns no content
+   * @throws {Error} "HTTP error! status: {status}" - When gateway returns error status
+   * @throws {Error} "Failed to fetch IPFS content {cid} from all gateways" - When all gateways fail
+   *
+   * @example
+   * ```typescript
+   * // Fetch from IPFS with custom gateways
+   * const encryptedBlob = await vana.data.fetchFromIPFS(file.url, {
+   *   gateways: [
+   *     'https://my-private-gateway.com/ipfs/',
+   *     'https://dweb.link/ipfs/',
+   *     'https://ipfs.io/ipfs/'
+   *   ]
+   * });
+   *
+   * // Decrypt the fetched content
+   * const encryptionKey = await generateEncryptionKey(walletClient);
+   * const decryptedBlob = await decryptBlob(encryptedBlob, encryptionKey, platform);
+   *
+   * // With raw CID
+   * const blob = await vana.data.fetchFromIPFS('QmXxx...', {
+   *   gateways: ['https://ipfs.io/ipfs/']
+   * });
+   * ```
+   */
+  async fetchFromIPFS(url, options) {
+    const defaultGateways = [
+      "https://dweb.link/ipfs/",
+      "https://ipfs.io/ipfs/"
+    ];
+    const gateways = options?.gateways ?? this.context.ipfsGateways ?? defaultGateways;
+    const { extractIpfsHash } = await import("../utils/ipfs");
+    const cid = extractIpfsHash(url);
+    if (!cid) {
+      throw new Error(
+        `Invalid IPFS URL format. Expected ipfs://... or a raw CID, got: ${url}`
+      );
+    }
+    const errors = [];
+    for (let i = 0; i < gateways.length; i++) {
+      const gateway = gateways[i];
+      const isLastGateway = i === gateways.length - 1;
+      const gatewayUrl = gateway.endsWith("/") ? `${gateway}${cid}` : `${gateway}/${cid}`;
+      try {
+        console.debug(`Trying IPFS gateway: ${gatewayUrl}`);
+        const response = await fetch(gatewayUrl);
+        if (response.ok) {
+          const blob = await response.blob();
+          if (blob.size > 0) {
+            console.debug(`Successfully fetched from gateway: ${gateway}`);
+            return blob;
+          } else {
+            if (isLastGateway) {
+              throw new Error("Empty response");
+            }
+            errors.push({
+              gateway,
+              error: "Empty response"
+            });
+          }
+        } else {
+          if (isLastGateway) {
+            if (response.status === 403) {
+              throw new Error(`HTTP error! status: 403 ${response.statusText}`);
+            } else if (response.status === 404) {
+              throw new Error(`HTTP error! status: 404 ${response.statusText}`);
+            } else {
+              throw new Error(
+                `HTTP error! status: ${response.status} ${response.statusText}`
+              );
+            }
+          }
+          errors.push({
+            gateway,
+            error: `HTTP ${response.status} ${response.statusText}`
+          });
+        }
+      } catch (error) {
+        if (isLastGateway && error instanceof Error && (error.message.includes("Empty response") || error.message.includes("HTTP error!"))) {
+          throw error;
+        }
+        errors.push({
+          gateway,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    if (this.context.downloadRelayer && gateways.length > 0) {
+      try {
+        const relayerUrl = gateways[0].endsWith("/") ? `${gateways[0]}${cid}` : `${gateways[0]}/${cid}`;
+        return await this.context.downloadRelayer.proxyDownload(relayerUrl);
+      } catch (relayerError) {
+        errors.push({
+          gateway: "download-relayer",
+          error: `Proxy failed: ${relayerError instanceof Error ? relayerError.message : "Unknown error"}`
+        });
+      }
+    }
+    const errorDetails = errors.map((e) => `${e.gateway}: ${e.error}`).join("\n  ");
+    throw new Error(
+      `Failed to fetch IPFS content ${cid} from all gateways:
+  ${errorDetails}`
+    );
+  }
+  /**
+   * Validates a data schema definition against the Vana meta-schema.
+   *
+   * @param schema - The data schema definition to validate
+   * @returns The validated DataSchema
+   * @throws SchemaValidationError if invalid
+   * @example
+   * ```typescript
+   * const schema = {
+   *   name: "User Profile",
+   *   version: "1.0.0",
+   *   dialect: "json",
+   *   schema: {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       age: { type: "number" }
+   *     }
+   *   }
+   * };
+   *
+   * const validatedSchema = vana.data.validateDataSchemaAgainstMetaSchema(schema);
+   * ```
+   */
+  validateDataSchemaAgainstMetaSchema(schema) {
+    return validateDataSchemaAgainstMetaSchema(schema);
+  }
+  /**
+   * Validates data against a JSON Schema from a data schema.
+   *
+   * @param data - The data to validate
+   * @param schema - The data schema containing the schema
+   * @returns Void (throws if validation fails)
+   * @throws SchemaValidationError if invalid
+   * @example
+   * ```typescript
+   * const schema = {
+   *   name: "User Profile",
+   *   version: "1.0.0",
+   *   dialect: "json",
+   *   schema: {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       age: { type: "number" }
+   *     },
+   *     required: ["name"]
+   *   }
+   * };
+   *
+   * const userData = { name: "Alice", age: 30 };
+   * vana.data.validateDataAgainstSchema(userData, schema);
+   * ```
+   */
+  validateDataAgainstSchema(data, schema) {
+    validateDataAgainstSchema(data, schema);
+  }
+  /**
+   * Fetches and validates a data schema from a URL, then returns the parsed data schema.
+   *
+   * @param url - The URL to fetch the data schema from
+   * @returns The validated data schema
+   * @throws SchemaValidationError if invalid or fetch fails
+   * @example
+   * ```typescript
+   * // Fetch and validate a schema from IPFS or HTTP
+   * const schema = await vana.data.fetchAndValidateSchema("https://example.com/schema.json");
+   * console.log(schema.name, schema.dialect);
+   *
+   * // Use the schema to validate user data
+   * if (schema.dialect === "json") {
+   *   vana.data.validateDataAgainstSchema(userData, schema);
+   * }
+   * ```
+   */
+  async fetchAndValidateSchema(url) {
+    return fetchAndValidateSchema(url);
+  }
+  /**
+   * Polls for confirmation of a relayer operation.
+   * @internal
+   */
+  async pollRelayerForConfirmation(operationId, options) {
+    if (!this.context.relayer) {
+      throw new Error("Relayer not configured for polling");
+    }
+    const pollingManager = new PollingManager(this.context.relayer);
+    const result = await pollingManager.startPolling(operationId, {
+      signal: options?.signal,
+      onStatusUpdate: options?.onStatusUpdate,
+      ...options?.pollingOptions
+    });
+    return {
+      fileId: 0,
+      // This would need to be extracted from transaction events
+      transactionHash: result.hash
+    };
+  }
+}
+export {
+  DataController
+};
+//# sourceMappingURL=data.js.map