@opendatalabs/vana-sdk 0.1.0-alpha.1bbb6d4 → 0.1.0-alpha.273dc39

package/dist/index.node.js

@@ -1139,12 +1139,486 @@ var PermissionError = class extends VanaError {
   }
 };
 
+// src/utils/multicall.ts
+import { encodeFunctionData, size } from "viem";
+
+// src/config/addresses.ts
+var CONTRACTS = {
+  // Data Portability Contracts (New Architecture)
+  DataPortabilityPermissions: {
+    addresses: {
+      14800: "0xD54523048AdD05b4d734aFaE7C68324Ebb7373eF",
+      1480: "0xD54523048AdD05b4d734aFaE7C68324Ebb7373eF"
+    }
+  },
+  DataPortabilityServers: {
+    addresses: {
+      14800: "0x1483B1F634DBA75AeaE60da7f01A679aabd5ee2c",
+      1480: "0x1483B1F634DBA75AeaE60da7f01A679aabd5ee2c"
+    }
+  },
+  DataPortabilityGrantees: {
+    addresses: {
+      14800: "0x8325C0A0948483EdA023A1A2Fd895e62C5131234",
+      1480: "0x8325C0A0948483EdA023A1A2Fd895e62C5131234"
+    }
+  },
+  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;
+};
+var getUtilityAddress = (chainId, contract) => {
+  return UTILITY_ADDRESSES[chainId][contract];
+};
+
+// src/utils/multicall.ts
+var DEFAULT_OPTIONS = {
+  maxGasPerBatch: 10000000n,
+  // 10M gas - conservative default
+  maxCalldataBytes: 1e5,
+  // 100KB - works with most RPC providers
+  checkpointFrequency: {
+    calls: 32,
+    bytes: 8192
+    // 8KB
+  },
+  allowFailure: false
+};
+async function gasAwareMulticall(client, parameters, options = {}) {
+  const chainId = await client.getChainId();
+  const multicall3Address = options.multicallAddress || getUtilityAddress(chainId, "Multicall3");
+  const opts = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+    multicallAddress: multicall3Address,
+    checkpointFrequency: {
+      ...DEFAULT_OPTIONS.checkpointFrequency,
+      ...options.checkpointFrequency
+    }
+  };
+  if (parameters.allowFailure !== void 0) {
+    opts.allowFailure = parameters.allowFailure;
+  }
+  const { contracts } = parameters;
+  if (!contracts || contracts.length === 0) {
+    return [];
+  }
+  const batches = await createBatches(
+    client,
+    contracts,
+    opts
+  );
+  const batchResults = await Promise.all(
+    batches.map((batch, index) => {
+      if (opts.onProgress && index > 0) {
+        const completed = batches.slice(0, index).reduce((sum, b) => sum + b.length, 0);
+        opts.onProgress(completed, contracts.length);
+      }
+      return client.multicall({
+        ...parameters,
+        contracts: batch,
+        multicallAddress: opts.multicallAddress,
+        allowFailure: opts.allowFailure
+      });
+    })
+  );
+  if (opts.onProgress) {
+    opts.onProgress(contracts.length, contracts.length);
+  }
+  return batchResults.flat();
+}
+async function createBatches(client, contracts, options) {
+  const batches = [];
+  let currentBatch = [];
+  let currentBytes = 0;
+  let lastCheckpointIndex = 0;
+  let lastCheckpointBytes = 0;
+  let lastEstimatedGas = 0n;
+  for (let i = 0; i < contracts.length; i++) {
+    const contract = contracts[i];
+    const encoded = encodeContractCall(contract);
+    const callBytes = size(encoded);
+    const callsSinceCheckpoint = i - lastCheckpointIndex;
+    const bytesSinceCheckpoint = currentBytes - lastCheckpointBytes;
+    const needsCheckpoint = callsSinceCheckpoint >= options.checkpointFrequency.calls || bytesSinceCheckpoint >= options.checkpointFrequency.bytes;
+    if (needsCheckpoint && currentBatch.length > 0) {
+      try {
+        lastEstimatedGas = await estimateBatchGas(
+          client,
+          currentBatch,
+          options.multicallAddress
+        );
+        lastCheckpointIndex = i;
+        lastCheckpointBytes = currentBytes;
+      } catch (error) {
+        if (currentBatch.length > 1) {
+          const halfBatch = currentBatch.slice(
+            0,
+            Math.floor(currentBatch.length / 2)
+          );
+          batches.push(halfBatch);
+          currentBatch = currentBatch.slice(halfBatch.length);
+          currentBytes = calculateBatchSize(currentBatch);
+          lastCheckpointIndex = i;
+          lastCheckpointBytes = currentBytes;
+          lastEstimatedGas = 0n;
+        } else {
+          if (!options.allowFailure) {
+            throw new Error(`Gas estimation failed for call ${i}: ${error}`);
+          }
+          currentBatch = [];
+          currentBytes = 0;
+          continue;
+        }
+      }
+    }
+    const wouldExceedCalldata = currentBytes + callBytes > options.maxCalldataBytes;
+    const wouldExceedGas = lastEstimatedGas > 0n && estimateNextGas(lastEstimatedGas, callsSinceCheckpoint + 1) > options.maxGasPerBatch;
+    if ((wouldExceedCalldata || wouldExceedGas) && currentBatch.length > 0) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentBytes = 0;
+      lastCheckpointIndex = i;
+      lastCheckpointBytes = 0;
+      lastEstimatedGas = 0n;
+    }
+    currentBatch.push(contract);
+    currentBytes += callBytes;
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+function encodeContractCall(contract) {
+  const { abi, functionName, args } = contract;
+  return encodeFunctionData({
+    abi,
+    functionName,
+    args
+  });
+}
+function calculateBatchSize(batch) {
+  return batch.reduce((total, contract) => {
+    const encoded = encodeContractCall(contract);
+    return total + size(encoded);
+  }, 0);
+}
+async function estimateBatchGas(client, batch, multicallAddress) {
+  const calls = batch.map((contract) => ({
+    target: contract.address,
+    allowFailure: false,
+    callData: encodeContractCall(contract)
+  }));
+  const gas = await client.estimateGas({
+    to: multicallAddress,
+    data: encodeFunctionData({
+      abi: multicall3Abi,
+      functionName: "aggregate3",
+      args: [calls]
+    })
+  });
+  return gas;
+}
+function estimateNextGas(lastGas, callsSinceCheckpoint) {
+  if (callsSinceCheckpoint === 0) return lastGas;
+  const avgGasPerCall = lastGas / BigInt(Math.max(1, callsSinceCheckpoint - 1));
+  const estimatedGas = lastGas + avgGasPerCall;
+  return estimatedGas * 110n / 100n;
+}
+var multicall3Abi = [
+  {
+    name: "aggregate3",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "allowFailure", type: "bool" },
+          { name: "callData", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "returnData",
+        type: "tuple[]",
+        components: [
+          { name: "success", type: "bool" },
+          { name: "returnData", type: "bytes" }
+        ]
+      }
+    ]
+  }
+];
+
 // src/utils/transactionParsing.ts
 import { parseEventLogs } from "viem";
 
 // src/config/eventMappings.ts
 var EVENT_MAPPINGS = {
-  // Permission operations
+  // DataPortabilityPermissions operations
   grant: {
     contract: "DataPortabilityPermissions",
     event: "PermissionAdded"
@@ -1153,6 +1627,15 @@ var EVENT_MAPPINGS = {
     contract: "DataPortabilityPermissions",
     event: "PermissionRevoked"
   },
+  revokePermission: {
+    contract: "DataPortabilityPermissions",
+    event: "PermissionRevoked"
+  },
+  addServerFilesAndPermissions: {
+    contract: "DataPortabilityPermissions",
+    event: "PermissionAdded"
+  },
+  // DataPortabilityServers operations
   trustServer: {
     contract: "DataPortabilityServers",
     event: "ServerTrusted"
@@ -1161,15 +1644,51 @@ var EVENT_MAPPINGS = {
     contract: "DataPortabilityServers",
     event: "ServerUntrusted"
   },
-  // Data registry operations
+  registerServer: {
+    contract: "DataPortabilityServers",
+    event: "ServerRegistered"
+  },
+  updateServer: {
+    contract: "DataPortabilityServers",
+    event: "ServerUpdated"
+  },
+  addAndTrustServer: {
+    contract: "DataPortabilityServers",
+    event: "ServerTrusted"
+  },
+  // DataRegistry operations
   addFile: {
     contract: "DataRegistry",
     event: "FileAdded"
   },
+  addFileWithPermissionsAndSchema: {
+    contract: "DataRegistry",
+    event: "FileAdded"
+  },
+  addFileWithSchema: {
+    contract: "DataRegistry",
+    event: "FileAdded"
+  },
+  addFileWithPermissions: {
+    contract: "DataRegistry",
+    event: "FileAdded"
+  },
   addRefinement: {
     contract: "DataRegistry",
     event: "RefinementAdded"
   },
+  addRefiner: {
+    contract: "DataRefinerRegistry",
+    event: "RefinerAdded"
+  },
+  updateSchemaId: {
+    contract: "DataRefinerRegistry",
+    event: "SchemaAdded"
+  },
+  addSchema: {
+    contract: "DataRefinerRegistry",
+    event: "SchemaAdded"
+  },
   updateRefinement: {
     contract: "DataRegistry",
     event: "RefinementUpdated"
@@ -1177,10 +1696,15 @@ var EVENT_MAPPINGS = {
   addFilePermission: {
     contract: "DataRegistry",
     event: "PermissionGranted"
+  },
+  // DataPortabilityGrantees operations
+  registerGrantee: {
+    contract: "DataPortabilityGrantees",
+    event: "GranteeRegistered"
   }
 };
 
-// src/abi/ComputeEngineImplementation.ts
+// src/generated/abi/ComputeEngineImplementation.ts
 var ComputeEngineABI = [
   {
     inputs: [],
@@ -2465,7 +2989,7 @@ var ComputeEngineABI = [
   }
 ];
 
-// src/abi/DataRegistryImplementation.ts
+// src/generated/abi/DataRegistryImplementation.ts
 var DataRegistryABI = [
   {
     inputs: [],
@@ -3655,7 +4179,7 @@ var DataRegistryABI = [
   }
 ];
 
-// src/abi/TeePoolImplementation.ts
+// src/generated/abi/TeePoolImplementation.ts
 var TeePoolABI = [
   {
     inputs: [],
@@ -4940,7 +5464,7 @@ var TeePoolABI = [
   }
 ];
 
-// src/abi/TeePoolPhalaImplementation.ts
+// src/generated/abi/TeePoolPhalaImplementation.ts
 var TeePoolPhalaABI = [
   {
     inputs: [],
@@ -6225,7 +6749,7 @@ var TeePoolPhalaABI = [
   }
 ];
 
-// src/abi/DataPortabilityPermissionsImplementation.ts
+// src/generated/abi/DataPortabilityPermissionsImplementation.ts
 var DataPortabilityPermissionsABI = [
   {
     inputs: [],
@@ -7493,7 +8017,7 @@ var DataPortabilityPermissionsABI = [
   }
 ];
 
-// src/abi/DataPortabilityServersImplementation.ts
+// src/generated/abi/DataPortabilityServersImplementation.ts
 var DataPortabilityServersABI = [
   {
     inputs: [],
@@ -8885,7 +9409,7 @@ var DataPortabilityServersABI = [
   }
 ];
 
-// src/abi/DataPortabilityGranteesImplementation.ts
+// src/generated/abi/DataPortabilityGranteesImplementation.ts
 var DataPortabilityGranteesABI = [
   {
     inputs: [],
@@ -9745,7 +10269,7 @@ var DataPortabilityGranteesABI = [
   }
 ];
 
-// src/abi/DataRefinerRegistryImplementation.ts
+// src/generated/abi/DataRefinerRegistryImplementation.ts
 var DataRefinerRegistryABI = [
   {
     inputs: [],
@@ -10701,7 +11225,7 @@ var DataRefinerRegistryABI = [
   }
 ];
 
-// src/abi/QueryEngineImplementation.ts
+// src/generated/abi/QueryEngineImplementation.ts
 var QueryEngineABI = [
   {
     inputs: [],
@@ -11992,7 +12516,7 @@ var QueryEngineABI = [
   }
 ];
 
-// src/abi/ComputeInstructionRegistryImplementation.ts
+// src/generated/abi/ComputeInstructionRegistryImplementation.ts
 var ComputeInstructionRegistryABI = [
   {
     inputs: [],
@@ -12698,7 +13222,7 @@ var ComputeInstructionRegistryABI = [
   }
 ];
 
-// src/abi/TeePoolEphemeralStandardImplementation.ts
+// src/generated/abi/TeePoolEphemeralStandardImplementation.ts
 var TeePoolEphemeralStandardABI = [
   {
     inputs: [],
@@ -13606,7 +14130,7 @@ var TeePoolEphemeralStandardABI = [
   }
 ];
 
-// src/abi/TeePoolPersistentStandardImplementation.ts
+// src/generated/abi/TeePoolPersistentStandardImplementation.ts
 var TeePoolPersistentStandardABI = [
   {
     inputs: [],
@@ -14514,7 +15038,7 @@ var TeePoolPersistentStandardABI = [
   }
 ];
 
-// src/abi/TeePoolPersistentGpuImplementation.ts
+// src/generated/abi/TeePoolPersistentGpuImplementation.ts
 var TeePoolPersistentGpuABI = [
   {
     inputs: [],
@@ -15422,7 +15946,7 @@ var TeePoolPersistentGpuABI = [
   }
 ];
 
-// src/abi/TeePoolDedicatedStandardImplementation.ts
+// src/generated/abi/TeePoolDedicatedStandardImplementation.ts
 var TeePoolDedicatedStandardABI = [
   {
     inputs: [],
@@ -16330,7 +16854,7 @@ var TeePoolDedicatedStandardABI = [
   }
 ];
 
-// src/abi/TeePoolDedicatedGpuImplementation.ts
+// src/generated/abi/TeePoolDedicatedGpuImplementation.ts
 var TeePoolDedicatedGpuABI = [
   {
     inputs: [],
@@ -17238,7 +17762,7 @@ var TeePoolDedicatedGpuABI = [
   }
 ];
 
-// src/abi/VanaEpochImplementation.ts
+// src/generated/abi/VanaEpochImplementation.ts
 var VanaEpochABI = [
   {
     inputs: [],
@@ -18398,7 +18922,7 @@ var VanaEpochABI = [
   }
 ];
 
-// src/abi/DLPRegistryImplementation.ts
+// src/generated/abi/DLPRegistryImplementation.ts
 var DLPRegistryABI = [
   {
     inputs: [],
@@ -19839,7 +20363,7 @@ var DLPRegistryABI = [
   }
 ];
 
-// src/abi/DLPTreasuryImplementation.ts
+// src/generated/abi/DLPTreasuryImplementation.ts
 var DLPRegistryTreasuryABI = [
   {
     inputs: [],
@@ -20423,7 +20947,7 @@ var DLPRegistryTreasuryABI = [
   }
 ];
 
-// src/abi/DLPRewardDeployerTreasuryImplementation.ts
+// src/generated/abi/DLPRewardDeployerTreasuryImplementation.ts
 var DLPRewardDeployerTreasuryABI = [
   {
     inputs: [],
@@ -21007,7 +21531,7 @@ var DLPRewardDeployerTreasuryABI = [
   }
 ];
 
-// src/abi/DLPPerformanceImplementation.ts
+// src/generated/abi/DLPPerformanceImplementation.ts
 var DLPPerformanceABI = [
   {
     inputs: [],
@@ -22139,7 +22663,7 @@ var DLPPerformanceABI = [
   }
 ];
 
-// src/abi/DLPRewardDeployerImplementation.ts
+// src/generated/abi/DLPRewardDeployerImplementation.ts
 var DLPRewardDeployerABI = [
   {
     inputs: [],
@@ -23059,7 +23583,7 @@ var DLPRewardDeployerABI = [
   }
 ];
 
-// src/abi/DLPRewardSwapImplementation.ts
+// src/generated/abi/DLPRewardSwapImplementation.ts
 var DLPRewardSwapABI = [
   {
     inputs: [],
@@ -23970,7 +24494,7 @@ var DLPRewardSwapABI = [
   }
 ];
 
-// src/abi/SwapHelperImplementation.ts
+// src/generated/abi/SwapHelperImplementation.ts
 var SwapHelperABI = [
   {
     inputs: [],
@@ -24961,7 +25485,7 @@ var SwapHelperABI = [
   }
 ];
 
-// src/abi/DLPRootImplementation.ts
+// src/generated/abi/DLPRootImplementation.ts
 var DLPRootImplementation2Abi = [
   {
     inputs: [],
@@ -26579,7 +27103,7 @@ var DLPRootImplementation2Abi = [
   }
 ];
 
-// src/abi/DataLiquidityPoolImplementation.ts
+// src/generated/abi/DataLiquidityPoolImplementation.ts
 var DataLiquidityPoolImplementationAbi = [
   {
     inputs: [],
@@ -27538,7 +28062,7 @@ var DataLiquidityPoolImplementationAbi = [
   }
 ];
 
-// src/abi/DLPRegistryTreasuryImplementation.ts
+// src/generated/abi/DLPRegistryTreasuryImplementation.ts
 var DLPRegistryTreasuryABI2 = [
   {
     inputs: [],
@@ -28122,7 +28646,7 @@ var DLPRegistryTreasuryABI2 = [
   }
 ];
 
-// src/abi/VanaPoolStakingImplementation.ts
+// src/generated/abi/VanaPoolStakingImplementation.ts
 var VanaPoolStakingABI = [
   {
     inputs: [],
@@ -29015,7 +29539,7 @@ var VanaPoolStakingABI = [
   }
 ];
 
-// src/abi/VanaPoolEntityImplementation.ts
+// src/generated/abi/VanaPoolEntityImplementation.ts
 var VanaPoolEntityABI = [
   {
     inputs: [],
@@ -30221,7 +30745,7 @@ var VanaPoolEntityABI = [
   }
 ];
 
-// src/abi/VanaPoolTreasuryImplementation.ts
+// src/generated/abi/VanaPoolTreasuryImplementation.ts
 var VanaPoolTreasuryABI = [
   {
     inputs: [],
@@ -30731,7 +31255,7 @@ var VanaPoolTreasuryABI = [
   }
 ];
 
-// src/abi/DATImplementation.ts
+// src/generated/abi/DATImplementation.ts
 var DATABI = [
   {
     inputs: [],
@@ -31637,7 +32161,7 @@ var DATABI = [
   }
 ];
 
-// src/abi/DATFactoryImplementation.ts
+// src/generated/abi/DATFactoryImplementation.ts
 var DATFactoryABI = [
   {
     inputs: [],
@@ -32491,7 +33015,7 @@ var DATFactoryABI = [
   }
 ];
 
-// src/abi/DATPausableImplementation.ts
+// src/generated/abi/DATPausableImplementation.ts
 var DATPausableABI = [
   {
     inputs: [],
@@ -33986,7 +34510,7 @@ var DATPausableABI = [
   }
 ];
 
-// src/abi/DATVotesImplementation.ts
+// src/generated/abi/DATVotesImplementation.ts
 var DATVotesABI = [
   {
     inputs: [],
@@ -35418,7 +35942,7 @@ var DATVotesABI = [
   }
 ];
 
-// src/abi/index.ts
+// src/generated/abi/index.ts
 var contractAbis = {
   DataPortabilityPermissions: DataPortabilityPermissionsABI,
   DataPortabilityServers: DataPortabilityServersABI,
@@ -35524,288 +36048,99 @@ async function parseTransactionResult(context, hash, operation) {
   }
 }
 
-// src/config/addresses.ts
-var CONTRACTS = {
-  // Data Portability Contracts (New Architecture)
-  DataPortabilityPermissions: {
-    addresses: {
-      14800: "0xD54523048AdD05b4d734aFaE7C68324Ebb7373eF",
-      1480: "0xD54523048AdD05b4d734aFaE7C68324Ebb7373eF"
-    }
-  },
-  DataPortabilityServers: {
-    addresses: {
-      14800: "0x1483B1F634DBA75AeaE60da7f01A679aabd5ee2c",
-      1480: "0x1483B1F634DBA75AeaE60da7f01A679aabd5ee2c"
-    }
-  },
-  DataPortabilityGrantees: {
-    addresses: {
-      14800: "0x8325C0A0948483EdA023A1A2Fd895e62C5131234",
-      1480: "0x8325C0A0948483EdA023A1A2Fd895e62C5131234"
-    }
-  },
-  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"
-    }
+// src/utils/transactionHandle.ts
+var TransactionHandle = class {
+  constructor(context, hash, operation) {
+    this.context = context;
+    this.hash = hash;
+    this.operation = operation;
   }
-};
-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"
+  _receipt;
+  _eventData;
+  _receiptPromise;
+  _eventPromise;
+  /**
+   * Waits for transaction confirmation and returns the receipt.
+   * Results are memoized - multiple calls return the same promise.
+   *
+   * @param options Optional timeout configuration
+   * @param options.timeout Timeout in milliseconds (default: 30000)
+   * @returns Transaction receipt with gas usage, logs, and status
+   */
+  async waitForReceipt(options) {
+    if (this._receipt) {
+      return this._receipt;
+    }
+    if (!this._receiptPromise) {
+      this._receiptPromise = this.context.publicClient.waitForTransactionReceipt({
+        hash: this.hash,
+        timeout: options?.timeout ?? 3e4
+      }).then((receipt) => {
+        this._receipt = receipt;
+        return receipt;
+      });
     }
-  },
-  DLPRootStakesTreasury: {
-    addresses: {
-      14800: "0x52c3260ED5C235fcA43524CF508e29c897318775",
-      1480: "0x52c3260ED5C235fcA43524CF508e29c897318775"
+    return this._receiptPromise;
+  }
+  /**
+   * Waits for transaction confirmation and parses emitted events.
+   * Results are memoized - multiple calls return the same promise.
+   *
+   * @returns Parsed event data with transaction metadata
+   * @throws {Error} If no operation was specified for event parsing
+   */
+  async waitForEvents() {
+    if (this._eventData) {
+      return this._eventData;
     }
-  },
-  DLPRootRewardsTreasury: {
-    addresses: {
-      14800: "0xDBFb6B8b9E2eCAEbdE64d665cD553dB81e524479",
-      1480: "0xDBFb6B8b9E2eCAEbdE64d665cD553dB81e524479"
+    if (!this._eventPromise) {
+      if (!this.operation) {
+        throw new Error(
+          "Cannot parse events: no operation specified. Use waitForReceipt() instead or ensure the operation is configured."
+        );
+      }
+      this._eventPromise = parseTransactionResult(
+        this.context,
+        this.hash,
+        this.operation
+      ).then((eventData) => {
+        this._eventData = eventData;
+        return eventData;
+      });
     }
+    return this._eventPromise;
   }
-};
-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]
+  /**
+   * Enables string coercion for backwards compatibility.
+   * Allows TransactionHandle to be used anywhere a Hash is expected.
+   *
+   * @example
+   * ```typescript
+   * const hash: Hash = tx; // Works via toString()
+   * console.log(`Transaction: ${tx}`); // Prints hash
+   * ```
+   * @returns The transaction hash as a string
+   */
+  toString() {
+    return this.hash;
   }
-};
-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}`
-    );
+  /**
+   * JSON serialization support.
+   * Returns the hash when serialized to JSON.
+   *
+   * @returns The transaction hash for JSON serialization
+   */
+  toJSON() {
+    return this.hash;
+  }
+  /**
+   * Custom inspect for Node.js console.log
+   *
+   * @returns Formatted string representation for debugging
+   */
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `TransactionHandle { hash: '${this.hash}', operation: '${this.operation ?? "none"}' }`;
   }
-  return contractAddress;
 };
 
 // src/utils/grantFiles.ts
@@ -36437,31 +36772,32 @@ var PermissionsController = class {
    * ```
    */
   async grant(params) {
-    const txHash = await this.submitPermissionGrant(params);
-    return parseTransactionResult(this.context, txHash, "grant");
+    const txHandle = await this.submitPermissionGrant(params);
+    return await txHandle.waitForEvents();
   }
   /**
-   * Submits a permission grant transaction and returns the transaction hash immediately.
+   * Submits a permission grant transaction and returns a handle for flexible result access.
    *
-   * 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.
+   * @remarks
+   * This lower-level method provides maximum control over transaction timing.
+   * Returns a TransactionHandle that allows immediate hash access or optional event parsing.
+   * Use this when handling multiple transactions or when you need granular control.
    *
    * @param params - The permission grant configuration object
-   * @returns Promise that resolves to the transaction hash when successfully submitted
+   * @returns Promise resolving to TransactionHandle with hash and event parsing capabilities
    * @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}`);
+   * // Submit transaction and get immediate hash access
+   * const tx = await vana.permissions.submitPermissionGrant(params);
+   * console.log(`Transaction submitted: ${tx.hash}`);
    *
-   * // Later, when you need the permission data:
-   * const result = await parseTransactionResult(context, txHash, 'grant');
-   * console.log(`Permission ID: ${result.permissionId}`);
+   * // Optionally wait for and parse events
+   * const eventData = await tx.waitForEvents();
+   * console.log(`Permission ID: ${eventData.permissionId}`);
    * ```
    */
   async submitPermissionGrant(params) {
@@ -36519,12 +36855,18 @@ var PermissionsController = class {
     }
   }
   /**
-   * Internal method to complete the grant process after user confirmation.
-   * This is called by the confirm() function returned from prepareGrant().
+   * Completes the grant process after user confirmation.
+   *
+   * @remarks
+   * This internal method is called by the confirm() function returned from prepareGrant().
+   * It handles IPFS upload, signature creation, and transaction submission.
    *
    * @param params - The permission grant parameters containing user and operation details
    * @param grantFile - The prepared grant file with permissions and metadata
-   * @returns Promise resolving to the transaction hash
+   * @returns Promise resolving to TransactionHandle for flexible result access
+   * @throws {BlockchainError} When permission grant confirmation fails
+   * @throws {NetworkError} When IPFS upload fails
+   * @throws {SignatureError} When user rejects the signature
    */
   async confirmGrantInternal(params, grantFile) {
     try {
@@ -36713,14 +37055,20 @@ var PermissionsController = class {
           2
         )
       );
+      let hash;
       if (this.context.relayerCallbacks?.submitPermissionGrant) {
-        return await this.context.relayerCallbacks.submitPermissionGrant(
+        hash = await this.context.relayerCallbacks.submitPermissionGrant(
           typedData,
           signature
         );
       } else {
-        return await this.submitDirectTransaction(typedData, signature);
+        hash = await this.submitDirectTransaction(typedData, signature);
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "grant"
+      );
     } catch (error) {
       if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
         throw error;
@@ -36733,11 +37081,24 @@ var PermissionsController = class {
   }
   /**
    * Submits an already-signed trust server transaction to the blockchain.
+   *
+   * @remarks
    * This method extracts the trust server input from typed data and submits it directly.
+   * Used internally by trust server methods after signature collection.
    *
    * @param typedData - The EIP-712 typed data for TrustServer
-   * @param signature - The user's signature
-   * @returns Promise resolving to the transaction hash
+   * @param signature - The user's signature obtained via `signTypedData()`
+   * @returns Promise resolving to TransactionHandle for transaction tracking
+   * @throws {BlockchainError} When contract submission fails
+   * @throws {NetworkError} When blockchain communication fails
+   * @example
+   * ```typescript
+   * const txHandle = await vana.permissions.submitSignedTrustServer(
+   *   typedData,
+   *   "0x1234..."
+   * );
+   * const result = await txHandle.waitForEvents();
+   * ```
    */
   async submitSignedTrustServer(typedData, signature) {
     try {
@@ -36745,10 +37106,15 @@ var PermissionsController = class {
         nonce: BigInt(typedData.message.nonce),
         serverId: typedData.message.serverId
       };
-      return await this.submitTrustServerTransaction(
+      const hash = await this.submitTrustServerTransaction(
         trustServerInput,
         signature
       );
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "trustServer"
+      );
     } catch (error) {
       if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
         throw error;
@@ -36775,11 +37141,24 @@ var PermissionsController = class {
   }
   /**
    * Submits an already-signed add and trust server transaction to the blockchain.
+   *
+   * @remarks
    * This method extracts the add and trust server input from typed data and submits it directly.
+   * Combines server registration and trust operations in a single transaction.
    *
    * @param typedData - The EIP-712 typed data for AddAndTrustServer
-   * @param signature - The user's signature
-   * @returns Promise resolving to the transaction hash
+   * @param signature - The user's signature obtained via `signTypedData()`
+   * @returns Promise resolving to TransactionHandle for transaction tracking
+   * @throws {BlockchainError} When contract submission fails
+   * @throws {NetworkError} When blockchain communication fails
+   * @example
+   * ```typescript
+   * const txHandle = await vana.permissions.submitSignedAddAndTrustServer(
+   *   typedData,
+   *   "0x1234..."
+   * );
+   * const result = await txHandle.waitForEvents();
+   * ```
    */
   async submitSignedAddAndTrustServer(typedData, signature) {
     try {
@@ -36789,10 +37168,15 @@ var PermissionsController = class {
         serverUrl: typedData.message.serverUrl,
         publicKey: typedData.message.publicKey
       };
-      return await this.submitAddAndTrustServerTransaction(
+      const hash = await this.submitAddAndTrustServerTransaction(
         addAndTrustServerInput,
         signature
       );
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "addAndTrustServer"
+      );
     } catch (error) {
       if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
         throw error;
@@ -36805,22 +37189,41 @@ var PermissionsController = class {
   }
   /**
    * Submits an already-signed permission revoke transaction to the blockchain.
+   *
+   * @remarks
    * This method handles the revocation of previously granted permissions.
+   * Used internally by revocation methods after signature collection.
    *
    * @param typedData - The EIP-712 typed data for PermissionRevoke
-   * @param signature - The user's signature
-   * @returns Promise resolving to the transaction hash
+   * @param signature - The user's signature obtained via `signTypedData()`
+   * @returns Promise resolving to TransactionHandle for transaction tracking
+   * @throws {BlockchainError} When contract submission fails
+   * @throws {NetworkError} When blockchain communication fails
+   * @example
+   * ```typescript
+   * const txHandle = await vana.permissions.submitSignedRevoke(
+   *   typedData,
+   *   "0x1234..."
+   * );
+   * const result = await txHandle.waitForEvents();
+   * ```
    */
   async submitSignedRevoke(typedData, signature) {
     try {
+      let hash;
       if (this.context.relayerCallbacks?.submitPermissionRevoke) {
-        return await this.context.relayerCallbacks.submitPermissionRevoke(
+        hash = await this.context.relayerCallbacks.submitPermissionRevoke(
           typedData,
           signature
         );
       } else {
-        return await this.submitDirectRevokeTransaction(typedData, signature);
+        hash = await this.submitDirectRevokeTransaction(typedData, signature);
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "revoke"
+      );
     } catch (error) {
       if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
         throw error;
@@ -36833,22 +37236,41 @@ var PermissionsController = class {
   }
   /**
    * Submits an already-signed untrust server transaction to the blockchain.
+   *
+   * @remarks
    * This method handles the removal of trusted servers.
+   * Used internally by untrust server methods after signature collection.
    *
    * @param typedData - The EIP-712 typed data for UntrustServer
-   * @param signature - The user's signature
-   * @returns Promise resolving to the transaction hash
+   * @param signature - The user's signature obtained via `signTypedData()`
+   * @returns Promise resolving to TransactionHandle for transaction tracking
+   * @throws {BlockchainError} When contract submission fails
+   * @throws {NetworkError} When blockchain communication fails
+   * @example
+   * ```typescript
+   * const txHandle = await vana.permissions.submitSignedUntrustServer(
+   *   typedData,
+   *   "0x1234..."
+   * );
+   * const result = await txHandle.waitForEvents();
+   * ```
    */
   async submitSignedUntrustServer(typedData, signature) {
     try {
+      let hash;
       if (this.context.relayerCallbacks?.submitUntrustServer) {
-        return await this.context.relayerCallbacks.submitUntrustServer(
+        hash = await this.context.relayerCallbacks.submitUntrustServer(
           typedData,
           signature
         );
       } else {
-        return await this.submitSignedUntrustTransaction(typedData, signature);
+        hash = await this.submitSignedUntrustTransaction(typedData, signature);
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "untrustServer"
+      );
     } catch (error) {
       if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
         throw error;
@@ -36862,9 +37284,14 @@ var PermissionsController = class {
   /**
    * Submits a signed transaction directly to the blockchain.
    *
+   * @remarks
+   * Internal method used when relayer callbacks are not available. Formats the signature
+   * and submits the permission grant directly to the smart contract.
+   *
    * @param typedData - The typed data structure for the permission grant
    * @param signature - The cryptographic signature authorizing the transaction
    * @returns Promise resolving to the transaction hash
+   * @throws {BlockchainError} When contract submission fails
    */
   async submitDirectTransaction(typedData, signature) {
     const chainId = await this.context.walletClient.getChainId();
@@ -36925,8 +37352,8 @@ var PermissionsController = class {
    * ```
    */
   async revoke(params) {
-    const txHash = await this.submitPermissionRevoke(params);
-    return parseTransactionResult(this.context, txHash, "revoke");
+    const txHandle = await this.submitPermissionRevoke(params);
+    return await txHandle.waitForEvents();
   }
   /**
    * Submits a permission revocation transaction and returns the transaction hash immediately.
@@ -36968,7 +37395,11 @@ var PermissionsController = class {
         account: this.context.walletClient.account || await this.getUserAddress(),
         chain: this.context.walletClient.chain || null
       });
-      return txHash;
+      return new TransactionHandle(
+        this.context,
+        txHash,
+        "revoke"
+      );
     } catch (error) {
       if (error instanceof Error) {
         if (error instanceof RelayerError || error instanceof UserRejectedRequestError || error instanceof SerializationError || error instanceof SignatureError || error instanceof NetworkError || error instanceof NonceError) {
@@ -36983,15 +37414,29 @@ var PermissionsController = class {
     }
   }
   /**
-   * Revokes a permission with a signature (gasless transaction).
+   * Revokes a permission with a signature for gasless transactions.
+   *
+   * @remarks
+   * This method creates an EIP-712 signature for permission revocation and submits
+   * it either through relayer callbacks or directly to the blockchain. Provides
+   * gasless revocation when relayer is configured.
    *
    * @param params - Parameters for revoking the permission
-   * @returns Promise resolving to transaction hash
+   * @param params.permissionId - Permission identifier to revoke (accepts bigint, number, or string)
+   * @returns Promise resolving to TransactionHandle for transaction tracking
    * @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
+   * @example
+   * ```typescript
+   * const txHandle = await vana.permissions.submitRevokeWithSignature({
+   *   permissionId: 123n
+   * });
+   * const result = await txHandle.waitForEvents();
+   * console.log(`Permission ${result.permissionId} revoked`);
+   * ```
    */
   async submitRevokeWithSignature(params) {
     try {
@@ -37015,14 +37460,20 @@ var PermissionsController = class {
         message: revokePermissionInput
       };
       const signature = await this.signTypedData(typedData);
+      let hash;
       if (this.context.relayerCallbacks?.submitPermissionRevoke) {
-        return await this.context.relayerCallbacks.submitPermissionRevoke(
+        hash = await this.context.relayerCallbacks.submitPermissionRevoke(
           typedData,
           signature
         );
       } else {
-        return await this.submitDirectRevokeTransaction(typedData, signature);
+        hash = await this.submitDirectRevokeTransaction(typedData, signature);
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "revoke"
+      );
     } catch (error) {
       throw new PermissionError(
         `Failed to revoke permission with signature: ${error instanceof Error ? error.message : "Unknown error"}`,
@@ -37054,6 +37505,18 @@ var PermissionsController = class {
    * const serversNonce = await this.getServersUserNonce();
    * ```
    */
+  /**
+   * @deprecated Use getPermissionsUserNonce() for permission operations or getServersUserNonce() for server operations
+   *
+   * Retrieves the user's current nonce from the DataPortabilityServers contract.
+   *
+   * @remarks
+   * This method is deprecated in favor of more specific nonce methods that target
+   * the appropriate contract for the operation being performed.
+   *
+   * @returns Promise resolving to the user's current nonce as a bigint
+   * @throws {NonceError} When retrieving the nonce fails
+   */
   async getUserNonce() {
     try {
       const userAddress = await this.getUserAddress();
@@ -37090,6 +37553,16 @@ var PermissionsController = class {
    * console.log(`Current servers nonce: ${nonce}`);
    * ```
    */
+  /**
+   * Retrieves the user's current nonce from the DataPortabilityServers contract.
+   *
+   * @remarks
+   * Used for server-related operations (trust/untrust) to prevent replay attacks.
+   * The nonce must be incremented with each server operation.
+   *
+   * @returns Promise resolving to the user's current nonce as a bigint
+   * @throws {NonceError} When retrieving the nonce fails
+   */
   async getServersUserNonce() {
     try {
       const userAddress = await this.getUserAddress();
@@ -37126,6 +37599,16 @@ var PermissionsController = class {
    * console.log(`Current permissions nonce: ${nonce}`);
    * ```
    */
+  /**
+   * Retrieves the user's current nonce from the DataPortabilityPermissions contract.
+   *
+   * @remarks
+   * Used for permission-related operations (grant/revoke) to prevent replay attacks.
+   * The nonce must be incremented with each permission operation.
+   *
+   * @returns Promise resolving to the user's current nonce as a bigint
+   * @throws {NonceError} When retrieving the nonce fails
+   */
   async getPermissionsUserNonce() {
     try {
       const userAddress = await this.getUserAddress();
@@ -37531,7 +38014,11 @@ var PermissionsController = class {
         account: this.context.walletClient.account || await this.getUserAddress(),
         chain: this.context.walletClient.chain || null
       });
-      return txHash;
+      return new TransactionHandle(
+        this.context,
+        txHash,
+        "addAndTrustServer"
+      );
     } catch (error) {
       if (error instanceof Error && error.message.includes("rejected")) {
         throw new UserRejectedRequestError();
@@ -37565,7 +38052,11 @@ var PermissionsController = class {
         account: this.context.walletClient.account || await this.getUserAddress(),
         chain: this.context.walletClient.chain || null
       });
-      return txHash;
+      return new TransactionHandle(
+        this.context,
+        txHash,
+        "trustServer"
+      );
     } catch (error) {
       if (error instanceof Error && error.message.includes("rejected")) {
         throw new UserRejectedRequestError();
@@ -37580,7 +38071,7 @@ var PermissionsController = class {
    * Adds and trusts a server using a signature (gasless transaction).
    *
    * @param params - Parameters for adding and trusting the server
-   * @returns Promise resolving to transaction hash
+   * @returns Promise resolving to TransactionHandle with ServerTrustResult event data
    */
   async submitAddAndTrustServerWithSignature(params) {
     try {
@@ -37604,17 +38095,23 @@ var PermissionsController = class {
       });
       const signature = await this.signTypedData(typedData);
       console.debug("\u{1F50D} Generated signature:", signature);
+      let hash;
       if (this.context.relayerCallbacks?.submitAddAndTrustServer) {
-        return await this.context.relayerCallbacks.submitAddAndTrustServer(
+        hash = await this.context.relayerCallbacks.submitAddAndTrustServer(
           typedData,
           signature
         );
       } else {
-        return await this.submitAddAndTrustServerTransaction(
+        hash = await this.submitAddAndTrustServerTransaction(
           addAndTrustServerInput,
           signature
         );
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "addAndTrustServer"
+      );
     } catch (error) {
       if (error instanceof Error) {
         if (error instanceof RelayerError || error instanceof UserRejectedRequestError || error instanceof SerializationError || error instanceof SignatureError || error instanceof NetworkError || error instanceof NonceError) {
@@ -37652,17 +38149,23 @@ var PermissionsController = class {
       };
       const typedData = await this.composeTrustServerMessage(trustServerInput);
       const signature = await this.signTypedData(typedData);
+      let hash;
       if (this.context.relayerCallbacks?.submitTrustServer) {
-        return await this.context.relayerCallbacks.submitTrustServer(
+        hash = await this.context.relayerCallbacks.submitTrustServer(
           typedData,
           signature
         );
       } else {
-        return await this.submitTrustServerTransaction(
+        hash = await this.submitTrustServerTransaction(
           trustServerInput,
           signature
         );
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "trustServer"
+      );
     } catch (error) {
       if (error instanceof Error) {
         if (error instanceof RelayerError || error instanceof UserRejectedRequestError || error instanceof SerializationError || error instanceof SignatureError || error instanceof NetworkError || error instanceof NonceError) {
@@ -37682,6 +38185,17 @@ var PermissionsController = class {
    * @param params - The untrust server parameters containing server details
    * @returns Promise resolving to the transaction hash
    */
+  /**
+   * Submits an untrust server transaction directly to the blockchain.
+   *
+   * @remarks
+   * Internal method used for direct blockchain submission of untrust server operations
+   * when relayer callbacks are not available.
+   *
+   * @param params - The untrust server parameters
+   * @returns Promise resolving to TransactionHandle for transaction tracking
+   * @throws {BlockchainError} When contract submission fails
+   */
   async submitDirectUntrustTransaction(params) {
     try {
       const chainId = await this.context.walletClient.getChainId();
@@ -37698,7 +38212,11 @@ var PermissionsController = class {
         account: this.context.walletClient.account || await this.getUserAddress(),
         chain: this.context.walletClient.chain || null
       });
-      return txHash;
+      return new TransactionHandle(
+        this.context,
+        txHash,
+        "untrustServer"
+      );
     } catch (error) {
       if (error instanceof Error && error.message.includes("rejected")) {
         throw new UserRejectedRequestError();
@@ -37766,14 +38284,20 @@ var PermissionsController = class {
       };
       const typedData = await this.composeUntrustServerMessage(untrustServerInput);
       const signature = await this.signTypedData(typedData);
+      let hash;
       if (this.context.relayerCallbacks?.submitUntrustServer) {
-        return await this.context.relayerCallbacks.submitUntrustServer(
+        hash = await this.context.relayerCallbacks.submitUntrustServer(
           typedData,
           signature
         );
       } else {
-        return await this.submitSignedUntrustTransaction(typedData, signature);
+        hash = await this.submitSignedUntrustTransaction(typedData, signature);
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "untrustServer"
+      );
     } catch (error) {
       if (error instanceof Error) {
         if (error instanceof RelayerError || error instanceof UserRejectedRequestError || error instanceof SerializationError || error instanceof SignatureError || error instanceof NetworkError || error instanceof NonceError) {
@@ -37897,18 +38421,19 @@ var PermissionsController = class {
         };
       }
       const endIndex = Math.min(offset + limit, total);
-      const serverPromises = [];
+      const serverIdCalls = [];
       for (let i = offset; i < endIndex; i++) {
-        const promise = this.context.publicClient.readContract({
+        serverIdCalls.push({
           address: DataPortabilityServersAddress,
           abi: DataPortabilityServersAbi,
           functionName: "userServerIdsAt",
           args: [user, BigInt(i)]
         });
-        serverPromises.push(promise);
       }
-      const serverIds = await Promise.all(serverPromises);
-      const servers = serverIds.map((id) => Number(id));
+      const serverIdResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: serverIdCalls
+      });
+      const servers = serverIdResults.map((result) => Number(result)).filter((id) => id > 0);
       return {
         servers,
         total,
@@ -37933,35 +38458,51 @@ var PermissionsController = class {
   async getTrustedServersWithInfo(options = {}) {
     try {
       const paginatedResult = await this.getTrustedServersPaginated(options);
-      const serverInfoPromises = paginatedResult.servers.map(
-        async (serverId, _index) => {
-          try {
-            const serverInfo = await this.getServerInfo(BigInt(serverId));
-            return {
-              id: BigInt(serverId),
-              owner: serverInfo.owner,
-              serverAddress: serverInfo.serverAddress,
-              publicKey: serverInfo.publicKey,
-              url: serverInfo.url,
-              startBlock: 0n,
-              // We don't have this info from the old method structure
-              endBlock: 0n
-              // 0 means still active
-            };
-          } catch {
-            return {
-              id: BigInt(serverId),
-              owner: "0x0000000000000000000000000000000000000000",
-              serverAddress: "0x0000000000000000000000000000000000000000",
-              publicKey: "",
-              url: "",
-              startBlock: 0n,
-              endBlock: 0n
-            };
-          }
-        }
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverInfoCalls = paginatedResult.servers.map(
+        (serverId) => ({
+          address: DataPortabilityServersAddress,
+          abi: DataPortabilityServersAbi,
+          functionName: "servers",
+          args: [BigInt(serverId)]
+        })
       );
-      return await Promise.all(serverInfoPromises);
+      const serverInfoResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: serverInfoCalls,
+        allowFailure: true
+      });
+      return serverInfoResults.map((result, index) => {
+        const serverId = paginatedResult.servers[index];
+        if (result.status === "success" && result.result) {
+          const serverInfo = result.result;
+          return {
+            id: BigInt(serverId),
+            owner: serverInfo.owner,
+            serverAddress: serverInfo.serverAddress,
+            publicKey: serverInfo.publicKey,
+            url: serverInfo.url,
+            startBlock: 0n,
+            // We don't have this info from the old method structure
+            endBlock: 0n
+            // 0 means still active
+          };
+        } else {
+          return {
+            id: BigInt(serverId),
+            owner: "0x0000000000000000000000000000000000000000",
+            serverAddress: "0x0000000000000000000000000000000000000000",
+            publicKey: "",
+            url: "",
+            startBlock: 0n,
+            endBlock: 0n
+          };
+        }
+      });
     } catch (error) {
       throw new BlockchainError(
         `Failed to get trusted servers with info: ${error instanceof Error ? error.message : "Unknown error"}`,
@@ -37972,9 +38513,28 @@ var PermissionsController = class {
   /**
    * Gets server information for multiple servers efficiently.
    *
-   * @param serverIds - Array of server IDs to query
-   * @returns Promise resolving to batch result with successes and failures
+   * @remarks
+   * This method uses multicall to fetch information for multiple servers in a single
+   * blockchain call, improving performance when querying many servers. Failed lookups
+   * are returned separately for error handling.
+   *
+   * @param serverIds - Array of numeric server IDs to query
+   * @returns Promise resolving to batch result containing successful lookups and failed IDs
    * @throws {BlockchainError} When reading from contract fails or chain is unavailable
+   * @example
+   * ```typescript
+   * const result = await vana.permissions.getServerInfoBatch([1, 2, 3, 999]);
+   *
+   * // Process successful lookups
+   * result.servers.forEach((server, id) => {
+   *   console.log(`Server ${id}: ${server.url}`);
+   * });
+   *
+   * // Handle failed lookups
+   * if (result.failed.length > 0) {
+   *   console.log(`Failed to fetch: ${result.failed.join(', ')}`);
+   * }
+   * ```
    */
   async getServerInfoBatch(serverIds) {
     if (serverIds.length === 0) {
@@ -37990,14 +38550,22 @@ var PermissionsController = class {
         "DataPortabilityServers"
       );
       const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
-      const serverInfoPromises = serverIds.map(async (serverId) => {
-        try {
-          const serverInfo = await this.context.publicClient.readContract({
-            address: DataPortabilityServersAddress,
-            abi: DataPortabilityServersAbi,
-            functionName: "servers",
-            args: [BigInt(serverId)]
-          });
+      const serverInfoCalls = serverIds.map(
+        (serverId) => ({
+          address: DataPortabilityServersAddress,
+          abi: DataPortabilityServersAbi,
+          functionName: "servers",
+          args: [BigInt(serverId)]
+        })
+      );
+      const serverInfoResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: serverInfoCalls,
+        allowFailure: true
+      });
+      const results = serverInfoResults.map((result, index) => {
+        const serverId = serverIds[index];
+        if (result.status === "success" && result.result) {
+          const serverInfo = result.result;
           const server = {
             id: Number(serverInfo.id),
             owner: serverInfo.owner,
@@ -38006,11 +38574,10 @@ var PermissionsController = class {
             publicKey: serverInfo.publicKey
           };
           return { serverId, server, success: true };
-        } catch {
+        } else {
           return { serverId, server: null, success: false };
         }
       });
-      const results = await Promise.all(serverInfoPromises);
       const servers = /* @__PURE__ */ new Map();
       const failed = [];
       for (const result of results) {
@@ -38031,9 +38598,24 @@ var PermissionsController = class {
   /**
    * Checks whether a specific server is trusted by a user.
    *
-   * @param serverId - Server ID to check (numeric)
+   * @remarks
+   * This method queries the user's trusted server list and checks if the specified
+   * server is present. Returns both the trust status and the index in the trust list
+   * if trusted.
+   *
+   * @param serverId - Numeric server ID to check
    * @param userAddress - Optional user address (defaults to current user)
-   * @returns Promise resolving to server trust status
+   * @returns Promise resolving to server trust status with trust index if applicable
+   * @throws {BlockchainError} When reading from contract fails
+   * @example
+   * ```typescript
+   * const status = await vana.permissions.checkServerTrustStatus(1);
+   * if (status.isTrusted) {
+   *   console.log(`Server is trusted at index ${status.trustIndex}`);
+   * } else {
+   *   console.log('Server is not trusted');
+   * }
+   * ```
    */
   async checkServerTrustStatus(serverId, userAddress) {
     try {
@@ -38057,6 +38639,10 @@ var PermissionsController = class {
   /**
    * Composes EIP-712 typed data for AddAndTrustServer.
    *
+   * @remarks
+   * Creates the complete typed data structure required for EIP-712 signature generation
+   * when adding and trusting a new server in a single transaction.
+   *
    * @param input - The add and trust server input data containing server details
    * @returns Promise resolving to the typed data structure for server add and trust
    */
@@ -38305,7 +38891,11 @@ var PermissionsController = class {
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
     });
-    return txHash;
+    return new TransactionHandle(
+      this.context,
+      txHash,
+      "registerGrantee"
+    );
   }
   /**
    * Registers a grantee with a signature (gasless transaction)
@@ -38332,7 +38922,15 @@ var PermissionsController = class {
     };
     const typedData = await this.buildRegisterGranteeTypedData(registerGranteeInput);
     const signature = await this.signTypedData(typedData);
-    return this.submitSignedRegisterGranteeTransaction(typedData, signature);
+    const hash = await this.submitSignedRegisterGranteeTransaction(
+      typedData,
+      signature
+    );
+    return new TransactionHandle(
+      this.context,
+      hash,
+      "registerGrantee"
+    );
   }
   /**
    * Submits a signed register grantee transaction via relayer
@@ -38347,7 +38945,15 @@ var PermissionsController = class {
    * ```
    */
   async submitSignedRegisterGrantee(typedData, signature) {
-    return this.submitSignedRegisterGranteeTransaction(typedData, signature);
+    const hash = await this.submitSignedRegisterGranteeTransaction(
+      typedData,
+      signature
+    );
+    return new TransactionHandle(
+      this.context,
+      hash,
+      "registerGrantee"
+    );
   }
   /**
    * Retrieves all registered grantees from the DataPortabilityGrantees contract.
@@ -39333,7 +39939,11 @@ var PermissionsController = class {
         chain: this.context.walletClient.chain,
         account: this.context.walletClient.account || null
       });
-      return hash;
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "updateServer"
+      );
     } catch (error) {
       throw new BlockchainError(
         `Failed to update server: ${error instanceof Error ? error.message : "Unknown error"}`,
@@ -39514,24 +40124,30 @@ var PermissionsController = class {
    *
    * @param typedData - The EIP-712 typed data for AddPermission
    * @param signature - The user's signature
-   * @returns Promise resolving to the transaction hash
+   * @returns Promise resolving to TransactionHandle with PermissionGrantResult event data
    * @throws {RelayerError} When gasless transaction submission fails
    * @throws {BlockchainError} When permission addition fails
    * @throws {NetworkError} When network communication fails
    */
   async submitSignedAddPermission(typedData, signature) {
     try {
+      let hash;
       if (this.context.relayerCallbacks?.submitAddPermission) {
-        return await this.context.relayerCallbacks.submitAddPermission(
+        hash = await this.context.relayerCallbacks.submitAddPermission(
           typedData,
           signature
         );
       } else {
-        return await this.submitDirectAddPermissionTransaction(
+        hash = await this.submitDirectAddPermissionTransaction(
           typedData,
           signature
         );
       }
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "addServerFilesAndPermissions"
+      );
     } catch (error) {
       if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
         throw error;
@@ -39585,14 +40201,31 @@ var PermissionsController = class {
   }
   /**
    * Submits an already-signed add server files and permissions transaction to the blockchain.
-   * This method supports both relayer-based gasless transactions and direct transactions.
+   *
+   * @remarks
+   * This method returns a TransactionHandle that provides immediate access to the transaction hash
+   * while allowing lazy-loaded access to parsed event data. Use `waitForEvents()` to retrieve
+   * the permission ID and other event details after transaction confirmation.
    *
    * @param typedData - The EIP-712 typed data for AddServerFilesAndPermissions
    * @param signature - The user's signature
-   * @returns Promise resolving to the transaction hash
+   * @returns TransactionHandle with immediate hash access and optional event parsing
    * @throws {RelayerError} When gasless transaction submission fails
    * @throws {BlockchainError} When server files and permissions addition fails
    * @throws {NetworkError} When network communication fails
+   *
+   * @example
+   * ```typescript
+   * const tx = await vana.permissions.submitSignedAddServerFilesAndPermissions(
+   *   typedData,
+   *   signature
+   * );
+   * console.log(`Transaction submitted: ${tx.hash}`);
+   *
+   * // Wait for confirmation and get the permission ID
+   * const { permissionId } = await tx.waitForEvents();
+   * console.log(`Permission created with ID: ${permissionId}`);
+   * ```
    */
   async submitSignedAddServerFilesAndPermissions(typedData, signature) {
     try {
@@ -39605,18 +40238,28 @@ var PermissionsController = class {
         console.debug(
           "\u{1F680} Using relayer for submitAddServerFilesAndPermissions"
         );
-        return await this.context.relayerCallbacks.submitAddServerFilesAndPermissions(
+        const hash = await this.context.relayerCallbacks.submitAddServerFilesAndPermissions(
           typedData,
           signature
         );
+        return new TransactionHandle(
+          this.context,
+          hash,
+          "addServerFilesAndPermissions"
+        );
       } else {
         console.debug(
           "\u{1F4DD} Using direct transaction for submitAddServerFilesAndPermissions"
         );
-        return await this.submitDirectAddServerFilesAndPermissionsTransaction(
+        const hash = await this.submitDirectAddServerFilesAndPermissionsTransaction(
           typedData,
           signature
         );
+        return new TransactionHandle(
+          this.context,
+          hash,
+          "addServerFilesAndPermissions"
+        );
       }
     } catch (error) {
       if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
@@ -39652,7 +40295,11 @@ var PermissionsController = class {
         chain: this.context.walletClient.chain,
         account: this.context.walletClient.account || null
       });
-      return hash;
+      return new TransactionHandle(
+        this.context,
+        hash,
+        "revokePermission"
+      );
     } catch (error) {
       throw new BlockchainError(
         `Failed to revoke permission: ${error instanceof Error ? error.message : "Unknown error"}`,
@@ -39730,7 +40377,7 @@ var PermissionsController = class {
 };
 
 // src/controllers/data.ts
-import { getContract as getContract2, decodeEventLog } from "viem";
+import { getContract as getContract2 } from "viem";
 
 // src/utils/blockchain/registry.ts
 import { getContract } from "viem";
@@ -39754,13 +40401,13 @@ async function fetchSchemaFromChain(context, schemaId) {
     throw new Error(`Schema with ID ${schemaId} not found`);
   }
   const schemaObj = schemaData;
-  if (!schemaObj.name || !schemaObj.typ || !schemaObj.definitionUrl) {
+  if (!schemaObj.name || !schemaObj.dialect || !schemaObj.definitionUrl) {
     throw new Error("Incomplete schema data");
   }
   return {
     id: schemaId,
     name: schemaObj.name,
-    type: schemaObj.typ,
+    dialect: schemaObj.dialect,
     definitionUrl: schemaObj.definitionUrl
   };
 }
@@ -40207,8 +40854,8 @@ var DataController = class {
    */
   async getUserFiles(params) {
     const { owner, subgraphUrl } = params;
-    const graphqlEndpoint = subgraphUrl || this.context.subgraphUrl;
-    if (!graphqlEndpoint) {
+    const endpoint = subgraphUrl || this.context.subgraphUrl;
+    if (!endpoint) {
       throw new Error(
         "subgraphUrl is required. Please provide a valid subgraph endpoint or configure it in Vana constructor."
       );
@@ -40232,7 +40879,7 @@ var DataController = class {
           }
         }
       `;
-      const response = await fetch(graphqlEndpoint, {
+      const response = await fetch(endpoint, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -40290,28 +40937,45 @@ var DataController = class {
     }
   }
   /**
-   * Retrieves a list of permissions granted by a user using the new subgraph entities.
+   * Retrieves a list of permissions granted by a user.
    *
-   * This method queries the Vana subgraph to find permissions directly granted by the user
-   * using the new Permission entity. It efficiently handles millions of permissions by:
-   * 1. Querying the subgraph for user's directly granted permissions
-   * 2. Returning complete permission information from subgraph
-   * 3. No need for additional contract calls as all data comes from subgraph
+   * This method supports automatic fallback between subgraph and RPC modes:
+   * - If subgraph URL is available, tries subgraph query first
+   * - Falls back to direct contract queries via RPC if subgraph fails
+   * - RPC mode uses gasAwareMulticall for efficient batch queries
    *
    * @param params - Object containing the user address and optional subgraph URL
    * @param params.user - The wallet address of the user to query permissions for
    * @param params.subgraphUrl - Optional subgraph URL to override the default
    * @returns Promise resolving to an array of permission objects
-   * @throws Error if subgraph is unavailable or returns invalid data
+   * @throws Error if both subgraph and RPC queries fail
    */
   async getUserPermissions(params) {
     const { user, subgraphUrl } = params;
-    const graphqlEndpoint = subgraphUrl || this.context.subgraphUrl;
-    if (!graphqlEndpoint) {
-      throw new Error(
-        "subgraphUrl is required. Please provide a valid subgraph endpoint or configure it in Vana constructor."
-      );
+    const endpoint = subgraphUrl || this.context.subgraphUrl;
+    if (endpoint) {
+      try {
+        const permissions = await this._getUserPermissionsViaSubgraph({
+          user,
+          subgraphUrl: endpoint
+        });
+        return permissions;
+      } catch (error) {
+        console.warn("Subgraph query failed, falling back to RPC:", error);
+      }
     }
+    return await this._getUserPermissionsViaRpc({ user });
+  }
+  /**
+   * Internal method: Query user permissions via subgraph
+   *
+   * @param params - Query parameters object
+   * @param params.user - The user address to query permissions for
+   * @param params.subgraphUrl - The subgraph URL endpoint to query
+   * @returns Promise resolving to an array of permission objects
+   */
+  async _getUserPermissionsViaSubgraph(params) {
+    const { user, subgraphUrl } = params;
     try {
       const query = `
         query GetUserPermissions($userId: ID!) {
@@ -40332,7 +40996,7 @@ var DataController = class {
           }
         }
       `;
-      const response = await fetch(graphqlEndpoint, {
+      const response = await fetch(subgraphUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -40352,15 +41016,14 @@ var DataController = class {
       const result = await response.json();
       if (result.errors) {
         throw new Error(
-          `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          `Subgraph query errors: ${result.errors.map((e) => e.message).join(", ")}`
         );
       }
       const userData = result.data?.user;
       if (!userData || !userData.permissions?.length) {
-        console.warn("No permissions found for user:", user);
         return [];
       }
-      const permissions = userData.permissions.map((permission) => ({
+      return userData.permissions.map((permission) => ({
         id: permission.id,
         grant: permission.grant,
         nonce: BigInt(permission.nonce),
@@ -40370,131 +41033,158 @@ var DataController = class {
         transactionHash: permission.transactionHash,
         user: permission.user.id
       })).sort((a, b) => Number(b.addedAtTimestamp - a.addedAtTimestamp));
+    } catch (error) {
+      console.error("Failed to query user permissions from subgraph:", error);
+      throw error;
+    }
+  }
+  /**
+   * Internal method: Query user permissions via direct RPC
+   *
+   * @param params - Query parameters object
+   * @param params.user - The user address to query permissions for
+   * @returns Promise resolving to an array of permission objects
+   */
+  async _getUserPermissionsViaRpc(params) {
+    const { user } = params;
+    try {
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const permissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const permissionsAbi = getAbi("DataPortabilityPermissions");
+      const totalCount = await this.context.publicClient.readContract({
+        address: permissionsAddress,
+        abi: permissionsAbi,
+        functionName: "userPermissionIdsLength",
+        args: [user]
+      });
+      const total = Number(totalCount);
+      if (total === 0) {
+        return [];
+      }
+      const permissionIdCalls = [];
+      for (let i = 0; i < total; i++) {
+        permissionIdCalls.push({
+          address: permissionsAddress,
+          abi: permissionsAbi,
+          functionName: "userPermissionIdsAt",
+          args: [user, BigInt(i)]
+        });
+      }
+      const permissionIdResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: permissionIdCalls
+      });
+      const permissionIds = permissionIdResults.map((result) => result).filter((id) => id && id > 0n);
+      const permissionInfoCalls = permissionIds.map(
+        (permissionId) => ({
+          address: permissionsAddress,
+          abi: permissionsAbi,
+          functionName: "permissions",
+          args: [permissionId]
+        })
+      );
+      const permissionInfoResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: permissionInfoCalls,
+        allowFailure: true
+      });
+      const permissions = permissionInfoResults.map((result, index) => {
+        const permissionId = permissionIds[index];
+        if (result.status === "success" && result.result) {
+          const permissionInfo = result.result;
+          return {
+            id: permissionId.toString(),
+            grant: permissionInfo.grant,
+            nonce: permissionInfo.nonce,
+            signature: "",
+            // Not available from RPC, will be empty
+            addedAtBlock: permissionInfo.startBlock,
+            addedAtTimestamp: BigInt(0),
+            // Not available from RPC
+            transactionHash: "0x0000000000000000000000000000000000000000",
+            // Not available from RPC
+            user
+          };
+        } else {
+          return {
+            id: permissionId.toString(),
+            grant: "",
+            nonce: BigInt(0),
+            signature: "",
+            addedAtBlock: BigInt(0),
+            addedAtTimestamp: BigInt(0),
+            transactionHash: "0x0000000000000000000000000000000000000000",
+            user
+          };
+        }
+      }).filter((permission) => permission.grant !== "");
       return permissions;
     } catch (error) {
-      console.error("Failed to fetch user permissions from subgraph:", error);
       throw new Error(
-        `Failed to fetch user permissions from subgraph: ${error instanceof Error ? error.message : "Unknown error"}`
+        `RPC query failed: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   /**
-   * Retrieves a list of trusted servers for a user using the new subgraph entities.
+   * Retrieves a list of trusted servers for a user.
    *
-   * This method queries the Vana subgraph to find trusted servers directly associated with the user
-   * with support for both subgraph and direct RPC queries.
+   * This method supports automatic fallback between subgraph and RPC modes:
+   * - If subgraph URL is available, tries subgraph query first for fast results
+   * - Falls back to direct contract queries via RPC if subgraph fails
+   * - RPC mode uses gasAwareMulticall for efficient batch queries
    *
-   * This method supports multiple query modes:
-   * - 'subgraph': Fast query via subgraph (requires subgraphUrl)
-   * - 'rpc': Direct contract queries (slower but no external dependencies)
-   * - 'auto': Try subgraph first, fallback to RPC if unavailable
-   *
-   * @param params - Query parameters including user address and mode selection
-   * @returns Promise resolving to trusted servers with metadata about the query
-   * @throws Error if query fails in both modes (when using 'auto')
+   * @param params - Query parameters including user address and optional pagination
+   * @param params.user - The wallet address of the user to query trusted servers for
+   * @param params.subgraphUrl - Optional subgraph URL to override the default
+   * @param params.limit - Maximum number of results to return (default: 50)
+   * @param params.offset - Number of results to skip for pagination (default: 0)
+   * @returns Promise resolving to an array of trusted server objects
+   * @throws Error if both subgraph and RPC queries fail
    * @example
    * ```typescript
-   * // Use subgraph for fast queries
-   * const result = await vana.data.getUserTrustedServers({
-   *   user: '0x...',
-   *   mode: 'subgraph',
-   *   subgraphUrl: 'https://...'
+   * // Basic usage with automatic fallback
+   * const servers = await vana.data.getUserTrustedServers({
+   *   user: '0x...'
    * });
    *
-   * // Use direct RPC (no external dependencies)
-   * const result = await vana.data.getUserTrustedServers({
+   * // With pagination
+   * const servers = await vana.data.getUserTrustedServers({
    *   user: '0x...',
-   *   mode: 'rpc',
-   *   limit: 10
+   *   limit: 10,
+   *   offset: 20
    * });
    *
-   * // Auto-fallback mode
-   * const result = await vana.data.getUserTrustedServers({
+   * // With custom subgraph URL
+   * const servers = await vana.data.getUserTrustedServers({
    *   user: '0x...',
-   *   mode: 'auto' // tries subgraph first, falls back to RPC
+   *   subgraphUrl: 'https://custom-subgraph.com/graphql'
    * });
    * ```
    */
   async getUserTrustedServers(params) {
-    const { user, mode = "auto", limit = 50, offset = 0 } = params;
-    const warnings = [];
-    let trySubgraph = false;
-    let tryRpc = false;
-    switch (mode) {
-      case "subgraph":
-        trySubgraph = true;
-        break;
-      case "rpc":
-        tryRpc = true;
-        break;
-      case "auto":
-        trySubgraph = true;
-        tryRpc = true;
-        break;
-    }
-    if (trySubgraph) {
-      const subgraphUrl = params.subgraphUrl || this.context.subgraphUrl;
-      if (!subgraphUrl) {
-        if (mode === "subgraph") {
-          throw new Error(
-            "subgraphUrl is required for subgraph mode. Please provide a valid subgraph endpoint or configure it in Vana constructor."
-          );
-        }
-        warnings.push(
-          "Subgraph mode not available for trusted servers - using direct contract calls"
-        );
-      } else {
-        try {
-          const servers = await this._getUserTrustedServersViaSubgraph({
-            user,
-            subgraphUrl
-          });
-          const paginatedServers = limit ? servers.slice(offset, offset + limit) : servers;
-          return {
-            servers: paginatedServers,
-            usedMode: "subgraph",
-            total: servers.length,
-            hasMore: limit ? offset + limit < servers.length : false,
-            warnings: warnings.length > 0 ? warnings : void 0
-          };
-        } catch (error) {
-          if (mode === "subgraph") {
-            throw error;
-          }
-          warnings.push(
-            `Subgraph query failed: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-          console.warn(
-            "Subgraph query failed, falling back to RPC mode:",
-            error
-          );
-        }
-      }
-    }
-    if (tryRpc) {
+    const { user, limit = 50, offset = 0 } = params;
+    const subgraphUrl = params.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
       try {
-        const rpcResult = await this._getUserTrustedServersViaRpc({
+        const servers = await this._getUserTrustedServersViaSubgraph({
           user,
-          limit,
-          offset
+          subgraphUrl
         });
-        return {
-          servers: rpcResult.servers,
-          usedMode: "rpc",
-          total: rpcResult.total,
-          hasMore: rpcResult.hasMore,
-          warnings: warnings.length > 0 ? warnings : void 0
-        };
+        return limit ? servers.slice(offset, offset + limit) : servers;
       } catch (error) {
-        if (mode === "rpc") {
-          throw error;
-        }
-        throw new Error(
-          `Both query methods failed. Subgraph: ${warnings[0] || "Unknown error"}. RPC: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
+        console.warn("Subgraph query failed, falling back to RPC:", error);
       }
     }
-    throw new Error("Invalid query mode specified");
+    const rpcResult = await this._getUserTrustedServersViaRpc({
+      user,
+      limit,
+      offset
+    });
+    return rpcResult.servers;
   }
   /**
    * Internal method: Query trusted servers via subgraph
@@ -40610,35 +41300,44 @@ var DataController = class {
         };
       }
       const endIndex = Math.min(offset + limit, total);
-      const serverIdPromises = [];
+      const serverIdCalls = [];
       for (let i = offset; i < endIndex; i++) {
-        const promise = this.context.publicClient.readContract({
+        serverIdCalls.push({
           address: DataPortabilityServersAddress,
           abi: DataPortabilityServersAbi,
           functionName: "userServerIdsAt",
           args: [user, BigInt(i)]
         });
-        serverIdPromises.push(promise);
       }
-      const serverIds = await Promise.all(serverIdPromises);
-      const serverInfoPromises = serverIds.map(async (serverId, index) => {
-        try {
-          const serverInfo = await this.context.publicClient.readContract({
-            address: DataPortabilityServersAddress,
-            abi: DataPortabilityServersAbi,
-            functionName: "servers",
-            args: [serverId]
-          });
+      const serverIdResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: serverIdCalls
+      });
+      const serverIds = serverIdResults.map((result) => result).filter((id) => id && id > 0n);
+      const serverInfoCalls = serverIds.map(
+        (serverId) => ({
+          address: DataPortabilityServersAddress,
+          abi: DataPortabilityServersAbi,
+          functionName: "servers",
+          args: [serverId]
+        })
+      );
+      const serverInfoResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: serverInfoCalls,
+        allowFailure: true
+      });
+      const servers = serverInfoResults.map((result, index) => {
+        const serverId = serverIds[index];
+        if (result.status === "success" && result.result) {
+          const serverInfo = result.result;
           return {
             id: `${user.toLowerCase()}-${serverId.toString()}`,
             serverAddress: serverInfo.serverAddress,
             serverUrl: serverInfo.url,
             trustedAt: BigInt(Date.now()),
-            // RPC mode doesn't have timestamp, use current time
             user,
             trustIndex: offset + index
           };
-        } catch {
+        } else {
           return {
             id: `${user.toLowerCase()}-${serverId.toString()}`,
             serverAddress: "0x0000000000000000000000000000000000000000",
@@ -40649,7 +41348,6 @@ var DataController = class {
           };
         }
       });
-      const servers = await Promise.all(serverInfoPromises);
       return {
         servers,
         total,
@@ -40776,12 +41474,25 @@ var DataController = class {
   /**
    * Registers a file URL directly on the blockchain with a schema ID.
    *
-   * @param url - The URL of the file to register
+   * @remarks
+   * This method registers an existing file URL on the DataRegistry contract
+   * with a schema ID, without uploading any data. Useful when you have already
+   * uploaded content to storage and just need to register it on-chain.
+   *
+   * @param url - The URL of the file to register (IPFS or HTTP/HTTPS)
    * @param schemaId - The schema ID to associate with the file
    * @returns Promise resolving to the file ID and transaction hash
-   *
-   * This method registers an existing file URL on the DataRegistry
-   * contract with a schema ID, without uploading any data.
+   * @throws {Error} When chain ID is not available - "Chain ID not available"
+   * @throws {Error} When wallet address is unavailable - "No addresses available"
+   * @throws {Error} When transaction fails - "Failed to register file with schema"
+   * @example
+   * ```typescript
+   * const { fileId, transactionHash } = await vana.data.registerFileWithSchema(
+   *   "ipfs://QmXxx...",
+   *   1
+   * );
+   * console.log(`File ${fileId} registered with schema in tx ${transactionHash}`);
+   * ```
    */
   async registerFileWithSchema(url, schemaId) {
     try {
@@ -40800,30 +41511,14 @@ var DataController = class {
         account: this.context.walletClient.account || userAddress,
         chain: this.context.walletClient.chain || null
       });
-      const receipt = await this.context.publicClient.waitForTransactionReceipt(
-        {
-          hash: txHash,
-          timeout: 3e4
-        }
+      const txHandle = new TransactionHandle(
+        this.context,
+        txHash,
+        "addFileWithSchema"
       );
-      let fileId = 0;
-      for (const log of receipt.logs) {
-        try {
-          const decoded = decodeEventLog({
-            abi: dataRegistryAbi,
-            data: log.data,
-            topics: log.topics
-          });
-          if (decoded.eventName === "FileAdded") {
-            fileId = Number(decoded.args.fileId);
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
+      const result = await txHandle.waitForEvents();
       return {
-        fileId,
+        fileId: Number(result.fileId),
         transactionHash: txHash
       };
     } catch (error) {
@@ -40878,31 +41573,14 @@ var DataController = class {
         account: this.context.walletClient.account || ownerAddress,
         chain: this.context.walletClient.chain || null
       });
-      const receipt = await this.context.publicClient.waitForTransactionReceipt(
-        {
-          hash: txHash,
-          timeout: 3e4
-          // 30 seconds timeout
-        }
+      const txHandle = new TransactionHandle(
+        this.context,
+        txHash,
+        "addFileWithPermissions"
       );
-      let fileId = 0;
-      for (const log of receipt.logs) {
-        try {
-          const decoded = decodeEventLog({
-            abi: dataRegistryAbi,
-            data: log.data,
-            topics: log.topics
-          });
-          if (decoded.eventName === "FileAdded") {
-            fileId = Number(decoded.args.fileId);
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
+      const result = await txHandle.waitForEvents();
       return {
-        fileId,
+        fileId: Number(result.fileId),
         transactionHash: txHash
       };
     } catch (error) {
@@ -40942,31 +41620,14 @@ var DataController = class {
         account: this.context.walletClient.account || ownerAddress,
         chain: this.context.walletClient.chain || null
       });
-      const receipt = await this.context.publicClient.waitForTransactionReceipt(
-        {
-          hash: txHash,
-          timeout: 3e4
-          // 30 seconds timeout
-        }
+      const txHandle = new TransactionHandle(
+        this.context,
+        txHash,
+        "addFileWithPermissionsAndSchema"
       );
-      let fileId = 0;
-      for (const log of receipt.logs) {
-        try {
-          const decoded = decodeEventLog({
-            abi: dataRegistryAbi,
-            data: log.data,
-            topics: log.topics
-          });
-          if (decoded.eventName === "FileAdded") {
-            fileId = Number(decoded.args.fileId);
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
+      const result = await txHandle.waitForEvents();
       return {
-        fileId,
+        fileId: Number(result.fileId),
         transactionHash: txHash
       };
     } catch (error) {
@@ -40979,8 +41640,30 @@ var DataController = class {
   /**
    * Adds a new refiner to the DataRefinerRegistry.
    *
-   * @param params - Refiner parameters including DLP ID, name, schema ID, and instruction URL
+   * @remarks
+   * Refiners are data processing templates that define how raw data should be
+   * transformed into structured formats. Each refiner is associated with a DLP
+   * (Data Liquidity Pool), has a specific schema for output, and includes
+   * instructions for the refinement process.
+   *
+   * @param params - Refiner configuration parameters
+   * @param params.dlpId - The Data Liquidity Pool ID this refiner belongs to
+   * @param params.name - Human-readable name for the refiner
+   * @param params.schemaId - Schema ID that defines the output format
+   * @param params.refinementInstructionUrl - URL containing processing instructions
    * @returns Promise resolving to the new refiner ID and transaction hash
+   * @throws {Error} When chain ID is not available - "Chain ID not available"
+   * @throws {Error} When transaction fails - "Failed to add refiner: {error}"
+   * @example
+   * ```typescript
+   * const result = await vana.data.addRefiner({
+   *   dlpId: 1,
+   *   name: "Social Media Sentiment Analyzer",
+   *   schemaId: 42,
+   *   refinementInstructionUrl: "ipfs://QmXxx..."
+   * });
+   * console.log(`Created refiner ${result.refinerId} in tx ${result.transactionHash}`);
+   * ```
    */
   async addRefiner(params) {
     try {
@@ -41006,30 +41689,14 @@ var DataController = class {
         account: this.context.walletClient.account || await this.getUserAddress(),
         chain: this.context.walletClient.chain || null
       });
-      const receipt = await this.context.publicClient.waitForTransactionReceipt(
-        {
-          hash: txHash,
-          timeout: 3e4
-        }
+      const txHandle = new TransactionHandle(
+        this.context,
+        txHash,
+        "addRefiner"
       );
-      let refinerId = 0;
-      for (const log of receipt.logs) {
-        try {
-          const decoded = decodeEventLog({
-            abi: dataRefinerRegistryAbi,
-            data: log.data,
-            topics: log.topics
-          });
-          if (decoded.eventName === "RefinerAdded") {
-            refinerId = Number(decoded.args.refinerId);
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
+      const result = await txHandle.waitForEvents();
       return {
-        refinerId,
+        refinerId: Number(result.refinerId),
         transactionHash: txHash
       };
     } catch (error) {
@@ -41042,8 +41709,25 @@ var DataController = class {
   /**
    * Retrieves a refiner by its ID.
    *
-   * @param refinerId - The refiner ID to retrieve
-   * @returns Promise resolving to the refiner information
+   * @remarks
+   * Queries the DataRefinerRegistry contract to get complete information about
+   * a specific refiner including its DLP association, schema, and instructions.
+   *
+   * @param refinerId - The numeric refiner ID to retrieve
+   * @returns Promise resolving to the refiner information object
+   * @throws {Error} When chain ID is not available - "Chain ID not available"
+   * @throws {Error} When refiner doesn't exist - "Refiner with ID {refinerId} does not exist"
+   * @throws {Error} When contract read fails - "Failed to fetch refiner: {error}"
+   * @example
+   * ```typescript
+   * const refiner = await vana.data.getRefiner(1);
+   * console.log({
+   *   name: refiner.name,
+   *   dlp: refiner.dlpId,
+   *   schema: refiner.schemaId,
+   *   instructions: refiner.refinementInstructionUrl
+   * });
+   * ```
    */
   async getRefiner(refinerId) {
     try {
@@ -41085,8 +41769,21 @@ var DataController = class {
   /**
    * Validates if a schema ID exists in the registry.
    *
-   * @param schemaId - The schema ID to validate
-   * @returns Promise resolving to boolean indicating if the schema ID is valid
+   * @remarks
+   * Checks the DataRefinerRegistry contract to determine if a given schema ID
+   * has been registered and is available for use.
+   *
+   * @param schemaId - The numeric schema ID to validate
+   * @returns Promise resolving to true if schema exists, false otherwise
+   * @example
+   * ```typescript
+   * const isValid = await vana.data.isValidSchemaId(42);
+   * if (isValid) {
+   *   console.log('Schema 42 is available for use');
+   * } else {
+   *   console.log('Schema 42 does not exist');
+   * }
+   * ```
    */
   async isValidSchemaId(schemaId) {
     try {
@@ -41116,7 +41813,16 @@ var DataController = class {
   /**
    * Gets the total number of refiners in the registry.
    *
+   * @remarks
+   * Queries the DataRefinerRegistry contract to get the total count of all
+   * registered refiners across all DLPs.
+   *
    * @returns Promise resolving to the total refiner count
+   * @example
+   * ```typescript
+   * const count = await vana.data.getRefinersCount();
+   * console.log(`Total refiners registered: ${count}`);
+   * ```
    */
   async getRefinersCount() {
     try {
@@ -41144,8 +41850,24 @@ var DataController = class {
   /**
    * Updates the schema ID for an existing refiner.
    *
-   * @param params - Parameters including refiner ID and new schema ID
+   * @remarks
+   * Allows the owner of a refiner to update its associated schema ID.
+   * This is useful when refiner output format needs to change.
+   *
+   * @param params - Update parameters
+   * @param params.refinerId - The refiner ID to update
+   * @param params.newSchemaId - The new schema ID to set
    * @returns Promise resolving to the transaction hash
+   * @throws {Error} When chain ID is not available - "Chain ID not available"
+   * @throws {Error} When transaction fails - "Failed to update schema ID: {error}"
+   * @example
+   * ```typescript
+   * const result = await vana.data.updateSchemaId({
+   *   refinerId: 1,
+   *   newSchemaId: 55
+   * });
+   * console.log(`Schema updated in tx ${result.transactionHash}`);
+   * ```
    */
   async updateSchemaId(params) {
     try {
@@ -41341,8 +42063,7 @@ var DataController = class {
    * ```
    */
   async addPermissionToFile(fileId, account, publicKey) {
-    const txHash = await this.submitFilePermission(fileId, account, publicKey);
-    return parseTransactionResult(this.context, txHash, "addFilePermission");
+    return await this.submitFilePermission(fileId, account, publicKey);
   }
   /**
    * Submits a file permission transaction and returns the transaction hash immediately.
@@ -41386,7 +42107,11 @@ var DataController = class {
         account: this.context.walletClient.account || await this.getUserAddress(),
         chain: this.context.walletClient.chain || null
       });
-      return txHash;
+      return new TransactionHandle(
+        this.context,
+        txHash,
+        "addFilePermission"
+      );
     } catch (error) {
       console.error("Failed to add permission to file:", error);
       throw new Error(
@@ -41757,8 +42482,203 @@ var DataController = class {
   }
 };
 
+// src/generated/subgraph.ts
+var GetSchemaDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: { kind: "Name", value: "GetSchema" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: { kind: "Variable", name: { kind: "Name", value: "id" } },
+          type: {
+            kind: "NonNullType",
+            type: { kind: "NamedType", name: { kind: "Name", value: "ID" } }
+          }
+        }
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "schema" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "id" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "id" }
+                }
+              }
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "id" } },
+                { kind: "Field", name: { kind: "Name", value: "name" } },
+                { kind: "Field", name: { kind: "Name", value: "dialect" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "definitionUrl" }
+                },
+                { kind: "Field", name: { kind: "Name", value: "createdAt" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "createdAtBlock" }
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "createdTxHash" }
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "refiners" },
+                  selectionSet: {
+                    kind: "SelectionSet",
+                    selections: [
+                      { kind: "Field", name: { kind: "Name", value: "id" } },
+                      { kind: "Field", name: { kind: "Name", value: "name" } },
+                      { kind: "Field", name: { kind: "Name", value: "owner" } }
+                    ]
+                  }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+var ListSchemasDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: { kind: "Name", value: "ListSchemas" },
+      variableDefinitions: [
+        {
+          kind: "VariableDefinition",
+          variable: {
+            kind: "Variable",
+            name: { kind: "Name", value: "first" }
+          },
+          type: {
+            kind: "NonNullType",
+            type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
+          }
+        },
+        {
+          kind: "VariableDefinition",
+          variable: { kind: "Variable", name: { kind: "Name", value: "skip" } },
+          type: {
+            kind: "NonNullType",
+            type: { kind: "NamedType", name: { kind: "Name", value: "Int" } }
+          }
+        }
+      ],
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "schemas" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "first" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "first" }
+                }
+              },
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "skip" },
+                value: {
+                  kind: "Variable",
+                  name: { kind: "Name", value: "skip" }
+                }
+              },
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "orderBy" },
+                value: { kind: "EnumValue", value: "createdAt" }
+              },
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "orderDirection" },
+                value: { kind: "EnumValue", value: "desc" }
+              }
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "id" } },
+                { kind: "Field", name: { kind: "Name", value: "name" } },
+                { kind: "Field", name: { kind: "Name", value: "dialect" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "definitionUrl" }
+                },
+                { kind: "Field", name: { kind: "Name", value: "createdAt" } },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "createdAtBlock" }
+                },
+                {
+                  kind: "Field",
+                  name: { kind: "Name", value: "createdTxHash" }
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+var CountSchemasDocument = {
+  kind: "Document",
+  definitions: [
+    {
+      kind: "OperationDefinition",
+      operation: "query",
+      name: { kind: "Name", value: "CountSchemas" },
+      selectionSet: {
+        kind: "SelectionSet",
+        selections: [
+          {
+            kind: "Field",
+            name: { kind: "Name", value: "schemas" },
+            arguments: [
+              {
+                kind: "Argument",
+                name: { kind: "Name", value: "first" },
+                value: { kind: "IntValue", value: "1000" }
+              }
+            ],
+            selectionSet: {
+              kind: "SelectionSet",
+              selections: [
+                { kind: "Field", name: { kind: "Name", value: "id" } }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+
 // src/controllers/schemas.ts
-import { decodeEventLog as decodeEventLog2 } from "viem";
+import { print } from "graphql";
 var SchemaController = class {
   constructor(context) {
     this.context = context;
@@ -41860,30 +42780,14 @@ var SchemaController = class {
         account: this.context.walletClient.account || userAddress,
         chain: this.context.walletClient.chain || null
       });
-      const receipt = await this.context.publicClient.waitForTransactionReceipt(
-        {
-          hash: txHash,
-          timeout: 3e4
-          // 30 seconds timeout
-        }
+      const txHandle = new TransactionHandle(
+        this.context,
+        txHash,
+        "addSchema"
       );
-      let schemaId = 0;
-      for (const log of receipt.logs) {
-        try {
-          const decoded = decodeEventLog2({
-            abi: dataRefinerRegistryAbi,
-            data: log.data,
-            topics: log.topics
-          });
-          if (decoded.eventName === "SchemaAdded") {
-            schemaId = Number(decoded.args.schemaId);
-            break;
-          }
-        } catch {
-        }
-      }
+      const result = await txHandle.waitForEvents();
       return {
-        schemaId,
+        schemaId: Number(result.schemaId),
         definitionUrl: uploadResult.url,
         transactionHash: txHash
       };
@@ -41900,15 +42804,30 @@ var SchemaController = class {
    * Retrieves a schema by its ID.
    *
    * @param schemaId - The ID of the schema to retrieve
+   * @param options - Optional parameters
+   * @param options.subgraphUrl - Custom subgraph URL to use instead of default
    * @returns Promise resolving to the schema object
    * @throws {Error} When the schema is not found or chain is unavailable
    * @example
    * ```typescript
    * const schema = await vana.schemas.get(1);
    * console.log(`Schema: ${schema.name} (${schema.type})`);
+   *
+   * // With custom subgraph
+   * const schema = await vana.schemas.get(1, {
+   *   subgraphUrl: 'https://custom-subgraph.com/graphql'
+   * });
    * ```
    */
-  async get(schemaId) {
+  async get(schemaId, options = {}) {
+    const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        return await this._getSchemaViaSubgraph({ schemaId, subgraphUrl });
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to RPC:", error);
+      }
+    }
     try {
       return await fetchSchemaFromChain(this.context, schemaId);
     } catch (error) {
@@ -41920,15 +42839,30 @@ var SchemaController = class {
   /**
    * Gets the total number of schemas registered on the network.
    *
+   * @param options - Optional parameters
+   * @param options.subgraphUrl - Custom subgraph URL to use instead of default
    * @returns Promise resolving to the total schema count
    * @throws {Error} When the count cannot be retrieved
    * @example
    * ```typescript
    * const count = await vana.schemas.count();
    * console.log(`Total schemas: ${count}`);
+   *
+   * // With custom subgraph
+   * const count = await vana.schemas.count({
+   *   subgraphUrl: 'https://custom-subgraph.com/graphql'
+   * });
    * ```
    */
-  async count() {
+  async count(options = {}) {
+    const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        return await this._countSchemasViaSubgraph({ subgraphUrl });
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to RPC:", error);
+      }
+    }
     try {
       return await fetchSchemaCountFromChain(this.context);
     } catch (error) {
@@ -41943,6 +42877,7 @@ var SchemaController = class {
    * @param options - Optional parameters for listing schemas
    * @param options.limit - Maximum number of schemas to return
    * @param options.offset - Number of schemas to skip
+   * @param options.subgraphUrl - Custom subgraph URL to use instead of default
    * @returns Promise resolving to an array of schemas
    * @example
    * ```typescript
@@ -41951,23 +42886,78 @@ var SchemaController = class {
    *
    * // Get schemas with pagination
    * const schemas = await vana.schemas.list({ limit: 10, offset: 0 });
+   *
+   * // With custom subgraph
+   * const schemas = await vana.schemas.list({
+   *   limit: 10,
+   *   offset: 0,
+   *   subgraphUrl: 'https://custom-subgraph.com/graphql'
+   * });
    * ```
    */
   async list(options = {}) {
     const { limit = 100, offset = 0 } = options;
+    const subgraphUrl = options.subgraphUrl || this.context.subgraphUrl;
+    if (subgraphUrl) {
+      try {
+        return await this._listSchemasViaSubgraph({
+          limit,
+          offset,
+          subgraphUrl
+        });
+      } catch (error) {
+        console.debug("Subgraph query failed, falling back to RPC:", error);
+      }
+    }
     try {
       const totalCount = await this.count();
-      const schemas = [];
       const start = offset;
       const end = Math.min(start + limit, totalCount);
+      if (end <= start) {
+        return [];
+      }
+      const chainId = this.context.walletClient.chain?.id;
+      if (!chainId) {
+        throw new Error("Chain ID not available");
+      }
+      const dataRefinerRegistryAddress = getContractAddress(
+        chainId,
+        "DataRefinerRegistry"
+      );
+      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const schemaCalls = [];
       for (let i = start; i < end; i++) {
-        try {
-          const schema = await this.get(i + 1);
-          schemas.push(schema);
-        } catch (error) {
-          console.warn(`Failed to retrieve schema ${i + 1}:`, error);
-        }
+        schemaCalls.push({
+          address: dataRefinerRegistryAddress,
+          abi: dataRefinerRegistryAbi,
+          functionName: "schemas",
+          args: [BigInt(i + 1)]
+          // Schema IDs are 1-based
+        });
       }
+      const schemaResults = await gasAwareMulticall(this.context.publicClient, {
+        contracts: schemaCalls,
+        allowFailure: true
+      });
+      const schemas = [];
+      schemaResults.forEach((result, index) => {
+        if (result.status === "success" && result.result) {
+          const schemaId = start + index + 1;
+          const schemaData = result.result;
+          if (schemaData.name && schemaData.dialect && schemaData.definitionUrl) {
+            schemas.push({
+              id: schemaId,
+              name: schemaData.name,
+              dialect: schemaData.dialect,
+              definitionUrl: schemaData.definitionUrl
+            });
+          } else {
+            console.warn(`Incomplete schema data for ID ${schemaId}`);
+          }
+        } else {
+          console.warn(`Failed to retrieve schema ${start + index + 1}`);
+        }
+      });
       return schemas;
     } catch (error) {
       throw new Error(
@@ -41998,7 +42988,7 @@ var SchemaController = class {
         address: dataRefinerRegistryAddress,
         abi: dataRefinerRegistryAbi,
         functionName: "addSchema",
-        args: [params.name, params.type, params.definitionUrl],
+        args: [params.name, params.dialect, params.definitionUrl],
         account: this.context.walletClient.account || userAddress,
         chain: this.context.walletClient.chain || null
       });
@@ -42013,6 +43003,119 @@ var SchemaController = class {
       );
     }
   }
+  /**
+   * Internal method: Query schema via subgraph
+   *
+   * @param params - Query parameters
+   * @param params.schemaId - The ID of the schema to retrieve
+   * @param params.subgraphUrl - The subgraph URL to query
+   * @returns Promise resolving to the schema object
+   * @private
+   */
+  async _getSchemaViaSubgraph(params) {
+    const { schemaId, subgraphUrl } = params;
+    const response = await fetch(subgraphUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query: print(GetSchemaDocument),
+        variables: { id: schemaId.toString() }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Subgraph request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const result = await response.json();
+    if (result.errors) {
+      throw new Error(
+        `Subgraph query errors: ${result.errors.map((e) => e.message).join(", ")}`
+      );
+    }
+    if (!result.data?.schema) {
+      throw new Error(`Schema ${schemaId} not found in subgraph`);
+    }
+    const subgraphSchema = result.data.schema;
+    return {
+      id: parseInt(subgraphSchema.id),
+      name: subgraphSchema.name,
+      dialect: subgraphSchema.dialect,
+      definitionUrl: subgraphSchema.definitionUrl
+    };
+  }
+  /**
+   * Internal method: List schemas via subgraph
+   *
+   * @param params - Query parameters
+   * @param params.limit - Maximum number of schemas to return
+   * @param params.offset - Number of schemas to skip
+   * @param params.subgraphUrl - The subgraph URL to query
+   * @returns Promise resolving to an array of schemas
+   * @private
+   */
+  async _listSchemasViaSubgraph(params) {
+    const { limit, offset, subgraphUrl } = params;
+    const response = await fetch(subgraphUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query: print(ListSchemasDocument),
+        variables: { first: limit, skip: offset }
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Subgraph request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const result = await response.json();
+    if (result.errors) {
+      throw new Error(
+        `Subgraph query errors: ${result.errors.map((e) => e.message).join(", ")}`
+      );
+    }
+    if (!result.data?.schemas) {
+      return [];
+    }
+    return result.data.schemas.map((schema) => ({
+      id: parseInt(schema.id),
+      name: schema.name,
+      dialect: schema.dialect,
+      definitionUrl: schema.definitionUrl
+    }));
+  }
+  /**
+   * Internal method: Count schemas via subgraph
+   *
+   * @param params - Query parameters
+   * @param params.subgraphUrl - The subgraph URL to query
+   * @returns Promise resolving to the total schema count
+   * @private
+   */
+  async _countSchemasViaSubgraph(params) {
+    const { subgraphUrl } = params;
+    const response = await fetch(subgraphUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query: print(CountSchemasDocument),
+        variables: {}
+      })
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Subgraph request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    const result = await response.json();
+    if (result.errors) {
+      throw new Error(
+        `Subgraph query errors: ${result.errors.map((e) => e.message).join(", ")}`
+      );
+    }
+    return result.data?.schemas?.length || 0;
+  }
   /**
    * Gets the user's wallet address.
    *
@@ -42453,7 +43556,12 @@ var chains = {
 };
 
 // src/core/client.ts
-var defaultFromBlock = BigInt(292220);
+var defaultFromBlocks = {
+  14800: BigInt(732312),
+  // Moksha Testnet - earliest contract deployment
+  1480: BigInt(758584)
+  // Vana Mainnet - earliest contract deployment
+};
 var _client;
 var createClient = (chainId = mokshaTestnet.id) => {
   if (!_client || _client.chain?.id !== chainId) {
@@ -44098,7 +45206,7 @@ var vanaMainnet2 = {
       url: "https://vanascan.io"
     }
   },
-  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/vana/7.0.6/gn"
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/vana/7.0.7/gn"
 };
 var moksha = {
   id: 14800,
@@ -44119,7 +45227,7 @@ var moksha = {
       url: "https://moksha.vanascan.io"
     }
   },
-  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/7.0.6/gn"
+  subgraphUrl: "https://api.goldsky.com/api/public/project_cm168cz887zva010j39il7a6p/subgraphs/moksha/7.0.7/gn"
 };
 function getChainConfig(chainId) {
   switch (chainId) {
@@ -45099,37 +46207,37 @@ async function handleRelayerRequest(sdk, payload) {
   }
   switch (typedData.primaryType) {
     case "Permission":
-      return await sdk.permissions.submitSignedGrant(
+      return sdk.permissions.submitSignedGrant(
         typedData,
         signature
       );
     case "PermissionRevoke":
-      return await sdk.permissions.submitSignedRevoke(
+      return sdk.permissions.submitSignedRevoke(
         typedData,
         signature
       );
     case "TrustServer":
-      return await sdk.permissions.submitSignedTrustServer(
+      return sdk.permissions.submitSignedTrustServer(
         typedData,
         signature
       );
     case "AddServer":
-      return await sdk.permissions.submitSignedAddAndTrustServer(
+      return sdk.permissions.submitSignedAddAndTrustServer(
         typedData,
         signature
       );
     case "UntrustServer":
-      return await sdk.permissions.submitSignedUntrustServer(
+      return sdk.permissions.submitSignedUntrustServer(
         typedData,
         signature
       );
     case "RegisterGrantee":
-      return await sdk.permissions.submitSignedRegisterGrantee(
+      return sdk.permissions.submitSignedRegisterGrantee(
         typedData,
         signature
       );
     case "ServerFilesAndPermission":
-      return await sdk.permissions.submitSignedAddServerFilesAndPermissions(
+      return sdk.permissions.submitSignedAddServerFilesAndPermissions(
         typedData,
         signature
       );
@@ -45592,6 +46700,7 @@ export {
   SignatureError,
   StorageError,
   StorageManager,
+  TransactionHandle,
   UserRejectedRequestError,
   Vana,
   VanaCore,