@opendatalabs/vana-sdk 0.1.0-alpha.3bc04d8 → 0.1.0-alpha.3cd7595

package/dist/index.browser.js

@@ -425,17 +425,178 @@ var init_dataSchema_schema = __esm({
   }
 });
 
+// src/utils/ipfs.ts
+var ipfs_exports = {};
+__export(ipfs_exports, {
+  DEFAULT_IPFS_GATEWAY: () => DEFAULT_IPFS_GATEWAY,
+  IPFS_GATEWAYS: () => IPFS_GATEWAYS,
+  convertIpfsUrl: () => convertIpfsUrl,
+  convertIpfsUrlWithFallbacks: () => convertIpfsUrlWithFallbacks,
+  extractIpfsHash: () => extractIpfsHash,
+  fetchWithFallbacks: () => fetchWithFallbacks,
+  getGatewayUrls: () => getGatewayUrls,
+  isIpfsUrl: () => isIpfsUrl
+});
+function isIpfsUrl(url) {
+  return url.startsWith("ipfs://");
+}
+function convertIpfsUrl(url, gateway = DEFAULT_IPFS_GATEWAY) {
+  if (isIpfsUrl(url)) {
+    const hash = url.replace("ipfs://", "");
+    return `${gateway}${hash}`;
+  }
+  return url;
+}
+function extractIpfsHash(url) {
+  const patterns = [
+    /ipfs\/([a-zA-Z0-9]+)/,
+    // https://gateway.pinata.cloud/ipfs/HASH
+    /^ipfs:\/\/([a-zA-Z0-9]+)$/,
+    // ipfs://HASH
+    /^([a-zA-Z0-9]{46,})$/
+    // Just the hash (46+ chars for IPFS hashes)
+  ];
+  for (const pattern of patterns) {
+    const match = url.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function getGatewayUrls(hash) {
+  return IPFS_GATEWAYS.map((gateway) => `${gateway}${hash}`);
+}
+function convertIpfsUrlWithFallbacks(url) {
+  const hash = extractIpfsHash(url);
+  if (hash) {
+    return getGatewayUrls(hash);
+  }
+  return [url];
+}
+async function fetchWithFallbacks(url, options) {
+  const hash = extractIpfsHash(url);
+  if (!hash) {
+    return fetch(url, options);
+  }
+  const gatewayUrls = getGatewayUrls(hash);
+  let lastError = null;
+  for (let i = 0; i < gatewayUrls.length; i++) {
+    const gatewayUrl = gatewayUrls[i];
+    try {
+      const response = await fetch(gatewayUrl, {
+        ...options,
+        // Add timeout to avoid hanging on slow gateways
+        signal: AbortSignal.timeout(1e4)
+        // 10 second timeout
+      });
+      if (response.ok) {
+        return response;
+      }
+      if (response.status === 429) {
+        lastError = new Error(`Gateway rate limited: ${gatewayUrl}`);
+        continue;
+      }
+      lastError = new Error(`Gateway error ${response.status}: ${gatewayUrl}`);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (lastError.message.includes("429") || lastError.name === "TimeoutError") {
+        continue;
+      }
+    }
+    if (i < gatewayUrls.length - 1) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3 * (i + 1)));
+    }
+  }
+  throw new Error(
+    `All IPFS gateways failed for hash ${hash}. Last error: ${lastError?.message}`
+  );
+}
+var DEFAULT_IPFS_GATEWAY, IPFS_GATEWAYS;
+var init_ipfs = __esm({
+  "src/utils/ipfs.ts"() {
+    "use strict";
+    DEFAULT_IPFS_GATEWAY = "https://dweb.link/ipfs/";
+    IPFS_GATEWAYS = [
+      "https://dweb.link/ipfs/",
+      // Interplanetary Shipyard - highly reliable
+      "https://ipfs.io/ipfs/",
+      // IPFS Foundation - reliable
+      "https://cloudflare-ipfs.com/ipfs/",
+      // Cloudflare - good performance
+      "https://gateway.pinata.cloud/ipfs/",
+      // Pinata - backup option (has rate limits)
+      "https://ipfs.filebase.io/ipfs/"
+      // Filebase - emerging reliable option
+    ];
+  }
+});
+
+// src/utils/download.ts
+var download_exports = {};
+__export(download_exports, {
+  fetchWithRelayer: () => fetchWithRelayer
+});
+async function fetchWithRelayer(url, downloadRelayer) {
+  let processedUrl = url;
+  if (url.startsWith("ar://")) {
+    const txId = url.replace("ar://", "");
+    processedUrl = `https://arweave.net/${txId}`;
+  }
+  const ipfsHash = extractIpfsHash(processedUrl);
+  if (ipfsHash) {
+    try {
+      return await fetchWithFallbacks(url);
+    } catch (ipfsError) {
+      if (downloadRelayer) {
+        try {
+          const gatewayUrl = `https://gateway.pinata.cloud/ipfs/${ipfsHash}`;
+          const blob = await downloadRelayer.proxyDownload(gatewayUrl);
+          return new Response(blob);
+        } catch {
+          throw ipfsError;
+        }
+      }
+      throw ipfsError;
+    }
+  }
+  try {
+    const response = await fetch(processedUrl);
+    return response;
+  } catch (error) {
+    if (downloadRelayer) {
+      try {
+        const blob = await downloadRelayer.proxyDownload(processedUrl);
+        return new Response(blob);
+      } catch {
+        throw error;
+      }
+    }
+    throw new Error(
+      `Failed to fetch from ${processedUrl}: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+var init_download = __esm({
+  "src/utils/download.ts"() {
+    "use strict";
+    init_ipfs();
+  }
+});
+
 // src/utils/schemaValidation.ts
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-function validateDataSchema(schema) {
-  return schemaValidator.validateDataSchema(schema);
+function validateDataSchemaAgainstMetaSchema(schema) {
+  const validator = schemaValidator;
+  validator.validateDataSchemaAgainstMetaSchema(schema);
+  return schema;
 }
 function validateDataAgainstSchema(data, schema) {
   return schemaValidator.validateDataAgainstSchema(data, schema);
 }
-function fetchAndValidateSchema(url) {
-  return schemaValidator.fetchAndValidateSchema(url);
+function fetchAndValidateSchema(url, downloadRelayer) {
+  return schemaValidator.fetchAndValidateSchema(url, downloadRelayer);
 }
 var SchemaValidationError, SchemaValidator, schemaValidator;
 var init_schemaValidation = __esm({
@@ -462,9 +623,9 @@ var init_schemaValidation = __esm({
         this.dataSchemaValidator = this.ajv.compile(dataSchema_schema_default);
       }
       /**
-       * Validates a data schema against the Vana meta-schema
+       * Validates a data schema definition against the Vana meta-schema
        *
-       * @param schema - The data schema to validate
+       * @param schema - The data schema definition to validate
        * @throws SchemaValidationError if invalid
        * @example
        * ```typescript
@@ -483,10 +644,10 @@ var init_schemaValidation = __esm({
        *   }
        * };
        *
-       * validator.validateDataSchema(schema); // throws if invalid
+       * validator.validateDataSchemaAgainstMetaSchema(schema); // throws if invalid
        * ```
        */
-      validateDataSchema(schema) {
+      validateDataSchemaAgainstMetaSchema(schema) {
         const isValid = this.dataSchemaValidator(schema);
         if (!isValid) {
           const errors = this.dataSchemaValidator.errors || [];
@@ -506,10 +667,10 @@ var init_schemaValidation = __esm({
         }
       }
       /**
-       * Validates data against a JSON Schema from a schema
+       * Validates data against a JSON Schema
        *
        * @param data - The data to validate
-       * @param schema - The schema containing the validation rules (DataSchema or Schema)
+       * @param schema - The schema containing the validation rules (must have been validated or fetched from chain)
        * @throws SchemaValidationError if invalid
        * @example
        * ```typescript
@@ -519,25 +680,22 @@ var init_schemaValidation = __esm({
        * const schema = await vana.schemas.get(1);
        * validator.validateDataAgainstSchema(userData, schema);
        *
-       * // Also works with DataSchema object
-       * const dataSchema: DataSchema = {
+       * // Also works with pre-validated DataSchema object
+       * const dataSchema = validator.validateDataSchemaAgainstMetaSchema({
        *   name: "User Profile",
        *   version: "1.0.0",
        *   dialect: "json",
        *   schema: { type: "object", properties: { name: { type: "string" } } }
-       * };
+       * });
        * validator.validateDataAgainstSchema(userData, dataSchema);
        * ```
        */
       validateDataAgainstSchema(data, schema) {
-        if (!("id" in schema)) {
-          this.validateDataSchema(schema);
-        }
         if (schema.dialect !== "json") {
-          throw new SchemaValidationError(
-            `Data validation only supported for JSON dialect, got: ${schema.dialect}`,
-            []
+          console.warn(
+            `[SchemaValidator] Data validation skipped: dialect '${schema.dialect}' does not support data validation. Only JSON schemas can validate data structure.`
           );
+          return;
         }
         if (typeof schema.schema !== "object") {
           throw new SchemaValidationError(
@@ -603,9 +761,11 @@ var init_schemaValidation = __esm({
         }
       }
       /**
-       * Fetches and validates a schema from a URL
+       * Fetches and validates a data schema from a URL
        *
-       * @param url - The URL to fetch the schema from
+       * @param url - The URL to fetch the data schema from
+       * @param downloadRelayer - Optional download relayer for CORS bypass
+       * @param downloadRelayer.proxyDownload - Function to proxy downloads through application server
        * @returns The validated data schema
        * @throws SchemaValidationError if invalid or fetch fails
        * @example
@@ -614,14 +774,15 @@ var init_schemaValidation = __esm({
        * const schema = await validator.fetchAndValidateSchema("https://example.com/schema.json");
        * ```
        */
-      async fetchAndValidateSchema(url) {
+      async fetchAndValidateSchema(url, downloadRelayer) {
         try {
-          const response = await fetch(url);
+          const { fetchWithRelayer: fetchWithRelayer2 } = await Promise.resolve().then(() => (init_download(), download_exports));
+          const response = await fetchWithRelayer2(url, downloadRelayer);
           if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
           }
           const schema = await response.json();
-          this.validateDataSchema(schema);
+          this.validateDataSchemaAgainstMetaSchema(schema);
           if (schema.dialect === "sqlite" && typeof schema.schema === "string") {
             this.validateSQLiteDDL(schema.schema, schema.dialectVersion);
           }
@@ -3039,6 +3200,19 @@ var init_DataRegistryImplementation = __esm({
         name: "Upgraded",
         type: "event"
       },
+      {
+        inputs: [],
+        name: "DATA_PORTABILITY_ROLE",
+        outputs: [
+          {
+            internalType: "bytes32",
+            name: "",
+            type: "bytes32"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
       {
         inputs: [],
         name: "DEFAULT_ADMIN_ROLE",
@@ -3136,14 +3310,9 @@ var init_DataRegistryImplementation = __esm({
       {
         inputs: [
           {
-            internalType: "string",
-            name: "url",
-            type: "string"
-          },
-          {
-            internalType: "address",
-            name: "ownerAddress",
-            type: "address"
+            internalType: "uint256",
+            name: "fileId",
+            type: "uint256"
           },
           {
             components: [
@@ -3161,16 +3330,15 @@ var init_DataRegistryImplementation = __esm({
             internalType: "struct IDataRegistry.Permission[]",
             name: "permissions",
             type: "tuple[]"
-          }
-        ],
-        name: "addFileWithPermissions",
-        outputs: [
+          },
           {
             internalType: "uint256",
-            name: "",
+            name: "schemaId",
             type: "uint256"
           }
         ],
+        name: "addFilePermissionsAndSchema",
+        outputs: [],
         stateMutability: "nonpayable",
         type: "function"
       },
@@ -3202,14 +3370,9 @@ var init_DataRegistryImplementation = __esm({
             internalType: "struct IDataRegistry.Permission[]",
             name: "permissions",
             type: "tuple[]"
-          },
-          {
-            internalType: "uint256",
-            name: "schemaId",
-            type: "uint256"
           }
         ],
-        name: "addFileWithPermissionsAndSchema",
+        name: "addFileWithPermissions",
         outputs: [
           {
             internalType: "uint256",
@@ -3228,136 +3391,42 @@ var init_DataRegistryImplementation = __esm({
             type: "string"
           },
           {
-            internalType: "uint256",
-            name: "schemaId",
-            type: "uint256"
-          }
-        ],
-        name: "addFileWithSchema",
-        outputs: [
-          {
-            internalType: "uint256",
-            name: "",
-            type: "uint256"
-          }
-        ],
-        stateMutability: "nonpayable",
-        type: "function"
-      },
-      {
-        inputs: [
-          {
-            internalType: "uint256",
-            name: "fileId",
-            type: "uint256"
+            internalType: "address",
+            name: "ownerAddress",
+            type: "address"
           },
           {
             components: [
               {
-                internalType: "bytes",
-                name: "signature",
-                type: "bytes"
+                internalType: "address",
+                name: "account",
+                type: "address"
               },
               {
-                components: [
-                  {
-                    internalType: "uint256",
-                    name: "score",
-                    type: "uint256"
-                  },
-                  {
-                    internalType: "uint256",
-                    name: "dlpId",
-                    type: "uint256"
-                  },
-                  {
-                    internalType: "string",
-                    name: "metadata",
-                    type: "string"
-                  },
-                  {
-                    internalType: "string",
-                    name: "proofUrl",
-                    type: "string"
-                  },
-                  {
-                    internalType: "string",
-                    name: "instruction",
-                    type: "string"
-                  }
-                ],
-                internalType: "struct IDataRegistry.ProofData",
-                name: "data",
-                type: "tuple"
+                internalType: "string",
+                name: "key",
+                type: "string"
               }
             ],
-            internalType: "struct IDataRegistry.Proof",
-            name: "proof",
-            type: "tuple"
-          }
-        ],
-        name: "addProof",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function"
-      },
-      {
-        inputs: [
-          {
-            internalType: "uint256",
-            name: "fileId",
-            type: "uint256"
+            internalType: "struct IDataRegistry.Permission[]",
+            name: "permissions",
+            type: "tuple[]"
           },
           {
             internalType: "uint256",
-            name: "refinerId",
+            name: "schemaId",
             type: "uint256"
-          },
-          {
-            internalType: "string",
-            name: "url",
-            type: "string"
-          },
-          {
-            internalType: "address",
-            name: "account",
-            type: "address"
-          },
-          {
-            internalType: "string",
-            name: "key",
-            type: "string"
           }
         ],
-        name: "addRefinementWithPermission",
-        outputs: [],
-        stateMutability: "nonpayable",
-        type: "function"
-      },
-      {
-        inputs: [],
-        name: "dataRefinerRegistry",
-        outputs: [
-          {
-            internalType: "contract IDataRefinerRegistry",
-            name: "",
-            type: "address"
-          }
-        ],
-        stateMutability: "view",
-        type: "function"
-      },
-      {
-        inputs: [],
-        name: "emitLegacyEvents",
+        name: "addFileWithPermissionsAndSchema",
         outputs: [
           {
-            internalType: "bool",
+            internalType: "uint256",
             name: "",
-            type: "bool"
+            type: "uint256"
           }
         ],
-        stateMutability: "view",
+        stateMutability: "nonpayable",
         type: "function"
       },
       {
@@ -3366,41 +3435,22 @@ var init_DataRegistryImplementation = __esm({
             internalType: "string",
             name: "url",
             type: "string"
-          }
-        ],
-        name: "fileIdByUrl",
-        outputs: [
+          },
           {
             internalType: "uint256",
-            name: "",
+            name: "schemaId",
             type: "uint256"
           }
         ],
-        stateMutability: "view",
-        type: "function"
-      },
-      {
-        inputs: [
-          {
-            internalType: "uint256",
-            name: "fileId",
-            type: "uint256"
-          },
-          {
-            internalType: "address",
-            name: "account",
-            type: "address"
-          }
-        ],
-        name: "filePermissions",
+        name: "addFileWithSchema",
         outputs: [
           {
-            internalType: "string",
+            internalType: "uint256",
             name: "",
-            type: "string"
+            type: "uint256"
           }
         ],
-        stateMutability: "view",
+        stateMutability: "nonpayable",
         type: "function"
       },
       {
@@ -3410,14 +3460,173 @@ var init_DataRegistryImplementation = __esm({
             name: "fileId",
             type: "uint256"
           },
-          {
-            internalType: "uint256",
-            name: "index",
-            type: "uint256"
-          }
-        ],
-        name: "fileProofs",
-        outputs: [
+          {
+            components: [
+              {
+                internalType: "bytes",
+                name: "signature",
+                type: "bytes"
+              },
+              {
+                components: [
+                  {
+                    internalType: "uint256",
+                    name: "score",
+                    type: "uint256"
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "dlpId",
+                    type: "uint256"
+                  },
+                  {
+                    internalType: "string",
+                    name: "metadata",
+                    type: "string"
+                  },
+                  {
+                    internalType: "string",
+                    name: "proofUrl",
+                    type: "string"
+                  },
+                  {
+                    internalType: "string",
+                    name: "instruction",
+                    type: "string"
+                  }
+                ],
+                internalType: "struct IDataRegistry.ProofData",
+                name: "data",
+                type: "tuple"
+              }
+            ],
+            internalType: "struct IDataRegistry.Proof",
+            name: "proof",
+            type: "tuple"
+          }
+        ],
+        name: "addProof",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [
+          {
+            internalType: "uint256",
+            name: "fileId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "refinerId",
+            type: "uint256"
+          },
+          {
+            internalType: "string",
+            name: "url",
+            type: "string"
+          },
+          {
+            internalType: "address",
+            name: "account",
+            type: "address"
+          },
+          {
+            internalType: "string",
+            name: "key",
+            type: "string"
+          }
+        ],
+        name: "addRefinementWithPermission",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "dataRefinerRegistry",
+        outputs: [
+          {
+            internalType: "contract IDataRefinerRegistry",
+            name: "",
+            type: "address"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "emitLegacyEvents",
+        outputs: [
+          {
+            internalType: "bool",
+            name: "",
+            type: "bool"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          {
+            internalType: "string",
+            name: "url",
+            type: "string"
+          }
+        ],
+        name: "fileIdByUrl",
+        outputs: [
+          {
+            internalType: "uint256",
+            name: "",
+            type: "uint256"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          {
+            internalType: "uint256",
+            name: "fileId",
+            type: "uint256"
+          },
+          {
+            internalType: "address",
+            name: "account",
+            type: "address"
+          }
+        ],
+        name: "filePermissions",
+        outputs: [
+          {
+            internalType: "string",
+            name: "",
+            type: "string"
+          }
+        ],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          {
+            internalType: "uint256",
+            name: "fileId",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "index",
+            type: "uint256"
+          }
+        ],
+        name: "fileProofs",
+        outputs: [
           {
             components: [
               {
@@ -36110,110 +36319,644 @@ var init_transactionHandle = __esm({
   }
 });
 
-// src/utils/ipfs.ts
-var ipfs_exports = {};
-__export(ipfs_exports, {
-  DEFAULT_IPFS_GATEWAY: () => DEFAULT_IPFS_GATEWAY,
-  IPFS_GATEWAYS: () => IPFS_GATEWAYS,
-  convertIpfsUrl: () => convertIpfsUrl,
-  convertIpfsUrlWithFallbacks: () => convertIpfsUrlWithFallbacks,
-  extractIpfsHash: () => extractIpfsHash,
-  fetchWithFallbacks: () => fetchWithFallbacks,
-  getGatewayUrls: () => getGatewayUrls,
-  isIpfsUrl: () => isIpfsUrl
-});
-function isIpfsUrl(url) {
-  return url.startsWith("ipfs://");
-}
-function convertIpfsUrl(url, gateway = DEFAULT_IPFS_GATEWAY) {
-  if (isIpfsUrl(url)) {
-    const hash = url.replace("ipfs://", "");
-    return `${gateway}${hash}`;
-  }
-  return url;
-}
-function extractIpfsHash(url) {
-  const patterns = [
-    /ipfs\/([a-zA-Z0-9]+)/,
-    // https://gateway.pinata.cloud/ipfs/HASH
-    /^ipfs:\/\/([a-zA-Z0-9]+)$/,
-    // ipfs://HASH
-    /^([a-zA-Z0-9]{46,})$/
-    // Just the hash (46+ chars for IPFS hashes)
-  ];
-  for (const pattern of patterns) {
-    const match = url.match(pattern);
-    if (match) {
-      return match[1];
-    }
-  }
-  return null;
-}
-function getGatewayUrls(hash) {
-  return IPFS_GATEWAYS.map((gateway) => `${gateway}${hash}`);
-}
-function convertIpfsUrlWithFallbacks(url) {
-  const hash = extractIpfsHash(url);
-  if (hash) {
-    return getGatewayUrls(hash);
-  }
-  return [url];
-}
-async function fetchWithFallbacks(url, options) {
-  const hash = extractIpfsHash(url);
-  if (!hash) {
-    return fetch(url, options);
-  }
-  const gatewayUrls = getGatewayUrls(hash);
-  let lastError = null;
-  for (let i = 0; i < gatewayUrls.length; i++) {
-    const gatewayUrl = gatewayUrls[i];
-    try {
-      const response = await fetch(gatewayUrl, {
-        ...options,
-        // Add timeout to avoid hanging on slow gateways
-        signal: AbortSignal.timeout(1e4)
-        // 10 second timeout
-      });
-      if (response.ok) {
-        return response;
-      }
-      if (response.status === 429) {
-        lastError = new Error(`Gateway rate limited: ${gatewayUrl}`);
-        continue;
-      }
-      lastError = new Error(`Gateway error ${response.status}: ${gatewayUrl}`);
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (lastError.message.includes("429") || lastError.name === "TimeoutError") {
-        continue;
-      }
-    }
-    if (i < gatewayUrls.length - 1) {
-      await new Promise((resolve) => setTimeout(resolve, 1e3 * (i + 1)));
-    }
-  }
-  throw new Error(
-    `All IPFS gateways failed for hash ${hash}. Last error: ${lastError?.message}`
-  );
-}
-var DEFAULT_IPFS_GATEWAY, IPFS_GATEWAYS;
-var init_ipfs = __esm({
-  "src/utils/ipfs.ts"() {
+// src/generated/subgraph.ts
+var GetUserPermissionsDocument, GetUserTrustedServersDocument, GetUserFilesDocument, GetFileProofsDocument, GetDlpDocument, GetSchemaDocument, ListSchemasDocument, CountSchemasDocument;
+var init_subgraph = __esm({
+  "src/generated/subgraph.ts"() {
     "use strict";
-    DEFAULT_IPFS_GATEWAY = "https://dweb.link/ipfs/";
-    IPFS_GATEWAYS = [
-      "https://dweb.link/ipfs/",
-      // Interplanetary Shipyard - highly reliable
-      "https://ipfs.io/ipfs/",
-      // IPFS Foundation - reliable
-      "https://cloudflare-ipfs.com/ipfs/",
-      // Cloudflare - good performance
-      "https://gateway.pinata.cloud/ipfs/",
-      // Pinata - backup option (has rate limits)
-      "https://ipfs.filebase.io/ipfs/"
-      // Filebase - emerging reliable option
-    ];
+    GetUserPermissionsDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetUserPermissions" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "userId" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "user" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "userId" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "permissions" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } },
+                          { kind: "Field", name: { kind: "Name", value: "grant" } },
+                          { kind: "Field", name: { kind: "Name", value: "nonce" } },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "signature" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "startBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "endBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtTimestamp" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "transactionHash" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "grantee" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "id" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "address" }
+                                }
+                              ]
+                            }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "filePermissions" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "file" },
+                                  selectionSet: {
+                                    kind: "SelectionSet",
+                                    selections: [
+                                      {
+                                        kind: "Field",
+                                        name: { kind: "Name", value: "id" }
+                                      },
+                                      {
+                                        kind: "Field",
+                                        name: { kind: "Name", value: "url" }
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetUserTrustedServersDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetUserTrustedServers" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "userId" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "user" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "userId" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "serverTrusts" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "server" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "id" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "serverAddress" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "url" }
+                                },
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "publicKey" }
+                                }
+                              ]
+                            }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "trustedAt" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "trustedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "untrustedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "transactionHash" }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetUserFilesDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetUserFiles" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "userId" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "user" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "userId" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "files" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } },
+                          { kind: "Field", name: { kind: "Name", value: "url" } },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "schemaId" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtBlock" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "addedAtTimestamp" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "transactionHash" }
+                          },
+                          {
+                            kind: "Field",
+                            name: { kind: "Name", value: "owner" },
+                            selectionSet: {
+                              kind: "SelectionSet",
+                              selections: [
+                                {
+                                  kind: "Field",
+                                  name: { kind: "Name", value: "id" }
+                                }
+                              ]
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetFileProofsDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetFileProofs" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "fileIds" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: {
+                  kind: "ListType",
+                  type: {
+                    kind: "NonNullType",
+                    type: {
+                      kind: "NamedType",
+                      name: { kind: "Name", value: "BigInt" }
+                    }
+                  }
+                }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "dataRegistryProofs" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "where" },
+                    value: {
+                      kind: "ObjectValue",
+                      fields: [
+                        {
+                          kind: "ObjectField",
+                          name: { kind: "Name", value: "fileId_in" },
+                          value: {
+                            kind: "Variable",
+                            name: { kind: "Name", value: "fileIds" }
+                          }
+                        }
+                      ]
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "fileId" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "dlp" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetDlpDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetDLP" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "dlp" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "id" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    { kind: "Field", name: { kind: "Name", value: "name" } },
+                    { kind: "Field", name: { kind: "Name", value: "metadata" } },
+                    { kind: "Field", name: { kind: "Name", value: "status" } },
+                    { kind: "Field", name: { kind: "Name", value: "address" } },
+                    { kind: "Field", name: { kind: "Name", value: "owner" } }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    GetSchemaDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "GetSchema" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "schema" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "id" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "id" }
+                    }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    { kind: "Field", name: { kind: "Name", value: "name" } },
+                    { kind: "Field", name: { kind: "Name", value: "dialect" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "definitionUrl" }
+                    },
+                    { kind: "Field", name: { kind: "Name", value: "createdAt" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "createdAtBlock" }
+                    },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "createdTxHash" }
+                    },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "refiners" },
+                      selectionSet: {
+                        kind: "SelectionSet",
+                        selections: [
+                          { kind: "Field", name: { kind: "Name", value: "id" } },
+                          { kind: "Field", name: { kind: "Name", value: "name" } },
+                          { kind: "Field", name: { kind: "Name", value: "owner" } }
+                        ]
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    ListSchemasDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "ListSchemas" },
+          variableDefinitions: [
+            {
+              kind: "VariableDefinition",
+              variable: {
+                kind: "Variable",
+                name: { kind: "Name", value: "first" }
+              },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
+              }
+            },
+            {
+              kind: "VariableDefinition",
+              variable: { kind: "Variable", name: { kind: "Name", value: "skip" } },
+              type: {
+                kind: "NonNullType",
+                type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
+              }
+            }
+          ],
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "schemas" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "first" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "first" }
+                    }
+                  },
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "skip" },
+                    value: {
+                      kind: "Variable",
+                      name: { kind: "Name", value: "skip" }
+                    }
+                  },
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "orderBy" },
+                    value: { kind: "EnumValue", value: "createdAt" }
+                  },
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "orderDirection" },
+                    value: { kind: "EnumValue", value: "desc" }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } },
+                    { kind: "Field", name: { kind: "Name", value: "name" } },
+                    { kind: "Field", name: { kind: "Name", value: "dialect" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "definitionUrl" }
+                    },
+                    { kind: "Field", name: { kind: "Name", value: "createdAt" } },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "createdAtBlock" }
+                    },
+                    {
+                      kind: "Field",
+                      name: { kind: "Name", value: "createdTxHash" }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
+    CountSchemasDocument = {
+      kind: "Document",
+      definitions: [
+        {
+          kind: "OperationDefinition",
+          operation: "query",
+          name: { kind: "Name", value: "CountSchemas" },
+          selectionSet: {
+            kind: "SelectionSet",
+            selections: [
+              {
+                kind: "Field",
+                name: { kind: "Name", value: "schemas" },
+                arguments: [
+                  {
+                    kind: "Argument",
+                    name: { kind: "Name", value: "first" },
+                    value: { kind: "IntValue", value: "1000" }
+                  }
+                ],
+                selectionSet: {
+                  kind: "SelectionSet",
+                  selections: [
+                    { kind: "Field", name: { kind: "Name", value: "id" } }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      ]
+    };
   }
 });
 
@@ -36275,212 +37018,10 @@ var init_registry = __esm({
   }
 });
 
-// src/generated/subgraph.ts
-var GetSchemaDocument, ListSchemasDocument, CountSchemasDocument;
-var init_subgraph = __esm({
-  "src/generated/subgraph.ts"() {
-    "use strict";
-    GetSchemaDocument = {
-      kind: "Document",
-      definitions: [
-        {
-          kind: "OperationDefinition",
-          operation: "query",
-          name: { kind: "Name", value: "GetSchema" },
-          variableDefinitions: [
-            {
-              kind: "VariableDefinition",
-              variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
-              type: {
-                kind: "NonNullType",
-                type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
-              }
-            }
-          ],
-          selectionSet: {
-            kind: "SelectionSet",
-            selections: [
-              {
-                kind: "Field",
-                name: { kind: "Name", value: "schema" },
-                arguments: [
-                  {
-                    kind: "Argument",
-                    name: { kind: "Name", value: "id" },
-                    value: {
-                      kind: "Variable",
-                      name: { kind: "Name", value: "id" }
-                    }
-                  }
-                ],
-                selectionSet: {
-                  kind: "SelectionSet",
-                  selections: [
-                    { kind: "Field", name: { kind: "Name", value: "id" } },
-                    { kind: "Field", name: { kind: "Name", value: "name" } },
-                    { kind: "Field", name: { kind: "Name", value: "dialect" } },
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: "definitionUrl" }
-                    },
-                    { kind: "Field", name: { kind: "Name", value: "createdAt" } },
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: "createdAtBlock" }
-                    },
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: "createdTxHash" }
-                    },
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: "refiners" },
-                      selectionSet: {
-                        kind: "SelectionSet",
-                        selections: [
-                          { kind: "Field", name: { kind: "Name", value: "id" } },
-                          { kind: "Field", name: { kind: "Name", value: "name" } },
-                          { kind: "Field", name: { kind: "Name", value: "owner" } }
-                        ]
-                      }
-                    }
-                  ]
-                }
-              }
-            ]
-          }
-        }
-      ]
-    };
-    ListSchemasDocument = {
-      kind: "Document",
-      definitions: [
-        {
-          kind: "OperationDefinition",
-          operation: "query",
-          name: { kind: "Name", value: "ListSchemas" },
-          variableDefinitions: [
-            {
-              kind: "VariableDefinition",
-              variable: {
-                kind: "Variable",
-                name: { kind: "Name", value: "first" }
-              },
-              type: {
-                kind: "NonNullType",
-                type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
-              }
-            },
-            {
-              kind: "VariableDefinition",
-              variable: { kind: "Variable", name: { kind: "Name", value: "skip" } },
-              type: {
-                kind: "NonNullType",
-                type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
-              }
-            }
-          ],
-          selectionSet: {
-            kind: "SelectionSet",
-            selections: [
-              {
-                kind: "Field",
-                name: { kind: "Name", value: "schemas" },
-                arguments: [
-                  {
-                    kind: "Argument",
-                    name: { kind: "Name", value: "first" },
-                    value: {
-                      kind: "Variable",
-                      name: { kind: "Name", value: "first" }
-                    }
-                  },
-                  {
-                    kind: "Argument",
-                    name: { kind: "Name", value: "skip" },
-                    value: {
-                      kind: "Variable",
-                      name: { kind: "Name", value: "skip" }
-                    }
-                  },
-                  {
-                    kind: "Argument",
-                    name: { kind: "Name", value: "orderBy" },
-                    value: { kind: "EnumValue", value: "createdAt" }
-                  },
-                  {
-                    kind: "Argument",
-                    name: { kind: "Name", value: "orderDirection" },
-                    value: { kind: "EnumValue", value: "desc" }
-                  }
-                ],
-                selectionSet: {
-                  kind: "SelectionSet",
-                  selections: [
-                    { kind: "Field", name: { kind: "Name", value: "id" } },
-                    { kind: "Field", name: { kind: "Name", value: "name" } },
-                    { kind: "Field", name: { kind: "Name", value: "dialect" } },
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: "definitionUrl" }
-                    },
-                    { kind: "Field", name: { kind: "Name", value: "createdAt" } },
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: "createdAtBlock" }
-                    },
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: "createdTxHash" }
-                    }
-                  ]
-                }
-              }
-            ]
-          }
-        }
-      ]
-    };
-    CountSchemasDocument = {
-      kind: "Document",
-      definitions: [
-        {
-          kind: "OperationDefinition",
-          operation: "query",
-          name: { kind: "Name", value: "CountSchemas" },
-          selectionSet: {
-            kind: "SelectionSet",
-            selections: [
-              {
-                kind: "Field",
-                name: { kind: "Name", value: "schemas" },
-                arguments: [
-                  {
-                    kind: "Argument",
-                    name: { kind: "Name", value: "first" },
-                    value: { kind: "IntValue", value: "1000" }
-                  }
-                ],
-                selectionSet: {
-                  kind: "SelectionSet",
-                  selections: [
-                    { kind: "Field", name: { kind: "Name", value: "id" } }
-                  ]
-                }
-              }
-            ]
-          }
-        }
-      ]
-    };
-  }
-});
-
 // src/utils/urlResolver.ts
