@opendatalabs/vana-sdk 0.1.0-alpha.8eb4e46 → 0.1.0-alpha.9a32094

package/dist/index.browser.js

@@ -29,6 +29,28 @@ function parseEncryptedDataBuffer(encryptedBuffer) {
     mac: encryptedBuffer.slice(-32)
   };
 }
+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"() {
     "use strict";
@@ -79,7 +101,7 @@ var init_error_utils = __esm({
 
 // src/platform/browser.ts
 import * as openpgp from "openpgp";
-var BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
+var BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserCacheAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
 var init_browser = __esm({
   "src/platform/browser.ts"() {
     "use strict";
@@ -258,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();
@@ -800,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
@@ -33276,6 +33114,332 @@ 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) {
@@ -33677,6 +33841,158 @@ 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
+   *
+   * @param cache - Platform cache adapter instance
+   * @param walletAddress - Wallet address that created the signature
+   * @param messageHash - Hash of the message that was signed
+   * @returns The cached signature if valid, null if expired or not found
+   * @example
+   * ```typescript
+   * const messageHash = SignatureCache.hashMessage(typedData);
+   * const cached = SignatureCache.get(cache, '0x123...', messageHash);
+   * if (cached) {
+   *   console.log('Using cached signature:', cached);
+   * }
+   * ```
+   */
+  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 with configurable TTL
+   *
+   * @param cache - Platform cache adapter instance
+   * @param walletAddress - Wallet address that created the signature
+   * @param messageHash - Hash of the message that was signed
+   * @param signature - The signature to cache
+   * @param ttlHours - Time to live in hours (default: 2)
+   * @example
+   * ```typescript
+   * const signature = await wallet.signTypedData(typedData);
+   * const messageHash = SignatureCache.hashMessage(typedData);
+   *
+   * // Cache for default 2 hours
+   * SignatureCache.set(cache, walletAddress, messageHash, signature);
+   *
+   * // Cache for 24 hours
+   * SignatureCache.set(cache, walletAddress, messageHash, signature, 24);
+   * ```
+   */
+  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)
+   *
+   * @param cache - Platform cache adapter instance
+   * @example
+   * ```typescript
+   * // Clear all signatures when user logs out
+   * SignatureCache.clear(cache);
+   *
+   * // Clear before running tests
+   * beforeEach(() => {
+   *   SignatureCache.clear(cache);
+   * });
+   * ```
+   */
+  static clear(cache) {
+    try {
+      cache.clear();
+    } catch {
+    }
+  }
+  static getCacheKey(walletAddress, messageHash) {
+    return `${this.PREFIX}${walletAddress.toLowerCase()}:${messageHash}`;
+  }
+  /**
+   * Generate a deterministic hash of a message object for cache key generation
+   *
+   * @remarks
+   * Creates a consistent hash from complex objects including EIP-712 typed data.
+   * Handles BigInt serialization and produces a 32-character hash that balances
+   * uniqueness with key length constraints.
+   *
+   * @param message - The message object to hash (typically EIP-712 typed data)
+   * @returns A 32-character hash string suitable for cache keys
+   * @example
+   * ```typescript
+   * const typedData = {
+   *   domain: { name: 'Vana', version: '1' },
+   *   message: { nonce: 123n, grant: '...' }
+   * };
+   *
+   * const hash = SignatureCache.hashMessage(typedData);
+   * // Returns something like: "a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6"
+   * ```
+   */
+  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
+   *
+   * @param _key - The object key being serialized (unused)
+   * @param value - The value to serialize
+   * @returns The serialized value
+   */
+  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) {
@@ -33685,21 +34001,21 @@ var PermissionsController = class {
   /**
    * Grants permission for an application to access user data with gasless transactions.
    *
-   * @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.
+   * 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.
+   *
    * @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({
+   * const result = await vana.permissions.grant({
    *   grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
    *   operation: "llm_inference",
    *   parameters: {
@@ -33709,10 +34025,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);
   }
@@ -33726,6 +34074,8 @@ var PermissionsController = class {
    * until the returned `confirm()` function is called.
    * @param params - The permission grant parameters
    * @returns A promise resolving to a preview object and confirm function
+   * @throws {SerializationError} When grant parameters are invalid or cannot be serialized
+   * @throws {BlockchainError} When grant validation fails or preparation encounters an error
    * @example
    * ```typescript
    * const { preview, confirm } = await vana.permissions.prepareGrant({
@@ -34130,22 +34480,51 @@ 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 (accepts bigint, number, or string).
+   *   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");
@@ -34183,6 +34562,11 @@ var PermissionsController = class {
    *
    * @param params - Parameters for revoking the permission
    * @returns Promise resolving to transaction hash
+   * @throws {BlockchainError} When chain ID is not available
+   * @throws {NonceError} When retrieving user nonce fails
+   * @throws {SignatureError} When user rejects the signature request
+   * @throws {RelayerError} When gasless submission fails
+   * @throws {PermissionError} When revocation fails for any other reason
    */
   async revokeWithSignature(params) {
     try {
@@ -34225,6 +34609,9 @@ var PermissionsController = class {
    * Retrieves the user's current nonce from the DataPermissions contract.
    *
    * @returns Promise resolving to the user's current nonce value
+   * @throws {Error} When wallet account is not available
+   * @throws {Error} When chain ID is not available
+   * @throws {NonceError} When reading nonce from contract fails
    */
   async getUserNonce() {
     try {
@@ -34311,17 +34698,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();
@@ -34464,6 +34858,7 @@ var PermissionsController = class {
    *
    * @param fileId - The file ID to query permissions for
    * @returns Promise resolving to array of permission IDs
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getFilePermissionIds(fileId) {
     try {
@@ -34492,6 +34887,7 @@ var PermissionsController = class {
    *
    * @param permissionId - The permission ID to query files for
    * @returns Promise resolving to array of file IDs
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getPermissionFileIds(permissionId) {
     try {
@@ -34520,6 +34916,7 @@ var PermissionsController = class {
    *
    * @param permissionId - The permission ID to check
    * @returns Promise resolving to boolean indicating if permission is active
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async isActivePermission(permissionId) {
     try {
@@ -34548,6 +34945,7 @@ var PermissionsController = class {
    *
    * @param permissionId - The permission ID to query
    * @returns Promise resolving to permission info
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getPermissionInfo(permissionId) {
     try {
@@ -34595,13 +34993,18 @@ var PermissionsController = class {
    * Trusts a server for data processing.
    *
    * @param params - Parameters for trusting the server
+   * @param params.serverId - The server's Ethereum address
+   * @param params.serverUrl - The server's URL endpoint
    * @returns Promise resolving to transaction hash
+   * @throws {UserRejectedRequestError} When user rejects the transaction
+   * @throws {BlockchainError} When chain ID is unavailable or transaction fails
+   * @throws {Error} When wallet account is not available
    * @example
    * ```typescript
    * // Trust a server by providing its ID and URL
    * const txHash = await vana.permissions.trustServer({
    *   serverId: '0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6',
-   *   serverUrl: 'https://myserver.example.com'
+   *   serverUrl: 'https://personal-server.vana.org'
    * });
    * console.log('Server trusted in transaction:', txHash);
    *
@@ -34642,6 +35045,12 @@ var PermissionsController = class {
    *
    * @param params - Parameters for trusting the server
    * @returns Promise resolving to transaction hash
+   * @throws {BlockchainError} When chain ID is not available
+   * @throws {NonceError} When retrieving user nonce fails
+   * @throws {SignatureError} When user rejects the signature request
+   * @throws {RelayerError} When gasless submission fails
+   * @throws {ServerUrlMismatchError} When server URL doesn't match existing registration
+   * @throws {BlockchainError} When trust operation fails for any other reason
    */
   async trustServerWithSignature(params) {
     try {
@@ -34716,7 +35125,12 @@ var PermissionsController = class {
    * Untrusts a server.
    *
    * @param params - Parameters for untrusting the server
+   * @param params.serverId - The server's Ethereum address to untrust
    * @returns Promise resolving to transaction hash
+   * @throws {Error} When wallet account is not available
+   * @throws {NonceError} When retrieving user nonce fails
+   * @throws {UserRejectedRequestError} When user rejects the transaction
+   * @throws {BlockchainError} When untrust transaction fails
    */
   async untrustServer(params) {
     const nonce = await this.getUserNonce();
@@ -34730,7 +35144,13 @@ var PermissionsController = class {
    * Untrusts a server using a signature (gasless transaction).
    *
    * @param params - Parameters for untrusting the server
+   * @param params.serverId - The server's Ethereum address to untrust
    * @returns Promise resolving to transaction hash
+   * @throws {Error} When wallet account is not available
+   * @throws {NonceError} When retrieving user nonce fails
+   * @throws {SignatureError} When user rejects the signature request
+   * @throws {RelayerError} When gasless submission fails
+   * @throws {BlockchainError} When untrust transaction fails
    */
   async untrustServerWithSignature(params) {
     try {
@@ -34772,6 +35192,7 @@ var PermissionsController = class {
    *
    * @param userAddress - Optional user address (defaults to current user)
    * @returns Promise resolving to array of trusted server addresses
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getTrustedServers(userAddress) {
     try {
@@ -34801,6 +35222,7 @@ var PermissionsController = class {
    *
    * @param serverId - Server address
    * @returns Promise resolving to server information
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getServerInfo(serverId) {
     try {
@@ -34829,6 +35251,7 @@ var PermissionsController = class {
    *
    * @param userAddress - Optional user address (defaults to current user)
    * @returns Promise resolving to the number of trusted servers
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getTrustedServersCount(userAddress) {
     try {
@@ -34858,6 +35281,7 @@ var PermissionsController = class {
    *
    * @param options - Query options including pagination parameters
    * @returns Promise resolving to paginated trusted servers
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getTrustedServersPaginated(options = {}) {
     try {
@@ -34917,6 +35341,7 @@ var PermissionsController = class {
    *
    * @param options - Query options
    * @returns Promise resolving to array of trusted server info
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getTrustedServersWithInfo(options = {}) {
     try {
@@ -34954,6 +35379,7 @@ var PermissionsController = class {
    *
    * @param serverIds - Array of server IDs to query
    * @returns Promise resolving to batch result with successes and failures
+   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
    */
   async getServerInfoBatch(serverIds) {
     if (serverIds.length === 0) {
@@ -35155,15 +35581,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 {
@@ -35328,6 +35761,7 @@ var DataController = class {
       if (encrypt2) {
         const encryptionKey = await generateEncryptionKey(
           this.context.walletClient,
+          this.context.platform,
           DEFAULT_ENCRYPTION_SEED
         );
         finalBlob = await encryptBlobWithSignedKey(
@@ -35353,26 +35787,21 @@ var DataController = class {
       );
       const userAddress = owner || await this.getUserAddress();
       let encryptedPermissions = [];
-      if (permissions.length > 0 && encrypt2) {
+      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 publicKey = permission.publicKey;
-            if (!publicKey) {
-              throw new Error(
-                `Public key required for permission to ${permission.grantee} when encryption is enabled`
-              );
-            }
             const encryptedKey = await encryptWithWalletPublicKey(
               userEncryptionKey,
-              publicKey,
+              permission.publicKey,
               this.context.platform
             );
             return {
-              account: permission.grantee,
+              account: permission.account,
               key: encryptedKey
             };
           })
@@ -35444,9 +35873,14 @@ var DataController = class {
    * @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)
+   * @throws {Error} "No addresses available in wallet client" - When wallet is not connected
+   * @throws {Error} "Network error: Cannot access the file URL" - When file URL is inaccessible (CORS, server down)
+   * @throws {Error} "File not found: The encrypted file is no longer available" - When file returns 404
+   * @throws {Error} "Access denied" - When file returns 403 (no permission)
+   * @throws {Error} "File is empty or could not be retrieved" - When file has no content
+   * @throws {Error} "Invalid file format: This file doesn't appear to be encrypted with the Vana protocol" - When file is not properly encrypted
+   * @throws {Error} "Wrong encryption key" - When decryption fails due to incorrect key/seed
+   * @throws {Error} "Failed to decrypt file: {error}" - General decryption failures
    * @example
    * ```typescript
    * // Basic file decryption
@@ -35476,6 +35910,7 @@ var DataController = class {
     try {
       const encryptionKey = await generateEncryptionKey(
         this.context.walletClient,
+        this.context.platform,
         encryptionSeed || DEFAULT_ENCRYPTION_SEED
       );
       let encryptedBlob;
@@ -35565,11 +36000,20 @@ var DataController = class {
    * This method queries the Vana subgraph to find files directly owned by the user.
    * It efficiently handles large datasets by using the File entity's owner field
    * and returns complete file metadata without additional contract calls.
+   *
+   * **Deduplication Behavior:**
+   * The method automatically deduplicates files by ID, keeping only the latest version
+   * (highest timestamp) when duplicate file IDs are found. This handles cases where
+   * the subgraph may contain multiple entries for the same file due to re-indexing
+   * or blockchain reorganizations.
    * @param params - The query parameters object
    * @param params.owner - The wallet address of the file owner to query
    * @param params.subgraphUrl - Optional subgraph URL to override the default endpoint
-   * @returns A Promise that resolves to an array of UserFile objects with metadata
-   * @throws {Error} When the subgraph is unavailable or returns invalid data
+   * @returns A Promise that resolves to an array of UserFile objects with metadata, sorted by latest timestamp first
+   * @throws {Error} When subgraphUrl is not provided and not configured - "subgraphUrl is required"
+   * @throws {Error} When subgraph request fails - "Subgraph request failed: {status} {statusText}"
+   * @throws {Error} When subgraph returns errors - "Subgraph errors: {error messages}"
+   * @throws {Error} When JSON parsing fails - "Failed to fetch user files from subgraph: {error}"
    * @example
    * ```typescript
    * // Query files for a specific user
@@ -36072,6 +36516,9 @@ var DataController = class {
    *
    * @param fileId - The file ID to look up
    * @returns Promise resolving to UserFile object
+   * @throws {Error} "Chain ID not available" - When wallet chain is not configured
+   * @throws {Error} "File not found" - When file ID doesn't exist or returns empty data
+   * @throws {Error} "Failed to fetch file {fileId}: {error}" - General contract read failures
    * @example
    * ```typescript
    * try {
@@ -36141,7 +36588,21 @@ 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
+   * @deprecated Since v2.0.0 - Use vana.data.upload() instead for the high-level API with automatic encryption
+   *
+   * Migration guide:
+   * ```typescript
+   * // Old way (deprecated):
+   * const encrypted = await encryptBlob(data, key);
+   * const result = await vana.data.uploadEncryptedFile(encrypted, filename);
+   *
+   * // New way:
+   * const result = await vana.data.upload({
+   *   content: data,
+   *   filename: filename,
+   *   encrypt: true  // Handles encryption automatically
+   * });
+   * ```
    * @param encryptedFile - The encrypted file blob to upload
    * @param filename - Optional filename for the upload
    * @param providerName - Optional storage provider to use
@@ -36229,7 +36690,22 @@ 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
+   * @deprecated Since v2.0.0 - Use vana.data.upload() instead for the high-level API with automatic encryption and schema validation
+   *
+   * Migration guide:
+   * ```typescript
+   * // Old way (deprecated):
+   * const encrypted = await encryptBlob(data, key);
+   * const result = await vana.data.uploadEncryptedFileWithSchema(encrypted, schemaId, filename);
+   *
+   * // New way:
+   * const result = await vana.data.upload({
+   *   content: data,
+   *   filename: filename,
+   *   schemaId: schemaId,  // Automatic validation
+   *   encrypt: true
+   * });
+   * ```
    * @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
@@ -36372,6 +36848,7 @@ var DataController = class {
    * Gets the user's address from the wallet client.
    *
    * @returns Promise resolving to the user's wallet address
+   * @throws {Error} When no addresses are available in wallet client
    */
   async getUserAddress() {
     const addresses = await this.context.walletClient.getAddresses();
@@ -36387,6 +36864,10 @@ var DataController = class {
    * @param ownerAddress - The address of the file owner
    * @param permissions - Array of permissions to set for the file
    * @returns Promise resolving to file ID and transaction hash
+   * @throws {Error} When chain ID is not available
+   * @throws {ContractError} When contract execution fails
+   * @throws {Error} When transaction receipt is not available
+   * @throws {Error} When FileAdded event cannot be parsed
    *
    * This method handles the core logic of registering a file
    * with specific permissions on the DataRegistry contract. It can be used
@@ -36451,6 +36932,10 @@ var DataController = class {
    * @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
+   * @throws {Error} When chain ID is not available
+   * @throws {ContractError} When contract execution fails
+   * @throws {Error} When transaction receipt is not available
+   * @throws {Error} When FileAdded event cannot be parsed
    */
   async addFileWithPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0) {
     try {
@@ -36505,7 +36990,24 @@ var DataController = class {
   /**
    * Adds a new schema to the DataRefinerRegistry.
    *
-   * @deprecated Use vana.schemas.create() instead for the high-level API with automatic IPFS upload
+   * @deprecated Since v2.0.0 - Use vana.schemas.create() instead for the high-level API with automatic IPFS upload
+   *
+   * Migration guide:
+   * ```typescript
+   * // Old way (deprecated):
+   * const result = await vana.data.addSchema({
+   *   name: "UserProfile",
+   *   type: "JSON",
+   *   definitionUrl: "ipfs://..."
+   * });
+   *
+   * // New way:
+   * const result = await vana.schemas.create({
+   *   name: "UserProfile",
+   *   type: "JSON",
+   *   definition: schemaObject  // Automatically uploads to IPFS
+   * });
+   * ```
    * @param params - Schema parameters including name, type, and definition URL
    * @returns Promise resolving to the new schema ID and transaction hash
    */
@@ -36564,7 +37066,16 @@ var DataController = class {
   /**
    * Retrieves a schema by its ID.
    *
-   * @deprecated Use vana.schemas.get() instead
+   * @deprecated Since v2.0.0 - Use vana.schemas.get() instead
+   *
+   * Migration guide:
+   * ```typescript
+   * // Old way (deprecated):
+   * const schema = await vana.data.getSchema(schemaId);
+   *
+   * // New way:
+   * const schema = await vana.schemas.get(schemaId);
+   * ```
    * @param schemaId - The schema ID to retrieve
    * @returns Promise resolving to the schema information
    */
@@ -36610,7 +37121,16 @@ var DataController = class {
   /**
    * Gets the total number of schemas in the registry.
    *
-   * @deprecated Use vana.schemas.count() instead
+   * @deprecated Since v2.0.0 - Use vana.schemas.count() instead
+   *
+   * Migration guide:
+   * ```typescript
+   * // Old way (deprecated):
+   * const count = await vana.data.getSchemasCount();
+   *
+   * // New way:
+   * const count = await vana.schemas.count();
+   * ```
    * @returns Promise resolving to the total schema count
    */
   async getSchemasCount() {
@@ -36859,6 +37379,7 @@ var DataController = class {
     try {
       const userEncryptionKey = await generateEncryptionKey(
         this.context.walletClient,
+        this.context.platform,
         DEFAULT_ENCRYPTION_SEED
       );
       const encryptedData = await encryptBlobWithSignedKey(
@@ -36924,16 +37445,50 @@ 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 (hex string with 0x prefix)
+   * @returns Promise resolving to permission data from PermissionGranted event
+   * @throws {Error} "No addresses available in wallet client" - When wallet is not connected
+   * @throws {Error} "Chain ID not available" - When wallet chain is not configured
+   * @throws {Error} "Failed to add permission to file: {error}" - When transaction fails or user doesn't own file
+   * @example
+   * ```typescript
+   * const result = await vana.data.addPermissionToFile(fileId, 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 addPermissionToFile(fileId, account, publicKey) {
+  async submitFilePermission(fileId, account, publicKey) {
     try {
       const userEncryptionKey = await generateEncryptionKey(
         this.context.walletClient,
+        this.context.platform,
         DEFAULT_ENCRYPTION_SEED
       );
       const encryptedKey = await encryptWithWalletPublicKey(
@@ -37054,7 +37609,9 @@ var DataController = class {
    *
    * @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
+   * @throws {Error} "HTTP error! status: {status} {statusText}" - When server returns error status
+   * @throws {Error} "Empty response" - When server returns no content
+   * @throws {Error} "Network error: Failed to fetch from {url}" - When network request fails
    *
    * @example
    * ```typescript
@@ -37106,7 +37663,10 @@ var DataController = class {
    * @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
+   * @throws {Error} "Invalid IPFS URL format" - When URL is not ipfs:// or valid CID
+   * @throws {Error} "Empty response" - When gateway returns no content
+   * @throws {Error} "HTTP error! status: {status}" - When gateway returns error status
+   * @throws {Error} "Failed to fetch IPFS content {cid} from all gateways" - When all gateways fail
    *
    * @example
    * ```typescript
@@ -37647,6 +38207,39 @@ var ServerController = class {
     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(
@@ -37689,10 +38282,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({
@@ -37794,6 +38390,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(
@@ -38097,7 +38737,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
@@ -38206,6 +38847,7 @@ var ProtocolController = class {
    * Gets the current chain ID from the wallet client.
    *
    * @returns The chain ID
+   * @throws {Error} When chain ID is not available from wallet client
    */
   getChainId() {
     const chainId = this.context.walletClient.chain?.id;
@@ -38218,6 +38860,7 @@ var ProtocolController = class {
    * Gets the current chain name from the wallet client.
    *
    * @returns The chain name
+   * @throws {Error} When chain name is not available from wallet client
    */
   getChainName() {
     const chainName = this.context.walletClient.chain?.name;
@@ -38718,6 +39361,7 @@ var GoogleDriveStorage = class {
 };
 
 // src/storage/providers/ipfs.ts
+init_crypto_utils();
 var IpfsStorage = class _IpfsStorage {
   constructor(config) {
     this.config = config;
@@ -38757,7 +39401,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",
@@ -40049,15 +40693,35 @@ var VanaCore = class {
   }
   /**
    * Encrypts data using the Vana protocol standard encryption.
-   * This method automatically uses the correct platform adapter for the current environment.
+   * 
+   * @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 key The key 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.encryptBlob("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 encryptBlob(data, key) {
@@ -40065,16 +40729,52 @@ var VanaCore = class {
   }
   /**
    * Decrypts data that was encrypted using the Vana protocol.
-   * This method automatically uses the correct platform adapter for the current environment.
+   * 
+   * @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.decryptBlob(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 decryptBlob(encryptedData, walletSignature) {
@@ -40919,6 +41619,7 @@ export {
   SerializationError,
   ServerController,
   ServerUrlMismatchError,
+  SignatureCache,
   SignatureError,
   StorageError,
   StorageManager,
@@ -40989,6 +41690,7 @@ export {
   validateGrantFile,
   validateGranteeAccess,
   validateOperationAccess,
-  vanaMainnet2 as vanaMainnet
+  vanaMainnet2 as vanaMainnet,
+  withSignatureCache
 };
 //# sourceMappingURL=index.browser.js.map