@opendatalabs/vana-sdk 0.1.0-alpha.c17525f → 0.1.0-alpha.cb72de2

package/dist/index.browser.js

@@ -29,10 +29,27 @@ function parseEncryptedDataBuffer(encryptedBuffer) {
     mac: encryptedBuffer.slice(-32)
   };
 }
-function uint8ArrayToHex(array) {
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join(
-    ""
-  );
+function toBase64(str) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "utf8").toString("base64");
+  } else if (typeof btoa !== "undefined") {
+    return btoa(str);
+  } else {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    let result = "";
+    let i = 0;
+    while (i < str.length) {
+      const a = str.charCodeAt(i++);
+      const b = i < str.length ? str.charCodeAt(i++) : 0;
+      const c = i < str.length ? str.charCodeAt(i++) : 0;
+      const bitmap = a << 16 | b << 8 | c;
+      result += chars.charAt(bitmap >> 18 & 63);
+      result += chars.charAt(bitmap >> 12 & 63);
+      result += i - 2 < str.length ? chars.charAt(bitmap >> 6 & 63) : "=";
+      result += i - 1 < str.length ? chars.charAt(bitmap & 63) : "=";
+    }
+    return result;
+  }
 }
 var init_crypto_utils = __esm({
   "src/platform/shared/crypto-utils.ts"() {
@@ -84,147 +101,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, BrowserCacheAdapter, 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 +163,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,
@@ -407,15 +280,62 @@ var init_browser = __esm({
         return fetch(url, options);
       }
     };
+    BrowserCacheAdapter = class {
+      constructor() {
+        __publicField(this, "prefix", "vana_cache_");
+      }
+      get(key) {
+        try {
+          if (typeof sessionStorage === "undefined") {
+            return null;
+          }
+          return sessionStorage.getItem(this.prefix + key);
+        } catch {
+          return null;
+        }
+      }
+      set(key, value) {
+        try {
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.setItem(this.prefix + key, value);
+          }
+        } catch {
+        }
+      }
+      delete(key) {
+        try {
+          if (typeof sessionStorage !== "undefined") {
+            sessionStorage.removeItem(this.prefix + key);
+          }
+        } catch {
+        }
+      }
+      clear() {
+        try {
+          if (typeof sessionStorage === "undefined") {
+            return;
+          }
+          const keys = Object.keys(sessionStorage);
+          for (const key of keys) {
+            if (key.startsWith(this.prefix)) {
+              sessionStorage.removeItem(key);
+            }
+          }
+        } catch {
+        }
+      }
+    };
     BrowserPlatformAdapter = class {
       constructor() {
         __publicField(this, "crypto");
         __publicField(this, "pgp");
         __publicField(this, "http");
+        __publicField(this, "cache");
         __publicField(this, "platform", "browser");
         this.crypto = new BrowserCryptoAdapter();
         this.pgp = new BrowserPGPAdapter();
         this.http = new BrowserHttpAdapter();
+        this.cache = new BrowserCacheAdapter();
       }
     };
     browserPlatformAdapter = new BrowserPlatformAdapter();
@@ -539,6 +459,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 +485,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 +558,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 +757,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;
@@ -995,276 +869,45 @@ var PermissionError = class extends VanaError {
   }
 };
 
-// src/config/addresses.ts
-var CONTRACTS = {
-  // Core Platform Contracts
-  DataPermissions: {
-    addresses: {
-      14800: "0x31fb1D48f6B2265A4cAD516BC39E96a18fb7c8de",
-      1480: "0x31fb1D48f6B2265A4cAD516BC39E96a18fb7c8de"
-    }
-  },
-  DataRegistry: {
-    addresses: {
-      14800: "0x8C8788f98385F6ba1adD4234e551ABba0f82Cb7C",
-      1480: "0x8C8788f98385F6ba1adD4234e551ABba0f82Cb7C"
-    }
-  },
-  TeePoolPhala: {
-    addresses: {
-      14800: "0xE8EC6BD73b23Ad40E6B9a6f4bD343FAc411bD99A",
-      1480: "0xE8EC6BD73b23Ad40E6B9a6f4bD343FAc411bD99A"
-    }
-  },
-  ComputeEngine: {
-    addresses: {
-      14800: "0xb2BFe33FA420c45F1Cf1287542ad81ae935447bd",
-      1480: "0xb2BFe33FA420c45F1Cf1287542ad81ae935447bd"
-    }
-  },
-  // Data Access Infrastructure
-  DataRefinerRegistry: {
-    addresses: {
-      14800: "0x93c3EF89369fDcf08Be159D9DeF0F18AB6Be008c",
-      1480: "0x93c3EF89369fDcf08Be159D9DeF0F18AB6Be008c"
-    }
-  },
-  QueryEngine: {
-    addresses: {
-      14800: "0xd25Eb66EA2452cf3238A2eC6C1FD1B7F5B320490",
-      1480: "0xd25Eb66EA2452cf3238A2eC6C1FD1B7F5B320490"
-    }
-  },
-  VanaTreasury: {
-    addresses: {
-      14800: "0x94a1E56e555ac48d092f490fB10CDFaB434915eD",
-      1480: "0x94a1E56e555ac48d092f490fB10CDFaB434915eD"
-    }
-  },
-  ComputeInstructionRegistry: {
-    addresses: {
-      14800: "0x5786B12b4c6Ba2bFAF0e77Ed30Bf6d32805563A5",
-      1480: "0x5786B12b4c6Ba2bFAF0e77Ed30Bf6d32805563A5"
-    }
-  },
-  // TEE Pool Variants
-  TeePoolEphemeralStandard: {
-    addresses: {
-      14800: "0xe124bae846D5ec157f75Bd9e68ca87C4d2AB835A",
-      1480: "0xe124bae846D5ec157f75Bd9e68ca87C4d2AB835A"
-    }
-  },
-  TeePoolPersistentStandard: {
-    addresses: {
-      14800: "0xe8bB8d0629651Cf33e0845d743976Dc1f0971d76",
-      1480: "0xe8bB8d0629651Cf33e0845d743976Dc1f0971d76"
-    }
-  },
-  TeePoolPersistentGpu: {
-    addresses: {
-      14800: "0x1c346Cd74f8551f8fa13f3F4b6b8dAE22338E6a9",
-      1480: "0x1c346Cd74f8551f8fa13f3F4b6b8dAE22338E6a9"
-    }
-  },
-  TeePoolDedicatedStandard: {
-    addresses: {
-      14800: "0xf024b7ac5E8417416f53B41ecfa58C8e9396687d",
-      1480: "0xf024b7ac5E8417416f53B41ecfa58C8e9396687d"
-    }
-  },
-  TeePoolDedicatedGpu: {
-    addresses: {
-      14800: "0xB1686FA9620bBf851714d1cB47b8a4Bf4664644E",
-      1480: "0xB1686FA9620bBf851714d1cB47b8a4Bf4664644E"
-    }
-  },
-  // DLP Reward System
-  VanaEpoch: {
-    addresses: {
-      14800: "0x2063cFF0609D59bCCc196E20Eb58A8696a6b15A0",
-      1480: "0x2063cFF0609D59bCCc196E20Eb58A8696a6b15A0"
-    }
-  },
-  DLPRegistry: {
-    addresses: {
-      14800: "0x4D59880a924526d1dD33260552Ff4328b1E18a43",
-      1480: "0x4D59880a924526d1dD33260552Ff4328b1E18a43"
-    }
-  },
-  DLPRegistryTreasury: {
-    addresses: {
-      14800: "0xb12ce1d27bEeFe39b6F0110b1AB77C21Aa0c9F9a",
-      1480: "0xb12ce1d27bEeFe39b6F0110b1AB77C21Aa0c9F9a"
-    }
-  },
-  DLPPerformance: {
-    addresses: {
-      14800: "0x847715C7DB37cF286611182Be0bD333cbfa29cc1",
-      1480: "0x847715C7DB37cF286611182Be0bD333cbfa29cc1"
-    }
-  },
-  DLPRewardDeployer: {
-    addresses: {
-      14800: "0xEFD0F9Ba9De70586b7c4189971cF754adC923B04",
-      1480: "0xEFD0F9Ba9De70586b7c4189971cF754adC923B04"
-    }
-  },
-  DLPRewardDeployerTreasury: {
-    addresses: {
-      14800: "0xb547ca8Fe4990fe330FeAeb1C2EBb42F925Af5b8",
-      1480: "0xb547ca8Fe4990fe330FeAeb1C2EBb42F925Af5b8"
-    }
-  },
-  DLPRewardSwap: {
-    addresses: {
-      14800: "0x7c6862C46830F0fc3bF3FF509EA1bD0EE7267fB0",
-      1480: "0x7c6862C46830F0fc3bF3FF509EA1bD0EE7267fB0"
-    }
-  },
-  SwapHelper: {
-    addresses: {
-      14800: "0x55D5e6F73326315bF2E091e97F04f0770e5C54e2",
-      1480: "0x55D5e6F73326315bF2E091e97F04f0770e5C54e2"
-    }
-  },
-  // VanaPool (Staking)
-  VanaPoolStaking: {
-    addresses: {
-      14800: "0x641C18E2F286c86f96CE95C8ec1EB9fC0415Ca0e",
-      1480: "0x641C18E2F286c86f96CE95C8ec1EB9fC0415Ca0e"
-    }
-  },
-  VanaPoolEntity: {
-    addresses: {
-      14800: "0x44f20490A82e1f1F1cC25Dd3BA8647034eDdce30",
-      1480: "0x44f20490A82e1f1F1cC25Dd3BA8647034eDdce30"
-    }
-  },
-  VanaPoolTreasury: {
-    addresses: {
-      14800: "0x143BE72CF2541604A7691933CAccd6D9cC17c003",
-      1480: "0x143BE72CF2541604A7691933CAccd6D9cC17c003"
-    }
-  },
-  // DLP Deployment Contracts
-  DAT: {
-    addresses: {
-      14800: "0xA706b93ccED89f13340673889e29F0a5cd84212d",
-      1480: "0xA706b93ccED89f13340673889e29F0a5cd84212d"
-    }
-  },
-  DATFactory: {
-    addresses: {
-      14800: "0x40f8bccF35a75ecef63BC3B1B3E06ffEB9220644",
-      1480: "0x40f8bccF35a75ecef63BC3B1B3E06ffEB9220644"
-    }
-  },
-  DATPausable: {
-    addresses: {
-      14800: "0xe69FE86f0B95cC2f8416Fe22815c85DC8887e76e",
-      1480: "0xe69FE86f0B95cC2f8416Fe22815c85DC8887e76e"
-    }
-  },
-  DATVotes: {
-    addresses: {
-      14800: "0xaE04c8A77E9B27869eb563720524A9aE0baf1831",
-      1480: "0xaE04c8A77E9B27869eb563720524A9aE0baf1831"
-    }
-  },
-  // Utility Contracts (no ABIs in SDK)
-  Multicall3: {
-    addresses: {
-      14800: "0xD8d2dFca27E8797fd779F8547166A2d3B29d360E",
-      1480: "0xD8d2dFca27E8797fd779F8547166A2d3B29d360E"
-    }
-  },
-  Multisend: {
-    addresses: {
-      14800: "0x8807e8BCDFbaA8c2761760f3FBA37F6f7F2C5b2d",
-      1480: "0x8807e8BCDFbaA8c2761760f3FBA37F6f7F2C5b2d"
-    }
-  }
-};
-var LEGACY_CONTRACTS = {
-  // DEPRECATED: Original Intel SGX TeePool (PRO-347)
-  TeePool: {
-    addresses: {
-      14800: "0x3c92fD91639b41f13338CE62f19131e7d19eaa0D",
-      1480: "0x3c92fD91639b41f13338CE62f19131e7d19eaa0D"
-    }
-  },
-  // DEPRECATED: DLPRoot system (replaced by VanaPool + DLPRewards)
-  DLPRootEpoch: {
-    addresses: {
-      14800: "0xc3d176cF6BccFCB9225b53B87a95147218e1537F",
-      1480: "0xc3d176cF6BccFCB9225b53B87a95147218e1537F"
-    }
-  },
-  DLPRootCore: {
-    addresses: {
-      14800: "0x0aBa5e28228c323A67712101d61a54d4ff5720FD",
-      1480: "0x0aBa5e28228c323A67712101d61a54d4ff5720FD"
-    }
-  },
-  DLPRoot: {
-    addresses: {
-      14800: "0xff14346dF2B8Fd0c95BF34f1c92e49417b508AD5",
-      1480: "0xff14346dF2B8Fd0c95BF34f1c92e49417b508AD5"
-    }
-  },
-  DLPRootMetrics: {
-    addresses: {
-      14800: "0xbb532917B6407c060Afd9Cb7d53527eCb91d6662",
-      1480: "0xbb532917B6407c060Afd9Cb7d53527eCb91d6662"
-    }
-  },
-  DLPRootStakesTreasury: {
-    addresses: {
-      14800: "0x52c3260ED5C235fcA43524CF508e29c897318775",
-      1480: "0x52c3260ED5C235fcA43524CF508e29c897318775"
-    }
-  },
-  DLPRootRewardsTreasury: {
-    addresses: {
-      14800: "0xDBFb6B8b9E2eCAEbdE64d665cD553dB81e524479",
-      1480: "0xDBFb6B8b9E2eCAEbdE64d665cD553dB81e524479"
-    }
-  }
-};
-var CONTRACT_ADDRESSES = {
-  14800: Object.fromEntries(
-    Object.entries(CONTRACTS).map(([name, info]) => [name, info.addresses[14800]]).filter(([, addr]) => addr)
-  ),
-  1480: Object.fromEntries(
-    Object.entries(CONTRACTS).map(([name, info]) => [name, info.addresses[1480]]).filter(([, addr]) => addr)
-  )
-};
-var UTILITY_ADDRESSES = {
-  14800: {
-    Multicall3: CONTRACTS.Multicall3.addresses[14800],
-    Multisend: CONTRACTS.Multisend.addresses[14800]
-  },
-  1480: {
-    Multicall3: CONTRACTS.Multicall3.addresses[1480],
-    Multisend: CONTRACTS.Multisend.addresses[1480]
-  }
-};
-var LEGACY_ADDRESSES = {
-  14800: Object.fromEntries(
-    Object.entries(LEGACY_CONTRACTS).map(([name, info]) => [name, info.addresses[14800]]).filter(([, addr]) => addr)
-  ),
-  1480: Object.fromEntries(
-    Object.entries(LEGACY_CONTRACTS).map(([name, info]) => [name, info.addresses[1480]]).filter(([, addr]) => addr)
-  )
-};
-var getContractAddress = (chainId, contract) => {
-  const contractAddress = CONTRACT_ADDRESSES[chainId]?.[contract];
-  if (!contractAddress) {
-    throw new Error(
-      `Contract address not found for ${contract} on chain ${chainId}`
-    );
+// src/utils/transactionParsing.ts
+import { parseEventLogs } from "viem";
+
+// src/config/eventMappings.ts
+var EVENT_MAPPINGS = {
+  // Permission operations
+  grant: {
+    contract: "DataPermissions",
+    event: "PermissionAdded"
+  },
+  revoke: {
+    contract: "DataPermissions",
+    event: "PermissionRevoked"
+  },
+  trustServer: {
+    contract: "DataPermissions",
+    event: "ServerTrusted"
+  },
+  untrustServer: {
+    contract: "DataPermissions",
+    event: "ServerUntrusted"
+  },
+  // Data registry operations  
+  addFile: {
+    contract: "DataRegistry",
+    event: "FileAdded"
+  },
+  addRefinement: {
+    contract: "DataRegistry",
+    event: "RefinementAdded"
+  },
+  updateRefinement: {
+    contract: "DataRegistry",
+    event: "RefinementUpdated"
+  },
+  addFilePermission: {
+    contract: "DataRegistry",
+    event: "PermissionGranted"
   }
-  return contractAddress;
 };
 
 // src/abi/ComputeEngineImplementation.ts
@@ -7913,6 +7556,12 @@ var DataRefinerRegistryABI = [
         name: "schemaId",
         type: "uint256"
       },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "schemaDefinitionUrl",
+        type: "string"
+      },
       {
         indexed: false,
         internalType: "string",
@@ -8016,7 +7665,7 @@ var DataRefinerRegistryABI = [
       {
         indexed: false,
         internalType: "string",
-        name: "typ",
+        name: "dialect",
         type: "string"
       },
       {
@@ -8112,6 +7761,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 +7818,7 @@ var DataRefinerRegistryABI = [
         type: "string"
       }
     ],
-    name: "addRefiner",
+    name: "addRefinerWithSchemaId",
     outputs: [
       {
         internalType: "uint256",
@@ -8155,7 +7838,7 @@ var DataRefinerRegistryABI = [
       },
       {
         internalType: "string",
-        name: "typ",
+        name: "dialect",
         type: "string"
       },
       {
@@ -8518,7 +8201,7 @@ var DataRefinerRegistryABI = [
           },
           {
             internalType: "string",
-            name: "typ",
+            name: "dialect",
             type: "string"
           },
           {
@@ -33431,11 +33114,337 @@ function getAbi(contract) {
   return abi;
 }
 
+// src/utils/transactionParsing.ts
+async function parseTransactionResult(context, hash, operation) {
+  const mapping = EVENT_MAPPINGS[operation];
+  try {
+    console.debug(`\u{1F50D} Parsing ${operation} transaction: ${hash}`);
+    const receipt = await context.publicClient.waitForTransactionReceipt({
+      hash,
+      timeout: 3e4
+      // 30 second timeout
+    });
+    console.debug(`\u2705 Transaction confirmed in block ${receipt.blockNumber}`);
+    const abi = getAbi(mapping.contract);
+    const events = parseEventLogs({
+      logs: receipt.logs,
+      abi,
+      eventName: mapping.event,
+      strict: true
+      // Only return logs that conform to the ABI
+    });
+    if (events.length === 0) {
+      throw new BlockchainError(
+        `No ${mapping.event} event found in transaction ${hash}. Transaction may have failed or reverted.`
+      );
+    }
+    if (events.length > 1) {
+      console.warn(
+        `\u26A0\uFE0F  Multiple ${mapping.event} events found in transaction ${hash}. Using the first one.`
+      );
+    }
+    const event = events[0];
+    console.debug(`\u{1F389} Found ${mapping.event} event with args:`, event.args);
+    return {
+      ...event.args,
+      transactionHash: hash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed
+    };
+  } catch (error) {
+    if (error instanceof BlockchainError || error instanceof NetworkError) {
+      throw error;
+    }
+    if (error instanceof Error && error.message.includes("timeout")) {
+      throw new NetworkError(
+        `Transaction ${hash} confirmation timeout after 30 seconds. The transaction may still be pending.`,
+        error
+      );
+    }
+    throw new BlockchainError(
+      `Failed to parse ${operation} transaction ${hash}: ${error instanceof Error ? error.message : "Unknown error"}`,
+      error
+    );
+  }
+}
+
+// src/config/addresses.ts
+var CONTRACTS = {
+  // Core Platform Contracts
+  DataPermissions: {
+    addresses: {
+      14800: "0x31fb1D48f6B2265A4cAD516BC39E96a18fb7c8de",
+      1480: "0x31fb1D48f6B2265A4cAD516BC39E96a18fb7c8de"
+    }
+  },
+  DataRegistry: {
+    addresses: {
+      14800: "0x8C8788f98385F6ba1adD4234e551ABba0f82Cb7C",
+      1480: "0x8C8788f98385F6ba1adD4234e551ABba0f82Cb7C"
+    }
+  },
+  TeePoolPhala: {
+    addresses: {
+      14800: "0xE8EC6BD73b23Ad40E6B9a6f4bD343FAc411bD99A",
+      1480: "0xE8EC6BD73b23Ad40E6B9a6f4bD343FAc411bD99A"
+    }
+  },
+  ComputeEngine: {
+    addresses: {
+      14800: "0xb2BFe33FA420c45F1Cf1287542ad81ae935447bd",
+      1480: "0xb2BFe33FA420c45F1Cf1287542ad81ae935447bd"
+    }
+  },
+  // Data Access Infrastructure
+  DataRefinerRegistry: {
+    addresses: {
+      14800: "0x93c3EF89369fDcf08Be159D9DeF0F18AB6Be008c",
+      1480: "0x93c3EF89369fDcf08Be159D9DeF0F18AB6Be008c"
+    }
+  },
+  QueryEngine: {
+    addresses: {
+      14800: "0xd25Eb66EA2452cf3238A2eC6C1FD1B7F5B320490",
+      1480: "0xd25Eb66EA2452cf3238A2eC6C1FD1B7F5B320490"
+    }
+  },
+  VanaTreasury: {
+    addresses: {
+      14800: "0x94a1E56e555ac48d092f490fB10CDFaB434915eD",
+      1480: "0x94a1E56e555ac48d092f490fB10CDFaB434915eD"
+    }
+  },
+  ComputeInstructionRegistry: {
+    addresses: {
+      14800: "0x5786B12b4c6Ba2bFAF0e77Ed30Bf6d32805563A5",
+      1480: "0x5786B12b4c6Ba2bFAF0e77Ed30Bf6d32805563A5"
+    }
+  },
+  // TEE Pool Variants
+  TeePoolEphemeralStandard: {
+    addresses: {
+      14800: "0xe124bae846D5ec157f75Bd9e68ca87C4d2AB835A",
+      1480: "0xe124bae846D5ec157f75Bd9e68ca87C4d2AB835A"
+    }
+  },
+  TeePoolPersistentStandard: {
+    addresses: {
+      14800: "0xe8bB8d0629651Cf33e0845d743976Dc1f0971d76",
+      1480: "0xe8bB8d0629651Cf33e0845d743976Dc1f0971d76"
+    }
+  },
+  TeePoolPersistentGpu: {
+    addresses: {
+      14800: "0x1c346Cd74f8551f8fa13f3F4b6b8dAE22338E6a9",
+      1480: "0x1c346Cd74f8551f8fa13f3F4b6b8dAE22338E6a9"
+    }
+  },
+  TeePoolDedicatedStandard: {
+    addresses: {
+      14800: "0xf024b7ac5E8417416f53B41ecfa58C8e9396687d",
+      1480: "0xf024b7ac5E8417416f53B41ecfa58C8e9396687d"
+    }
+  },
+  TeePoolDedicatedGpu: {
+    addresses: {
+      14800: "0xB1686FA9620bBf851714d1cB47b8a4Bf4664644E",
+      1480: "0xB1686FA9620bBf851714d1cB47b8a4Bf4664644E"
+    }
+  },
+  // DLP Reward System
+  VanaEpoch: {
+    addresses: {
+      14800: "0x2063cFF0609D59bCCc196E20Eb58A8696a6b15A0",
+      1480: "0x2063cFF0609D59bCCc196E20Eb58A8696a6b15A0"
+    }
+  },
+  DLPRegistry: {
+    addresses: {
+      14800: "0x4D59880a924526d1dD33260552Ff4328b1E18a43",
+      1480: "0x4D59880a924526d1dD33260552Ff4328b1E18a43"
+    }
+  },
+  DLPRegistryTreasury: {
+    addresses: {
+      14800: "0xb12ce1d27bEeFe39b6F0110b1AB77C21Aa0c9F9a",
+      1480: "0xb12ce1d27bEeFe39b6F0110b1AB77C21Aa0c9F9a"
+    }
+  },
+  DLPPerformance: {
+    addresses: {
+      14800: "0x847715C7DB37cF286611182Be0bD333cbfa29cc1",
+      1480: "0x847715C7DB37cF286611182Be0bD333cbfa29cc1"
+    }
+  },
+  DLPRewardDeployer: {
+    addresses: {
+      14800: "0xEFD0F9Ba9De70586b7c4189971cF754adC923B04",
+      1480: "0xEFD0F9Ba9De70586b7c4189971cF754adC923B04"
+    }
+  },
+  DLPRewardDeployerTreasury: {
+    addresses: {
+      14800: "0xb547ca8Fe4990fe330FeAeb1C2EBb42F925Af5b8",
+      1480: "0xb547ca8Fe4990fe330FeAeb1C2EBb42F925Af5b8"
+    }
+  },
+  DLPRewardSwap: {
+    addresses: {
+      14800: "0x7c6862C46830F0fc3bF3FF509EA1bD0EE7267fB0",
+      1480: "0x7c6862C46830F0fc3bF3FF509EA1bD0EE7267fB0"
+    }
+  },
+  SwapHelper: {
+    addresses: {
+      14800: "0x55D5e6F73326315bF2E091e97F04f0770e5C54e2",
+      1480: "0x55D5e6F73326315bF2E091e97F04f0770e5C54e2"
+    }
+  },
+  // VanaPool (Staking)
+  VanaPoolStaking: {
+    addresses: {
+      14800: "0x641C18E2F286c86f96CE95C8ec1EB9fC0415Ca0e",
+      1480: "0x641C18E2F286c86f96CE95C8ec1EB9fC0415Ca0e"
+    }
+  },
+  VanaPoolEntity: {
+    addresses: {
+      14800: "0x44f20490A82e1f1F1cC25Dd3BA8647034eDdce30",
+      1480: "0x44f20490A82e1f1F1cC25Dd3BA8647034eDdce30"
+    }
+  },
+  VanaPoolTreasury: {
+    addresses: {
+      14800: "0x143BE72CF2541604A7691933CAccd6D9cC17c003",
+      1480: "0x143BE72CF2541604A7691933CAccd6D9cC17c003"
+    }
+  },
+  // DLP Deployment Contracts
+  DAT: {
+    addresses: {
+      14800: "0xA706b93ccED89f13340673889e29F0a5cd84212d",
+      1480: "0xA706b93ccED89f13340673889e29F0a5cd84212d"
+    }
+  },
+  DATFactory: {
+    addresses: {
+      14800: "0x40f8bccF35a75ecef63BC3B1B3E06ffEB9220644",
+      1480: "0x40f8bccF35a75ecef63BC3B1B3E06ffEB9220644"
+    }
+  },
+  DATPausable: {
+    addresses: {
+      14800: "0xe69FE86f0B95cC2f8416Fe22815c85DC8887e76e",
+      1480: "0xe69FE86f0B95cC2f8416Fe22815c85DC8887e76e"
+    }
+  },
+  DATVotes: {
+    addresses: {
+      14800: "0xaE04c8A77E9B27869eb563720524A9aE0baf1831",
+      1480: "0xaE04c8A77E9B27869eb563720524A9aE0baf1831"
+    }
+  },
+  // Utility Contracts (no ABIs in SDK)
+  Multicall3: {
+    addresses: {
+      14800: "0xD8d2dFca27E8797fd779F8547166A2d3B29d360E",
+      1480: "0xD8d2dFca27E8797fd779F8547166A2d3B29d360E"
+    }
+  },
+  Multisend: {
+    addresses: {
+      14800: "0x8807e8BCDFbaA8c2761760f3FBA37F6f7F2C5b2d",
+      1480: "0x8807e8BCDFbaA8c2761760f3FBA37F6f7F2C5b2d"
+    }
+  }
+};
+var LEGACY_CONTRACTS = {
+  // DEPRECATED: Original Intel SGX TeePool (PRO-347)
+  TeePool: {
+    addresses: {
+      14800: "0x3c92fD91639b41f13338CE62f19131e7d19eaa0D",
+      1480: "0x3c92fD91639b41f13338CE62f19131e7d19eaa0D"
+    }
+  },
+  // DEPRECATED: DLPRoot system (replaced by VanaPool + DLPRewards)
+  DLPRootEpoch: {
+    addresses: {
+      14800: "0xc3d176cF6BccFCB9225b53B87a95147218e1537F",
+      1480: "0xc3d176cF6BccFCB9225b53B87a95147218e1537F"
+    }
+  },
+  DLPRootCore: {
+    addresses: {
+      14800: "0x0aBa5e28228c323A67712101d61a54d4ff5720FD",
+      1480: "0x0aBa5e28228c323A67712101d61a54d4ff5720FD"
+    }
+  },
+  DLPRoot: {
+    addresses: {
+      14800: "0xff14346dF2B8Fd0c95BF34f1c92e49417b508AD5",
+      1480: "0xff14346dF2B8Fd0c95BF34f1c92e49417b508AD5"
+    }
+  },
+  DLPRootMetrics: {
+    addresses: {
+      14800: "0xbb532917B6407c060Afd9Cb7d53527eCb91d6662",
+      1480: "0xbb532917B6407c060Afd9Cb7d53527eCb91d6662"
+    }
+  },
+  DLPRootStakesTreasury: {
+    addresses: {
+      14800: "0x52c3260ED5C235fcA43524CF508e29c897318775",
+      1480: "0x52c3260ED5C235fcA43524CF508e29c897318775"
+    }
+  },
+  DLPRootRewardsTreasury: {
+    addresses: {
+      14800: "0xDBFb6B8b9E2eCAEbdE64d665cD553dB81e524479",
+      1480: "0xDBFb6B8b9E2eCAEbdE64d665cD553dB81e524479"
+    }
+  }
+};
+var CONTRACT_ADDRESSES = {
+  14800: Object.fromEntries(
+    Object.entries(CONTRACTS).map(([name, info]) => [name, info.addresses[14800]]).filter(([, addr]) => addr)
+  ),
+  1480: Object.fromEntries(
+    Object.entries(CONTRACTS).map(([name, info]) => [name, info.addresses[1480]]).filter(([, addr]) => addr)
+  )
+};
+var UTILITY_ADDRESSES = {
+  14800: {
+    Multicall3: CONTRACTS.Multicall3.addresses[14800],
+    Multisend: CONTRACTS.Multisend.addresses[14800]
+  },
+  1480: {
+    Multicall3: CONTRACTS.Multicall3.addresses[1480],
+    Multisend: CONTRACTS.Multisend.addresses[1480]
+  }
+};
+var LEGACY_ADDRESSES = {
+  14800: Object.fromEntries(
+    Object.entries(LEGACY_CONTRACTS).map(([name, info]) => [name, info.addresses[14800]]).filter(([, addr]) => addr)
+  ),
+  1480: Object.fromEntries(
+    Object.entries(LEGACY_CONTRACTS).map(([name, info]) => [name, info.addresses[1480]]).filter(([, addr]) => addr)
+  )
+};
+var getContractAddress = (chainId, contract) => {
+  const contractAddress = CONTRACT_ADDRESSES[chainId]?.[contract];
+  if (!contractAddress) {
+    throw new Error(
+      `Contract address not found for ${contract} on chain ${chainId}`
+    );
+  }
+  return contractAddress;
+};
+
 // src/utils/grantFiles.ts
 import { keccak256, toHex } from "viem";
 function createGrantFile(params) {
   const grantFile = {
-    grantee: params.to,
+    grantee: params.grantee,
     operation: params.operation,
     parameters: params.parameters
   };
@@ -33832,6 +33841,91 @@ function validateOperationAccess(grantFile, requestedOperation) {
   }
 }
 
+// src/utils/signatureCache.ts
+init_crypto_utils();
+var SignatureCache = class {
+  /**
+   * Get a cached signature if it exists and hasn't expired
+   */
+  static get(cache, walletAddress, messageHash) {
+    const key = this.getCacheKey(walletAddress, messageHash);
+    try {
+      const stored = cache.get(key);
+      if (!stored) return null;
+      const cached = JSON.parse(stored);
+      if (Date.now() > cached.expires) {
+        cache.delete(key);
+        return null;
+      }
+      return cached.signature;
+    } catch {
+      try {
+        cache.delete(key);
+      } catch {
+      }
+      return null;
+    }
+  }
+  /**
+   * Store a signature in the cache
+   */
+  static set(cache, walletAddress, messageHash, signature, ttlHours = this.DEFAULT_TTL_HOURS) {
+    const key = this.getCacheKey(walletAddress, messageHash);
+    const cached = {
+      signature,
+      expires: Date.now() + ttlHours * 36e5
+      // Convert hours to milliseconds
+    };
+    try {
+      cache.set(key, JSON.stringify(cached));
+    } catch {
+    }
+  }
+  /**
+   * Clear all cached signatures (useful for testing or explicit cleanup)
+   */
+  static clear(cache) {
+    try {
+      cache.clear();
+    } catch {
+    }
+  }
+  static getCacheKey(walletAddress, messageHash) {
+    return `${this.PREFIX}${walletAddress.toLowerCase()}:${messageHash}`;
+  }
+  static hashMessage(message) {
+    const jsonString = JSON.stringify(message, this.bigIntReplacer);
+    const base64Hash = toBase64(jsonString);
+    const cleaned = base64Hash.replace(/[^a-zA-Z0-9]/g, "");
+    if (cleaned.length > 32) {
+      return cleaned.substring(0, 16) + cleaned.substring(cleaned.length - 16);
+    }
+    return cleaned.substring(0, 32);
+  }
+  /**
+   * Custom JSON replacer that converts BigInt values to strings for serialization
+   * This ensures deterministic cache key generation for EIP-712 typed data
+   */
+  static bigIntReplacer(key, value) {
+    if (typeof value === "bigint") {
+      return `__BIGINT__${value.toString()}`;
+    }
+    return value;
+  }
+};
+__publicField(SignatureCache, "PREFIX", "vana_sig_");
+__publicField(SignatureCache, "DEFAULT_TTL_HOURS", 2);
+async function withSignatureCache(cache, walletAddress, typedData, signFn, ttlHours) {
+  const messageHash = SignatureCache.hashMessage(typedData);
+  const cached = SignatureCache.get(cache, walletAddress, messageHash);
+  if (cached) {
+    return cached;
+  }
+  const signature = await signFn();
+  SignatureCache.set(cache, walletAddress, messageHash, signature, ttlHours);
+  return signature;
+}
+
 // src/controllers/permissions.ts
 var PermissionsController = class {
   constructor(context) {
@@ -33839,23 +33933,23 @@ var PermissionsController = class {
   }
   /**
    * Grants permission for an application to access user data with gasless transactions.
+   * 
+   * This method provides a complete end-to-end permission grant flow that returns
+   * the permission ID and other relevant data immediately after successful submission.
+   * For advanced users who need more control over the transaction lifecycle, use
+   * `submitPermissionGrant()` instead.
    *
-   * @remarks
-   * This method combines signature creation and gasless submission for a complete
-   * end-to-end permission grant flow. It creates the grant file, stores it on IPFS,
-   * generates an EIP-712 signature, and submits via relayer. The grant file contains
-   * detailed parameters while the blockchain stores only a reference to enable
-   * efficient permission queries.
    * @param params - The permission grant configuration object
-   * @returns A Promise that resolves to the transaction hash when successfully submitted
+   * @returns Promise resolving to permission data from the PermissionAdded event
    * @throws {RelayerError} When gasless transaction submission fails
    * @throws {SignatureError} When user rejects the signature request
    * @throws {SerializationError} When grant data cannot be serialized
-   * @throws {BlockchainError} When permission grant preparation fails
+   * @throws {BlockchainError} When permission grant fails or event parsing fails
+   * @throws {NetworkError} When transaction confirmation times out
    * @example
    * ```typescript
-   * const txHash = await vana.permissions.grant({
-   *   to: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
+   * const result = await vana.permissions.grant({
+   *   grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
    *   operation: "llm_inference",
    *   parameters: {
    *     model: "gpt-4",
@@ -33864,10 +33958,42 @@ var PermissionsController = class {
    *   },
    * });
    *
-   * console.log(`Permission granted: ${txHash}`);
+   * console.log(`Permission ${result.permissionId} granted to ${result.user}`);
+   * console.log(`Transaction: ${result.transactionHash}`);
+   * 
+   * // Can immediately use the permission ID for other operations
+   * await vana.permissions.revoke({ permissionId: result.permissionId });
    * ```
    */
   async grant(params) {
+    const txHash = await this.submitPermissionGrant(params);
+    return parseTransactionResult(this.context, txHash, "grant");
+  }
+  /**
+   * Submits a permission grant transaction and returns the transaction hash immediately.
+   * 
+   * This is the lower-level method that provides maximum control over transaction timing.
+   * Use this when you want to handle transaction confirmation and event parsing separately,
+   * or when submitting multiple transactions in batch.
+   *
+   * @param params - The permission grant configuration object  
+   * @returns Promise that resolves to the transaction hash when successfully submitted
+   * @throws {RelayerError} When gasless transaction submission fails
+   * @throws {SignatureError} When user rejects the signature request
+   * @throws {SerializationError} When grant data cannot be serialized
+   * @throws {BlockchainError} When permission grant preparation fails
+   * @example
+   * ```typescript
+   * // Submit transaction and handle confirmation later
+   * const txHash = await vana.permissions.submitPermissionGrant(params);
+   * console.log(`Transaction submitted: ${txHash}`);
+   * 
+   * // Later, when you need the permission data:
+   * const result = await parseTransactionResult(context, txHash, 'grant');
+   * console.log(`Permission ID: ${result.permissionId}`);
+   * ```
+   */
+  async submitPermissionGrant(params) {
     const { typedData, signature } = await this.createAndSign(params);
     return await this.submitSignedGrant(typedData, signature);
   }
@@ -33884,7 +34010,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 +34059,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 +34089,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 +34136,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 +34152,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 +34182,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,
@@ -34276,23 +34410,52 @@ var PermissionsController = class {
   }
   /**
    * Revokes a previously granted permission.
+   * 
+   * This method provides complete revocation with automatic event parsing to confirm
+   * the permission was successfully revoked. For advanced users who need more control,
+   * use `submitPermissionRevoke()` instead.
    *
    * @param params - Parameters for revoking the permission
-   * @returns Promise resolving to transaction hash
+   * @param params.permissionId - Permission identifier as bigint for contract compatibility.
+   *   Obtain from permission grants via `getUserPermissionGrantsOnChain()`.
+   * @returns Promise resolving to revocation data from PermissionRevoked event
+   * @throws {BlockchainError} When revocation fails or event parsing fails
+   * @throws {UserRejectedRequestError} When user rejects the transaction
+   * @throws {NetworkError} When transaction confirmation times out
    * @example
    * ```typescript
-   * // Revoke a permission by its ID
-   * const txHash = await vana.permissions.revoke({
+   * // Revoke a permission and get confirmation
+   * const result = await vana.permissions.revoke({
    *   permissionId: 123n
    * });
-   * console.log('Permission revoked in transaction:', txHash);
-   *
-   * // Wait for confirmation if needed
-   * const receipt = await vana.core.waitForTransaction(txHash);
-   * console.log('Revocation confirmed in block:', receipt.blockNumber);
+   * console.log(`Permission ${result.permissionId} revoked in transaction ${result.transactionHash}`);
+   * console.log(`Revoked in block ${result.blockNumber}`);
    * ```
    */
   async revoke(params) {
+    const txHash = await this.submitPermissionRevoke(params);
+    return parseTransactionResult(this.context, txHash, "revoke");
+  }
+  /**
+   * Submits a permission revocation transaction and returns the transaction hash immediately.
+   * 
+   * This is the lower-level method that provides maximum control over transaction timing.
+   * Use this when you want to handle transaction confirmation and event parsing separately.
+   *
+   * @param params - Parameters for revoking the permission
+   * @returns Promise resolving to the transaction hash when successfully submitted
+   * @throws {BlockchainError} When revocation transaction fails
+   * @throws {UserRejectedRequestError} When user rejects the transaction
+   * @example
+   * ```typescript
+   * // Submit revocation and handle confirmation later
+   * const txHash = await vana.permissions.submitPermissionRevoke({
+   *   permissionId: 123n
+   * });
+   * console.log(`Revocation submitted: ${txHash}`);
+   * ```
+   */
+  async submitPermissionRevoke(params) {
     try {
       if (!this.context.walletClient.chain?.id) {
         throw new BlockchainError("Chain ID not available");
@@ -34399,7 +34562,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
@@ -34458,17 +34621,24 @@ var PermissionsController = class {
     };
   }
   /**
-   * Signs typed data using the wallet client.
+   * Signs typed data using the wallet client with signature caching.
    *
    * @param typedData - The EIP-712 typed data structure to sign
    * @returns Promise resolving to the cryptographic signature
    */
   async signTypedData(typedData) {
     try {
-      const signature = await this.context.walletClient.signTypedData(
-        typedData
+      const walletAddress = this.context.walletClient.account?.address || await this.getUserAddress();
+      return await withSignatureCache(
+        this.context.platform.cache,
+        walletAddress,
+        typedData,
+        async () => {
+          return await this.context.walletClient.signTypedData(
+            typedData
+          );
+        }
       );
-      return signature;
     } catch (error) {
       if (error instanceof Error && error.message.includes("rejected")) {
         throw new UserRejectedRequestError();
@@ -34492,36 +34662,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 +34722,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 +34740,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 +34747,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"}`
       );
     }
   }
@@ -35336,15 +35472,22 @@ import { getContract, decodeEventLog } from "viem";
 
 // src/utils/encryption.ts
 var DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
-async function generateEncryptionKey(wallet, seed = DEFAULT_ENCRYPTION_SEED) {
+async function generateEncryptionKey(wallet, platformAdapter, seed = DEFAULT_ENCRYPTION_SEED) {
   if (!wallet.account) {
     throw new Error("Wallet account is required for encryption key generation");
   }
-  const signature = await wallet.signMessage({
-    account: wallet.account,
-    message: seed
-  });
-  return signature;
+  const messageData = { message: seed };
+  return await withSignatureCache(
+    platformAdapter.cache,
+    wallet.account.address,
+    messageData,
+    async () => {
+      return await wallet.signMessage({
+        account: wallet.account,
+        message: seed
+      });
+    }
+  );
 }
 async function encryptWithWalletPublicKey(data, publicKey, platformAdapter) {
   try {
@@ -35398,32 +35541,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) {
@@ -35440,12 +35570,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;
   }
+  async upload(params) {
+    const {
+      content,
+      filename,
+      schemaId,
+      permissions = [],
+      encrypt: encrypt2 = true,
+      providerName,
+      owner
+    } = 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,
+          this.context.platform,
+          DEFAULT_ENCRYPTION_SEED
+        );
+        finalBlob = await encryptBlobWithSignedKey(
+          blob,
+          encryptionKey,
+          this.context.platform
+        );
+      }
+      if (!this.context.storageManager) {
+        if (this.context.validateStorageRequired) {
+          this.context.validateStorageRequired();
+          throw new Error("Storage validation failed");
+        } else {
+          throw new Error(
+            "Storage manager not configured. Please provide storage providers in VanaConfig."
+          );
+        }
+      }
+      const uploadResult = await this.context.storageManager.upload(
+        finalBlob,
+        filename,
+        providerName
+      );
+      const userAddress = owner || await this.getUserAddress();
+      let encryptedPermissions = [];
+      if (permissions.length > 0) {
+        const userEncryptionKey = await generateEncryptionKey(
+          this.context.walletClient,
+          this.context.platform,
+          DEFAULT_ENCRYPTION_SEED
+        );
+        encryptedPermissions = await Promise.all(
+          permissions.map(async (permission) => {
+            const encryptedKey = await encryptWithWalletPublicKey(
+              userEncryptionKey,
+              permission.publicKey,
+              this.context.platform
+            );
+            return {
+              account: permission.account,
+              key: encryptedKey
+            };
+          })
+        );
+      }
+      let result;
+      if (this.context.relayerCallbacks?.submitFileAdditionComplete) {
+        result = await this.context.relayerCallbacks.submitFileAdditionComplete(
+          {
+            url: uploadResult.url,
+            userAddress,
+            permissions: encryptedPermissions,
+            schemaId: schemaId || 0,
+            ownerAddress: owner
+          }
+        );
+      } 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,
+        this.context.platform,
+        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.
    *
@@ -36029,6 +36462,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
@@ -36116,6 +36550,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
@@ -36194,81 +36629,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.
    *
@@ -36329,26 +36689,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.
    *
@@ -36423,9 +36763,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
    */
@@ -36484,6 +36885,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
    */
@@ -36509,11 +36911,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);
@@ -36525,6 +36931,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() {
@@ -36570,7 +36977,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,
@@ -36773,9 +37180,10 @@ var DataController = class {
     try {
       const userEncryptionKey = await generateEncryptionKey(
         this.context.walletClient,
+        this.context.platform,
         DEFAULT_ENCRYPTION_SEED
       );
-      const encryptedData = await encryptUserData(
+      const encryptedData = await encryptBlobWithSignedKey(
         data,
         userEncryptionKey,
         this.context.platform
@@ -36838,16 +37246,47 @@ var DataController = class {
    * 1. Gets the user's encryption key
    * 2. Encrypts the user's encryption key with the provided public key
    * 3. Adds the permission to the file
+   * 4. Returns the permission data from the blockchain event
+   *
+   * For advanced users who need more control over transaction timing,
+   * use `submitFilePermission()` instead.
    *
    * @param fileId - The ID of the file to add permissions for
    * @param account - The address of the account to grant permission to
    * @param publicKey - The public key to encrypt the user's encryption key with
-   * @returns Promise resolving to the transaction hash
+   * @returns Promise resolving to permission data from PermissionGranted event
+   * @example
+   * ```typescript
+   * const result = await vana.data.addPermissionToFile(fileId, account, publicKey);
+   * console.log(`Permission granted to ${result.account} for file ${result.fileId}`);
+   * console.log(`Transaction: ${result.transactionHash}`);
+   * ```
    */
   async addPermissionToFile(fileId, account, publicKey) {
+    const txHash = await this.submitFilePermission(fileId, account, publicKey);
+    return parseTransactionResult(this.context, txHash, "addFilePermission");
+  }
+  /**
+   * Submits a file permission transaction and returns the transaction hash immediately.
+   *
+   * This is the lower-level method that provides maximum control over transaction timing.
+   * Use this when you want to handle transaction confirmation and event parsing separately.
+   *
+   * @param fileId - The ID of the file to add permissions for
+   * @param account - The address of the account to grant permission to
+   * @param publicKey - The public key to encrypt the user's encryption key with
+   * @returns Promise resolving to the transaction hash
+   * @example
+   * ```typescript
+   * const txHash = await vana.data.submitFilePermission(fileId, account, publicKey);
+   * console.log(`Transaction submitted: ${txHash}`);
+   * ```
+   */
+  async submitFilePermission(fileId, account, publicKey) {
     try {
       const userEncryptionKey = await generateEncryptionKey(
         this.context.walletClient,
+        this.context.platform,
         DEFAULT_ENCRYPTION_SEED
       );
       const encryptedKey = await encryptWithWalletPublicKey(
@@ -36939,12 +37378,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
@@ -36957,6 +37397,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.
    *
@@ -37078,12 +37674,365 @@ 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);
   }
+  /**
+   * Retrieves the cryptographic identity of a personal server.
+   *
+   * @remarks
+   * This method fetches the public key and metadata for a personal server,
+   * which is required for encrypting data before sharing with the server.
+   * The identity includes the server's public key, address, and operational
+   * details needed for secure communication. This information is cached
+   * by identity servers to enable offline key retrieval.
+   *
+   * @param request - Parameters containing the user address
+   * @param request.userAddress - The wallet address associated with the personal server
+   * @returns Promise resolving to the server's identity information
+   * @throws {NetworkError} When the identity service is unavailable or returns invalid data
+   * @throws {PersonalServerError} When server identity cannot be retrieved
+   * @example
+   * ```typescript
+   * // Get server identity for data encryption
+   * const identity = await vana.server.getIdentity({
+   *   userAddress: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36"
+   * });
+   * 
+   * console.log(`Server: ${identity.name}`);
+   * console.log(`Address: ${identity.address}`);
+   * console.log(`Public Key: ${identity.public_key}`);
+   * 
+   * // Use the public key for encrypting data to share with this server
+   * const encryptedData = await encryptWithWalletPublicKey(
+   *   userData,
+   *   identity.public_key
+   * );
+   * ```
+   */
   async getIdentity(request) {
     try {
       const response = await fetch(
@@ -37104,6 +38053,7 @@ var ServerController = class {
       }
       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 || "",
@@ -37125,10 +38075,13 @@ var ServerController = class {
    * 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
+   * @param params.permissionId - The permission ID authorizing this operation.
+   *   Obtain from granted permissions via `vana.permissions.getUserPermissionGrantsOnChain()`.
    * @returns A Promise that resolves to an operation response with status and control URLs
-   * @throws {PersonalServerError} When server request fails or parameters are invalid
-   * @throws {NetworkError} When personal server API communication fails
+   * @throws {PersonalServerError} When server request fails or parameters are invalid.
+   *   Verify permissionId exists and is active for the target server.
+   * @throws {NetworkError} When personal server API communication fails.
+   *   Check server URL configuration and network connectivity.
    * @example
    * ```typescript
    * const response = await vana.server.createOperation({
@@ -37230,6 +38183,50 @@ var ServerController = class {
       );
     }
   }
+  /**
+   * Cancels a running operation on the personal server.
+   *
+   * @remarks
+   * This method attempts to cancel an operation that is currently processing
+   * on the personal server. The operation must be in a cancellable state
+   * (typically `starting` or `processing`). Not all operations support 
+   * cancellation, and cancellation may not be immediate. The server will
+   * attempt to stop the operation and update its status to `canceled`.
+   *
+   * **Cancellation Behavior:**
+   * - Operations in `succeeded` or `failed` states cannot be canceled
+   * - Some long-running operations may take time to respond to cancellation
+   * - Always verify cancellation by polling the operation status afterward
+   *
+   * @param operationId - The unique identifier of the operation to cancel,
+   *   obtained from `createOperation()` response
+   * @returns Promise that resolves when the cancellation request is accepted
+   * @throws {PersonalServerError} When the operation cannot be canceled or doesn't exist.
+   *   Check operation status - it may already be completed or failed.
+   * @throws {NetworkError} When unable to reach the personal server API.
+   *   Verify server URL and network connectivity.
+   * @example
+   * ```typescript
+   * // Start a long-running operation
+   * const operation = await vana.server.createOperation({
+   *   permissionId: 123
+   * });
+   *
+   * // Cancel if needed
+   * try {
+   *   await vana.server.cancelOperation(operation.id);
+   *   console.log("Cancellation requested");
+   *   
+   *   // Verify cancellation
+   *   const status = await vana.server.getOperation(operation.id);
+   *   if (status.status === "canceled") {
+   *     console.log("Operation successfully canceled");
+   *   }
+   * } catch (error) {
+   *   console.error("Failed to cancel:", error);
+   * }
+   * ```
+   */
   async cancelOperation(operationId) {
     try {
       const response = await fetch(
@@ -37256,7 +38253,7 @@ var ServerController = class {
   /**
    * Makes the request to the personal server API.
    *
-   * @param params - The post request parameters to serialize
+   * @param requestBody - The post request parameters to serialize
    * @returns JSON string representation of the request data
    */
   async makeRequest(requestBody) {
@@ -37339,7 +38336,7 @@ var ServerController = class {
 
 // src/contracts/contractController.ts
 import {
-  getContract as getContract2
+  getContract as getContract3
 } from "viem";
 
 // src/core/client.ts
@@ -37440,7 +38437,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
@@ -37533,7 +38530,8 @@ var ProtocolController = class {
    * are actually deployed on the current network.
    * @param contractName - The name of the Vana contract to retrieve (use const assertion for full typing)
    * @returns An object containing the contract's address and fully typed ABI
-   * @throws {ContractNotFoundError} When the contract is not deployed on the current chain
+   * @throws {ContractNotFoundError} When the contract is not deployed on the current chain.
+   *   Verify contract name spelling and check current network with `getChainId()`.
    * @example
    * ```typescript
    * // Get contract info with full type inference
@@ -38154,6 +39152,7 @@ var GoogleDriveStorage = class {
 };
 
 // src/storage/providers/ipfs.ts
+init_crypto_utils();
 var IpfsStorage = class _IpfsStorage {
   constructor(config) {
     this.config = config;
@@ -38193,7 +39192,7 @@ var IpfsStorage = class _IpfsStorage {
    * ```
    */
   static forInfura(credentials) {
-    const auth = btoa(`${credentials.projectId}:${credentials.projectSecret}`);
+    const auth = toBase64(`${credentials.projectId}:${credentials.projectSecret}`);
     return new _IpfsStorage({
       apiEndpoint: "https://ipfs.infura.io:5001/api/v0/add",
       gatewayUrl: "https://ipfs.infura.io/ipfs",
@@ -38717,175 +39716,151 @@ var PinataStorage = class {
   }
 };
 
-// src/storage/providers/server-proxy.ts
-var ServerProxyStorage = class {
-  constructor(config) {
-    this.config = config;
-    if (!config.uploadUrl) {
-      throw new StorageError(
-        "Upload URL is required",
-        "MISSING_UPLOAD_URL",
-        "server-proxy"
-      );
-    }
-    if (!config.downloadUrl) {
-      throw new StorageError(
-        "Download URL is required",
-        "MISSING_DOWNLOAD_URL",
-        "server-proxy"
+// src/storage/providers/callback-storage.ts
+var CallbackStorage = class {
+  constructor(callbacks) {
+    this.callbacks = callbacks;
+    if (!callbacks.upload || !callbacks.download) {
+      throw new Error(
+        "CallbackStorage requires both upload and download callbacks"
       );
     }
   }
   /**
-   * Uploads a file through your server endpoint
+   * Upload a file using the provided callback
    *
-   * @remarks
-   * This method sends the file to your configured upload endpoint via FormData.
-   * Your server is responsible for handling the actual storage implementation
-   * and must return a JSON response with `success: true` and an `identifier` field.
-   *
-   * @param file - The file to upload
-   * @param filename - Optional custom filename
-   * @returns Promise that resolves to the server-provided identifier
-   * @throws {StorageError} When the upload fails or server returns an error
-   *
-   * @example
-   * ```typescript
-   * const identifier = await serverStorage.upload(fileBlob, { name: "report.pdf" });
-   * console.log("File uploaded with identifier:", identifier);
-   * ```
+   * @param file - The blob to upload
+   * @param filename - Optional filename for the upload
+   * @returns The upload result with URL and metadata
    */
   async upload(file, filename) {
     try {
-      const formData = new FormData();
-      formData.append("file", file);
-      if (filename) {
-        formData.append("name", filename);
-      }
-      const response = await fetch(this.config.uploadUrl, {
-        method: "POST",
-        body: formData
-      });
-      if (!response.ok) {
-        const _errorText = await response.text();
-        throw new StorageError(
-          `Server upload failed: ${response.status} ${response.statusText}`,
-          "UPLOAD_FAILED",
-          "server-proxy"
-        );
-      }
-      const result = await response.json();
-      if (!result.success) {
+      const result = await this.callbacks.upload(file, filename);
+      if (!result.url || result.url.trim() === "") {
         throw new StorageError(
-          `Upload failed: ${result.error || "Unknown server error"}`,
-          "UPLOAD_FAILED",
-          "server-proxy"
+          "Upload callback returned invalid result: missing or empty url",
+          "INVALID_UPLOAD_RESULT",
+          "callback-storage"
         );
       }
-      if (!result.identifier) {
-        throw new StorageError(
-          "Server upload succeeded but no identifier returned",
-          "NO_IDENTIFIER_RETURNED",
-          "server-proxy"
-        );
-      }
-      return {
-        url: result.url || result.identifier,
-        size: file.size,
-        contentType: file.type || "application/octet-stream"
-      };
+      return result;
     } catch (error) {
       if (error instanceof StorageError) {
         throw error;
       }
       throw new StorageError(
-        `Server proxy upload error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        `Upload failed: ${error instanceof Error ? error.message : String(error)}`,
         "UPLOAD_ERROR",
-        "server-proxy"
+        "callback-storage",
+        { cause: error instanceof Error ? error : void 0 }
       );
     }
   }
   /**
-   * Downloads a file through your server endpoint
-   *
-   * @remarks
-   * This method sends the identifier to your configured download endpoint via POST request.
-   * Your server is responsible for retrieving the file from your storage backend
-   * and returning the file content as a blob response.
-   *
-   * @param url - The server-provided URL or identifier from upload
-   * @returns Promise that resolves to the downloaded file content
-   * @throws {StorageError} When the download fails or file is not found
+   * Download a file using the provided callback
    *
-   * @example
-   * ```typescript
-   * const fileBlob = await serverStorage.download("file-123");
-   * const url = URL.createObjectURL(fileBlob);
-   * ```
+   * @param url - The URL or identifier to download
+   * @returns The downloaded blob
    */
   async download(url) {
     try {
-      const identifier = this.extractIdentifierFromUrl(url);
-      const response = await fetch(this.config.downloadUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ identifier })
-      });
-      if (!response.ok) {
-        const _errorText = await response.text();
+      const identifier = this.callbacks.extractIdentifier ? this.callbacks.extractIdentifier(url) : url;
+      const blob = await this.callbacks.download(identifier);
+      if (!(blob instanceof Blob)) {
         throw new StorageError(
-          `Server download failed: ${response.status} ${response.statusText}`,
-          "DOWNLOAD_FAILED",
-          "server-proxy"
+          "Download callback returned invalid result: expected Blob",
+          "INVALID_DOWNLOAD_RESULT",
+          "callback-storage"
         );
       }
-      return await response.blob();
+      return blob;
     } catch (error) {
       if (error instanceof StorageError) {
         throw error;
       }
       throw new StorageError(
-        `Server proxy download error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        `Download failed: ${error instanceof Error ? error.message : String(error)}`,
         "DOWNLOAD_ERROR",
-        "server-proxy"
+        "callback-storage",
+        { cause: error instanceof Error ? error : void 0 }
       );
     }
   }
-  async list(_options) {
-    throw new StorageError(
-      "List operation is not supported by server proxy storage",
-      "LIST_NOT_SUPPORTED",
-      "server-proxy"
-    );
-  }
-  async delete(_url) {
-    throw new StorageError(
-      "Delete operation is not supported by server proxy storage",
-      "DELETE_NOT_SUPPORTED",
-      "server-proxy"
-    );
+  /**
+   * List files using the provided callback (if available)
+   *
+   * @param options - Optional list options including filters and pagination
+   * @returns Array of storage files
+   */
+  async list(options) {
+    if (!this.callbacks.list) {
+      throw new StorageError(
+        "List operation not supported - no list callback provided",
+        "NOT_SUPPORTED",
+        "callback-storage"
+      );
+    }
+    try {
+      const result = await this.callbacks.list(options?.namePattern, options);
+      return result.items.map((item, index) => ({
+        id: item.identifier,
+        name: item.identifier.split("/").pop() || `file-${index}`,
+        url: item.identifier,
+        size: item.size || 0,
+        contentType: "application/octet-stream",
+        createdAt: item.lastModified || /* @__PURE__ */ new Date(),
+        metadata: item.metadata
+      }));
+    } catch (error) {
+      throw new StorageError(
+        `List failed: ${error instanceof Error ? error.message : String(error)}`,
+        "LIST_ERROR",
+        "callback-storage",
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
   }
   /**
-   * Extract identifier from URL or return as-is
+   * Delete a file using the provided callback (if available)
    *
-   * @param url - URL or identifier string
-   * @returns identifier string
+   * @param url - The URL or identifier to delete
+   * @returns True if deletion succeeded
    */
-  extractIdentifierFromUrl(url) {
-    return url;
+  async delete(url) {
+    if (!this.callbacks.delete) {
+      throw new StorageError(
+        "Delete operation not supported - no delete callback provided",
+        "NOT_SUPPORTED",
+        "callback-storage"
+      );
+    }
+    try {
+      const identifier = this.callbacks.extractIdentifier ? this.callbacks.extractIdentifier(url) : url;
+      return await this.callbacks.delete(identifier);
+    } catch (error) {
+      throw new StorageError(
+        `Delete failed: ${error instanceof Error ? error.message : String(error)}`,
+        "DELETE_ERROR",
+        "callback-storage",
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
   }
+  /**
+   * Get provider configuration
+   *
+   * @returns Provider configuration metadata
+   */
   getConfig() {
     return {
-      name: "Server Proxy",
-      type: "server-proxy",
+      name: "callback-storage",
+      type: "callback",
       requiresAuth: false,
       features: {
         upload: true,
         download: true,
-        list: false,
-        delete: false
+        list: !!this.callbacks.list,
+        delete: !!this.callbacks.delete
       }
     };
   }
@@ -39099,7 +40074,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) {
@@ -39111,11 +40086,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.
@@ -39123,6 +40140,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
@@ -39137,8 +40158,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. */
@@ -39147,9 +40170,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)) {
@@ -39204,14 +40231,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.
    *
@@ -39400,37 +40483,97 @@ var VanaCore = class {
     return this.platform;
   }
   /**
-   * Encrypts user data using the Vana protocol standard encryption.
-   * This method automatically uses the correct platform adapter for the current environment.
+   * Encrypts data using the Vana protocol standard encryption.
+   * 
+   * @remarks
+   * This method implements the Vana network's standard encryption protocol using
+   * platform-appropriate cryptographic libraries. It automatically handles different
+   * input types (string or Blob) and produces encrypted output suitable for secure
+   * storage or transmission. The encryption is compatible with the network's
+   * decryption protocols and can be decrypted by authorized parties.
    *
-   * @param data The data to encrypt (string or Blob)
-   * @param walletSignature The wallet signature to use as encryption key
-   * @returns The encrypted data as Blob
+   * @param data - The data to encrypt (string or Blob)
+   * @param key - The encryption key (typically generated via `generateEncryptionKey`)
+   * @returns The encrypted data as a Blob
+   * @throws {Error} When encryption fails due to invalid key or data format
    * @example
    * ```typescript
-   * const encryptionKey = await generateEncryptionKey(walletClient);
-   * const encrypted = await vana.encryptUserData("sensitive data", encryptionKey);
+   * import { generateEncryptionKey } from '@opendatalabs/vana-sdk/node';
+   * 
+   * // Generate encryption key from wallet signature
+   * const encryptionKey = await generateEncryptionKey(vana.walletClient);
+   * 
+   * // Encrypt string data
+   * const sensitiveData = "User's private information";
+   * const encrypted = await vana.encryptBlob(sensitiveData, encryptionKey);
+   * 
+   * // Encrypt file data
+   * const fileBlob = new Blob([fileContent], { type: 'application/json' });
+   * const encryptedFile = await vana.encryptBlob(fileBlob, encryptionKey);
+   * 
+   * // Store encrypted data safely
+   * await storageProvider.upload(encrypted, 'encrypted-data.bin');
    * ```
    */
-  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.
-   * This method automatically uses the correct platform adapter for the current environment.
+   * Decrypts data that was encrypted using the Vana protocol.
+   * 
+   * @remarks
+   * This method decrypts data that was previously encrypted using the Vana network's
+   * standard encryption protocol. It requires the same wallet signature that was used
+   * for encryption and automatically uses the appropriate platform adapter for
+   * cryptographic operations. The decrypted output maintains the original data format.
    *
-   * @param encryptedData The encrypted data (string or Blob)
-   * @param walletSignature The wallet signature to use as decryption key
-   * @returns The decrypted data as Blob
+   * @param encryptedData - The encrypted data (string or Blob)
+   * @param walletSignature - The wallet signature used as decryption key
+   * @returns The decrypted data as a Blob
+   * @throws {Error} When decryption fails due to invalid signature or corrupted data
    * @example
    * ```typescript
-   * const encryptionKey = await generateEncryptionKey(walletClient);
-   * const decrypted = await vana.decryptUserData(encryptedData, encryptionKey);
-   * const text = await decrypted.text();
+   * import { generateEncryptionKey } from '@opendatalabs/vana-sdk/node';
+   * 
+   * // Retrieve encrypted data from storage
+   * const encryptedBlob = await storageProvider.download('encrypted-data.bin');
+   * 
+   * // Generate the same key used for encryption
+   * const decryptionKey = await generateEncryptionKey(vana.walletClient);
+   * 
+   * // Decrypt the data
+   * const decrypted = await vana.decryptBlob(encryptedBlob, decryptionKey);
+   * 
+   * // Convert back to original format
+   * const originalText = await decrypted.text();
+   * const originalJson = JSON.parse(originalText);
+   * 
+   * console.log('Decrypted data:', originalJson);
+   * ```
+   * 
+   * @example
+   * ```typescript
+   * // Decrypt file downloaded from Vana network
+   * const userFiles = await vana.data.getUserFiles();
+   * const file = userFiles[0];
+   * 
+   * // Download encrypted content
+   * const encrypted = await fetch(file.url).then(r => r.blob());
+   * 
+   * // Decrypt with user's key
+   * const decryptionKey = await generateEncryptionKey(vana.walletClient);
+   * const decrypted = await vana.decryptBlob(encrypted, decryptionKey);
+   * 
+   * // Process original data
+   * const fileContent = await decrypted.arrayBuffer();
    * ```
    */
-  async decryptUserData(encryptedData, walletSignature) {
-    return decryptUserData(encryptedData, walletSignature, this.platform);
+  async decryptBlob(encryptedData, walletSignature) {
+    return decryptBlobWithSignedKey(
+      encryptedData,
+      walletSignature,
+      this.platform
+    );
   }
 };
 
@@ -39461,7 +40604,7 @@ function createValidatedGrant(params) {
   try {
     validateGrant(grantFile, {
       schema: true,
-      grantee: params.to,
+      grantee: params.grantee,
       operation: params.operation
     });
   } catch (error) {
@@ -40218,31 +41361,22 @@ 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,
   BaseController,
   BlockchainError,
   BrowserPlatformAdapter,
+  CallbackStorage,
   CircuitBreaker,
   ContractFactory,
   ContractNotFoundError,
@@ -40275,14 +41409,16 @@ export {
   SchemaValidator,
   SerializationError,
   ServerController,
-  ServerProxyStorage,
   ServerUrlMismatchError,
+  SignatureCache,
   SignatureError,
   StorageError,
   StorageManager,
   UserRejectedRequestError,
-  VanaBrowser as Vana,
-  VanaBrowser,
+  Vana,
+  VanaBrowserImpl,
+  VanaCore,
+  VanaCoreFactory,
   VanaError,
   __contractCache,
   chains,
@@ -40295,13 +41431,13 @@ export {
   createGrantFile,
   createPlatformAdapterSafe,
   createValidatedGrant,
-  decryptUserData,
+  decryptBlobWithSignedKey,
   decryptWithPrivateKey,
   decryptWithWalletPrivateKey,
   index_browser_default as default,
   detectPlatform,
+  encryptBlobWithSignedKey,
   encryptFileKey,
-  encryptUserData,
   encryptWithWalletPublicKey,
   extractIpfsHash,
   fetchAndValidateSchema,
@@ -40325,13 +41461,11 @@ export {
   getPlatformCapabilities,
   isAPIResponse,
   isGrantExpired,
-  isIdentityServerOutput,
   isIpfsUrl,
-  isPersonalServerOutput,
   isPlatformSupported,
   isReplicateAPIResponse,
   moksha,
-  mokshaTestnet,
+  mokshaTestnet2 as mokshaTestnet,
   parseReplicateOutput,
   retrieveAndValidateGrant,
   retrieveGrantFile,
@@ -40347,6 +41481,7 @@ export {
   validateGrantFile,
   validateGranteeAccess,
   validateOperationAccess,
-  vanaMainnet
+  vanaMainnet2 as vanaMainnet,
+  withSignatureCache
 };
 //# sourceMappingURL=index.browser.js.map