@opendatalabs/vana-sdk 0.1.0-alpha.376e2fd → 0.1.0-alpha.52b50da

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,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) {
@@ -33684,22 +33933,22 @@ 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({
+   * const result = await vana.permissions.grant({
    *   grantee: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
    *   operation: "llm_inference",
    *   parameters: {
@@ -33709,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);
   }
@@ -34129,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");
@@ -34311,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();
@@ -35155,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 {
@@ -35272,7 +35596,8 @@ var DataController = class {
       schemaId,
       permissions = [],
       encrypt: encrypt2 = true,
-      providerName
+      providerName,
+      owner
     } = params;
     try {
       let blob;
@@ -35327,6 +35652,7 @@ var DataController = class {
       if (encrypt2) {
         const encryptionKey = await generateEncryptionKey(
           this.context.walletClient,
+          this.context.platform,
           DEFAULT_ENCRYPTION_SEED
         );
         finalBlob = await encryptBlobWithSignedKey(
@@ -35350,28 +35676,23 @@ var DataController = class {
         filename,
         providerName
       );
-      const userAddress = await this.getUserAddress();
+      const userAddress = owner || await this.getUserAddress();
       let encryptedPermissions = [];
       if (permissions.length > 0 && encrypt2) {
         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
             };
           })
@@ -35384,7 +35705,8 @@ var DataController = class {
             url: uploadResult.url,
             userAddress,
             permissions: encryptedPermissions,
-            schemaId: schemaId || 0
+            schemaId: schemaId || 0,
+            ownerAddress: owner
           }
         );
       } else if (this.context.relayerCallbacks?.submitFileAddition) {
@@ -35474,6 +35796,7 @@ var DataController = class {
     try {
       const encryptionKey = await generateEncryptionKey(
         this.context.walletClient,
+        this.context.platform,
         encryptionSeed || DEFAULT_ENCRYPTION_SEED
       );
       let encryptedBlob;
@@ -36857,6 +37180,7 @@ var DataController = class {
     try {
       const userEncryptionKey = await generateEncryptionKey(
         this.context.walletClient,
+        this.context.platform,
         DEFAULT_ENCRYPTION_SEED
       );
       const encryptedData = await encryptBlobWithSignedKey(
@@ -36922,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(
@@ -37645,6 +38000,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(
@@ -37687,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({
@@ -37792,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(
@@ -38095,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
@@ -38716,6 +39152,7 @@ var GoogleDriveStorage = class {
 };
 
 // src/storage/providers/ipfs.ts
+init_crypto_utils();
 var IpfsStorage = class _IpfsStorage {
   constructor(config) {
     this.config = config;
@@ -38755,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",
@@ -39279,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
-   *
-   * @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
+   * Upload a file using the provided callback
    *
-   * @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
+   * Download a file using the provided callback
    *
-   * @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
-   *
-   * @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
       }
     };
   }
@@ -40071,15 +40484,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) {
@@ -40087,16 +40520,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) {
@@ -40907,6 +41376,7 @@ export {
   BaseController,
   BlockchainError,
   BrowserPlatformAdapter,
+  CallbackStorage,
   CircuitBreaker,
   ContractFactory,
   ContractNotFoundError,
@@ -40939,8 +41409,8 @@ export {
   SchemaValidator,
   SerializationError,
   ServerController,
-  ServerProxyStorage,
   ServerUrlMismatchError,
+  SignatureCache,
   SignatureError,
   StorageError,
   StorageManager,
@@ -41011,6 +41481,7 @@ export {
   validateGrantFile,
   validateGranteeAccess,
   validateOperationAccess,
-  vanaMainnet2 as vanaMainnet
+  vanaMainnet2 as vanaMainnet,
+  withSignatureCache
 };
 //# sourceMappingURL=index.browser.js.map