@opendatalabs/vana-sdk 0.1.0-alpha.e64ec83 → 0.1.0-alpha.f05a34e

package/dist/index.browser.js

@@ -29,11 +29,6 @@ function parseEncryptedDataBuffer(encryptedBuffer) {
     mac: encryptedBuffer.slice(-32)
   };
 }
-function uint8ArrayToHex(array) {
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
-    ""
-  );
-}
 var init_crypto_utils = __esm({
   "src/platform/shared/crypto-utils.ts"() {
     "use strict";
@@ -84,147 +79,59 @@ var init_error_utils = __esm({
 
 // src/platform/browser.ts
 import * as openpgp from "openpgp";
-function hexToUint8Array(hex) {
-  const result = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    result[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  return result;
-}
-var BrowserECDH, BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
+var BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
 var init_browser = __esm({
   "src/platform/browser.ts"() {
     "use strict";
     init_crypto_utils();
     init_pgp_utils();
     init_error_utils();
-    BrowserECDH = class {
-      async generateKeyPair() {
-        const keyPair = await crypto.subtle.generateKey(
-          {
-            name: "ECDH",
-            namedCurve: "P-256"
-          },
-          true,
-          ["deriveKey", "deriveBits"]
-        );
-        return keyPair;
-      }
-      async encrypt(publicKeyHex, message) {
-        const ephemeralKeyPair = await this.generateKeyPair();
-        const publicKeyData = hexToUint8Array(publicKeyHex);
-        const importedPublicKey = await crypto.subtle.importKey(
-          "raw",
-          publicKeyData,
-          { name: "ECDH", namedCurve: "P-256" },
-          false,
-          []
-        );
-        const sharedKey = await crypto.subtle.deriveKey(
-          { name: "ECDH", public: importedPublicKey },
-          ephemeralKeyPair.privateKey,
-          { name: "AES-GCM", length: 256 },
-          false,
-          ["encrypt"]
-        );
-        const iv = crypto.getRandomValues(new Uint8Array(12));
-        const encoder = new TextEncoder();
-        const data = encoder.encode(message);
-        const encrypted = await crypto.subtle.encrypt(
-          { name: "AES-GCM", iv },
-          sharedKey,
-          data
-        );
-        const ephemeralPublicKeyData = await crypto.subtle.exportKey(
-          "raw",
-          ephemeralKeyPair.publicKey
-        );
-        return JSON.stringify({
-          encrypted: Array.from(new Uint8Array(encrypted)),
-          iv: Array.from(iv),
-          ephemeralPublicKey: Array.from(new Uint8Array(ephemeralPublicKeyData)),
-          publicKey: publicKeyHex
-        });
-      }
-      async decrypt(privateKeyHex, encryptedData) {
-        try {
-          const data = JSON.parse(encryptedData);
-          if (!data.encrypted || !data.iv || !data.ephemeralPublicKey) {
-            throw new Error("Invalid encrypted data format");
-          }
-          const privateKeyData = hexToUint8Array(privateKeyHex);
-          const importedPrivateKey = await crypto.subtle.importKey(
-            "pkcs8",
-            privateKeyData,
-            { name: "ECDH", namedCurve: "P-256" },
-            false,
-            ["deriveKey"]
-          );
-          const ephemeralPublicKey = await crypto.subtle.importKey(
-            "raw",
-            new Uint8Array(data.ephemeralPublicKey),
-            { name: "ECDH", namedCurve: "P-256" },
-            false,
-            []
-          );
-          const sharedKey = await crypto.subtle.deriveKey(
-            { name: "ECDH", public: ephemeralPublicKey },
-            importedPrivateKey,
-            { name: "AES-GCM", length: 256 },
-            false,
-            ["decrypt"]
-          );
-          const decrypted = await crypto.subtle.decrypt(
-            { name: "AES-GCM", iv: new Uint8Array(data.iv) },
-            sharedKey,
-            new Uint8Array(data.encrypted)
-          );
-          return new TextDecoder().decode(decrypted);
-        } catch (error) {
-          throw new Error(
-            `Decryption failed: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      }
-    };
     BrowserCryptoAdapter = class {
       async encryptWithPublicKey(data, publicKeyHex) {
         try {
-          const ecdh = new BrowserECDH();
-          return await ecdh.encrypt(publicKeyHex, data);
+          const eccrypto = await import("eccrypto-js");
+          const publicKeyBuffer = Buffer.from(publicKeyHex, "hex");
+          const encrypted = await eccrypto.encrypt(
+            publicKeyBuffer,
+            Buffer.from(data, "utf8")
+          );
+          const result = Buffer.concat([
+            encrypted.iv,
+            encrypted.ephemPublicKey,
+            encrypted.ciphertext,
+            encrypted.mac
+          ]);
+          return result.toString("hex");
         } catch (error) {
           throw new Error(`Encryption failed: ${error}`);
         }
       }
       async decryptWithPrivateKey(encryptedData, privateKeyHex) {
         try {
-          const ecdh = new BrowserECDH();
-          return await ecdh.decrypt(privateKeyHex, encryptedData);
+          const eccrypto = await import("eccrypto-js");
+          const privateKeyBuffer = processWalletPrivateKey(privateKeyHex);
+          const encryptedBuffer = Buffer.from(encryptedData, "hex");
+          const { iv, ephemPublicKey, ciphertext, mac } = parseEncryptedDataBuffer(encryptedBuffer);
+          const encryptedObj = { iv, ephemPublicKey, ciphertext, mac };
+          const decryptedBuffer = await eccrypto.decrypt(
+            privateKeyBuffer,
+            encryptedObj
+          );
+          return decryptedBuffer.toString("utf8");
         } catch (error) {
           throw new Error(`Decryption failed: ${error}`);
         }
       }
       async generateKeyPair() {
         try {
-          const keyPair = await crypto.subtle.generateKey(
-            {
-              name: "ECDH",
-              namedCurve: "P-256"
-            },
-            true,
-            ["deriveKey", "deriveBits"]
-          );
-          const publicKeyBuffer = await crypto.subtle.exportKey(
-            "raw",
-            keyPair.publicKey
-          );
-          const privateKeyBuffer = await crypto.subtle.exportKey(
-            "pkcs8",
-            keyPair.privateKey
-          );
+          const eccrypto = await import("eccrypto-js");
+          const privateKeyBytes = new Uint8Array(32);
+          crypto.getRandomValues(privateKeyBytes);
+          const privateKey = Buffer.from(privateKeyBytes);
+          const publicKey = eccrypto.getPublicCompressed(privateKey);
           return {
-            publicKey: uint8ArrayToHex(new Uint8Array(publicKeyBuffer)),
-            privateKey: uint8ArrayToHex(new Uint8Array(privateKeyBuffer))
+            privateKey: privateKey.toString("hex"),
+            publicKey: publicKey.toString("hex")
           };
         } catch (error) {
           throw wrapCryptoError("key generation", error);
@@ -234,65 +141,9 @@ var init_browser = __esm({
         try {
           const eccrypto = await import("eccrypto-js");
           const uncompressedKey = processWalletPublicKey(publicKey);
-          const iv = Buffer.from([
-            1,
-            2,
-            3,
-            4,
-            5,
-            6,
-            7,
-            8,
-            9,
-            10,
-            11,
-            12,
-            13,
-            14,
-            15,
-            16
-          ]);
-          const ephemeralKey = Buffer.from([
-            17,
-            34,
-            51,
-            68,
-            85,
-            102,
-            119,
-            136,
-            153,
-            170,
-            187,
-            204,
-            221,
-            238,
-            255,
-            0,
-            16,
-            32,
-            48,
-            64,
-            80,
-            96,
-            112,
-            128,
-            144,
-            160,
-            176,
-            192,
-            208,
-            224,
-            240,
-            0
-          ]);
           const encryptedBuffer = await eccrypto.encrypt(
             uncompressedKey,
-            Buffer.from(data),
-            {
-              iv,
-              ephemPrivateKey: ephemeralKey
-            }
+            Buffer.from(data)
           );
           const result = Buffer.concat([
             encryptedBuffer.iv,
@@ -539,6 +390,9 @@ function isWalletConfig(config) {
 function isChainConfig(config) {
   return "chainId" in config && !("walletClient" in config);
 }
+function hasStorageConfig(config) {
+  return config.storage?.providers !== void 0 && Object.keys(config.storage.providers).length > 0;
+}
 
 // src/types/chains.ts
 function isVanaChainId(chainId) {
@@ -562,8 +416,8 @@ var StorageError = class extends Error {
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 
-// src/schemas/dataContract.schema.json
-var dataContract_schema_default = {
+// src/schemas/dataSchema.schema.json
+var dataSchema_schema_default = {
   $id: "https://vana.org/data-schema.json",
   $schema: "http://json-schema.org/draft-07/schema#",
   title: "Schema",
@@ -635,7 +489,7 @@ var SchemaValidator = class {
       strict: false
     });
     addFormats(this.ajv);
-    this.dataSchemaValidator = this.ajv.compile(dataContract_schema_default);
+    this.dataSchemaValidator = this.ajv.compile(dataSchema_schema_default);
   }
   /**
    * Validates a data schema against the Vana meta-schema
@@ -834,55 +688,6 @@ function isReplicateAPIResponse(value) {
     obj.status
   );
 }
-function isIdentityServerOutput(value) {
-  console.debug("\u{1F50D} Type Guard: Checking value:", value);
-  console.debug("\u{1F50D} Type Guard: Value type:", typeof value);
-  if (typeof value !== "object" || value === null) {
-    console.debug("\u{1F50D} Type Guard: Failed - not object or null");
-    return false;
-  }
-  const obj = value;
-  console.debug("\u{1F50D} Type Guard: Object keys:", Object.keys(obj));
-  console.debug(
-    "\u{1F50D} Type Guard: user_address:",
-    obj.user_address,
-    typeof obj.user_address
-  );
-  if (typeof obj.user_address !== "string") {
-    console.debug("\u{1F50D} Type Guard: Failed - user_address not string");
-    return false;
-  }
-  console.debug(
-    "\u{1F50D} Type Guard: personal_server:",
-    obj.personal_server,
-    typeof obj.personal_server
-  );
-  if (typeof obj.personal_server !== "object" || obj.personal_server === null) {
-    console.debug("\u{1F50D} Type Guard: Failed - personal_server not object or null");
-    return false;
-  }
-  const personalServer = obj.personal_server;
-  console.debug(
-    "\u{1F50D} Type Guard: Personal server keys:",
-    Object.keys(personalServer)
-  );
-  console.debug("\u{1F50D} Type Guard: address:", personalServer.address);
-  console.debug("\u{1F50D} Type Guard: public_key:", personalServer.public_key);
-  const hasAddress = "address" in personalServer;
-  const hasPublicKey = "public_key" in personalServer;
-  console.debug(
-    "\u{1F50D} Type Guard: Has address:",
-    hasAddress,
-    "Has public_key:",
-    hasPublicKey
-  );
-  return hasAddress && hasPublicKey;
-}
-function isPersonalServerOutput(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  return "user_address" in obj && "identity" in obj && typeof obj.user_address === "string" && typeof obj.identity === "object";
-}
 function isAPIResponse(value) {
   if (typeof value !== "object" || value === null) return false;
   const obj = value;
@@ -7913,6 +7718,12 @@ var DataRefinerRegistryABI = [
         name: "schemaId",
         type: "uint256"
       },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "schemaDefinitionUrl",
+        type: "string"
+      },
       {
         indexed: false,
         internalType: "string",
@@ -8016,7 +7827,7 @@ var DataRefinerRegistryABI = [
       {
         indexed: false,
         internalType: "string",
-        name: "typ",
+        name: "dialect",
         type: "string"
       },
       {
@@ -8112,6 +7923,40 @@ var DataRefinerRegistryABI = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "dlpId",
+        type: "uint256"
+      },
+      {
+        internalType: "string",
+        name: "name",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "schemaDefinitionUrl",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "refinementInstructionUrl",
+        type: "string"
+      }
+    ],
+    name: "addRefiner",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -8135,7 +7980,7 @@ var DataRefinerRegistryABI = [
         type: "string"
       }
     ],
-    name: "addRefiner",
+    name: "addRefinerWithSchemaId",
     outputs: [
       {
         internalType: "uint256",
@@ -8155,7 +8000,7 @@ var DataRefinerRegistryABI = [
       },
       {
         internalType: "string",
-        name: "typ",
+        name: "dialect",
         type: "string"
       },
       {
@@ -8518,7 +8363,7 @@ var DataRefinerRegistryABI = [
           },
           {
             internalType: "string",
-            name: "typ",
+            name: "dialect",
             type: "string"
           },
           {
@@ -33435,7 +33280,7 @@ function getAbi(contract) {
 import { keccak256, toHex } from "viem";
 function createGrantFile(params) {
   const grantFile = {
-    grantee: params.to,
+    grantee: params.grantee,
     operation: params.operation,
     parameters: params.parameters
   };
@@ -33855,7 +33700,7 @@ var PermissionsController = class {
    * @example
    * ```typescript
    * const txHash = await vana.permissions.grant({
-   *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+   *   grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
    *   operation: "llm_inference",
    *   parameters: {
    *     model: "gpt-4",
@@ -33884,7 +33729,7 @@ var PermissionsController = class {
    * @example
    * ```typescript
    * const { preview, confirm } = await vana.permissions.prepareGrant({
-   *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+   *   grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
    *   operation: "llm_inference",
    *   files: [1, 2, 3],
    *   parameters: { model: "gpt-4", prompt: "Analyze my social media data" }
@@ -33933,9 +33778,13 @@ var PermissionsController = class {
       console.debug("\u{1F50D} Debug - Grant URL from params:", grantUrl);
       if (!grantUrl) {
         if (!this.context.relayerCallbacks?.storeGrantFile && !this.context.storageManager) {
-          throw new Error(
-            "No storage available. Provide a grantUrl, configure relayerCallbacks.storeGrantFile, or storageManager."
-          );
+          if (this.context.validateStorageRequired) {
+            this.context.validateStorageRequired();
+          } else {
+            throw new Error(
+              "No storage available. Provide a grantUrl, configure relayerCallbacks.storeGrantFile, or storageManager."
+            );
+          }
         }
         if (this.context.relayerCallbacks?.storeGrantFile) {
           grantUrl = await this.context.relayerCallbacks.storeGrantFile(grantFile);
@@ -33959,7 +33808,7 @@ var PermissionsController = class {
         grantUrl
       );
       const typedData = await this.composePermissionGrantMessage({
-        to: params.to,
+        grantee: params.grantee,
         operation: params.operation,
         // Placeholder - real data is in IPFS
         files: params.files,
@@ -34006,7 +33855,7 @@ var PermissionsController = class {
    * @example
    * ```typescript
    * const { typedData, signature } = await vana.permissions.createAndSign({
-   *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+   *   grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
    *   operation: "data_analysis",
    *   parameters: { analysisType: "sentiment" },
    * });
@@ -34022,9 +33871,13 @@ var PermissionsController = class {
       console.debug("\u{1F50D} Debug - Grant URL from params:", grantUrl);
       if (!grantUrl) {
         if (!this.context.relayerCallbacks?.storeGrantFile && !this.context.storageManager) {
-          throw new Error(
-            "No storage available. Provide a grantUrl, configure relayerCallbacks.storeGrantFile, or storageManager."
-          );
+          if (this.context.validateStorageRequired) {
+            this.context.validateStorageRequired();
+          } else {
+            throw new Error(
+              "No storage available. Provide a grantUrl, configure relayerCallbacks.storeGrantFile, or storageManager."
+            );
+          }
         }
         if (this.context.relayerCallbacks?.storeGrantFile) {
           grantUrl = await this.context.relayerCallbacks.storeGrantFile(grantFile);
@@ -34048,7 +33901,7 @@ var PermissionsController = class {
         grantUrl
       );
       const typedData = await this.composePermissionGrantMessage({
-        to: params.to,
+        grantee: params.grantee,
         operation: params.operation,
         // Placeholder - real data is in IPFS
         files: params.files,
@@ -34399,7 +34252,7 @@ var PermissionsController = class {
    * Composes the EIP-712 typed data for PermissionGrant (new simplified format).
    *
    * @param params - The parameters for composing the permission grant message
-   * @param params.to - The recipient address for the permission grant
+   * @param params.grantee - The recipient address for the permission grant
    * @param params.operation - The type of operation being granted permission for
    * @param params.files - Array of file IDs that the permission applies to
    * @param params.grantUrl - URL where the grant details are stored
@@ -34492,36 +34345,45 @@ var PermissionsController = class {
     return addresses[0];
   }
   /**
-   * Retrieves all permissions granted by the current user using subgraph queries.
+   * Gets on-chain permission grant data without expensive off-chain resolution.
    *
    * @remarks
-   * This method queries the Vana subgraph to find permissions directly granted by the user
-   * using the Permission entity. It efficiently handles millions of permissions by leveraging
-   * indexed subgraph data instead of scanning contract logs. The method fetches complete
-   * grant files from IPFS to provide detailed permission information including operation
-   * parameters and grantee details.
-   * @param params - Optional query parameters
-   * @param params.limit - Maximum number of permissions to return (default: 50)
-   * @param params.subgraphUrl - Optional subgraph URL to override the default endpoint
-   * @returns A Promise that resolves to an array of `GrantedPermission` objects
-   * @throws {BlockchainError} When subgraph is unavailable or returns invalid data
+   * This method provides a fast, performance-focused way to retrieve permission grants
+   * by querying only the subgraph without making expensive IPFS or individual contract calls.
+   * It eliminates the N+1 query problem of the legacy `getUserPermissions()` method.
+   *
+   * The returned data contains all on-chain information but does NOT include resolved
+   * operation details, parameters, or file IDs. Use `retrieveGrantFile()` separately
+   * for specific grants when detailed data is needed.
+   *
+   * **Performance**: Completes in ~100-500ms regardless of permission count.
+   * **Reliability**: Single point of failure (subgraph) with clear RPC fallback path.
+   *
+   * @param options - Options for retrieving permissions (limit, subgraph URL)
+   * @returns A Promise that resolves to an array of `OnChainPermissionGrant` objects
+   * @throws {BlockchainError} When subgraph query fails
+   * @throws {NetworkError} When network requests fail
    * @example
    * ```typescript
-   * // Get all permissions granted by current user
-   * const permissions = await vana.permissions.getUserPermissions();
+   * // Fast: Get all on-chain permission data
+   * const grants = await vana.permissions.getUserPermissionGrantsOnChain({ limit: 20 });
    *
-   * permissions.forEach(permission => {
-   *   console.log(`Granted ${permission.operation} to ${permission.grantee}`);
+   * // Display in UI immediately
+   * grants.forEach(grant => {
+   *   console.log(`Permission ${grant.id}: ${grant.grantUrl}`);
    * });
    *
-   * // Limit results
-   * const recent = await vana.permissions.getUserPermissions({ limit: 10 });
+   * // Lazy load detailed data for specific permission when user clicks
+   * const grantFile = await retrieveGrantFile(grants[0].grantUrl);
+   * console.log(`Operation: ${grantFile.operation}`);
+   * console.log(`Parameters:`, grantFile.parameters);
    * ```
    */
-  async getUserPermissions(params) {
+  async getUserPermissionGrantsOnChain(options = {}) {
+    const { limit = 50, subgraphUrl } = options;
     try {
       const userAddress = await this.getUserAddress();
-      const graphqlEndpoint = params?.subgraphUrl || this.context.subgraphUrl;
+      const graphqlEndpoint = subgraphUrl || this.context.subgraphUrl;
       if (!graphqlEndpoint) {
         throw new BlockchainError(
           "subgraphUrl is required. Please provide a valid subgraph endpoint or configure it in Vana constructor."
@@ -34543,16 +34405,6 @@ var PermissionsController = class {
           }
         }
       `;
-      console.info("Query:", query);
-      console.info(
-        "Body:",
-        JSON.stringify({
-          query,
-          variables: {
-            userId: userAddress.toLowerCase()
-          }
-        })
-      );
       const response = await fetch(graphqlEndpoint, {
         method: "POST",
         headers: {
@@ -34571,7 +34423,6 @@ var PermissionsController = class {
         );
       }
       const result = await response.json();
-      console.info("Result:", result);
       if (result.errors) {
         throw new BlockchainError(
           `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
@@ -34579,64 +34430,32 @@ var PermissionsController = class {
       }
       const userData = result.data?.user;
       if (!userData || !userData.permissions?.length) {
-        console.warn("No permissions found for user:", userAddress);
         return [];
       }
-      const userPermissions = [];
-      const limit = params?.limit || 50;
-      const permissionsToProcess = userData.permissions.slice(0, limit);
-      for (const permission of permissionsToProcess) {
-        try {
-          let operation;
-          let files = [];
-          let parameters;
-          let granteeAddress;
-          try {
-            const grantFile = await retrieveGrantFile(permission.grant);
-            operation = grantFile.operation;
-            parameters = grantFile.parameters;
-            granteeAddress = grantFile.grantee;
-          } catch {
-          }
-          try {
-            const fileIds = await this.getPermissionFileIds(
-              BigInt(permission.id)
-            );
-            files = fileIds.map((id) => Number(id));
-          } catch {
-          }
-          userPermissions.push({
-            id: BigInt(permission.id),
-            files,
-            operation: operation || "",
-            parameters: parameters || {},
-            grant: permission.grant,
-            grantor: userAddress.toLowerCase(),
-            // Current user is the grantor
-            grantee: granteeAddress || userAddress,
-            // Application that received permission
-            active: true,
-            // Default to active if not specified
-            grantedAt: Number(permission.addedAtBlock),
-            nonce: Number(permission.nonce)
-          });
-        } catch (error) {
-          console.error(
-            "SDK Error: Failed to process permission:",
-            permission.id,
-            error
-          );
-        }
-      }
-      return userPermissions.sort((a, b) => {
+      const onChainGrants = userData.permissions.slice(0, limit).map((permission) => ({
+        id: BigInt(permission.id),
+        grantUrl: permission.grant,
+        grantSignature: permission.grantSignature,
+        grantHash: permission.grantHash,
+        nonce: BigInt(permission.nonce),
+        addedAtBlock: BigInt(permission.addedAtBlock),
+        addedAtTimestamp: BigInt(permission.addedAtTimestamp || "0"),
+        transactionHash: permission.transactionHash || "",
+        grantor: userAddress,
+        active: true
+        // TODO: Add revocation status from subgraph when available
+      }));
+      return onChainGrants.sort((a, b) => {
         if (a.id < b.id) return 1;
         if (a.id > b.id) return -1;
         return 0;
       });
     } catch (error) {
-      console.error("Failed to fetch user permissions:", error);
+      if (error instanceof BlockchainError || error instanceof NetworkError) {
+        throw error;
+      }
       throw new BlockchainError(
-        `Failed to fetch user permissions: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to fetch user permission grants: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
@@ -35334,590 +35153,6 @@ var PermissionsController = class {
 // src/controllers/data.ts
 import { getContract, decodeEventLog } from "viem";
 
-// src/controllers/server.ts
-var ServerController = class {
-  constructor(context) {
-    this.context = context;
-    __publicField(this, "REPLICATE_API_URL", "https://api.replicate.com/v1/predictions");
-    __publicField(this, "PERSONAL_SERVER_VERSION", "vana-com/personal-server:6dae0fead4017557a2e6bd020643359ac1769228a9cfe3bd2365eeeb9711610e");
-    __publicField(this, "IDENTITY_SERVER_VERSION", "vana-com/identity-server:8e357fbeb87c0558b545809cabd0ef2f311082d8ce1f12b93cb8ad2f38cfbfd2");
-  }
-  /**
-   * Posts a computation request to a user's personal server.
-   *
-   * @remarks
-   * This method submits a computation request to the specified user's personal server
-   * via the Replicate API. It creates a signed request with the user address and
-   * permission ID, then submits it for processing. The response includes URLs for
-   * polling results and canceling the computation if needed.
-   *
-   * The method requires a valid Replicate API token and uses the application's
-   * wallet client for request signing to ensure authenticity.
-   * @param params - The request parameters object
-   * @param params.permissionId - The permission ID authorizing this computation
-   * @returns A Promise that resolves to a prediction response with status and control URLs
-   * @throws {PersonalServerError} When server request fails or parameters are invalid
-   * @throws {SignatureError} When request signing fails
-   * @throws {NetworkError} When Replicate API communication fails
-   * @example
-   * ```typescript
-   * const response = await vana.server.postRequest({
-   *   permissionId: 123,
-   * });
-   *
-   * console.log(`Request submitted: ${response.id}`);
-   * console.log(`Poll for results: ${response.urls.get}`);
-   * ```
-   */
-  async postRequest(params) {
-    try {
-      this.validatePostRequestParams(params);
-      const requestJson = this.createRequestJson(params);
-      const signature = await this.createSignature(requestJson);
-      const replicateInput = {
-        replicate_api_token: this.getReplicateApiToken(),
-        signature,
-        request_json: requestJson
-      };
-      console.debug("\u{1F50D} Debug - replicateInput", replicateInput);
-      const response = await this.makeReplicateRequest(replicateInput);
-      return response;
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error instanceof NetworkError || error instanceof SerializationError || error instanceof SignatureError || error instanceof PersonalServerError) {
-          throw error;
-        }
-        throw new PersonalServerError(
-          `Personal server request failed: ${error.message}`,
-          error
-        );
-      }
-      throw new PersonalServerError(
-        "Personal server request failed with unknown error"
-      );
-    }
-  }
-  /**
-   * Initializes the personal server and fetches user identity.
-   *
-   * @param params - The request parameters containing user address
-   * @returns Promise resolving to the user's identity information
-   */
-  async initPersonalServer(params) {
-    try {
-      this.validateInitPersonalServerParams(params);
-      const response = await this.makePersonalServerRequest(params);
-      const result = await this.pollPersonalServerResult(response);
-      return result;
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error instanceof NetworkError || error instanceof SerializationError || error instanceof PersonalServerError) {
-          throw error;
-        }
-        throw new PersonalServerError(
-          `Personal server initialization failed: ${error.message}`,
-          error
-        );
-      }
-      throw new PersonalServerError(
-        "Personal server initialization failed with unknown error"
-      );
-    }
-  }
-  /**
-   * Retrieves the public key for a user's personal server via the Identity Server.
-   *
-   * @remarks
-   * This method uses the Identity Server to deterministically derive the personal server's
-   * public key from the user's EVM address. This enables anyone to encrypt data for a
-   * specific user's server without requiring that server to be online. The Identity Server
-   * provides a reliable way to obtain encryption keys for secure data sharing across the
-   * Vana network.
-   *
-   * The derived public key is deterministic and consistent, allowing for predictable
-   * encryption workflows in decentralized applications.
-   * @param userAddress - The user's EVM address to derive the server public key for
-   * @returns A Promise that resolves to the server's public key as a hex string
-   * @throws {PersonalServerError} When user address is invalid or server lookup fails
-   * @throws {NetworkError} When Identity Server API request fails
-   * @example
-   * ```typescript
-   * // Get public key for encrypting data to a user's server
-   * const publicKey = await vana.server.getTrustedServerPublicKey(
-   *   "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36"
-   * );
-   *
-   * // Use the public key for encryption
-   * const encryptedData = await encryptForServer(data, publicKey);
-   * ```
-   */
-  async getTrustedServerPublicKey(userAddress) {
-    try {
-      if (!userAddress || typeof userAddress !== "string") {
-        throw new PersonalServerError(
-          "User address is required and must be a valid string"
-        );
-      }
-      if (!userAddress.startsWith("0x") || userAddress.length !== 42) {
-        throw new PersonalServerError(
-          "User address must be a valid EVM address"
-        );
-      }
-      const requestBody = {
-        version: this.IDENTITY_SERVER_VERSION,
-        input: {
-          user_address: userAddress
-        }
-      };
-      console.debug("Identity Server Request for Public Key:", {
-        url: this.REPLICATE_API_URL,
-        method: "POST",
-        body: requestBody
-      });
-      const response = await fetch(this.REPLICATE_API_URL, {
-        method: "POST",
-        headers: {
-          Authorization: `Token ${this.getReplicateApiToken()}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.debug("Identity Server Error Response:", {
-          status: response.status,
-          statusText: response.statusText,
-          error: errorText
-        });
-        throw new NetworkError(
-          `Identity Server API request failed: ${response.status} ${response.statusText} - ${errorText}`
-        );
-      }
-      const data = await response.json();
-      console.debug("Identity Server Success Response:", data);
-      const result = await this.pollIdentityServerResult({
-        id: data.id,
-        status: data.status,
-        urls: {
-          get: data.urls?.get || "",
-          cancel: data.urls?.cancel || ""
-        },
-        input: data.input,
-        output: data.output,
-        error: data.error
-      });
-      return result;
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error instanceof NetworkError || error instanceof PersonalServerError) {
-          throw error;
-        }
-        throw new PersonalServerError(
-          `Failed to get trusted server public key: ${error.message}`,
-          error
-        );
-      }
-      throw new PersonalServerError(
-        "Failed to get trusted server public key with unknown error"
-      );
-    }
-  }
-  /**
-   * Polls the status of a computation request for updates and results.
-   *
-   * @remarks
-   * This method checks the current status of a computation request by querying
-   * the Replicate API using the provided polling URL. It returns the current
-   * status, any available output, and error information. The method should be
-   * called periodically until the computation completes or fails.
-   *
-   * Common status values include: `starting`, `processing`, `succeeded`, `failed`, `canceled`.
-   * @param getUrl - The polling URL returned from the initial request submission
-   * @returns A Promise that resolves to the current prediction response with status and results
-   * @throws {NetworkError} When the polling request fails or returns invalid data
-   * @example
-   * ```typescript
-   * // Poll until completion
-   * let result = await vana.server.pollStatus(response.urls.get);
-   *
-   * while (result.status === "processing") {
-   *   await new Promise(resolve => setTimeout(resolve, 1000));
-   *   result = await vana.server.pollStatus(response.urls.get);
-   * }
-   *
-   * if (result.status === "succeeded") {
-   *   console.log("Computation completed:", result.output);
-   * }
-   * ```
-   */
-  async pollStatus(getUrl) {
-    try {
-      console.debug("Polling Replicate Status:", getUrl);
-      const response = await fetch(getUrl, {
-        method: "GET",
-        headers: {
-          Authorization: `Token ${this.getReplicateApiToken()}`,
-          "Content-Type": "application/json"
-        }
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.debug("Polling Error Response:", {
-          status: response.status,
-          statusText: response.statusText,
-          error: errorText
-        });
-        throw new NetworkError(
-          `Status polling failed: ${response.status} ${response.statusText} - ${errorText}`
-        );
-      }
-      const data = await response.json();
-      console.debug("Polling Success Response:", data);
-      return {
-        id: data.id,
-        status: data.status,
-        urls: {
-          get: data.urls?.get || getUrl,
-          cancel: data.urls?.cancel || ""
-        },
-        input: data.input,
-        output: data.output,
-        error: data.error
-      };
-    } catch (error) {
-      if (error instanceof NetworkError) {
-        throw error;
-      }
-      throw new NetworkError(
-        `Failed to poll status: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Validates the post request parameters.
-   *
-   * @param params - The post request parameters to validate
-   */
-  validatePostRequestParams(params) {
-    if (typeof params.permissionId !== "number" || params.permissionId <= 0) {
-      throw new PersonalServerError(
-        "Permission ID is required and must be a valid positive number"
-      );
-    }
-  }
-  /**
-   * Validates the init personal server parameters.
-   *
-   * @param params - The initialization parameters to validate
-   */
-  validateInitPersonalServerParams(params) {
-    if (!params.userAddress || typeof params.userAddress !== "string") {
-      throw new PersonalServerError(
-        "User address is required and must be a valid string"
-      );
-    }
-    if (!params.userAddress.startsWith("0x") || params.userAddress.length !== 42) {
-      throw new PersonalServerError(
-        "User address must be a valid Vana address"
-      );
-    }
-  }
-  /**
-   * Creates the request JSON string for the personal server.
-   *
-   * @param params - The post request parameters to serialize
-   * @returns JSON string representation of the request data
-   */
-  createRequestJson(params) {
-    try {
-      const requestData = {
-        permission_id: params.permissionId
-      };
-      return JSON.stringify(requestData);
-    } catch (error) {
-      throw new SerializationError(
-        `Failed to create request JSON: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Creates a signature for the request JSON.
-   *
-   * @param requestJson - The JSON string to sign
-   * @returns Promise resolving to the cryptographic signature
-   */
-  async createSignature(requestJson) {
-    try {
-      console.debug("\u{1F50D} Debug - createSignature", requestJson);
-      const client = this.context.applicationClient || this.context.walletClient;
-      const account = client.account;
-      if (!account) {
-        throw new SignatureError("No account available for signing");
-      }
-      if (account.type !== "local") {
-        throw new SignatureError(
-          "Only local accounts are supported for signing"
-        );
-      }
-      const signature = await account.signMessage({
-        message: requestJson
-      });
-      return signature;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("User rejected")) {
-        throw new SignatureError("User rejected the signature request");
-      }
-      throw new SignatureError(
-        `Failed to create signature: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Gets the Replicate API token from environment.
-   *
-   * @returns The Replicate API token from environment variables
-   */
-  getReplicateApiToken() {
-    const token = process.env.REPLICATE_API_TOKEN || process.env.NEXT_PUBLIC_REPLICATE_API_TOKEN;
-    if (!token) {
-      throw new PersonalServerError(
-        "REPLICATE_API_TOKEN environment variable is required"
-      );
-    }
-    return token;
-  }
-  /**
-   * Makes the request to the Replicate API.
-   *
-   * @param input - The input parameters for the Replicate API request
-   * @returns Promise resolving to the Replicate prediction response
-   */
-  async makeReplicateRequest(input) {
-    try {
-      const requestBody = {
-        version: this.PERSONAL_SERVER_VERSION,
-        input
-      };
-      console.debug("Replicate Request:", {
-        url: this.REPLICATE_API_URL,
-        method: "POST",
-        headers: {
-          Authorization: `Token ${this.getReplicateApiToken().substring(0, 10)}...`,
-          "Content-Type": "application/json"
-        },
-        body: requestBody
-      });
-      const response = await fetch(this.REPLICATE_API_URL, {
-        method: "POST",
-        headers: {
-          Authorization: `Token ${this.getReplicateApiToken()}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.debug("Replicate Error Response:", {
-          status: response.status,
-          statusText: response.statusText,
-          error: errorText
-        });
-        throw new NetworkError(
-          `Replicate API request failed: ${response.status} ${response.statusText} - ${errorText}`
-        );
-      }
-      const data = await response.json();
-      console.debug("Replicate Success Response:", data);
-      return {
-        id: data.id,
-        status: data.status,
-        urls: {
-          get: data.urls?.get || "",
-          cancel: data.urls?.cancel || ""
-        },
-        input: data.input,
-        output: data.output,
-        error: data.error
-      };
-    } catch (error) {
-      if (error instanceof NetworkError) {
-        throw error;
-      }
-      throw new NetworkError(
-        `Failed to make Replicate API request: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Makes the request to the personal server.
-   *
-   * @param params - The initialization parameters for the personal server
-   * @returns Promise resolving to the Replicate prediction response
-   */
-  async makePersonalServerRequest(params) {
-    try {
-      const requestBody = {
-        version: this.IDENTITY_SERVER_VERSION,
-        input: {
-          user_address: params.userAddress
-        }
-      };
-      console.debug("Personal Server Request:", {
-        url: this.REPLICATE_API_URL,
-        method: "POST",
-        headers: {
-          Authorization: `Token ${this.getReplicateApiToken().substring(0, 10)}...`,
-          "Content-Type": "application/json"
-        },
-        body: requestBody
-      });
-      const response = await fetch(this.REPLICATE_API_URL, {
-        method: "POST",
-        headers: {
-          Authorization: `Token ${this.getReplicateApiToken()}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(requestBody)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.debug("Personal Server Error Response:", {
-          status: response.status,
-          statusText: response.statusText,
-          error: errorText
-        });
-        throw new NetworkError(
-          `Personal Server API request failed: ${response.status} ${response.statusText} - ${errorText}`
-        );
-      }
-      const data = await response.json();
-      console.debug("Personal Server Success Response:", data);
-      return {
-        id: data.id,
-        status: data.status,
-        urls: {
-          get: data.urls?.get || "",
-          cancel: data.urls?.cancel || ""
-        },
-        input: data.input,
-        output: data.output,
-        error: data.error
-      };
-    } catch (error) {
-      if (error instanceof NetworkError) {
-        throw error;
-      }
-      throw new NetworkError(
-        `Failed to make Personal Server API request: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Polls the identity server result until completion and extracts the public key.
-   *
-   * @param initialResponse - The initial response from the identity server
-   * @returns Promise resolving to the extracted public key
-   */
-  async pollIdentityServerResult(initialResponse) {
-    const maxAttempts = 60;
-    let attempts = 0;
-    let currentResponse = initialResponse;
-    while (attempts < maxAttempts) {
-      if (currentResponse.status === "succeeded") {
-        const output = currentResponse.output;
-        let parsedOutput;
-        if (typeof output === "string") {
-          try {
-            parsedOutput = JSON.parse(output);
-          } catch {
-            throw new PersonalServerError(
-              "Failed to parse Identity Server response as JSON"
-            );
-          }
-        } else {
-          parsedOutput = output;
-        }
-        const personalServer = parsedOutput.personal_server;
-        if (!personalServer || !personalServer.public_key) {
-          throw new PersonalServerError(
-            "Identity Server response missing personal_server.public_key"
-          );
-        }
-        return personalServer.public_key;
-      } else if (currentResponse.status === "failed") {
-        throw new PersonalServerError(
-          `Identity Server request failed: ${currentResponse.error || "Unknown error"}`
-        );
-      } else if (currentResponse.status === "canceled") {
-        throw new PersonalServerError("Identity Server request was canceled");
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      attempts++;
-      if (currentResponse.urls.get) {
-        currentResponse = await this.pollStatus(currentResponse.urls.get);
-      }
-    }
-    throw new PersonalServerError(
-      "Identity Server request timed out after 60 seconds"
-    );
-  }
-  /**
-   * Polls the personal server result until completion.
-   *
-   * @param initialResponse - The initial response from the personal server
-   * @returns Promise resolving to the personal server response data
-   */
-  async pollPersonalServerResult(initialResponse) {
-    const maxAttempts = 60;
-    let attempts = 0;
-    let currentResponse = initialResponse;
-    while (attempts < maxAttempts) {
-      if (currentResponse.status === "succeeded") {
-        const output = currentResponse.output;
-        let parsedOutput;
-        if (typeof output === "string") {
-          try {
-            parsedOutput = JSON.parse(output);
-          } catch {
-            parsedOutput = output;
-          }
-        } else {
-          parsedOutput = output;
-        }
-        const personalServer = parsedOutput.personal_server;
-        const derivedAddress = personalServer?.address;
-        const publicKey = personalServer?.public_key;
-        return {
-          userAddress: parsedOutput.user_address,
-          identity: {
-            metadata: {
-              derivedAddress,
-              publicKey
-            }
-          },
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-      } else if (currentResponse.status === "failed") {
-        throw new PersonalServerError(
-          `Personal server initialization failed: ${currentResponse.error || "Unknown error"}`
-        );
-      } else if (currentResponse.status === "canceled") {
-        throw new PersonalServerError(
-          "Personal server initialization was canceled"
-        );
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      attempts++;
-      if (currentResponse.urls.get) {
-        currentResponse = await this.pollStatus(currentResponse.urls.get);
-      }
-    }
-    throw new PersonalServerError(
-      "Personal server initialization timed out after 60 seconds"
-    );
-  }
-};
-
 // src/utils/encryption.ts
 var DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
 async function generateEncryptionKey(wallet, seed = DEFAULT_ENCRYPTION_SEED) {
@@ -35982,32 +35217,19 @@ async function decryptWithPrivateKey(encryptedData, privateKey, platformAdapter)
     throw new Error(`Failed to decrypt with private key: ${error}`);
   }
 }
-async function encryptUserData(data, walletSignature, platformAdapter) {
+async function encryptBlobWithSignedKey(data, key, platformAdapter) {
   try {
     const dataBuffer = data instanceof Blob ? await data.arrayBuffer() : new TextEncoder().encode(data);
     const dataArray = new Uint8Array(dataBuffer);
     const encrypted = await platformAdapter.crypto.encryptWithPassword(
       dataArray,
-      walletSignature
+      key
     );
     return new Blob([encrypted], {
       type: "application/octet-stream"
     });
   } catch (error) {
-    throw new Error(`Failed to encrypt user data: ${error}`);
-  }
-}
-async function decryptUserData(encryptedData, walletSignature, platformAdapter) {
-  try {
-    const encryptedBuffer = encryptedData instanceof Blob ? await encryptedData.arrayBuffer() : new TextEncoder().encode(encryptedData);
-    const encryptedArray = new Uint8Array(encryptedBuffer);
-    const decrypted = await platformAdapter.crypto.decryptWithPassword(
-      encryptedArray,
-      walletSignature
-    );
-    return new Blob([decrypted], { type: "text/plain" });
-  } catch (error) {
-    throw new Error(`Failed to decrypt user data: ${error}`);
+    throw new Error(`Failed to encrypt data: ${error}`);
   }
 }
 async function generateEncryptionKeyPair(platformAdapter) {
@@ -36024,13 +35246,315 @@ async function generatePGPKeyPair(platformAdapter, options) {
     throw new Error(`Failed to generate PGP key pair: ${error}`);
   }
 }
+async function decryptBlobWithSignedKey(encryptedData, key, platformAdapter) {
+  try {
+    const encryptedBuffer = encryptedData instanceof Blob ? await encryptedData.arrayBuffer() : new TextEncoder().encode(encryptedData);
+    const encryptedArray = new Uint8Array(encryptedBuffer);
+    const decrypted = await platformAdapter.crypto.decryptWithPassword(
+      encryptedArray,
+      key
+    );
+    return new Blob([decrypted], { type: "text/plain" });
+  } catch (error) {
+    throw new Error(`Failed to decrypt data: ${error}`);
+  }
+}
 
 // src/controllers/data.ts
 var DataController = class {
   constructor(context) {
     this.context = context;
-    __publicField(this, "serverController");
-    this.serverController = new ServerController(context);
+  }
+  async upload(params) {
+    const {
+      content,
+      filename,
+      schemaId,
+      permissions = [],
+      encrypt: encrypt2 = true,
+      providerName
+    } = params;
+    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) {
+        blob = new Blob([content], { type: "application/octet-stream" });
+      } else {
+        blob = new Blob([JSON.stringify(content)], {
+          type: "application/json"
+        });
+      }
+      let isValid = true;
+      let validationErrors = [];
+      if (schemaId !== void 0) {
+        try {
+          const schema = await this.getSchema(schemaId);
+          const response = await fetch(schema.definitionUrl);
+          if (!response.ok) {
+            throw new Error(
+              `Failed to fetch schema definition: ${response.status}`
+            );
+          }
+          const schemaDefinition = await response.json();
+          const dataSchema = {
+            name: schema.name,
+            version: "1.0.0",
+            dialect: "json",
+            schema: schemaDefinition
+          };
+          let parsedContent;
+          if (typeof content === "string") {
+            try {
+              parsedContent = JSON.parse(content);
+            } catch {
+              parsedContent = content;
+            }
+          } else {
+            parsedContent = content;
+          }
+          validateDataAgainstSchema(parsedContent, dataSchema);
+        } catch (error) {
+          isValid = false;
+          validationErrors = [
+            error instanceof Error ? error.message : "Schema validation failed"
+          ];
+        }
+      }
+      let finalBlob = blob;
+      if (encrypt2) {
+        const encryptionKey = await generateEncryptionKey(
+          this.context.walletClient,
+          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 uploadResult = await this.context.storageManager.upload(
+        finalBlob,
+        filename,
+        providerName
+      );
+      const userAddress = await this.getUserAddress();
+      let encryptedPermissions = [];
+      if (permissions.length > 0 && encrypt2) {
+        const userEncryptionKey = await generateEncryptionKey(
+          this.context.walletClient,
+          DEFAULT_ENCRYPTION_SEED
+        );
+        encryptedPermissions = await Promise.all(
+          permissions.map(async (permission) => {
+            const publicKey = permission.publicKey;
+            if (!publicKey) {
+              throw new Error(
+                `Public key required for permission to ${permission.grantee} when encryption is enabled`
+              );
+            }
+            const encryptedKey = await encryptWithWalletPublicKey(
+              userEncryptionKey,
+              publicKey,
+              this.context.platform
+            );
+            return {
+              account: permission.grantee,
+              key: encryptedKey
+            };
+          })
+        );
+      }
+      let result;
+      if (this.context.relayerCallbacks?.submitFileAdditionComplete) {
+        result = await this.context.relayerCallbacks.submitFileAdditionComplete(
+          {
+            url: uploadResult.url,
+            userAddress,
+            permissions: encryptedPermissions,
+            schemaId: schemaId || 0
+          }
+        );
+      } else if (this.context.relayerCallbacks?.submitFileAddition) {
+        const needsComplexRegistration = schemaId !== void 0 || encryptedPermissions.length > 0;
+        if (needsComplexRegistration) {
+          throw new Error(
+            "The configured relay callback does not support schemas or permissions. Please update your relay server implementation to provide the `submitFileAdditionComplete` callback."
+          );
+        }
+        result = await this.context.relayerCallbacks.submitFileAddition(
+          uploadResult.url,
+          userAddress
+        );
+      } else {
+        result = await this.addFileWithPermissionsAndSchema(
+          uploadResult.url,
+          userAddress,
+          encryptedPermissions,
+          schemaId || 0
+        );
+      }
+      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"}`
+      );
+    }
+  }
+  /**
+   * Decrypts a file owned by the user using their wallet signature.
+   *
+   * @remarks
+   * This is the high-level convenience method for decrypting user files, serving as the
+   * symmetrical counterpart to the `upload` method. It handles the complete decryption
+   * workflow including key generation, URL protocol detection, content fetching, and
+   * decryption.
+   *
+   * The method automatically:
+   * - Generates the decryption key from the user's wallet signature
+   * - Determines the appropriate fetch method based on the file URL protocol
+   * - Fetches the encrypted content from IPFS or standard HTTP URLs
+   * - Decrypts the content using the generated key
+   *
+   * For IPFS URLs, the method uses gateway fallback for improved reliability. For
+   * standard HTTP URLs, it uses a simple fetch. If you need custom authentication
+   * headers or specific gateway configurations, use the low-level primitives directly.
+   *
+   * @param file - The user file to decrypt (typically from getUserFiles)
+   * @param encryptionSeed - Optional custom encryption seed (defaults to Vana standard)
+   * @returns Promise resolving to the decrypted file content as a Blob
+   * @throws {Error} When the wallet is not connected
+   * @throws {Error} When fetching the encrypted content fails
+   * @throws {Error} When decryption fails (wrong key or corrupted data)
+   * @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, encryptionSeed) {
+    try {
+      const encryptionKey = await generateEncryptionKey(
+        this.context.walletClient,
+        encryptionSeed || 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 data files owned by a specific user address.
@@ -36615,6 +36139,7 @@ var DataController = class {
   /**
    * Uploads an encrypted file to storage and registers it on the blockchain.
    *
+   * @deprecated Use vana.data.upload() instead for the high-level API with automatic encryption
    * @param encryptedFile - The encrypted file blob to upload
    * @param filename - Optional filename for the upload
    * @param providerName - Optional storage provider to use
@@ -36702,6 +36227,7 @@ var DataController = class {
   /**
    * Uploads an encrypted file to storage and registers it on the blockchain with a schema.
    *
+   * @deprecated Use vana.data.upload() instead for the high-level API with automatic encryption and schema validation
    * @param encryptedFile - The encrypted file blob to upload
    * @param schemaId - The schema ID to associate with the file
    * @param filename - Optional filename for the upload
@@ -36780,81 +36306,6 @@ var DataController = class {
       );
     }
   }
-  /**
-   * Decrypts a file that was encrypted using the Vana protocol.
-   *
-   * @param file - The UserFile object containing the file URL and metadata
-   * @param encryptionSeed - Optional custom encryption seed (defaults to Vana standard)
-   * @returns Promise resolving to the decrypted file as a Blob
-   *
-   * This method handles the complete flow of:
-   * 1. Generating the encryption key from the user's wallet signature
-   * 2. Fetching the encrypted file from the stored URL
-   * 3. Decrypting the file using the canonical Vana decryption method
-   */
-  async decryptFile(file, encryptionSeed = DEFAULT_ENCRYPTION_SEED) {
-    try {
-      const encryptionKey = await generateEncryptionKey(
-        this.context.walletClient,
-        encryptionSeed
-      );
-      const fetchUrl = this.convertToDownloadUrl(file.url);
-      console.debug(
-        `Fetching encrypted file from URL: ${fetchUrl} (original: ${file.url})`
-      );
-      const response = await fetch(fetchUrl);
-      if (!response.ok) {
-        if (response.status === 404) {
-          throw new Error(
-            "File not found. The encrypted file may have been moved or deleted."
-          );
-        } else if (response.status === 403) {
-          throw new Error(
-            "Access denied. You may not have permission to access this file."
-          );
-        } else {
-          throw new Error(
-            `Network error: ${response.status} ${response.statusText}`
-          );
-        }
-      }
-      const encryptedBlob = await response.blob();
-      console.debug(
-        `Retrieved blob of size: ${encryptedBlob.size} bytes, type: ${encryptedBlob.type}`
-      );
-      if (encryptedBlob.size === 0) {
-        throw new Error("File is empty or could not be retrieved.");
-      }
-      const decryptedBlob = await decryptUserData(
-        encryptedBlob,
-        encryptionKey,
-        this.context.platform
-      );
-      return decryptedBlob;
-    } catch (error) {
-      console.error("Failed to decrypt file:", error);
-      if (error instanceof Error) {
-        if (error.message.includes("Session key decryption failed") || error.message.includes("Error decrypting message")) {
-          throw new Error(
-            "Wrong encryption key. This file may have been encrypted with a different wallet or encryption seed. Try using the same wallet that originally encrypted this file."
-          );
-        } else if (error.message.includes("Failed to fetch") || error.message.includes("Network error")) {
-          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 (error.message.includes("File not found")) {
-          throw new Error(
-            "File not found: The encrypted file is no longer available at the stored URL."
-          );
-        } else if (error.message.includes("not a valid OpenPGP message") || error.message.includes("does not conform to a valid OpenPGP format")) {
-          throw new Error(
-            "Invalid file format: This file doesn't appear to be encrypted with the Vana protocol."
-          );
-        }
-      }
-      throw error;
-    }
-  }
   /**
    * Registers a file URL directly on the blockchain with a schema ID.
    *
@@ -36915,26 +36366,6 @@ var DataController = class {
       );
     }
   }
-  /**
-   * Converts IPFS and Google Drive URLs to direct download URLs for fetching.
-   *
-   * @param url - The URL to convert to a direct download URL
-   * @returns The converted direct download URL or the original URL if not a special URL
-   */
-  convertToDownloadUrl(url) {
-    if (url.startsWith("ipfs://")) {
-      const hash = url.replace("ipfs://", "");
-      return `https://ipfs.io/ipfs/${hash}`;
-    }
-    if (url.includes("drive.google.com/file/d/")) {
-      const fileIdMatch = url.match(/\/file\/d\/([a-zA-Z0-9-_]+)/);
-      if (fileIdMatch) {
-        const fileId = fileIdMatch[1];
-        return `https://drive.google.com/uc?id=${fileId}&export=download`;
-      }
-    }
-    return url;
-  }
   /**
    * Gets the user's address from the wallet client.
    *
@@ -37009,9 +36440,70 @@ var DataController = class {
       );
     }
   }
+  /**
+   * Adds a file to the registry with permissions and schema.
+   * This combines the functionality of addFileWithPermissions and schema validation.
+   *
+   * @param url - The URL of the file to register
+   * @param ownerAddress - The address of the file owner
+   * @param permissions - Array of permissions to grant (account and encrypted key)
+   * @param schemaId - The schema ID to associate with the file (0 for no schema)
+   * @returns Promise resolving to object with fileId and transactionHash
+   */
+  async addFileWithPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0) {
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const txHash = await this.context.walletClient.writeContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        functionName: "addFileWithPermissionsAndSchema",
+        args: [url, ownerAddress, permissions, BigInt(schemaId)],
+        account: this.context.walletClient.account || ownerAddress,
+        chain: this.context.walletClient.chain || null
+      });
+      const receipt = await this.context.publicClient.waitForTransactionReceipt(
+        {
+          hash: txHash,
+          timeout: 3e4
+          // 30 seconds timeout
+        }
+      );
+      let fileId = 0;
+      for (const log of receipt.logs) {
+        try {
+          const decoded = decodeEventLog({
+            abi: dataRegistryAbi,
+            data: log.data,
+            topics: log.topics
+          });
+          if (decoded.eventName === "FileAdded") {
+            fileId = Number(decoded.args.fileId);
+            break;
+          }
+        } catch {
+          continue;
+        }
+      }
+      return {
+        fileId,
+        transactionHash: txHash
+      };
+    } 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 new schema to the DataRefinerRegistry.
    *
+   * @deprecated Use vana.schemas.create() instead for the high-level API with automatic IPFS upload
    * @param params - Schema parameters including name, type, and definition URL
    * @returns Promise resolving to the new schema ID and transaction hash
    */
@@ -37070,6 +36562,7 @@ var DataController = class {
   /**
    * Retrieves a schema by its ID.
    *
+   * @deprecated Use vana.schemas.get() instead
    * @param schemaId - The schema ID to retrieve
    * @returns Promise resolving to the schema information
    */
@@ -37095,11 +36588,15 @@ var DataController = class {
       if (!schemaData) {
         throw new Error("Schema not found");
       }
+      const schemaObj = schemaData;
+      if (!schemaObj.name || !schemaObj.typ || !schemaObj.definitionUrl) {
+        throw new Error("Incomplete schema data");
+      }
       return {
         id: schemaId,
-        name: schemaData.name,
-        type: schemaData.typ,
-        definitionUrl: schemaData.definitionUrl
+        name: schemaObj.name,
+        type: schemaObj.typ,
+        definitionUrl: schemaObj.definitionUrl
       };
     } catch (error) {
       console.error("Failed to get schema:", error);
@@ -37111,6 +36608,7 @@ var DataController = class {
   /**
    * Gets the total number of schemas in the registry.
    *
+   * @deprecated Use vana.schemas.count() instead
    * @returns Promise resolving to the total schema count
    */
   async getSchemasCount() {
@@ -37156,7 +36654,7 @@ var DataController = class {
       const txHash = await this.context.walletClient.writeContract({
         address: dataRefinerRegistryAddress,
         abi: dataRefinerRegistryAbi,
-        functionName: "addRefiner",
+        functionName: "addRefinerWithSchemaId",
         args: [
           BigInt(params.dlpId),
           params.name,
@@ -37361,7 +36859,7 @@ var DataController = class {
         this.context.walletClient,
         DEFAULT_ENCRYPTION_SEED
       );
-      const encryptedData = await encryptUserData(
+      const encryptedData = await encryptBlobWithSignedKey(
         data,
         userEncryptionKey,
         this.context.platform
@@ -37495,25 +36993,6 @@ var DataController = class {
       );
     }
   }
-  /**
-   * Gets the trusted server public key for a given server address.
-   * This method reads from the permissions contract to find servers and their public keys.
-   *
-   * @param serverAddress - The address of the trusted server
-   * @returns Promise resolving to the server's public key
-   */
-  async getTrustedServerPublicKey(serverAddress) {
-    try {
-      return await this.serverController.getTrustedServerPublicKey(
-        serverAddress
-      );
-    } catch (error) {
-      console.error("Failed to get trusted server public key:", error);
-      throw new Error(
-        `Failed to get trusted server public key: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
   /**
    * Decrypts a file that the user has permission to access using their private key.
    *
@@ -37544,12 +37023,13 @@ var DataController = class {
         privateKey,
         this.context.platform
       );
-      const response = await fetch(this.convertToDownloadUrl(file.url));
-      if (!response.ok) {
-        throw new Error(`Failed to download file: ${response.statusText}`);
+      let encryptedData;
+      if (file.url.startsWith("ipfs://")) {
+        encryptedData = await this.fetchFromIPFS(file.url);
+      } else {
+        encryptedData = await this.fetch(file.url);
       }
-      const encryptedData = await response.blob();
-      const decryptedData = await decryptUserData(
+      const decryptedData = await decryptBlobWithSignedKey(
         encryptedData,
         userEncryptionKey,
         this.context.platform
@@ -37562,6 +37042,162 @@ var DataController = class {
       );
     }
   }
+  /**
+   * 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} When the fetch fails or returns a non-ok response
+   *
+   * @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 response = await fetch(url);
+      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} When all gateways fail to fetch the content
+   *
+   * @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;
+    let cid;
+    if (url.startsWith("ipfs://")) {
+      cid = url.replace("ipfs://", "");
+    } else if (url.startsWith("Qm") || url.startsWith("bafy")) {
+      cid = url;
+    } else {
+      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"
+        });
+      }
+    }
+    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 against the Vana meta-schema.
    *
@@ -37683,9 +37319,589 @@ var DataController = class {
   }
 };
 
+// src/controllers/schemas.ts
+import { getContract as getContract2, decodeEventLog as decodeEventLog2 } from "viem";
+var SchemaController = class {
+  constructor(context) {
+    this.context = context;
+  }
+  /**
+   * Creates a new schema with automatic validation and IPFS upload.
+   *
+   * @remarks
+   * This is the primary method for creating schemas on the Vana network. It handles
+   * the complete workflow including schema validation, IPFS upload, and blockchain
+   * registration. The schema definition is stored unencrypted on IPFS to enable
+   * public access and reusability.
+   *
+   * The method automatically:
+   * - Validates the schema definition against the Vana metaschema
+   * - Uploads the definition to IPFS to generate a permanent URL
+   * - Registers the schema on the blockchain with the generated URL
+   *
+   * @param params - Schema creation parameters including name, type, and definition
+   * @returns Promise resolving to creation results with schema ID and transaction hash
+   * @throws {SchemaValidationError} When the schema definition is invalid
+   * @throws {Error} When IPFS upload or blockchain registration fails
+   * @example
+   * ```typescript
+   * // Create a JSON schema for user profiles
+   * const result = await vana.schemas.create({
+   *   name: "User Profile",
+   *   type: "personal",
+   *   definition: {
+   *     type: "object",
+   *     properties: {
+   *       name: { type: "string" },
+   *       age: { type: "number", minimum: 0 }
+   *     },
+   *     required: ["name"]
+   *   }
+   * });
+   *
+   * console.log(`Schema created with ID: ${result.schemaId}`);
+   * ```
+   */
+  async create(params) {
+    const { name, type, definition } = params;
+    try {
+      let schemaDefinition;
+      if (typeof definition === "string") {
+        try {
+          schemaDefinition = JSON.parse(definition);
+        } catch {
+          throw new SchemaValidationError(
+            "Invalid JSON in schema definition",
+            []
+          );
+        }
+      } else {
+        schemaDefinition = definition;
+      }
+      const dataSchema = {
+        name,
+        version: "1.0.0",
+        dialect: "json",
+        schema: schemaDefinition
+      };
+      validateDataSchema(dataSchema);
+      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 schemaBlob = new Blob([JSON.stringify(schemaDefinition)], {
+        type: "application/json"
+      });
+      const uploadResult = await this.context.storageManager.upload(
+        schemaBlob,
+        `${name.replace(/[^a-zA-Z0-9]/g, "_")}.json`,
+        "ipfs"
+        // Use IPFS for public schema storage
+      );
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const userAddress = await this.getUserAddress();
+      const txHash = await this.context.walletClient.writeContract({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        functionName: "addSchema",
+        args: [name, type, uploadResult.url],
+        account: this.context.walletClient.account || userAddress,
+        chain: this.context.walletClient.chain || null
+      });
+      const receipt = await this.context.publicClient.waitForTransactionReceipt(
+        {
+          hash: txHash,
+          timeout: 3e4
+          // 30 seconds timeout
+        }
+      );
+      let schemaId = 0;
+      for (const log of receipt.logs) {
+        try {
+          const decoded = decodeEventLog2({
+            abi: dataRefinerRegistryAbi,
+            data: log.data,
+            topics: log.topics
+          });
+          if (decoded.eventName === "SchemaAdded") {
+            schemaId = Number(decoded.args.schemaId);
+            break;
+          }
+        } catch {
+        }
+      }
+      return {
+        schemaId,
+        definitionUrl: uploadResult.url,
+        transactionHash: txHash
+      };
+    } catch (error) {
+      if (error instanceof SchemaValidationError) {
+        throw error;
+      }
+      throw new Error(
+        `Schema creation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Retrieves a schema by its ID.
+   *
+   * @param schemaId - The ID of the schema to retrieve
+   * @returns Promise resolving to the schema object
+   * @throws {Error} When the schema is not found or chain is unavailable
+   * @example
+   * ```typescript
+   * const schema = await vana.schemas.get(1);
+   * console.log(`Schema: ${schema.name} (${schema.type})`);
+   * ```
+   */
+  async get(schemaId) {
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const dataRefinerRegistry = getContract2({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        client: this.context.publicClient
+      });
+      const schemaData = await dataRefinerRegistry.read.schemas([
+        BigInt(schemaId)
+      ]);
+      if (!schemaData) {
+        throw new Error(`Schema with ID ${schemaId} not found`);
+      }
+      const schemaObj = schemaData;
+      if (!schemaObj.name || !schemaObj.typ || !schemaObj.definitionUrl) {
+        throw new Error("Incomplete schema data");
+      }
+      return {
+        id: schemaId,
+        name: schemaObj.name,
+        type: schemaObj.typ,
+        definitionUrl: schemaObj.definitionUrl
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get schema: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Gets the total number of schemas registered on the network.
+   *
+   * @returns Promise resolving to the total schema count
+   * @throws {Error} When the count cannot be retrieved
+   * @example
+   * ```typescript
+   * const count = await vana.schemas.count();
+   * console.log(`Total schemas: ${count}`);
+   * ```
+   */
+  async count() {
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const dataRefinerRegistry = getContract2({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        client: this.context.publicClient
+      });
+      const count = await dataRefinerRegistry.read.schemasCount();
+      return Number(count);
+    } catch (error) {
+      throw new Error(
+        `Failed to get schemas count: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Lists all schemas with pagination.
+   *
+   * @param options - Optional parameters for listing schemas
+   * @param options.limit - Maximum number of schemas to return
+   * @param options.offset - Number of schemas to skip
+   * @returns Promise resolving to an array of schemas
+   * @example
+   * ```typescript
+   * // Get all schemas
+   * const schemas = await vana.schemas.list();
+   *
+   * // Get schemas with pagination
+   * const schemas = await vana.schemas.list({ limit: 10, offset: 0 });
+   * ```
+   */
+  async list(options = {}) {
+    const { limit = 100, offset = 0 } = options;
+    try {
+      const totalCount = await this.count();
+      const schemas = [];
+      const start = offset;
+      const end = Math.min(start + limit, totalCount);
+      for (let i = start; i < end; i++) {
+        try {
+          const schema = await this.get(i + 1);
+          schemas.push(schema);
+        } catch (error) {
+          console.warn(`Failed to retrieve schema ${i + 1}:`, error);
+        }
+      }
+      return schemas;
+    } catch (error) {
+      throw new Error(
+        `Failed to list schemas: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Adds a schema using the legacy method (low-level API).
+   *
+   * @deprecated Use create() instead for the high-level API with automatic IPFS upload
+   * @param params - Schema parameters including pre-generated definition URL
+   * @returns Promise resolving to the add schema result
+   */
+  async addSchema(params) {
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const userAddress = await this.getUserAddress();
+      const txHash = await this.context.walletClient.writeContract({
+        address: dataRefinerRegistryAddress,
+        abi: dataRefinerRegistryAbi,
+        functionName: "addSchema",
+        args: [params.name, params.type, params.definitionUrl],
+        account: this.context.walletClient.account || userAddress,
+        chain: this.context.walletClient.chain || null
+      });
+      return {
+        schemaId: 0,
+        // TODO: Parse from transaction receipt
+        transactionHash: txHash
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to add schema: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Gets the user's wallet address.
+   *
+   * @private
+   * @returns Promise resolving to the user's address
+   */
+  async getUserAddress() {
+    if (!this.context.walletClient.account) {
+      throw new Error("No wallet account connected");
+    }
+    if (typeof this.context.walletClient.account === "string") {
+      return this.context.walletClient.account;
+    }
+    if (typeof this.context.walletClient.account === "object" && this.context.walletClient.account.address) {
+      return this.context.walletClient.account.address;
+    }
+    throw new Error("Unable to determine wallet address");
+  }
+};
+
+// src/controllers/server.ts
+var ServerController = class {
+  constructor(context) {
+    this.context = context;
+    __publicField(this, "PERSONAL_SERVER_BASE_URL", process.env.NEXT_PUBLIC_PERSONAL_SERVER_BASE_URL);
+  }
+  async getIdentity(request) {
+    try {
+      const response = await fetch(
+        `${this.PERSONAL_SERVER_BASE_URL}/identity?address=${request.userAddress}`,
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      console.debug("\u{1F50D} Debug - getIdentity response", response);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new NetworkError(
+          `Local identity API request failed: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      const serverResponse = await response.json();
+      return {
+        kind: serverResponse.personal_server.kind,
+        address: serverResponse.personal_server.address,
+        public_key: serverResponse.personal_server.public_key,
+        base_url: this.PERSONAL_SERVER_BASE_URL || "",
+        name: "Hosted Vana Server"
+      };
+    } catch (error) {
+      if (error instanceof NetworkError || error instanceof PersonalServerError) {
+        throw error;
+      }
+      throw new PersonalServerError(
+        `Failed to get personal server identity: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Creates an operation via the personal server API.
+   *
+   * @remarks
+   * This method submits a computation request to the personal server API.
+   * The response includes the operation ID.
+   * @param params - The request parameters object
+   * @param params.permissionId - The permission ID authorizing this operation
+   * @returns A Promise that resolves to an operation response with status and control URLs
+   * @throws {PersonalServerError} When 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,
+   * });
+   *
+   * console.log(`Operation created: ${response.id}`);
+   * ```
+   */
+  async createOperation(params) {
+    try {
+      const requestData = {
+        permission_id: params.permissionId
+      };
+      const requestJson = JSON.stringify(requestData);
+      const signature = await this.createSignature(requestJson);
+      const requestBody = {
+        app_signature: signature,
+        operation_request_json: requestJson
+      };
+      console.debug("\u{1F50D} Debug - createOperation requestBody", requestBody);
+      const response = await this.makeRequest(requestBody);
+      return response;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error instanceof NetworkError || error instanceof SerializationError || error instanceof SignatureError || error instanceof PersonalServerError) {
+          throw error;
+        }
+        throw new PersonalServerError(
+          `Personal server operation creation failed: ${error.message}`,
+          error
+        );
+      }
+      throw new PersonalServerError(
+        "Personal server operation creation failed with unknown error"
+      );
+    }
+  }
+  /**
+   * Polls the status of a computation request for updates and results.
+   *
+   * @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
+   * @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);
+   * }
+   * ```
+   */
+  async getOperation(operationId) {
+    try {
+      console.debug("Polling Operation Status:", operationId);
+      const response = await fetch(
+        `${this.PERSONAL_SERVER_BASE_URL}/operations/${operationId}`,
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.debug("Polling Error Response:", {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText
+        });
+        throw new NetworkError(
+          `Status polling failed: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      const data = await response.json();
+      console.debug("Polling Success Response:", data);
+      return data;
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError(
+        `Failed to poll status: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  async cancelOperation(operationId) {
+    try {
+      const response = await fetch(
+        `${this.PERSONAL_SERVER_BASE_URL}/operations/${operationId}/cancel`,
+        {
+          method: "POST"
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new PersonalServerError(
+          `Failed to cancel operation: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError(
+        `Failed to cancel operation: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Makes the request to the personal server API.
+   *
+   * @param requestBody - The post request parameters to serialize
+   * @returns JSON string representation of the request data
+   */
+  async makeRequest(requestBody) {
+    try {
+      console.debug("Personal Server Request:", {
+        url: `${this.PERSONAL_SERVER_BASE_URL}/operations`,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: requestBody
+      });
+      const response = await fetch(
+        `${this.PERSONAL_SERVER_BASE_URL}/operations`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(requestBody)
+        }
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.debug("Personal Server Error Response:", {
+          status: response.status,
+          statusText: response.statusText,
+          error: errorText
+        });
+        throw new NetworkError(
+          `Personal server API request failed: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      const data = await response.json();
+      console.debug("Personal Server Success Response:", data);
+      return data;
+    } catch (error) {
+      if (error instanceof NetworkError) {
+        throw error;
+      }
+      throw new NetworkError(
+        `Failed to make personal server API request: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Creates a signature for the request JSON.
+   *
+   * @param requestJson - The JSON string to sign
+   * @returns Promise resolving to the cryptographic signature
+   */
+  async createSignature(requestJson) {
+    try {
+      console.debug("\u{1F50D} Debug - createSignature", requestJson);
+      const client = this.context.applicationClient || this.context.walletClient;
+      const account = client.account;
+      if (!account) {
+        throw new SignatureError("No account available for signing");
+      }
+      if (account.type !== "local") {
+        throw new SignatureError(
+          "Only local accounts are supported for signing"
+        );
+      }
+      console.debug("\u{1F50D} Debug - createSignature account", account);
+      const signature = await account.signMessage({
+        message: requestJson
+      });
+      return signature;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("User rejected")) {
+        throw new SignatureError("User rejected the signature request");
+      }
+      throw new SignatureError(
+        `Failed to create signature: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+};
+
 // src/contracts/contractController.ts
 import {
-  getContract as getContract2
+  getContract as getContract3
 } from "viem";
 
 // src/core/client.ts
@@ -37786,7 +38002,7 @@ function getContractController(contract, client = createClient()) {
   const cacheKey = createCacheKey(contract, chainId);
   let controller = contractCache.get(cacheKey);
   if (!controller) {
-    controller = getContract2({
+    controller = getContract3({
       address: getContractAddress(chainId, contract),
       abi: getAbi(contract),
       client
@@ -39445,7 +39661,7 @@ var moksha = {
       url: "https://moksha.vanascan.io"
     }
   },
-  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/7.0.4/gn"
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/7.0.3/gn"
 };
 function getChainConfig(chainId) {
   switch (chainId) {
@@ -39457,11 +39673,53 @@ function getChainConfig(chainId) {
       return void 0;
   }
 }
+var mokshaTestnet2 = moksha;
 function getAllChains() {
   return [vanaMainnet2, moksha];
 }
 
 // src/core.ts
+var VanaCoreFactory = class {
+  /**
+   * Creates a VanaCore instance that enforces storage requirements at compile time.
+   * Use this factory when you know you'll need storage-dependent operations.
+   *
+   * @param platform - The platform adapter for environment-specific operations
+   * @param config - Configuration that includes required storage providers
+   * @returns VanaCore instance with storage validation
+   * @example
+   * ```typescript
+   * const vanaCore = VanaCoreFactory.createWithStorage(platformAdapter, {
+   *   walletClient: myWalletClient,
+   *   storage: {
+   *     providers: { ipfs: new IPFSStorage() },
+   *     defaultProvider: 'ipfs'
+   *   }
+   * });
+   * ```
+   */
+  static createWithStorage(platform, config) {
+    const core = new VanaCore(platform, config);
+    return core;
+  }
+  /**
+   * Creates a VanaCore instance without storage requirements.
+   * Storage-dependent operations will fail at runtime if not configured.
+   *
+   * @param platform - The platform adapter for environment-specific operations
+   * @param config - Basic configuration without required storage
+   * @returns VanaCore instance
+   * @example
+   * ```typescript
+   * const vanaCore = VanaCoreFactory.create(platformAdapter, {
+   *   walletClient: myWalletClient
+   * });
+   * ```
+   */
+  static create(platform, config) {
+    return new VanaCore(platform, config);
+  }
+};
 var VanaCore = class {
   /**
    * Initializes a new VanaCore client instance with the provided configuration.
@@ -39469,6 +39727,10 @@ var VanaCore = class {
    * @remarks
    * The constructor validates the configuration, initializes storage providers if configured,
    * creates wallet and public clients, and sets up all SDK controllers with shared context.
+   *
+   * IMPORTANT: This constructor will validate storage requirements at runtime to fail fast.
+   * Methods that require storage will throw runtime errors if storage is not configured.
+   *
    * @param platform - The platform adapter for environment-specific operations
    * @param config - The configuration object specifying wallet or chain settings
    * @throws {InvalidConfigurationError} When the configuration is invalid or incomplete
@@ -39483,8 +39745,10 @@ var VanaCore = class {
   constructor(platform, config) {
     /** Manages gasless data access permissions and trusted server registry. */
     __publicField(this, "permissions");
-    /** Handles user data file operations and schema management. */
+    /** Handles user data file operations. */
     __publicField(this, "data");
+    /** Manages data schemas and refiners. */
+    __publicField(this, "schemas");
     /** Provides personal server setup and trusted server interactions. */
     __publicField(this, "server");
     /** Offers low-level access to Vana protocol smart contracts. */
@@ -39493,9 +39757,13 @@ var VanaCore = class {
     __publicField(this, "platform");
     __publicField(this, "relayerCallbacks");
     __publicField(this, "storageManager");
+    __publicField(this, "hasRequiredStorage");
+    __publicField(this, "ipfsGateways");
     this.platform = platform;
     this.validateConfig(config);
     this.relayerCallbacks = config.relayerCallbacks;
+    this.ipfsGateways = config.ipfsGateways;
+    this.hasRequiredStorage = hasStorageConfig(config);
     if (config.storage?.providers) {
       this.storageManager = new StorageManager();
       for (const [name, provider] of Object.entries(config.storage.providers)) {
@@ -39550,14 +39818,70 @@ var VanaCore = class {
       relayerCallbacks: this.relayerCallbacks,
       storageManager: this.storageManager,
       subgraphUrl,
-      platform: this.platform
+      platform: this.platform,
       // Pass the platform adapter to controllers
+      validateStorageRequired: this.validateStorageRequired.bind(this),
+      hasStorage: this.hasStorage.bind(this),
+      ipfsGateways: this.ipfsGateways
     };
     this.permissions = new PermissionsController(sharedContext);
     this.data = new DataController(sharedContext);
+    this.schemas = new SchemaController(sharedContext);
     this.server = new ServerController(sharedContext);
     this.protocol = new ProtocolController(sharedContext);
   }
+  /**
+   * Validates that storage is available for storage-dependent operations.
+   * This method enforces the fail-fast principle by checking storage availability
+   * at method call time rather than during expensive operations.
+   *
+   * @throws {InvalidConfigurationError} When storage is required but not configured
+   * @example
+   * ```typescript
+   * // This will throw if storage is not configured
+   * vana.validateStorageRequired();
+   * await vana.data.uploadFile(file); // Safe to proceed
+   * ```
+   */
+  validateStorageRequired() {
+    if (!this.hasRequiredStorage) {
+      throw new InvalidConfigurationError(
+        "Storage configuration is required for this operation. Please configure storage providers in VanaConfig.storage, provide a relayerCallbacks.storeGrantFile implementation, or pass pre-stored URLs to avoid this dependency. \n\nFor better type safety, consider using VanaCoreFactory.createWithStorage() with VanaConfigWithStorage to catch this error at compile time."
+      );
+    }
+  }
+  /**
+   * Checks whether storage is configured without throwing an error.
+   *
+   * @returns True if storage is properly configured
+   * @example
+   * ```typescript
+   * if (vana.hasStorage()) {
+   *   await vana.data.uploadFile(file);
+   * } else {
+   *   console.warn('Storage not configured - using pre-stored URLs only');
+   * }
+   * ```
+   */
+  hasStorage() {
+    return this.hasRequiredStorage;
+  }
+  /**
+   * Type guard to check if this instance has storage enabled at compile time.
+   * Use this when you need TypeScript to understand that storage is available.
+   *
+   * @returns True if storage is configured, with type narrowing
+   * @example
+   * ```typescript
+   * if (vana.isStorageEnabled()) {
+   *   // TypeScript knows storage is available here
+   *   await vana.data.uploadFile(file);
+   * }
+   * ```
+   */
+  isStorageEnabled() {
+    return this.hasRequiredStorage;
+  }
   /**
    * Validates the provided configuration object against all requirements.
    *
@@ -39746,23 +40070,23 @@ var VanaCore = class {
     return this.platform;
   }
   /**
-   * Encrypts user data using the Vana protocol standard encryption.
+   * Encrypts data using the Vana protocol standard encryption.
    * This method automatically uses the correct platform adapter for the current environment.
    *
    * @param data The data to encrypt (string or Blob)
-   * @param walletSignature The wallet signature to use as encryption key
+   * @param key The key to use as encryption key
    * @returns The encrypted data as Blob
    * @example
    * ```typescript
    * const encryptionKey = await generateEncryptionKey(walletClient);
-   * const encrypted = await vana.encryptUserData("sensitive data", encryptionKey);
+   * const encrypted = await vana.encryptBlob("sensitive data", encryptionKey);
    * ```
    */
-  async encryptUserData(data, walletSignature) {
-    return encryptUserData(data, walletSignature, this.platform);
+  async encryptBlob(data, key) {
+    return encryptBlobWithSignedKey(data, key, this.platform);
   }
   /**
-   * Decrypts user data using the Vana protocol standard decryption.
+   * Decrypts data that was encrypted using the Vana protocol.
    * This method automatically uses the correct platform adapter for the current environment.
    *
    * @param encryptedData The encrypted data (string or Blob)
@@ -39771,12 +40095,16 @@ var VanaCore = class {
    * @example
    * ```typescript
    * const encryptionKey = await generateEncryptionKey(walletClient);
-   * const decrypted = await vana.decryptUserData(encryptedData, encryptionKey);
+   * const decrypted = await vana.decryptBlob(encryptedData, encryptionKey);
    * const text = await decrypted.text();
    * ```
    */
-  async decryptUserData(encryptedData, walletSignature) {
-    return decryptUserData(encryptedData, walletSignature, this.platform);
+  async decryptBlob(encryptedData, walletSignature) {
+    return decryptBlobWithSignedKey(
+      encryptedData,
+      walletSignature,
+      this.platform
+    );
   }
 };
 
@@ -39807,7 +40135,7 @@ function createValidatedGrant(params) {
   try {
     validateGrant(grantFile, {
       schema: true,
-      grantee: params.to,
+      grantee: params.grantee,
       operation: params.operation
     });
   } catch (error) {
@@ -40564,25 +40892,15 @@ var ApiClient = class {
 };
 
 // src/index.browser.ts
-var VanaBrowser = class extends VanaCore {
-  /**
-   * Creates a Vana SDK instance configured for browser environments.
-   *
-   * @param config - SDK configuration object (wallet client or chain config)
-   * @example
-   * ```typescript
-   * // With wallet client
-   * const vana = new Vana({ walletClient });
-   *
-   * // With chain configuration
-   * const vana = new Vana({ chainId: 14800, account });
-   * ```
-   */
+var VanaBrowserImpl = class extends VanaCore {
   constructor(config) {
     super(new BrowserPlatformAdapter(), config);
   }
 };
-var index_browser_default = VanaBrowser;
+function Vana(config) {
+  return new VanaBrowserImpl(config);
+}
+var index_browser_default = Vana;
 export {
   ApiClient,
   AsyncQueue,
@@ -40627,8 +40945,10 @@ export {
   StorageError,
   StorageManager,
   UserRejectedRequestError,
-  VanaBrowser as Vana,
-  VanaBrowser,
+  Vana,
+  VanaBrowserImpl,
+  VanaCore,
+  VanaCoreFactory,
   VanaError,
   __contractCache,
   chains,
@@ -40641,13 +40961,13 @@ export {
   createGrantFile,
   createPlatformAdapterSafe,
   createValidatedGrant,
-  decryptUserData,
+  decryptBlobWithSignedKey,
   decryptWithPrivateKey,
   decryptWithWalletPrivateKey,
   index_browser_default as default,
   detectPlatform,
+  encryptBlobWithSignedKey,
   encryptFileKey,
-  encryptUserData,
   encryptWithWalletPublicKey,
   extractIpfsHash,
   fetchAndValidateSchema,
@@ -40671,13 +40991,11 @@ export {
   getPlatformCapabilities,
   isAPIResponse,
   isGrantExpired,
-  isIdentityServerOutput,
   isIpfsUrl,
-  isPersonalServerOutput,
   isPlatformSupported,
   isReplicateAPIResponse,
   moksha,
-  mokshaTestnet,
+  mokshaTestnet2 as mokshaTestnet,
   parseReplicateOutput,
   retrieveAndValidateGrant,
   retrieveGrantFile,
@@ -40693,6 +41011,6 @@ export {
   validateGrantFile,
   validateGranteeAccess,
   validateOperationAccess,
-  vanaMainnet
+  vanaMainnet2 as vanaMainnet
 };
 //# sourceMappingURL=index.browser.js.map