-async function fetchFromUrl(url) {
+async function fetchFromUrl(url, downloadRelayer) {
   try {
-    const httpUrl = resolveToHttp(url);
-    const response = await fetchWithRetry(httpUrl, url);
+    const response = await fetchWithRelayer(url, downloadRelayer);
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
@@ -36494,43 +37035,11 @@ async function fetchFromUrl(url) {
     );
   }
 }
-function resolveToHttp(url) {
-  if (url.startsWith("ipfs://")) {
-    return convertIpfsUrl(url);
-  }
-  if (url.startsWith("ar://")) {
-    const txId = url.replace("ar://", "");
-    return `https://arweave.net/${txId}`;
-  }
-  if (url.startsWith("https://") || url.startsWith("http://")) {
-    return url;
-  }
-  throw new Error(`Unsupported protocol in URL: ${url}`);
-}
-async function fetchWithRetry(httpUrl, originalUrl) {
-  try {
-    const response = await fetch(httpUrl);
-    if (response.ok) return response;
-  } catch {
-  }
-  if (originalUrl.startsWith("ipfs://")) {
-    for (const gateway of IPFS_GATEWAYS) {
-      try {
-        const alternativeUrl = convertIpfsUrl(originalUrl, gateway);
-        if (alternativeUrl === httpUrl) continue;
-        const response = await fetch(alternativeUrl);
-        if (response.ok) return response;
-      } catch {
-      }
-    }
-  }
-  return fetch(httpUrl);
-}
 var UrlResolutionError;
 var init_urlResolver = __esm({
   "src/utils/urlResolver.ts"() {
     "use strict";
-    init_ipfs();
+    init_download();
     UrlResolutionError = class extends Error {
       constructor(message, url, cause) {
         super(message);
@@ -36623,7 +37132,7 @@ var init_schemas = __esm({
             dialect,
             schema: schemaDefinition
           };
-          validateDataSchema(dataSchema);
+          validateDataSchemaAgainstMetaSchema(dataSchema);
           if (!this.context.storageManager) {
             if (this.context.validateStorageRequired) {
               this.context.validateStorageRequired();
@@ -36726,13 +37235,16 @@ var init_schemas = __esm({
             );
           }
         }
-        const definition = await fetchFromUrl(metadata.definitionUrl);
+        const definition = await fetchFromUrl(
+          metadata.definitionUrl,
+          this.context.downloadRelayer
+        );
         if (!definition || typeof definition !== "object") {
           throw new Error(
             `Invalid schema definition format for schema ${schemaId}`
           );
         }
-        validateDataSchema(definition);
+        validateDataSchemaAgainstMetaSchema(definition);
         const dataSchema = definition;
         if (dataSchema.name !== metadata.name) {
           throw new Error(
@@ -37065,9 +37577,12 @@ var init_schemas = __esm({
           schemas.map(async (schema) => {
             if (!schema.definitionUrl) return;
             try {
-              const definition = await fetchFromUrl(schema.definitionUrl);
+              const definition = await fetchFromUrl(
+                schema.definitionUrl,
+                this.context.downloadRelayer
+              );
               if (definition && typeof definition === "object") {
-                validateDataSchema(definition);
+                validateDataSchemaAgainstMetaSchema(definition);
                 const dataSchema = definition;
                 schema.version = dataSchema.version;
                 schema.description = dataSchema.description;
@@ -37159,6 +37674,7 @@ init_transactionHandle();
 init_errors();
 init_addresses();
 init_abi();
+import { getAddress as getAddress3 } from "viem";
 
 // src/utils/grantFiles.ts
 init_errors();
@@ -37207,63 +37723,26 @@ async function storeGrantFile(grantFile, relayerUrl) {
     );
   }
 }
-async function retrieveGrantFile(grantUrl, _relayerUrl) {
+async function retrieveGrantFile(grantUrl, _relayerUrl, downloadRelayer) {
   try {
     if (grantUrl.startsWith("http") && grantUrl.includes("/ipfs/")) {
       console.warn(
         `\u26A0\uFE0F  Grant URL uses HTTP gateway format instead of ipfs:// protocol. Found: ${grantUrl}. Consider using ipfs:// format for better protocol-agnostic storage.`
       );
     }
-    if (grantUrl.startsWith("http")) {
-      try {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error("Request timeout")), 1e4);
-        });
-        const response = await Promise.race([fetch(grantUrl), timeoutPromise]);
-        if (response.ok) {
-          const text = await response.text();
-          const grantFile = JSON.parse(text);
-          if (validateGrantFile(grantFile)) {
-            return grantFile;
-          }
-        }
-      } catch (directFetchError) {
-        console.warn(`Direct fetch failed for ${grantUrl}:`, directFetchError);
-      }
+    const { fetchWithRelayer: fetchWithRelayer2 } = await Promise.resolve().then(() => (init_download(), download_exports));
+    const response = await fetchWithRelayer2(grantUrl, downloadRelayer);
+    if (!response.ok) {
+      throw new NetworkError(
+        `Failed to retrieve grant file: HTTP ${response.status}`
+      );
     }
-    const { extractIpfsHash: extractIpfsHash2 } = await Promise.resolve().then(() => (init_ipfs(), ipfs_exports));
-    const ipfsHash = extractIpfsHash2(grantUrl);
-    if (ipfsHash) {
-      const gateways = [
-        `https://gateway.pinata.cloud/ipfs/${ipfsHash}`,
-        `https://ipfs.io/ipfs/${ipfsHash}`,
-        `https://dweb.link/ipfs/${ipfsHash}`
-      ];
-      for (const gatewayUrl of gateways) {
-        try {
-          const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => reject(new Error("Request timeout")), 1e4);
-          });
-          const response = await Promise.race([
-            fetch(gatewayUrl),
-            timeoutPromise
-          ]);
-          if (response.ok) {
-            const text = await response.text();
-            const grantFile = JSON.parse(text);
-            if (validateGrantFile(grantFile)) {
-              return grantFile;
-            }
-          }
-        } catch (gatewayError) {
-          console.warn(`Gateway ${gatewayUrl} failed:`, gatewayError);
-          continue;
-        }
-      }
+    const text = await response.text();
+    const grantFile = JSON.parse(text);
+    if (!validateGrantFile(grantFile)) {
+      throw new NetworkError(`Invalid grant file format from ${grantUrl}`);
     }
-    throw new NetworkError(
-      `Failed to retrieve grant file from ${grantUrl}. Tried direct fetch${ipfsHash ? " and IPFS gateways" : ""}.`
-    );
+    return grantFile;
   } catch (error) {
     if (error instanceof NetworkError) {
       throw error;
@@ -37329,6 +37808,7 @@ function validateGrantFile(data) {
 }
 
 // src/utils/grantValidation.ts
+import { getAddress } from "viem";
 import Ajv2 from "ajv";
 import addFormats2 from "ajv-formats";
 
@@ -37532,7 +38012,9 @@ function extractFieldFromBusinessError(error) {
   return void 0;
 }
 function validateGranteeAccess(grantFile, requestingAddress) {
-  if (grantFile.grantee.toLowerCase() !== requestingAddress.toLowerCase()) {
+  const normalizedGrantee = getAddress(grantFile.grantee);
+  const normalizedRequesting = getAddress(requestingAddress);
+  if (normalizedGrantee !== normalizedRequesting) {
     throw new GranteeMismatchError(
       "Permission denied: requesting address does not match grantee",
       grantFile.grantee,
@@ -37564,6 +38046,7 @@ function validateOperationAccess(grantFile, requestedOperation) {
 
 // src/utils/signatureCache.ts
 init_crypto_utils();
+import { getAddress as getAddress2 } from "viem";
 var SignatureCache = class {
   /**
    * Get a cached signature if it exists and hasn't expired
@@ -37654,7 +38137,7 @@ var SignatureCache = class {
     }
   }
   static getCacheKey(walletAddress, messageHash) {
-    return `${this.PREFIX}${walletAddress.toLowerCase()}:${messageHash}`;
+    return `${this.PREFIX}${getAddress2(walletAddress)}:${messageHash}`;
   }
   /**
    * Generate a deterministic hash of a message object for cache key generation
@@ -38929,20 +39412,22 @@ var PermissionsController = class {
       if (!userData || !userData.permissions?.length) {
         return [];
       }
-      const onChainGrants = userData.permissions.slice(0, limit).map((permission) => ({
-        id: BigInt(permission.id),
-        grantUrl: permission.grant,
-        grantSignature: permission.signature,
-        grantHash: "",
-        // Not available in new schema, compute if needed
-        nonce: BigInt(permission.nonce),
-        addedAtBlock: BigInt(permission.addedAtBlock),
-        addedAtTimestamp: BigInt(permission.addedAtTimestamp || "0"),
-        transactionHash: permission.transactionHash || "",
-        grantor: userAddress,
-        active: !permission.endBlock || BigInt(permission.endBlock) === 0n
-        // Active if no end block or end block is 0
-      }));
+      const onChainGrants = userData.permissions.slice(0, limit).map(
+        (permission) => ({
+          id: BigInt(permission.id),
+          grantUrl: permission.grant,
+          grantSignature: permission.signature,
+          nonce: BigInt(permission.nonce),
+          startBlock: BigInt(permission.startBlock),
+          addedAtBlock: BigInt(permission.addedAtBlock),
+          addedAtTimestamp: BigInt(permission.addedAtTimestamp || "0"),
+          transactionHash: permission.transactionHash || "",
+          grantor: userAddress,
+          grantee: permission.grantee,
+          active: !permission.endBlock || BigInt(permission.endBlock) === 0n
+          // Active if no end block or end block is 0
+        })
+      );
       return onChainGrants.sort((a, b) => {
         if (a.id < b.id) return 1;
         if (a.id > b.id) return -1;
@@ -39020,14 +39505,16 @@ var PermissionsController = class {
       );
       const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
       const userAddress = this.context.walletClient.account?.address || await this.getUserAddress();
+      const normalizedUserAddress = getAddress3(userAddress);
+      const normalizedServerAddress = getAddress3(params.serverAddress);
       const txHash = await this.context.walletClient.writeContract({
         address: DataPortabilityServersAddress,
         abi: DataPortabilityServersAbi,
         functionName: "addAndTrustServerByManager",
         args: [
-          userAddress,
+          normalizedUserAddress,
           {
-            serverAddress: params.serverAddress,
+            serverAddress: normalizedServerAddress,
             serverUrl: params.serverUrl,
             publicKey: params.publicKey
           }
@@ -39097,9 +39584,10 @@ var PermissionsController = class {
   async submitAddAndTrustServerWithSignature(params) {
     try {
       const nonce = await this.getServersUserNonce();
+      const serverAddress = getAddress3(params.serverAddress);
       const addAndTrustServerInput = {
         nonce,
-        serverAddress: params.serverAddress,
+        serverAddress,
         publicKey: params.publicKey,
         serverUrl: params.serverUrl
       };
@@ -39904,11 +40392,13 @@ var PermissionsController = class {
       "DataPortabilityGrantees"
     );
     const DataPortabilityGranteesAbi = getAbi("DataPortabilityGrantees");
+    const ownerAddress = getAddress3(params.owner);
+    const granteeAddress = getAddress3(params.granteeAddress);
     const txHash = await this.context.walletClient.writeContract({
       address: DataPortabilityGranteesAddress,
       abi: DataPortabilityGranteesAbi,
       functionName: "registerGrantee",
-      args: [params.owner, params.granteeAddress, params.publicKey],
+      args: [ownerAddress, granteeAddress, params.publicKey],
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
     });
@@ -39935,10 +40425,12 @@ var PermissionsController = class {
    */
   async submitRegisterGranteeWithSignature(params) {
     const nonce = await this.getServersUserNonce();
+    const owner = getAddress3(params.owner);
+    const granteeAddress = getAddress3(params.granteeAddress);
     const registerGranteeInput = {
       nonce,
-      owner: params.owner,
-      granteeAddress: params.granteeAddress,
+      owner,
+      granteeAddress,
       publicKey: params.publicKey
     };
     const typedData = await this.buildRegisterGranteeTypedData(registerGranteeInput);
@@ -41449,7 +41941,9 @@ var PermissionsController = class {
 init_transactionHandle();
 init_addresses();
 init_abi();
+init_subgraph();
 import { getContract as getContract2 } from "viem";
+import { print as print2 } from "graphql";
 
 // src/utils/encryption.ts
 var DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
@@ -41873,34 +42367,16 @@ var DataController = class {
       );
     }
     try {
-      const query = `
-        query GetUserFiles($userId: ID!) {
-          user(id: $userId) {
-            id
-            files {
-              id
-              url
-              schemaId
-              addedAtBlock
-              addedAtTimestamp
-              transactionHash
-              owner {
-                id
-              }
-            }
-          }
-        }
-      `;
       const response = await fetch(endpoint, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          query,
+          query: print2(GetUserFilesDocument),
           variables: {
             userId: owner.toLowerCase()
-            // Subgraph stores addresses in lowercase
+            // Subgraph requires lowercase addresses
           }
         })
       });
@@ -41947,7 +42423,10 @@ var DataController = class {
           try {
             proofMap = await this._fetchProofsFromSubgraph(fileIds, endpoint);
           } catch (subgraphError) {
-            console.debug("Failed to fetch proofs from subgraph, trying chain:", subgraphError);
+            console.debug(
+              "Failed to fetch proofs from subgraph, trying chain:",
+              subgraphError
+            );
             proofMap = await this._fetchProofsFromChain(fileIds);
           }
           for (const file of userFiles) {
@@ -41970,30 +42449,20 @@ var DataController = class {
   }
   /**
    * 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 query = `
-      query GetFileProofs($fileIds: [BigInt!]!) {
-        dataRegistryProofs(where: { fileId_in: $fileIds }) {
-          fileId
-          dlp {
-            id
-          }
-        }
-      }
-    `;
     const response = await fetch(subgraphUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
-        query,
+        query: print2(GetFileProofsDocument),
         variables: {
           fileIds: fileIds.map((id) => id.toString())
         }
@@ -42031,7 +42500,7 @@ var DataController = class {
   /**
    * 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
@@ -42097,25 +42566,13 @@ var DataController = class {
     const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
     if (subgraphUrl) {
       try {
-        const query = `
-          query GetDLP($id: ID!) {
-            dlp(id: $id) {
-              id
-              name
-              metadata
-              status
-              address
-              owner
-            }
-          }
-        `;
         const response = await fetch(subgraphUrl, {
           method: "POST",
           headers: {
             "Content-Type": "application/json"
           },
           body: JSON.stringify({
-            query,
+            query: print2(GetDlpDocument),
             variables: {
               id: dlpId.toString()
             }
@@ -42138,7 +42595,7 @@ var DataController = class {
         return {
           id: parseInt(result.data.dlp.id),
           name: result.data.dlp.name || "",
-          metadata: result.data.dlp.metadata,
+          metadata: result.data.dlp.metadata || void 0,
           status: result.data.dlp.status ? parseInt(result.data.dlp.status) : void 0,
           address: result.data.dlp.address,
           owner: result.data.dlp.owner
@@ -42195,7 +42652,7 @@ var DataController = class {
    * // 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 });
    * ```
@@ -42352,32 +42809,13 @@ var DataController = class {
   async _getUserPermissionsViaSubgraph(params) {
     const { user, subgraphUrl } = params;
     try {
-      const query = `
-        query GetUserPermissions($userId: ID!) {
-          user(id: $userId) {
-            id
-            permissions {
-              id
-              grant
-              nonce
-              signature
-              addedAtBlock
-              addedAtTimestamp
-              transactionHash
-              user {
-                id
-              }
-            }
-          }
-        }
-      `;
       const response = await fetch(subgraphUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          query,
+          query: print2(GetUserPermissionsDocument),
           variables: {
             userId: user.toLowerCase()
           }
@@ -42406,7 +42844,7 @@ var DataController = class {
         addedAtBlock: BigInt(permission.addedAtBlock),
         addedAtTimestamp: BigInt(permission.addedAtTimestamp),
         transactionHash: permission.transactionHash,
-        user: permission.user.id
+        user
       })).sort((a, b) => Number(b.addedAtTimestamp - a.addedAtTimestamp));
     } catch (error) {
       console.error("Failed to query user permissions from subgraph:", error);
@@ -42578,36 +43016,16 @@ var DataController = class {
       );
     }
     try {
-      const query = `
-        query GetUserTrustedServers($userId: ID!) {
-          user(id: $userId) {
-            id
-            serverTrusts {
-              id
-              server {
-                id
-                serverAddress
-                url
-                publicKey
-              }
-              trustedAt
-              trustedAtBlock
-              untrustedAtBlock
-              transactionHash
-            }
-          }
-        }
-      `;
       const response = await fetch(graphqlEndpoint, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
-          query,
+          query: print2(GetUserTrustedServersDocument),
           variables: {
             userId: user.toLowerCase()
-            // Subgraph stores addresses in lowercase
+            // Subgraph requires lowercase addresses
           }
         })
       });
@@ -43441,19 +43859,31 @@ var DataController = class {
     return await this.submitFilePermission(fileId, account, publicKey);
   }
   /**
-   * Submits a file permission transaction and returns the transaction hash immediately.
+   * Submits a file permission transaction to the blockchain.
    *
-   * This is the lower-level method that provides maximum control over transaction timing.
+   * @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 add permissions for
-   * @param account - The address of the account to grant permission to
-   * @param publicKey - The public key to encrypt the user's encryption key with
-   * @returns Promise resolving to the transaction hash
+   * @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).public_key`
+   * @returns Promise resolving to TransactionHandle 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 txHash = await vana.data.submitFilePermission(fileId, account, publicKey);
-   * console.log(`Transaction submitted: ${txHash}`);
+   * 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) {
@@ -43605,7 +44035,11 @@ var DataController = class {
    */
   async fetch(url) {
     try {
-      const response = await fetch(url);
+      const { fetchWithRelayer: fetchWithRelayer2 } = await Promise.resolve().then(() => (init_download(), download_exports));
+      const response = await fetchWithRelayer2(
+        url,
+        this.context.downloadRelayer
+      );
       if (!response.ok) {
         throw new Error(
           `HTTP error! status: ${response.status} ${response.statusText}`
@@ -43671,12 +44105,9 @@ var DataController = class {
       "https://ipfs.io/ipfs/"
     ];
     const gateways = options?.gateways || this.context.ipfsGateways || defaultGateways;
-    let cid;
-    if (url.startsWith("ipfs://")) {
-      cid = url.replace("ipfs://", "");
-    } else if (url.startsWith("Qm") || url.startsWith("bafy")) {
-      cid = url;
-    } else {
+    const { extractIpfsHash: extractIpfsHash2 } = await Promise.resolve().then(() => (init_ipfs(), ipfs_exports));
+    const cid = extractIpfsHash2(url);
+    if (!cid) {
       throw new Error(
         `Invalid IPFS URL format. Expected ipfs://... or a raw CID, got: ${url}`
       );
@@ -43730,6 +44161,17 @@ var DataController = class {
         });
       }
     }
+    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:
@@ -43737,10 +44179,10 @@ var DataController = class {
     );
   }
   /**
-   * Validates a data schema against the Vana meta-schema.
+   * Validates a data schema definition against the Vana meta-schema.
    *
-   * @param schema - The data schema to validate
-   * @returns Assertion that schema is valid (throws if invalid)
+   * @param schema - The data schema definition to validate
+   * @returns The validated DataSchema
    * @throws SchemaValidationError if invalid
    * @example
    * ```typescript
@@ -43757,11 +44199,11 @@ var DataController = class {
    *   }
    * };
    *
-   * vana.data.validateDataSchema(schema);
+   * const validatedSchema = vana.data.validateDataSchemaAgainstMetaSchema(schema);
    * ```
    */
-  validateDataSchema(schema) {
-    return validateDataSchema(schema);
+  validateDataSchemaAgainstMetaSchema(schema) {
+    return validateDataSchemaAgainstMetaSchema(schema);
   }
   /**
    * Validates data against a JSON Schema from a data schema.
@@ -43794,9 +44236,9 @@ var DataController = class {
     return validateDataAgainstSchema(data, schema);
   }
   /**
-   * Fetches and validates a schema from a URL, then returns the parsed data schema.
+   * Fetches and validates a data schema from a URL, then returns the parsed data schema.
    *
-   * @param url - The URL to fetch the schema from
+   * @param url - The URL to fetch the data schema from
    * @returns The validated data schema
    * @throws SchemaValidationError if invalid or fetch fails
    * @example
@@ -43821,6 +44263,73 @@ init_schemas();
 
 // src/controllers/server.ts
 init_errors();
+
+// src/utils/operationHandle.ts
+init_errors();
+var OperationHandle = class {
+  constructor(controller, id) {
+    this.controller = controller;
+    this.id = id;
+    __publicField(this, "_resultPromise");
+  }
+  /**
+   * Waits for the operation to complete and returns the result.
+   *
+   * @remarks
+   * Results are memoized - multiple calls return the same promise.
+   * The method polls the server at regular intervals until the operation
+   * succeeds, fails, or times out. Returns the raw string result from the
+   * server - callers are responsible for parsing if needed.
+   *
+   * @param options - Optional polling configuration
+   * @returns The operation result as a string when completed
+   * @throws {PersonalServerError} When the operation fails or times out
+   * @example
+   * ```typescript
+   * const result = await handle.waitForResult({
+   *   timeout: 60000,
+   *   pollingInterval: 500
+   * });
+   * // If expecting JSON, parse it:
+   * const data = JSON.parse(result);
+   * ```
+   */
+  async waitForResult(options) {
+    if (!this._resultPromise) {
+      this._resultPromise = this.pollForCompletion(options);
+    }
+    return this._resultPromise;
+  }
+  async pollForCompletion(options) {
+    const startTime = Date.now();
+    const timeout = options?.timeout ?? 3e4;
+    const interval = options?.pollingInterval ?? 500;
+    while (true) {
+      const result = await this.controller.getOperation(
+        this.id
+      );
+      if (result.status === "succeeded") {
+        if (result.result) {
+          return result.result;
+        }
+        throw new PersonalServerError(
+          "Operation succeeded but returned no result"
+        );
+      }
+      if (result.status === "failed") {
+        throw new PersonalServerError(
+          `Operation ${result.status}: ${result.result || "Unknown error"}`
+        );
+      }
+      if (Date.now() - startTime > timeout) {
+        throw new PersonalServerError(`Operation timed out after ${timeout}ms`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  }
+};
+
+// src/controllers/server.ts
 var ServerController = class {
   constructor(context) {
     this.context = context;
@@ -43902,26 +44411,29 @@ var ServerController = class {
     }
   }
   /**
-   * Creates an operation via the personal server API.
+   * Creates a server operation and returns a handle for lifecycle management.
    *
    * @remarks
-   * This method submits a computation request to the personal server API.
-   * The response includes the operation ID.
-   * @param params - The request parameters object
+   * This method submits a computation request to the personal server and returns
+   * an OperationHandle that provides Promise-based methods for waiting on results.
+   * The handle pattern matches TransactionHandle for consistency across async operations.
+   *
+   * @param params - The operation request parameters
    * @param params.permissionId - The permission ID authorizing this operation.
-   *   Obtain from granted permissions via `vana.permissions.getUserPermissionGrantsOnChain()`.
-   * @returns A Promise that resolves to an operation response with status and control URLs
-   * @throws {PersonalServerError} When server request fails or parameters are invalid.
-   *   Verify permissionId exists and is active for the target server.
-   * @throws {NetworkError} When personal server API communication fails.
-   *   Check server URL configuration and network connectivity.
+   *   Obtain via `vana.permissions.getUserPermissionGrantsOnChain()`.
+   * @returns An OperationHandle providing access to the operation ID and result methods
+   * @throws {PersonalServerError} When the server request fails or parameters are invalid
+   * @throws {NetworkError} When personal server API communication fails
    * @example
    * ```typescript
-   * const response = await vana.server.createOperation({
-   *   permissionId: 123,
+   * const operation = await vana.server.createOperation({
+   *   permissionId: 123
    * });
-   *
-   * console.log(`Operation created: ${response.id}`);
+   * console.log(`Operation ID: ${operation.id}`);
+   * 
+   * // Wait for completion
+   * const result = await operation.waitForResult();
+   * console.log("Result:", result);
    * ```
    */
   async createOperation(params) {
@@ -43937,7 +44449,7 @@ var ServerController = class {
       };
       console.debug("\u{1F50D} Debug - createOperation requestBody", requestBody);
       const response = await this.makeRequest(requestBody);
-      return response;
+      return new OperationHandle(this, response.id);
     } catch (error) {
       if (error instanceof Error) {
         if (error instanceof NetworkError || error instanceof SerializationError || error instanceof SignatureError || error instanceof PersonalServerError) {
@@ -43954,30 +44466,20 @@ var ServerController = class {
     }
   }
   /**
-   * Polls the status of a computation request for updates and results.
+   * Retrieves the current status and result of a server operation.
    *
    * @remarks
-   * This method checks the current status of a computation request by querying
-   * the personal server API using the provided operation ID. It returns the current
-   * status, any available output, and error information. The method can be
-   * called periodically until the operation completes or fails.
-   *
-   * Common status values include: `starting`, `processing`, `succeeded`, `failed`, `canceled`.
-   * @param operationId - The operation ID returned from the initial request submission
-   * @returns A Promise that resolves to the current operation response with status and results
-   * @throws {NetworkError} When the polling request fails or returns invalid data
+   * Common status values: `starting`, `running`, `succeeded`, `failed`, `canceled`.
+   * When status is `succeeded`, the result field contains the operation output.
+   *
+   * @param operationId - The ID of the operation to query
+   * @returns The operation response containing status, result, and metadata
+   * @throws {NetworkError} When the API request fails or returns invalid data
    * @example
    * ```typescript
-   * // Poll until completion
-   * let result = await vana.server.getOperation(response.id);
-   *
-   * while (result.status === "processing") {
-   *   await new Promise(resolve => setTimeout(resolve, 1000));
-   *   result = await vana.server.getOperation(response.id);
-   * }
-   *
-   * if (result.status === "succeeded") {
-   *   console.log("Computation completed:", result.output);
+   * const status = await vana.server.getOperation(operationId);
+   * if (status.status === 'succeeded') {
+   *   console.log('Result:', JSON.parse(status.result));
    * }
    * ```
    */
@@ -46013,6 +46515,7 @@ var VanaCore = class {
     /** Handles environment-specific operations like encryption and file systems. */
     __publicField(this, "platform");
     __publicField(this, "relayerCallbacks");
+    __publicField(this, "downloadRelayer");
     __publicField(this, "storageManager");
     __publicField(this, "hasRequiredStorage");
     __publicField(this, "ipfsGateways");
@@ -46020,6 +46523,7 @@ var VanaCore = class {
     this.platform = platform;
     this.validateConfig(config);
     this.relayerCallbacks = config.relayerCallbacks;
+    this.downloadRelayer = config.downloadRelayer;
     this.ipfsGateways = config.ipfsGateways;
     this.defaultPersonalServerUrl = config.defaultPersonalServerUrl;
     this.hasRequiredStorage = hasStorageConfig(config);
@@ -46075,6 +46579,7 @@ var VanaCore = class {
       applicationClient: walletClient,
       // Using same wallet for now
       relayerCallbacks: this.relayerCallbacks,
+      downloadRelayer: this.downloadRelayer,
       storageManager: this.storageManager,
       subgraphUrl,
       platform: this.platform,
@@ -47330,7 +47835,7 @@ export {
   storeGrantFile,
   summarizeGrant,
   validateDataAgainstSchema,
-  validateDataSchema,
+  validateDataSchemaAgainstMetaSchema,
   validateGrant,
   validateGrantExpiry,
   validateGrantFile,