@opendatalabs/vana-sdk 0.1.0-alpha.a7bcbd6 → 0.1.0-alpha.aa3959e

package/dist/index.browser.js

@@ -99,15 +99,35 @@ var init_error_utils = __esm({
   }
 });
 
+// src/utils/lazy-import.ts
+function lazyImport(importFn) {
+  let cached = null;
+  return () => {
+    if (!cached) {
+      cached = importFn().catch((err) => {
+        cached = null;
+        throw new Error("Failed to load module", { cause: err });
+      });
+    }
+    return cached;
+  };
+}
+var init_lazy_import = __esm({
+  "src/utils/lazy-import.ts"() {
+    "use strict";
+  }
+});
+
 // src/platform/browser.ts
-import * as openpgp from "openpgp";
-var BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserCacheAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
+var getOpenPGP, BrowserCryptoAdapter, BrowserPGPAdapter, BrowserHttpAdapter, BrowserCacheAdapter, BrowserPlatformAdapter, browserPlatformAdapter;
 var init_browser = __esm({
   "src/platform/browser.ts"() {
     "use strict";
     init_crypto_utils();
     init_pgp_utils();
     init_error_utils();
+    init_lazy_import();
+    getOpenPGP = lazyImport(() => import("openpgp"));
     BrowserCryptoAdapter = class {
       async encryptWithPublicKey(data, publicKeyHex) {
         try {
@@ -196,11 +216,11 @@ var init_browser = __esm({
       }
       async encryptWithPassword(data, password) {
         try {
-          const openpgp2 = await import("openpgp");
-          const message = await openpgp2.createMessage({
+          const openpgp = await getOpenPGP();
+          const message = await openpgp.createMessage({
             binary: data
           });
-          const encrypted = await openpgp2.encrypt({
+          const encrypted = await openpgp.encrypt({
             message,
             passwords: [password],
             format: "binary"
@@ -214,11 +234,11 @@ var init_browser = __esm({
       }
       async decryptWithPassword(encryptedData, password) {
         try {
-          const openpgp2 = await import("openpgp");
-          const message = await openpgp2.readMessage({
+          const openpgp = await getOpenPGP();
+          const message = await openpgp.readMessage({
             binaryMessage: encryptedData
           });
-          const { data: decrypted } = await openpgp2.decrypt({
+          const { data: decrypted } = await openpgp.decrypt({
             message,
             passwords: [password],
             format: "binary"
@@ -232,6 +252,7 @@ var init_browser = __esm({
     BrowserPGPAdapter = class {
       async encrypt(data, publicKeyArmored) {
         try {
+          const openpgp = await getOpenPGP();
           const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
           const encrypted = await openpgp.encrypt({
             message: await openpgp.createMessage({ text: data }),
@@ -247,6 +268,7 @@ var init_browser = __esm({
       }
       async decrypt(encryptedData, privateKeyArmored) {
         try {
+          const openpgp = await getOpenPGP();
           const privateKey = await openpgp.readPrivateKey({
             armoredKey: privateKeyArmored
           });
@@ -264,6 +286,7 @@ var init_browser = __esm({
       }
       async generateKeyPair(options) {
         try {
+          const openpgp = await getOpenPGP();
           const keyGenParams = getPGPKeyGenParams(options);
           const { privateKey, publicKey } = await openpgp.generateKey(keyGenParams);
           return { publicKey, privateKey };
@@ -876,11 +899,11 @@ import { parseEventLogs } from "viem";
 var EVENT_MAPPINGS = {
   // Permission operations
   grant: {
-    contract: "DataPermissions",
+    contract: "DataPortabilityPermissions",
     event: "PermissionAdded"
   },
   revoke: {
-    contract: "DataPermissions",
+    contract: "DataPortabilityPermissions",
     event: "PermissionRevoked"
   },
   trustServer: {
@@ -6094,6 +6117,22 @@ var DataPortabilityPermissionsABI = [
     name: "InvalidNonce",
     type: "error"
   },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "filesLength",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "permissionsLength",
+        type: "uint256"
+      }
+    ],
+    name: "InvalidPermissionsLength",
+    type: "error"
+  },
   {
     inputs: [],
     name: "InvalidSignature",
@@ -6425,6 +6464,84 @@ var DataPortabilityPermissionsABI = [
     stateMutability: "nonpayable",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "nonce",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "granteeId",
+            type: "uint256"
+          },
+          {
+            internalType: "string",
+            name: "grant",
+            type: "string"
+          },
+          {
+            internalType: "string[]",
+            name: "fileUrls",
+            type: "string[]"
+          },
+          {
+            internalType: "address",
+            name: "serverAddress",
+            type: "address"
+          },
+          {
+            internalType: "string",
+            name: "serverUrl",
+            type: "string"
+          },
+          {
+            internalType: "string",
+            name: "serverPublicKey",
+            type: "string"
+          },
+          {
+            components: [
+              {
+                internalType: "address",
+                name: "account",
+                type: "address"
+              },
+              {
+                internalType: "string",
+                name: "key",
+                type: "string"
+              }
+            ],
+            internalType: "struct IDataRegistry.Permission[][]",
+            name: "filePermissions",
+            type: "tuple[][]"
+          }
+        ],
+        internalType: "struct IDataPortabilityPermissions.ServerFilesAndPermissionInput",
+        name: "serverFilesAndPermissionInput",
+        type: "tuple"
+      },
+      {
+        internalType: "bytes",
+        name: "signature",
+        type: "bytes"
+      }
+    ],
+    name: "addServerFilesAndPermissions",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
   {
     inputs: [],
     name: "dataPortabilityGrantees",
@@ -6639,25 +6756,6 @@ var DataPortabilityPermissionsABI = [
     stateMutability: "nonpayable",
     type: "function"
   },
-  {
-    inputs: [
-      {
-        internalType: "uint256",
-        name: "permissionId",
-        type: "uint256"
-      }
-    ],
-    name: "isActivePermission",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
   {
     inputs: [
       {
@@ -6772,11 +6870,6 @@ var DataPortabilityPermissionsABI = [
             name: "grant",
             type: "string"
           },
-          {
-            internalType: "bytes",
-            name: "signature",
-            type: "bytes"
-          },
           {
             internalType: "uint256",
             name: "startBlock",
@@ -7494,9 +7587,9 @@ var DataPortabilityServersABI = [
       },
       {
         indexed: false,
-        internalType: "bytes",
+        internalType: "string",
         name: "publicKey",
-        type: "bytes"
+        type: "string"
       },
       {
         indexed: false,
@@ -7617,6 +7710,19 @@ var DataPortabilityServersABI = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [],
+    name: "PERMISSION_MANAGER_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [],
     name: "UPGRADE_INTERFACE_VERSION",
@@ -7632,22 +7738,22 @@ var DataPortabilityServersABI = [
   },
   {
     inputs: [
+      {
+        internalType: "address",
+        name: "ownerAddress",
+        type: "address"
+      },
       {
         components: [
-          {
-            internalType: "address",
-            name: "owner",
-            type: "address"
-          },
           {
             internalType: "address",
             name: "serverAddress",
             type: "address"
           },
           {
-            internalType: "bytes",
+            internalType: "string",
             name: "publicKey",
-            type: "bytes"
+            type: "string"
           },
           {
             internalType: "string",
@@ -7656,11 +7762,11 @@ var DataPortabilityServersABI = [
           }
         ],
         internalType: "struct IDataPortabilityServers.AddServerInput",
-        name: "addAndTrustServerInput",
+        name: "addServerInput",
         type: "tuple"
       }
     ],
-    name: "addAndTrustServer",
+    name: "addAndTrustServerOnBehalf",
     outputs: [],
     stateMutability: "nonpayable",
     type: "function"
@@ -7674,20 +7780,15 @@ var DataPortabilityServersABI = [
             name: "nonce",
             type: "uint256"
           },
-          {
-            internalType: "address",
-            name: "owner",
-            type: "address"
-          },
           {
             internalType: "address",
             name: "serverAddress",
             type: "address"
           },
           {
-            internalType: "bytes",
+            internalType: "string",
             name: "publicKey",
-            type: "bytes"
+            type: "string"
           },
           {
             internalType: "string",
@@ -7695,8 +7796,8 @@ var DataPortabilityServersABI = [
             type: "string"
           }
         ],
-        internalType: "struct IDataPortabilityServers.AddAndTrustServerInput",
-        name: "addAndTrustServerInput",
+        internalType: "struct IDataPortabilityServers.AddServerWithSignatureInput",
+        name: "addServerInput",
         type: "tuple"
       },
       {
@@ -7715,9 +7816,9 @@ var DataPortabilityServersABI = [
       {
         components: [
           {
-            internalType: "address",
-            name: "owner",
-            type: "address"
+            internalType: "uint256",
+            name: "nonce",
+            type: "uint256"
           },
           {
             internalType: "address",
@@ -7725,9 +7826,9 @@ var DataPortabilityServersABI = [
             type: "address"
           },
           {
-            internalType: "bytes",
+            internalType: "string",
             name: "publicKey",
-            type: "bytes"
+            type: "string"
           },
           {
             internalType: "string",
@@ -7735,12 +7836,17 @@ var DataPortabilityServersABI = [
             type: "string"
           }
         ],
-        internalType: "struct IDataPortabilityServers.AddServerInput",
+        internalType: "struct IDataPortabilityServers.AddServerWithSignatureInput",
         name: "addServerInput",
         type: "tuple"
+      },
+      {
+        internalType: "bytes",
+        name: "signature",
+        type: "bytes"
       }
     ],
-    name: "addServer",
+    name: "addServerWithSignature",
     outputs: [],
     stateMutability: "nonpayable",
     type: "function"
@@ -7867,49 +7973,6 @@ var DataPortabilityServersABI = [
     stateMutability: "nonpayable",
     type: "function"
   },
-  {
-    inputs: [
-      {
-        internalType: "uint256",
-        name: "serverId",
-        type: "uint256"
-      }
-    ],
-    name: "isActiveServer",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "userAddress",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "serverId",
-        type: "uint256"
-      }
-    ],
-    name: "isActiveServerForUser",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
   {
     inputs: [
       {
@@ -8064,9 +8127,9 @@ var DataPortabilityServersABI = [
             type: "address"
           },
           {
-            internalType: "bytes",
+            internalType: "string",
             name: "publicKey",
-            type: "bytes"
+            type: "string"
           },
           {
             internalType: "string",
@@ -8110,9 +8173,9 @@ var DataPortabilityServersABI = [
             type: "address"
           },
           {
-            internalType: "bytes",
+            internalType: "string",
             name: "publicKey",
-            type: "bytes"
+            type: "string"
           },
           {
             internalType: "string",
@@ -8432,6 +8495,123 @@ var DataPortabilityServersABI = [
     stateMutability: "view",
     type: "function"
   },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "userAddress",
+        type: "address"
+      }
+    ],
+    name: "userServerValues",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "id",
+            type: "uint256"
+          },
+          {
+            internalType: "address",
+            name: "owner",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "serverAddress",
+            type: "address"
+          },
+          {
+            internalType: "string",
+            name: "publicKey",
+            type: "string"
+          },
+          {
+            internalType: "string",
+            name: "url",
+            type: "string"
+          },
+          {
+            internalType: "uint256",
+            name: "startBlock",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "endBlock",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct IDataPortabilityServers.TrustedServerInfo[]",
+        name: "serversInfo",
+        type: "tuple[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "userAddress",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "serverId",
+        type: "uint256"
+      }
+    ],
+    name: "userServers",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "id",
+            type: "uint256"
+          },
+          {
+            internalType: "address",
+            name: "owner",
+            type: "address"
+          },
+          {
+            internalType: "address",
+            name: "serverAddress",
+            type: "address"
+          },
+          {
+            internalType: "string",
+            name: "publicKey",
+            type: "string"
+          },
+          {
+            internalType: "string",
+            name: "url",
+            type: "string"
+          },
+          {
+            internalType: "uint256",
+            name: "startBlock",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "endBlock",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct IDataPortabilityServers.TrustedServerInfo",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
   {
     inputs: [
       {
@@ -34993,7 +35173,6 @@ var DATVotesABI = [
 
 // src/abi/index.ts
 var contractAbis = {
-  DataPermissions: DataPortabilityPermissionsABI,
   DataPortabilityPermissions: DataPortabilityPermissionsABI,
   DataPortabilityServers: DataPortabilityServersABI,
   DataPortabilityGrantees: DataPortabilityGranteesABI,
@@ -35101,13 +35280,6 @@ async function parseTransactionResult(context, hash, operation) {
 // src/config/addresses.ts
 var CONTRACTS = {
   // Data Portability Contracts (New Architecture)
-  DataPermissions: {
-    addresses: {
-      14800: "0xD54523048AdD05b4d734aFaE7C68324Ebb7373eF",
-      // Points to DataPortabilityPermissions for backwards compatibility
-      1480: "0xD54523048AdD05b4d734aFaE7C68324Ebb7373eF"
-    }
-  },
   DataPortabilityPermissions: {
     addresses: {
       14800: "0xD54523048AdD05b4d734aFaE7C68324Ebb7373eF",
@@ -35942,6 +36114,42 @@ async function withSignatureCache(cache, walletAddress, typedData, signFn, ttlHo
   return signature;
 }
 
+// src/utils/signatureFormatter.ts
+var V_OFFSET_FOR_ETHEREUM = 27;
+function formatSignatureForContract(signature) {
+  const cleanSig = signature.startsWith("0x") ? signature.slice(2) : signature;
+  if (cleanSig.length !== 130) {
+    return signature;
+  }
+  const vHex = cleanSig.slice(128, 130);
+  const v = parseInt(vHex, 16);
+  if (isNaN(v)) {
+    return signature;
+  }
+  if (v < 27) {
+    const adjustedV = (v + V_OFFSET_FOR_ETHEREUM).toString(16).padStart(2, "0");
+    return `0x${cleanSig.slice(0, 128)}${adjustedV}`;
+  }
+  return signature;
+}
+
+// src/utils/typedDataConverter.ts
+function toViemTypedDataDefinition(typedData) {
+  const viemTypes = {};
+  for (const [typeName, typeArray] of Object.entries(typedData.types)) {
+    viemTypes[typeName] = typeArray.map((field) => ({
+      name: field.name,
+      type: field.type
+    }));
+  }
+  return {
+    domain: typedData.domain,
+    types: viemTypes,
+    primaryType: typedData.primaryType,
+    message: typedData.message
+  };
+}
+
 // src/controllers/permissions.ts
 var PermissionsController = class {
   constructor(context) {
@@ -36101,7 +36309,7 @@ var PermissionsController = class {
           throw new Error("Failed to store grant file - no URL returned");
         }
       }
-      const nonce = await this.getUserNonce();
+      const nonce = await this.getPermissionsUserNonce();
       console.debug(
         "\u{1F50D} Debug - Final grant URL being passed to compose:",
         grantUrl
@@ -36194,7 +36402,7 @@ var PermissionsController = class {
           throw new Error("Failed to store grant file - no URL returned");
         }
       }
-      const nonce = await this.getUserNonce();
+      const nonce = await this.getPermissionsUserNonce();
       console.debug(
         "\u{1F50D} Debug - Final grant URL being passed to compose:",
         grantUrl
@@ -36259,14 +36467,8 @@ var PermissionsController = class {
         )
       );
       if (this.context.relayerCallbacks?.submitPermissionGrant) {
-        const jsonSafeTypedData = JSON.parse(
-          JSON.stringify(
-            typedData,
-            (_key, value) => typeof value === "bigint" ? value.toString() : value
-          )
-        );
         return await this.context.relayerCallbacks.submitPermissionGrant(
-          jsonSafeTypedData,
+          typedData,
           signature
         );
       } else {
@@ -36336,7 +36538,6 @@ var PermissionsController = class {
     try {
       const addAndTrustServerInput = {
         nonce: BigInt(typedData.message.nonce),
-        owner: typedData.message.owner,
         serverAddress: typedData.message.serverAddress,
         serverUrl: typedData.message.serverUrl,
         publicKey: typedData.message.publicKey
@@ -36350,7 +36551,7 @@ var PermissionsController = class {
         throw error;
       }
       throw new BlockchainError(
-        `Add and trust server submission failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        `Add and trust server submission failed444444: ${error instanceof Error ? error.message : "Unknown error"}`,
         error
       );
     }
@@ -36366,14 +36567,8 @@ var PermissionsController = class {
   async submitSignedRevoke(typedData, signature) {
     try {
       if (this.context.relayerCallbacks?.submitPermissionRevoke) {
-        const jsonSafeTypedData = JSON.parse(
-          JSON.stringify(
-            typedData,
-            (_key, value) => typeof value === "bigint" ? value.toString() : value
-          )
-        );
         return await this.context.relayerCallbacks.submitPermissionRevoke(
-          jsonSafeTypedData,
+          typedData,
           signature
         );
       } else {
@@ -36426,11 +36621,11 @@ var PermissionsController = class {
    */
   async submitDirectTransaction(typedData, signature) {
     const chainId = await this.context.walletClient.getChainId();
-    const DataPermissionsAddress = getContractAddress(
+    const DataPortabilityPermissionsAddress = getContractAddress(
       chainId,
-      "DataPermissions"
+      "DataPortabilityPermissions"
     );
-    const DataPermissionsAbi = getAbi("DataPermissions");
+    const DataPortabilityPermissionsAbi = getAbi("DataPortabilityPermissions");
     const permissionInput = {
       nonce: typedData.message.nonce,
       granteeId: typedData.message.granteeId,
@@ -36447,11 +36642,12 @@ var PermissionsController = class {
       "\u{1F50D} Debug - Grant field length:",
       typedData.message.grant?.length || 0
     );
+    const formattedSignature = formatSignatureForContract(signature);
     const txHash = await this.context.walletClient.writeContract({
-      address: DataPermissionsAddress,
-      abi: DataPermissionsAbi,
+      address: DataPortabilityPermissionsAddress,
+      abi: DataPortabilityPermissionsAbi,
       functionName: "addPermission",
-      args: [permissionInput, signature],
+      args: [permissionInput, formattedSignature],
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
     });
@@ -36510,14 +36706,16 @@ var PermissionsController = class {
         throw new BlockchainError("Chain ID not available");
       }
       const chainId = await this.context.walletClient.getChainId();
-      const DataPermissionsAddress = getContractAddress(
+      const DataPortabilityPermissionsAddress = getContractAddress(
         chainId,
-        "DataPermissions"
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
       );
-      const DataPermissionsAbi = getAbi("DataPermissions");
       const txHash = await this.context.walletClient.writeContract({
-        address: DataPermissionsAddress,
-        abi: DataPermissionsAbi,
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
         functionName: "revokePermission",
         args: [params.permissionId],
         account: this.context.walletClient.account || await this.getUserAddress(),
@@ -36548,12 +36746,12 @@ var PermissionsController = class {
    * @throws {RelayerError} When gasless submission fails
    * @throws {PermissionError} When revocation fails for any other reason
    */
-  async revokeWithSignature(params) {
+  async submitRevokeWithSignature(params) {
     try {
       if (!this.context.walletClient.chain?.id) {
         throw new BlockchainError("Chain ID not available");
       }
-      const nonce = await this.getUserNonce();
+      const nonce = await this.getPermissionsUserNonce();
       const revokePermissionInput = {
         nonce,
         permissionId: params.permissionId
@@ -36586,7 +36784,10 @@ var PermissionsController = class {
     }
   }
   /**
+   * @deprecated Use getPermissionsUserNonce() for permission operations or getServersUserNonce() for server operations
+   *
    * Retrieves the user's current nonce from the DataPortabilityServers contract.
+   * This method is deprecated in favor of more specific nonce methods.
    *
    * The nonce is used to prevent replay attacks in signed transactions and must
    * be incremented with each transaction to maintain security.
@@ -36598,22 +36799,26 @@ var PermissionsController = class {
    * @private
    * @example
    * ```typescript
+   * // Deprecated - use specific methods instead
    * const nonce = await this.getUserNonce();
-   * console.log(`Current nonce: ${nonce}`);
+   *
+   * // Use these instead:
+   * const permissionsNonce = await this.getPermissionsUserNonce();
+   * const serversNonce = await this.getServersUserNonce();
    * ```
    */
   async getUserNonce() {
     try {
       const userAddress = await this.getUserAddress();
       const chainId = await this.context.walletClient.getChainId();
-      const DataPermissionsAddress = getContractAddress(
+      const DataPortabilityServersAddress = getContractAddress(
         chainId,
-        "DataPermissions"
+        "DataPortabilityServers"
       );
-      const DataPermissionsAbi = getAbi("DataPermissions");
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
       const nonce = await this.context.publicClient.readContract({
-        address: DataPermissionsAddress,
-        abi: DataPermissionsAbi,
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
         functionName: "userNonce",
         args: [userAddress]
       });
@@ -36624,6 +36829,80 @@ var PermissionsController = class {
       );
     }
   }
+  /**
+   * Retrieves the user's current nonce from the DataPortabilityServers contract.
+   * This nonce is used for server-related operations (AddAndTrustServer, TrustServer, UntrustServer).
+   *
+   * @returns Promise resolving to the current servers nonce
+   * @throws {NonceError} When reading nonce from contract fails
+   * @private
+   *
+   * @example
+   * ```typescript
+   * const nonce = await this.getServersUserNonce();
+   * console.log(`Current servers nonce: ${nonce}`);
+   * ```
+   */
+  async getServersUserNonce() {
+    try {
+      const userAddress = await this.getUserAddress();
+      const chainId = await this.context.walletClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const [nonce] = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "users",
+        args: [userAddress]
+      });
+      return nonce;
+    } catch (error) {
+      throw new NonceError(
+        `Failed to retrieve server nonce: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Retrieves the user's current nonce from the DataPortabilityPermissions contract.
+   * This nonce is used for permission-related operations (addPermission, addServerFilesAndPermissions).
+   *
+   * @returns Promise resolving to the current permissions nonce
+   * @throws {NonceError} When reading nonce from contract fails
+   * @private
+   *
+   * @example
+   * ```typescript
+   * const nonce = await this.getPermissionsUserNonce();
+   * console.log(`Current permissions nonce: ${nonce}`);
+   * ```
+   */
+  async getPermissionsUserNonce() {
+    try {
+      const userAddress = await this.getUserAddress();
+      const chainId = await this.context.walletClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const nonce = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "userNonce",
+        args: [userAddress]
+      });
+      return nonce;
+    } catch (error) {
+      throw new NonceError(
+        `Failed to retrieve permissions nonce: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
   /**
    * Composes the EIP-712 typed data for PermissionGrant (new simplified format).
    *
@@ -36682,6 +36961,66 @@ var PermissionsController = class {
       }
     };
   }
+  /**
+   * Creates EIP-712 typed data structure for server files and permissions.
+   *
+   * @param params - Parameters for the server files and permissions message
+   * @param params.granteeId - Grantee ID
+   * @param params.grant - Grant URL or grant data
+   * @param params.fileUrls - Array of file URLs
+   * @param params.serverAddress - Server address
+   * @param params.serverUrl - Server URL
+   * @param params.serverPublicKey - Server public key
+   * @param params.filePermissions - File permissions array
+   * @param params.nonce - Unique number to prevent replay attacks
+   * @returns Promise resolving to the typed data structure
+   */
+  async composeServerFilesAndPermissionMessage(params) {
+    const domain = await this.getPermissionDomain();
+    console.debug(
+      "\u{1F50D} Debug - Composing server files and permission message with grant:",
+      params.grant
+    );
+    if (!params.grant.startsWith("ipfs://") && params.grant.includes("/ipfs/")) {
+      const { extractIpfsHash: extractIpfsHash2 } = await Promise.resolve().then(() => (init_ipfs(), ipfs_exports));
+      const hash = extractIpfsHash2(params.grant);
+      if (hash) {
+        console.warn(
+          `\u26A0\uFE0F  Storing HTTP gateway URL on-chain instead of ipfs:// protocol. Found: ${params.grant}. Consider using ipfs://${hash} for better protocol-agnostic on-chain storage.`
+        );
+      }
+    }
+    return {
+      domain,
+      types: {
+        Permission: [
+          { name: "account", type: "address" },
+          { name: "key", type: "string" }
+        ],
+        ServerFilesAndPermission: [
+          { name: "nonce", type: "uint256" },
+          { name: "granteeId", type: "uint256" },
+          { name: "grant", type: "string" },
+          { name: "fileUrls", type: "string[]" },
+          { name: "serverAddress", type: "address" },
+          { name: "serverUrl", type: "string" },
+          { name: "serverPublicKey", type: "string" },
+          { name: "filePermissions", type: "Permission[][]" }
+        ]
+      },
+      primaryType: "ServerFilesAndPermission",
+      message: {
+        nonce: params.nonce,
+        granteeId: params.granteeId,
+        grant: params.grant,
+        fileUrls: params.fileUrls,
+        serverAddress: params.serverAddress,
+        serverUrl: params.serverUrl,
+        serverPublicKey: params.serverPublicKey,
+        filePermissions: params.filePermissions
+      }
+    };
+  }
   /**
    * Gets the EIP-712 domain for PermissionGrant signatures.
    *
@@ -36689,15 +37028,15 @@ var PermissionsController = class {
    */
   async getPermissionDomain() {
     const chainId = await this.context.walletClient.getChainId();
-    const DataPermissionsAddress = getContractAddress(
+    const DataPortabilityPermissionsAddress = getContractAddress(
       chainId,
-      "DataPermissions"
+      "DataPortabilityPermissions"
     );
     return {
       name: "VanaDataPortabilityPermissions",
       version: "1",
       chainId,
-      verifyingContract: DataPermissionsAddress
+      verifyingContract: DataPortabilityPermissionsAddress
     };
   }
   /**
@@ -36714,9 +37053,13 @@ var PermissionsController = class {
         walletAddress,
         typedData,
         async () => {
-          return await this.context.walletClient.signTypedData(
-            typedData
-          );
+          const viemCompatibleTypedData = toViemTypedDataDefinition(typedData);
+          return await this.context.walletClient.signTypedData({
+            ...viemCompatibleTypedData,
+            // Non-null assertion is safe here because getUserAddress() above ensures account exists
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            account: this.context.walletClient.account
+          });
         }
       );
     } catch (error) {
@@ -36863,122 +37206,6 @@ var PermissionsController = class {
       );
     }
   }
-  /**
-   * Gets all permission IDs for a specific file.
-   *
-   * @param fileId - The file ID to query permissions for
-   * @returns Promise resolving to array of permission IDs
-   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
-   */
-  async getFilePermissionIds(fileId) {
-    try {
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPermissionsAddress = getContractAddress(
-        chainId,
-        "DataPermissions"
-      );
-      const DataPermissionsAbi = getAbi("DataPermissions");
-      const permissionIds = await this.context.publicClient.readContract({
-        address: DataPermissionsAddress,
-        abi: DataPermissionsAbi,
-        functionName: "filePermissionIds",
-        args: [fileId]
-      });
-      return permissionIds;
-    } catch (error) {
-      throw new BlockchainError(
-        `Failed to get file permission IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error
-      );
-    }
-  }
-  /**
-   * Gets all file IDs associated with a permission.
-   *
-   * @param permissionId - The permission ID to query files for
-   * @returns Promise resolving to array of file IDs
-   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
-   */
-  async getPermissionFileIds(permissionId) {
-    try {
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPermissionsAddress = getContractAddress(
-        chainId,
-        "DataPermissions"
-      );
-      const DataPermissionsAbi = getAbi("DataPermissions");
-      const fileIds = await this.context.publicClient.readContract({
-        address: DataPermissionsAddress,
-        abi: DataPermissionsAbi,
-        functionName: "permissionFileIds",
-        args: [permissionId]
-      });
-      return fileIds;
-    } catch (error) {
-      throw new BlockchainError(
-        `Failed to get permission file IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error
-      );
-    }
-  }
-  /**
-   * Checks if a permission is active.
-   *
-   * @param permissionId - The permission ID to check
-   * @returns Promise resolving to boolean indicating if permission is active
-   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
-   */
-  async isActivePermission(permissionId) {
-    try {
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPermissionsAddress = getContractAddress(
-        chainId,
-        "DataPermissions"
-      );
-      const DataPermissionsAbi = getAbi("DataPermissions");
-      const isActive = await this.context.publicClient.readContract({
-        address: DataPermissionsAddress,
-        abi: DataPermissionsAbi,
-        functionName: "isActivePermission",
-        args: [permissionId]
-      });
-      return isActive;
-    } catch (error) {
-      throw new BlockchainError(
-        `Failed to check permission status: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error
-      );
-    }
-  }
-  /**
-   * Gets permission details from the contract.
-   *
-   * @param permissionId - The permission ID to query
-   * @returns Promise resolving to permission info
-   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
-   */
-  async getPermissionInfo(permissionId) {
-    try {
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPermissionsAddress = getContractAddress(
-        chainId,
-        "DataPermissions"
-      );
-      const DataPermissionsAbi = getAbi("DataPermissions");
-      const permissionInfo = await this.context.publicClient.readContract({
-        address: DataPermissionsAddress,
-        abi: DataPermissionsAbi,
-        functionName: "permissions",
-        args: [permissionId]
-      });
-      return permissionInfo;
-    } catch (error) {
-      throw new BlockchainError(
-        `Failed to get permission info: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error
-      );
-    }
-  }
   /**
    * Normalizes grant ID to hex format.
    * Handles conversion from permission ID (bigint/number/string) to proper hex hash format.
@@ -37041,13 +37268,14 @@ var PermissionsController = class {
         "DataPortabilityServers"
       );
       const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const userAddress = this.context.walletClient.account?.address || await this.getUserAddress();
       const txHash = await this.context.walletClient.writeContract({
         address: DataPortabilityServersAddress,
         abi: DataPortabilityServersAbi,
-        functionName: "addAndTrustServer",
+        functionName: "addAndTrustServerOnBehalf",
         args: [
+          userAddress,
           {
-            owner: params.owner,
             serverAddress: params.serverAddress,
             serverUrl: params.serverUrl,
             publicKey: params.publicKey
@@ -37074,7 +37302,7 @@ var PermissionsController = class {
    * @returns Promise resolving to transaction hash
    * @deprecated Use addAndTrustServer instead
    */
-  async trustServer(params) {
+  async submitTrustServer(params) {
     try {
       const chainId = await this.context.walletClient.getChainId();
       const DataPortabilityServersAddress = getContractAddress(
@@ -37107,12 +37335,11 @@ var PermissionsController = class {
    * @param params - Parameters for adding and trusting the server
    * @returns Promise resolving to transaction hash
    */
-  async addAndTrustServerWithSignature(params) {
+  async submitAddAndTrustServerWithSignature(params) {
     try {
-      const nonce = await this.getUserNonce();
+      const nonce = await this.getServersUserNonce();
       const addAndTrustServerInput = {
         nonce,
-        owner: params.owner,
         serverAddress: params.serverAddress,
         publicKey: params.publicKey,
         serverUrl: params.serverUrl
@@ -37122,16 +37349,13 @@ var PermissionsController = class {
       );
       console.debug("\u{1F50D} AddAndTrustServer Debug Info:", {
         nonce: nonce.toString(),
-        owner: params.owner,
         serverAddress: params.serverAddress,
         publicKey: params.publicKey,
         serverUrl: params.serverUrl,
         domain: typedData.domain,
         typedDataMessage: typedData.message
       });
-      const signature = await this.signTypedData(
-        typedData
-      );
+      const signature = await this.signTypedData(typedData);
       console.debug("\u{1F50D} Generated signature:", signature);
       if (this.context.relayerCallbacks?.submitAddAndTrustServer) {
         return await this.context.relayerCallbacks.submitAddAndTrustServer(
@@ -37172,17 +37396,15 @@ var PermissionsController = class {
    * @throws {ServerUrlMismatchError} When server URL doesn't match existing registration
    * @throws {BlockchainError} When trust operation fails for any other reason
    */
-  async trustServerWithSignature(params) {
+  async submitTrustServerWithSignature(params) {
     try {
-      const nonce = await this.getUserNonce();
+      const nonce = await this.getServersUserNonce();
       const trustServerInput = {
         nonce,
         serverId: params.serverId
       };
       const typedData = await this.composeTrustServerMessage(trustServerInput);
-      const signature = await this.signTypedData(
-        typedData
-      );
+      const signature = await this.signTypedData(typedData);
       if (this.context.relayerCallbacks?.submitTrustServer) {
         return await this.context.relayerCallbacks.submitTrustServer(
           typedData,
@@ -37268,8 +37490,8 @@ var PermissionsController = class {
    * console.log('Still trusting servers:', trustedServers);
    * ```
    */
-  async untrustServer(params) {
-    const nonce = await this.getUserNonce();
+  async submitUntrustServer(params) {
+    const nonce = await this.getServersUserNonce();
     const untrustServerInput = {
       nonce,
       serverId: params.serverId
@@ -37288,27 +37510,22 @@ var PermissionsController = class {
    * @throws {RelayerError} When gasless submission fails
    * @throws {BlockchainError} When untrust transaction fails
    */
-  async untrustServerWithSignature(params) {
+  async submitUntrustServerWithSignature(params) {
     try {
-      const nonce = await this.getUserNonce();
+      const nonce = await this.getServersUserNonce();
       const untrustServerInput = {
         nonce,
         serverId: params.serverId
       };
       const typedData = await this.composeUntrustServerMessage(untrustServerInput);
-      const signature = await this.signTypedData(
-        typedData
-      );
+      const signature = await this.signTypedData(typedData);
       if (this.context.relayerCallbacks?.submitUntrustServer) {
         return await this.context.relayerCallbacks.submitUntrustServer(
           typedData,
           signature
         );
       } else {
-        return await this.submitSignedUntrustTransaction(
-          typedData,
-          signature
-        );
+        return await this.submitSignedUntrustTransaction(typedData, signature);
       }
     } catch (error) {
       if (error instanceof Error) {
@@ -37368,131 +37585,6 @@ var PermissionsController = class {
       );
     }
   }
-  /**
-   * Retrieves detailed information about a specific server from the DataPortabilityServers contract.
-   *
-   * Returns complete server information including owner, address, public key, and URL.
-   * This information is used to establish secure connections and verify server identity.
-   *
-   * @param serverId - The unique numeric ID of the server to query
-   * @returns Promise resolving to complete server information
-   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
-   * @throws {NetworkError} When unable to connect to the blockchain network
-   * @throws {ServerNotFoundError} When the server ID does not exist
-   *
-   * @example
-   * ```typescript
-   * const server = await vana.permissions.getServerInfo(1);
-   *
-   * console.log(`Server ${server.id}:`);
-   * console.log(`  Owner: ${server.owner}`);
-   * console.log(`  Address: ${server.serverAddress}`);
-   * console.log(`  URL: ${server.url}`);
-   * console.log(`  Public Key: ${server.publicKey}`);
-   * ```
-   */
-  async getServerInfo(serverId) {
-    try {
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPortabilityServersAddress = getContractAddress(
-        chainId,
-        "DataPortabilityServers"
-      );
-      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
-      const serverInfo = await this.context.publicClient.readContract({
-        address: DataPortabilityServersAddress,
-        abi: DataPortabilityServersAbi,
-        functionName: "servers",
-        args: [BigInt(serverId)]
-      });
-      return {
-        id: Number(serverInfo.id),
-        owner: serverInfo.owner,
-        url: serverInfo.url,
-        serverAddress: serverInfo.serverAddress,
-        publicKey: serverInfo.publicKey
-      };
-    } catch (error) {
-      throw new BlockchainError(
-        `Failed to get server info: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error
-      );
-    }
-  }
-  /**
-   * Checks if a specific server is active in the DataPortabilityServers contract.
-   *
-   * An active server is one that is properly registered and operational, meaning
-   * it can receive and process data portability requests from users.
-   *
-   * @param serverId - The unique numeric ID of the server to check
-   * @returns Promise resolving to true if server is active, false otherwise
-   * @throws {BlockchainError} When reading from contract fails or chain is unavailable
-   * @throws {NetworkError} When unable to connect to the blockchain network
-   *
-   * @example
-   * ```typescript
-   * const isActive = await vana.permissions.isActiveServer(1);
-   *
-   * if (isActive) {
-   *   console.log('Server 1 is active and ready to process requests');
-   * } else {
-   *   console.log('Server 1 is inactive or not found');
-   * }
-   * ```
-   */
-  async isActiveServer(serverId) {
-    try {
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPortabilityServersAddress = getContractAddress(
-        chainId,
-        "DataPortabilityServers"
-      );
-      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
-      const isActive = await this.context.publicClient.readContract({
-        address: DataPortabilityServersAddress,
-        abi: DataPortabilityServersAbi,
-        functionName: "isActiveServer",
-        args: [BigInt(serverId)]
-      });
-      return isActive;
-    } catch (error) {
-      throw new BlockchainError(
-        `Failed to check server status: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error
-      );
-    }
-  }
-  /**
-   * Checks if a server is active for a specific user.
-   *
-   * @param serverId - Server ID (numeric)
-   * @param userAddress - Optional user address (defaults to current user)
-   * @returns Promise resolving to boolean indicating if server is active for the user
-   */
-  async isActiveServerForUser(serverId, userAddress) {
-    try {
-      const user = userAddress || await this.getUserAddress();
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPortabilityServersAddress = getContractAddress(
-        chainId,
-        "DataPortabilityServers"
-      );
-      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
-      const isActive = await this.context.publicClient.readContract({
-        address: DataPortabilityServersAddress,
-        abi: DataPortabilityServersAbi,
-        functionName: "isActiveServerForUser",
-        args: [user, BigInt(serverId)]
-      });
-      return isActive;
-    } catch (error) {
-      throw new BlockchainError(
-        `Failed to check server status for user: ${error instanceof Error ? error.message : "Unknown error"}`,
-        error
-      );
-    }
-  }
   /**
    * Gets the total count of trusted servers for a user.
    *
@@ -37595,27 +37687,29 @@ var PermissionsController = class {
     try {
       const paginatedResult = await this.getTrustedServersPaginated(options);
       const serverInfoPromises = paginatedResult.servers.map(
-        async (serverId, index) => {
+        async (serverId, _index) => {
           try {
-            const serverInfo = await this.getServerInfo(serverId);
+            const serverInfo = await this.getServerInfo(BigInt(serverId));
             return {
-              serverId,
+              id: BigInt(serverId),
               owner: serverInfo.owner,
-              url: serverInfo.url,
               serverAddress: serverInfo.serverAddress,
               publicKey: serverInfo.publicKey,
-              isTrusted: true,
-              trustIndex: options.offset ? options.offset + index : index
+              url: serverInfo.url,
+              startBlock: 0n,
+              // We don't have this info from the old method structure
+              endBlock: 0n
+              // 0 means still active
             };
           } catch {
             return {
-              serverId,
+              id: BigInt(serverId),
               owner: "0x0000000000000000000000000000000000000000",
-              url: "",
               serverAddress: "0x0000000000000000000000000000000000000000",
               publicKey: "",
-              isTrusted: true,
-              trustIndex: options.offset ? options.offset + index : index
+              url: "",
+              startBlock: 0n,
+              endBlock: 0n
             };
           }
         }
@@ -37721,18 +37815,18 @@ var PermissionsController = class {
    */
   async composeAddAndTrustServerMessage(input) {
     const domain = await this.getServersDomain();
+    console.debug(domain);
     return {
       domain,
       types: {
-        AddAndTrustServer: [
+        AddServer: [
           { name: "nonce", type: "uint256" },
-          { name: "owner", type: "address" },
           { name: "serverAddress", type: "address" },
-          { name: "publicKey", type: "bytes" },
+          { name: "publicKey", type: "string" },
           { name: "serverUrl", type: "string" }
         ]
       },
-      primaryType: "AddAndTrustServer",
+      primaryType: "AddServer",
       message: input
     };
   }
@@ -37813,13 +37907,13 @@ var PermissionsController = class {
       contractAddress: DataPortabilityServersAddress,
       input: {
         nonce: addAndTrustServerInput.nonce.toString(),
-        owner: addAndTrustServerInput.owner,
         serverAddress: addAndTrustServerInput.serverAddress,
         publicKey: addAndTrustServerInput.publicKey,
         serverUrl: addAndTrustServerInput.serverUrl
       },
       signature
     });
+    const formattedSignature = formatSignatureForContract(signature);
     const txHash = await this.context.walletClient.writeContract({
       address: DataPortabilityServersAddress,
       abi: DataPortabilityServersAbi,
@@ -37827,12 +37921,11 @@ var PermissionsController = class {
       args: [
         {
           nonce: addAndTrustServerInput.nonce,
-          owner: addAndTrustServerInput.owner,
           serverAddress: addAndTrustServerInput.serverAddress,
           publicKey: addAndTrustServerInput.publicKey,
           serverUrl: addAndTrustServerInput.serverUrl
         },
-        signature
+        formattedSignature
       ],
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
@@ -37853,6 +37946,7 @@ var PermissionsController = class {
       "DataPortabilityServers"
     );
     const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+    const formattedSignature = formatSignatureForContract(signature);
     const txHash = await this.context.walletClient.writeContract({
       address: DataPortabilityServersAddress,
       abi: DataPortabilityServersAbi,
@@ -37862,7 +37956,7 @@ var PermissionsController = class {
           nonce: trustServerInput.nonce,
           serverId: BigInt(trustServerInput.serverId)
         },
-        signature
+        formattedSignature
       ],
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
@@ -37878,17 +37972,18 @@ var PermissionsController = class {
    */
   async submitDirectRevokeTransaction(typedData, signature) {
     const chainId = await this.context.walletClient.getChainId();
-    const DataPermissionsAddress = getContractAddress(
+    const DataPortabilityPermissionsAddress = getContractAddress(
       chainId,
-      "DataPermissions"
+      "DataPortabilityPermissions"
     );
-    const DataPermissionsAbi = getAbi("DataPermissions");
+    const DataPortabilityPermissionsAbi = getAbi("DataPortabilityPermissions");
+    const formattedSignature = formatSignatureForContract(signature);
     const txHash = await this.context.walletClient.writeContract({
-      address: DataPermissionsAddress,
-      abi: DataPermissionsAbi,
+      address: DataPortabilityPermissionsAddress,
+      abi: DataPortabilityPermissionsAbi,
       functionName: "revokePermissionWithSignature",
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      args: [typedData.message, signature],
+      args: [typedData.message, formattedSignature],
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
     });
@@ -37908,12 +38003,13 @@ var PermissionsController = class {
       "DataPortabilityServers"
     );
     const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+    const formattedSignature = formatSignatureForContract(signature);
     const txHash = await this.context.walletClient.writeContract({
       address: DataPortabilityServersAddress,
       abi: DataPortabilityServersAbi,
       functionName: "untrustServerWithSignature",
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      args: [typedData.message, signature],
+      args: [typedData.message, formattedSignature],
       account: this.context.walletClient.account || await this.getUserAddress(),
       chain: this.context.walletClient.chain || null
     });
@@ -37947,7 +38043,7 @@ var PermissionsController = class {
    * console.log(`Grantee registered in transaction: ${txHash}`);
    * ```
    */
-  async registerGrantee(params) {
+  async submitRegisterGrantee(params) {
     const chainId = await this.context.walletClient.getChainId();
     const DataPortabilityGranteesAddress = getContractAddress(
       chainId,
@@ -37979,8 +38075,8 @@ var PermissionsController = class {
    * });
    * ```
    */
-  async registerGranteeWithSignature(params) {
-    const nonce = await this.getUserNonce();
+  async submitRegisterGranteeWithSignature(params) {
+    const nonce = await this.getServersUserNonce();
     const registerGranteeInput = {
       nonce,
       owner: params.owner,
@@ -38253,10 +38349,1192 @@ var PermissionsController = class {
     });
     return txHash;
   }
+  // ===========================
+  // DATA PORTABILITY SERVERS HELPER METHODS
+  // ===========================
+  /**
+   * Get all trusted server IDs for a user
+   *
+   * @param userAddress - User address to query (defaults to current user)
+   * @returns Promise resolving to array of server IDs
+   */
+  async getUserServerIds(userAddress) {
+    try {
+      const targetAddress = userAddress || await this.getUserAddress();
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverIds = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerIdsValues",
+        args: [targetAddress]
+      });
+      return [...serverIds];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user server IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get server ID at specific index for a user
+   *
+   * @param userAddress - User address to query
+   * @param serverIndex - Index in the user's server list
+   * @returns Promise resolving to server ID
+   */
+  async getUserServerIdAt(userAddress, serverIndex) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverId = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerIdsAt",
+        args: [userAddress, serverIndex]
+      });
+      return serverId;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user server ID at index: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get the number of trusted servers for a user
+   *
+   * @param userAddress - User address to query (defaults to current user)
+   * @returns Promise resolving to number of trusted servers
+   */
+  async getUserServerCount(userAddress) {
+    try {
+      const targetAddress = userAddress || await this.getUserAddress();
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const count = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerIdsLength",
+        args: [targetAddress]
+      });
+      return count;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user server count: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get detailed information about trusted servers for a user
+   *
+   * @param userAddress - User address to query (defaults to current user)
+   * @returns Promise resolving to array of trusted server info
+   */
+  async getUserTrustedServers(userAddress) {
+    try {
+      const targetAddress = userAddress || await this.getUserAddress();
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const servers = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerValues",
+        args: [targetAddress]
+      });
+      return [...servers];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user trusted servers: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get trusted server info for a specific server ID and user
+   *
+   * @param userAddress - User address to query
+   * @param serverId - Server ID to get info for
+   * @returns Promise resolving to trusted server info
+   */
+  async getUserTrustedServer(userAddress, serverId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServers",
+        args: [userAddress, serverId]
+      });
+      return serverInfo;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user trusted server: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get server information by server ID
+   *
+   * @param serverId - Server ID to get info for
+   * @returns Promise resolving to server info
+   */
+  async getServerInfo(serverId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "servers",
+        args: [serverId]
+      });
+      return serverInfo;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get server info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get server information by server address
+   *
+   * @param serverAddress - Server address to get info for
+   * @returns Promise resolving to server info
+   */
+  async getServerInfoByAddress(serverAddress) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "serverByAddress",
+        args: [serverAddress]
+      });
+      return serverInfo;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get server info by address: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  // ===========================
+  // DATA PORTABILITY PERMISSIONS HELPER METHODS
+  // ===========================
+  /**
+   * Get all permission IDs for a user
+   *
+   * @param userAddress - User address to query (defaults to current user)
+   * @returns Promise resolving to array of permission IDs
+   */
+  async getUserPermissionIds(userAddress) {
+    try {
+      const targetAddress = userAddress || await this.getUserAddress();
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const permissionIds = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "userPermissionIdsValues",
+        args: [targetAddress]
+      });
+      return [...permissionIds];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user permission IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get permission ID at specific index for a user
+   *
+   * @param userAddress - User address to query
+   * @param permissionIndex - Index in the user's permission list
+   * @returns Promise resolving to permission ID
+   */
+  async getUserPermissionIdAt(userAddress, permissionIndex) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const permissionId = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "userPermissionIdsAt",
+        args: [userAddress, permissionIndex]
+      });
+      return permissionId;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user permission ID at index: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get the number of permissions for a user
+   *
+   * @param userAddress - User address to query (defaults to current user)
+   * @returns Promise resolving to number of permissions
+   */
+  async getUserPermissionCount(userAddress) {
+    try {
+      const targetAddress = userAddress || await this.getUserAddress();
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const count = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "userPermissionIdsLength",
+        args: [targetAddress]
+      });
+      return count;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user permission count: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get detailed permission information by permission ID
+   *
+   * @param permissionId - Permission ID to get info for
+   * @returns Promise resolving to permission info
+   */
+  async getPermissionInfo(permissionId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const permissionInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "permissions",
+        args: [permissionId]
+      });
+      return permissionInfo;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get permission info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get all permission IDs for a specific file
+   *
+   * @param fileId - File ID to get permissions for
+   * @returns Promise resolving to array of permission IDs
+   */
+  async getFilePermissionIds(fileId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const permissionIds = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "filePermissionIds",
+        args: [fileId]
+      });
+      return [...permissionIds];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get file permission IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get all file IDs for a specific permission
+   *
+   * @param permissionId - Permission ID to get files for
+   * @returns Promise resolving to array of file IDs
+   */
+  async getPermissionFileIds(permissionId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const fileIds = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "permissionFileIds",
+        args: [permissionId]
+      });
+      return [...fileIds];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get permission file IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get all permissions for a specific file (alias for getFilePermissionIds)
+   *
+   * @param fileId - File ID to get permissions for
+   * @returns Promise resolving to array of permission IDs
+   */
+  async getFilePermissions(fileId) {
+    const chainId = await this.context.publicClient.getChainId();
+    const DataPortabilityPermissionsAddress = getContractAddress(
+      chainId,
+      "DataPortabilityPermissions"
+    );
+    const DataPortabilityPermissionsAbi = getAbi("DataPortabilityPermissions");
+    const permissions = await this.context.publicClient.readContract({
+      address: DataPortabilityPermissionsAddress,
+      abi: DataPortabilityPermissionsAbi,
+      functionName: "filePermissions",
+      args: [fileId]
+    });
+    return [...permissions];
+  }
+  // ===========================
+  // DATA PORTABILITY GRANTEES HELPER METHODS
+  // ===========================
+  /**
+   * Get grantee information by grantee ID
+   *
+   * @param granteeId - Grantee ID to get info for
+   * @returns Promise resolving to grantee info
+   */
+  async getGranteeInfo(granteeId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityGranteesAddress = getContractAddress(
+        chainId,
+        "DataPortabilityGrantees"
+      );
+      const DataPortabilityGranteesAbi = getAbi("DataPortabilityGrantees");
+      const granteeInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityGranteesAddress,
+        abi: DataPortabilityGranteesAbi,
+        functionName: "granteeInfo",
+        args: [granteeId]
+      });
+      return granteeInfo;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get grantee info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get grantee information by grantee address
+   *
+   * @param granteeAddress - Grantee address to get info for
+   * @returns Promise resolving to grantee info
+   */
+  async getGranteeInfoByAddress(granteeAddress) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityGranteesAddress = getContractAddress(
+        chainId,
+        "DataPortabilityGrantees"
+      );
+      const DataPortabilityGranteesAbi = getAbi("DataPortabilityGrantees");
+      const granteeInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityGranteesAddress,
+        abi: DataPortabilityGranteesAbi,
+        functionName: "granteeByAddress",
+        args: [granteeAddress]
+      });
+      return granteeInfo;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get grantee info by address: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get all permission IDs for a specific grantee
+   *
+   * @param granteeId - Grantee ID to get permissions for
+   * @returns Promise resolving to array of permission IDs
+   */
+  async getGranteePermissionIds(granteeId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityGranteesAddress = getContractAddress(
+        chainId,
+        "DataPortabilityGrantees"
+      );
+      const DataPortabilityGranteesAbi = getAbi("DataPortabilityGrantees");
+      const permissionIds = await this.context.publicClient.readContract({
+        address: DataPortabilityGranteesAddress,
+        abi: DataPortabilityGranteesAbi,
+        functionName: "granteePermissionIds",
+        args: [granteeId]
+      });
+      return [...permissionIds];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get grantee permission IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get all permissions for a specific grantee (alias for getGranteePermissionIds)
+   *
+   * @param granteeId - Grantee ID to get permissions for
+   * @returns Promise resolving to array of permission IDs
+   */
+  async getGranteePermissions(granteeId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityGranteesAddress = getContractAddress(
+        chainId,
+        "DataPortabilityGrantees"
+      );
+      const DataPortabilityGranteesAbi = getAbi("DataPortabilityGrantees");
+      const permissions = await this.context.publicClient.readContract({
+        address: DataPortabilityGranteesAddress,
+        abi: DataPortabilityGranteesAbi,
+        functionName: "granteePermissions",
+        args: [granteeId]
+      });
+      return [...permissions];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get grantee permissions: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  // ===== DataPortabilityServersImplementation Methods =====
+  /**
+   * Get all server IDs for a user
+   *
+   * @param userAddress - User address to get server IDs for
+   * @returns Promise resolving to array of server IDs
+   */
+  async getUserServerIdsValues(userAddress) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverIds = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerIdsValues",
+        args: [userAddress]
+      });
+      return [...serverIds];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user server IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get server ID at specific index for a user
+   *
+   * @param userAddress - User address
+   * @param serverIndex - Index of the server ID
+   * @returns Promise resolving to server ID
+   */
+  async getUserServerIdsAt(userAddress, serverIndex) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverId = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerIdsAt",
+        args: [userAddress, serverIndex]
+      });
+      return serverId;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user server ID at index: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get the number of servers a user has
+   *
+   * @param userAddress - User address
+   * @returns Promise resolving to number of servers
+   */
+  async getUserServerIdsLength(userAddress) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const length = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServerIdsLength",
+        args: [userAddress]
+      });
+      return length;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user server IDs length: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get trusted server info for a specific user and server ID
+   *
+   * @param userAddress - User address
+   * @param serverId - Server ID
+   * @returns Promise resolving to trusted server info
+   */
+  async getUserServers(userAddress, serverId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "userServers",
+        args: [userAddress, serverId]
+      });
+      return {
+        id: serverInfo.id,
+        owner: serverInfo.owner,
+        serverAddress: serverInfo.serverAddress,
+        publicKey: serverInfo.publicKey,
+        url: serverInfo.url,
+        startBlock: serverInfo.startBlock,
+        endBlock: serverInfo.endBlock
+      };
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user server info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get server info by server ID
+   *
+   * @param serverId - Server ID
+   * @returns Promise resolving to server info
+   */
+  async getServers(serverId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const serverInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "servers",
+        args: [serverId]
+      });
+      return {
+        id: serverInfo.id,
+        owner: serverInfo.owner,
+        serverAddress: serverInfo.serverAddress,
+        publicKey: serverInfo.publicKey,
+        url: serverInfo.url
+      };
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get server info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get user info including nonce and trusted server IDs
+   *
+   * @param userAddress - User address
+   * @returns Promise resolving to user info
+   */
+  async getUsers(userAddress) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const userInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "users",
+        args: [userAddress]
+      });
+      return {
+        nonce: userInfo[0],
+        trustedServerIds: [...userInfo[1]]
+      };
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Update server URL
+   *
+   * @param serverId - Server ID to update
+   * @param url - New URL for the server
+   * @returns Promise resolving to transaction hash
+   */
+  async submitUpdateServer(serverId, url) {
+    try {
+      const chainId = await this.context.walletClient.getChainId();
+      const DataPortabilityServersAddress = getContractAddress(
+        chainId,
+        "DataPortabilityServers"
+      );
+      const DataPortabilityServersAbi = getAbi("DataPortabilityServers");
+      const hash = await this.context.walletClient.writeContract({
+        address: DataPortabilityServersAddress,
+        abi: DataPortabilityServersAbi,
+        functionName: "updateServer",
+        args: [serverId, url],
+        chain: this.context.walletClient.chain,
+        account: this.context.walletClient.account || null
+      });
+      return hash;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to update server: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  // ===== DataPortabilityPermissionsImplementation Methods =====
+  /**
+   * Get all permission IDs for a user
+   *
+   * @param userAddress - User address to get permission IDs for
+   * @returns Promise resolving to array of permission IDs
+   */
+  async getUserPermissionIdsValues(userAddress) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const permissionIds = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "userPermissionIdsValues",
+        args: [userAddress]
+      });
+      return [...permissionIds];
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user permission IDs: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get permission ID at specific index for a user
+   *
+   * @param userAddress - User address
+   * @param permissionIndex - Index of the permission ID
+   * @returns Promise resolving to permission ID
+   */
+  async getUserPermissionIdsAt(userAddress, permissionIndex) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const permissionId = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "userPermissionIdsAt",
+        args: [userAddress, permissionIndex]
+      });
+      return permissionId;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user permission ID at index: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get the number of permissions a user has
+   *
+   * @param userAddress - User address
+   * @returns Promise resolving to number of permissions
+   */
+  async getUserPermissionIdsLength(userAddress) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const length = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "userPermissionIdsLength",
+        args: [userAddress]
+      });
+      return length;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get user permission IDs length: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Get permission info by permission ID
+   *
+   * @param permissionId - Permission ID
+   * @returns Promise resolving to permission info
+   */
+  async getPermissions(permissionId) {
+    try {
+      const chainId = await this.context.publicClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const permissionInfo = await this.context.publicClient.readContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "permissions",
+        args: [permissionId]
+      });
+      return {
+        id: permissionInfo.id,
+        grantor: permissionInfo.grantor,
+        nonce: permissionInfo.nonce,
+        granteeId: permissionInfo.granteeId,
+        grant: permissionInfo.grant,
+        startBlock: permissionInfo.startBlock,
+        endBlock: permissionInfo.endBlock,
+        fileIds: [...permissionInfo.fileIds]
+      };
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to get permission info: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Submit permission with signature to the blockchain (supports gasless transactions)
+   *
+   * @param params - Parameters for adding permission
+   * @returns Promise resolving to transaction hash
+   * @throws {RelayerError} When gasless transaction submission fails
+   * @throws {SignatureError} When user rejects the signature request
+   * @throws {BlockchainError} When permission addition fails
+   * @throws {NetworkError} When network communication fails
+   */
+  async submitAddPermission(params) {
+    try {
+      const nonce = await this.getPermissionsUserNonce();
+      const addPermissionInput = {
+        nonce,
+        granteeId: params.granteeId,
+        grant: params.grant,
+        fileUrls: params.fileUrls,
+        serverAddress: params.serverAddress,
+        serverUrl: params.serverUrl,
+        serverPublicKey: params.serverPublicKey,
+        filePermissions: params.filePermissions
+      };
+      const typedData = await this.composeServerFilesAndPermissionMessage(addPermissionInput);
+      const signature = await this.signTypedData(typedData);
+      return await this.submitSignedAddPermission(typedData, signature);
+    } catch (error) {
+      if (error instanceof RelayerError || error instanceof UserRejectedRequestError || error instanceof SerializationError || error instanceof SignatureError || error instanceof NetworkError || error instanceof NonceError) {
+        throw error;
+      }
+      throw new BlockchainError(
+        `Failed to add permission: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Submits an already-signed add permission transaction to the blockchain.
+   * This method supports both relayer-based gasless transactions and direct transactions.
+   *
+   * @param typedData - The EIP-712 typed data for AddPermission
+   * @param signature - The user's signature
+   * @returns Promise resolving to the transaction hash
+   * @throws {RelayerError} When gasless transaction submission fails
+   * @throws {BlockchainError} When permission addition fails
+   * @throws {NetworkError} When network communication fails
+   */
+  async submitSignedAddPermission(typedData, signature) {
+    try {
+      if (this.context.relayerCallbacks?.submitAddPermission) {
+        return await this.context.relayerCallbacks.submitAddPermission(
+          typedData,
+          signature
+        );
+      } else {
+        return await this.submitDirectAddPermissionTransaction(
+          typedData,
+          signature
+        );
+      }
+    } catch (error) {
+      if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
+        throw error;
+      }
+      throw new BlockchainError(
+        `Add permission submission failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Submit server files and permissions with signature to the blockchain (supports gasless transactions)
+   *
+   * @param params - Parameters for adding server files and permissions
+   * @returns Promise resolving to transaction hash
+   * @throws {RelayerError} When gasless transaction submission fails
+   * @throws {SignatureError} When user rejects the signature request
+   * @throws {BlockchainError} When server files and permissions addition fails
+   * @throws {NetworkError} When network communication fails
+   */
+  async submitAddServerFilesAndPermissions(params) {
+    try {
+      const nonce = await this.getPermissionsUserNonce();
+      const serverFilesAndPermissionInput = {
+        nonce,
+        granteeId: params.granteeId,
+        grant: params.grant,
+        fileUrls: params.fileUrls,
+        serverAddress: params.serverAddress,
+        serverUrl: params.serverUrl,
+        serverPublicKey: params.serverPublicKey,
+        filePermissions: params.filePermissions
+      };
+      const typedData = await this.composeServerFilesAndPermissionMessage(
+        serverFilesAndPermissionInput
+      );
+      const signature = await this.signTypedData(typedData);
+      return await this.submitSignedAddServerFilesAndPermissions(
+        typedData,
+        signature
+      );
+    } catch (error) {
+      if (error instanceof RelayerError || error instanceof UserRejectedRequestError || error instanceof SerializationError || error instanceof SignatureError || error instanceof NetworkError || error instanceof NonceError) {
+        throw error;
+      }
+      throw new BlockchainError(
+        `Failed to add server files and permissions: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Submits an already-signed add server files and permissions transaction to the blockchain.
+   * This method supports both relayer-based gasless transactions and direct transactions.
+   *
+   * @param typedData - The EIP-712 typed data for AddServerFilesAndPermissions
+   * @param signature - The user's signature
+   * @returns Promise resolving to the transaction hash
+   * @throws {RelayerError} When gasless transaction submission fails
+   * @throws {BlockchainError} When server files and permissions addition fails
+   * @throws {NetworkError} When network communication fails
+   */
+  async submitSignedAddServerFilesAndPermissions(typedData, signature) {
+    try {
+      console.debug("\u{1F50D} submitSignedAddServerFilesAndPermissions Debug Info:", {
+        hasRelayerCallbacks: !!this.context.relayerCallbacks,
+        hasSubmitMethod: !!this.context.relayerCallbacks?.submitAddServerFilesAndPermissions,
+        availableRelayerMethods: this.context.relayerCallbacks ? Object.keys(this.context.relayerCallbacks) : []
+      });
+      if (this.context.relayerCallbacks?.submitAddServerFilesAndPermissions) {
+        console.debug(
+          "\u{1F680} Using relayer for submitAddServerFilesAndPermissions"
+        );
+        return await this.context.relayerCallbacks.submitAddServerFilesAndPermissions(
+          typedData,
+          signature
+        );
+      } else {
+        console.debug(
+          "\u{1F4DD} Using direct transaction for submitAddServerFilesAndPermissions"
+        );
+        return await this.submitDirectAddServerFilesAndPermissionsTransaction(
+          typedData,
+          signature
+        );
+      }
+    } catch (error) {
+      if (error instanceof RelayerError || error instanceof NetworkError || error instanceof UserRejectedRequestError || error instanceof SignatureError || error instanceof NonceError) {
+        throw error;
+      }
+      throw new BlockchainError(
+        `Add server files and permissions submission failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Submit permission revocation with signature to the blockchain
+   *
+   * @param permissionId - Permission ID to revoke
+   * @returns Promise resolving to transaction hash
+   */
+  async submitRevokePermission(permissionId) {
+    try {
+      const chainId = await this.context.walletClient.getChainId();
+      const DataPortabilityPermissionsAddress = getContractAddress(
+        chainId,
+        "DataPortabilityPermissions"
+      );
+      const DataPortabilityPermissionsAbi = getAbi(
+        "DataPortabilityPermissions"
+      );
+      const hash = await this.context.walletClient.writeContract({
+        address: DataPortabilityPermissionsAddress,
+        abi: DataPortabilityPermissionsAbi,
+        functionName: "revokePermission",
+        args: [permissionId],
+        chain: this.context.walletClient.chain,
+        account: this.context.walletClient.account || null
+      });
+      return hash;
+    } catch (error) {
+      throw new BlockchainError(
+        `Failed to revoke permission: ${error instanceof Error ? error.message : "Unknown error"}`,
+        error
+      );
+    }
+  }
+  /**
+   * Submits a signed add permission transaction directly to the blockchain.
+   *
+   * @param typedData - The typed data structure for the permission addition
+   * @param signature - The cryptographic signature authorizing the transaction
+   * @returns Promise resolving to the transaction hash
+   */
+  async submitDirectAddPermissionTransaction(typedData, signature) {
+    const chainId = await this.context.walletClient.getChainId();
+    const DataPortabilityPermissionsAddress = getContractAddress(
+      chainId,
+      "DataPortabilityPermissions"
+    );
+    const DataPortabilityPermissionsAbi = getAbi("DataPortabilityPermissions");
+    const permissionInput = {
+      nonce: typedData.message.nonce,
+      granteeId: typedData.message.granteeId,
+      grant: typedData.message.grant,
+      fileIds: typedData.message.fileIds || []
+    };
+    const formattedSignature = formatSignatureForContract(signature);
+    const hash = await this.context.walletClient.writeContract({
+      address: DataPortabilityPermissionsAddress,
+      abi: DataPortabilityPermissionsAbi,
+      functionName: "addPermission",
+      args: [permissionInput, formattedSignature],
+      account: this.context.walletClient.account || await this.getUserAddress(),
+      chain: this.context.walletClient.chain || null
+    });
+    return hash;
+  }
+  /**
+   * Submits a signed add server files and permissions transaction directly to the blockchain.
+   *
+   * @param typedData - The typed data structure for the server files and permissions addition
+   * @param signature - The cryptographic signature authorizing the transaction
+   * @returns Promise resolving to the transaction hash
+   */
+  async submitDirectAddServerFilesAndPermissionsTransaction(typedData, signature) {
+    const chainId = await this.context.walletClient.getChainId();
+    const DataPortabilityPermissionsAddress = getContractAddress(
+      chainId,
+      "DataPortabilityPermissions"
+    );
+    const DataPortabilityPermissionsAbi = getAbi("DataPortabilityPermissions");
+    const serverFilesAndPermissionInput = {
+      nonce: typedData.message.nonce,
+      granteeId: typedData.message.granteeId,
+      grant: typedData.message.grant,
+      fileUrls: typedData.message.fileUrls,
+      serverAddress: typedData.message.serverAddress,
+      serverUrl: typedData.message.serverUrl,
+      serverPublicKey: typedData.message.serverPublicKey,
+      filePermissions: typedData.message.filePermissions
+    };
+    const formattedSignature = formatSignatureForContract(signature);
+    const hash = await this.context.walletClient.writeContract({
+      address: DataPortabilityPermissionsAddress,
+      abi: DataPortabilityPermissionsAbi,
+      functionName: "addServerFilesAndPermissions",
+      // @ts-expect-error - Complex nested array types cause compatibility issues with viem's generated types
+      args: [serverFilesAndPermissionInput, formattedSignature],
+      account: this.context.walletClient.account || await this.getUserAddress(),
+      chain: this.context.walletClient.chain || null
+    });
+    return hash;
+  }
 };
 
 // src/controllers/data.ts
-import { getContract, decodeEventLog } from "viem";
+import { getContract as getContract2, decodeEventLog } from "viem";
+
+// src/utils/blockchain/registry.ts
+import { getContract } from "viem";
+async function fetchSchemaFromChain(context, schemaId) {
+  const chainId = context.walletClient.chain?.id;
+  if (!chainId) {
+    throw new Error("Chain ID not available");
+  }
+  const dataRefinerRegistryAddress = getContractAddress(
+    chainId,
+    "DataRefinerRegistry"
+  );
+  const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+  const dataRefinerRegistry = getContract({
+    address: dataRefinerRegistryAddress,
+    abi: dataRefinerRegistryAbi,
+    client: context.publicClient
+  });
+  const schemaData = await dataRefinerRegistry.read.schemas([BigInt(schemaId)]);
+  if (!schemaData) {
+    throw new Error(`Schema with ID ${schemaId} not found`);
+  }
+  const schemaObj = schemaData;
+  if (!schemaObj.name || !schemaObj.typ || !schemaObj.definitionUrl) {
+    throw new Error("Incomplete schema data");
+  }
+  return {
+    id: schemaId,
+    name: schemaObj.name,
+    type: schemaObj.typ,
+    definitionUrl: schemaObj.definitionUrl
+  };
+}
+async function fetchSchemaCountFromChain(context) {
+  const chainId = context.walletClient.chain?.id;
+  if (!chainId) {
+    throw new Error("Chain ID not available");
+  }
+  const dataRefinerRegistryAddress = getContractAddress(
+    chainId,
+    "DataRefinerRegistry"
+  );
+  const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+  const dataRefinerRegistry = getContract({
+    address: dataRefinerRegistryAddress,
+    abi: dataRefinerRegistryAbi,
+    client: context.publicClient
+  });
+  const count = await dataRefinerRegistry.read.schemasCount();
+  return Number(count);
+}
 
 // src/utils/encryption.ts
 var DEFAULT_ENCRYPTION_SEED = "Please sign to retrieve your encryption key";
@@ -38338,7 +39616,11 @@ async function encryptBlobWithSignedKey(data, key, platformAdapter) {
       dataArray,
       key
     );
-    return new Blob([encrypted], {
+    const encryptedArrayBuffer = encrypted.buffer.slice(
+      encrypted.byteOffset,
+      encrypted.byteOffset + encrypted.byteLength
+    );
+    return new Blob([encryptedArrayBuffer], {
       type: "application/octet-stream"
     });
   } catch (error) {
@@ -38367,7 +39649,11 @@ async function decryptBlobWithSignedKey(encryptedData, key, platformAdapter) {
       encryptedArray,
       key
     );
-    return new Blob([decrypted], { type: "text/plain" });
+    const decryptedArrayBuffer = decrypted.buffer.slice(
+      decrypted.byteOffset,
+      decrypted.byteOffset + decrypted.byteLength
+    );
+    return new Blob([decryptedArrayBuffer], { type: "text/plain" });
   } catch (error) {
     throw new Error(`Failed to decrypt data: ${error}`);
   }
@@ -38384,28 +39670,16 @@ var DataController = class {
       filename,
       schemaId,
       permissions = [],
-      encrypt: encrypt2 = true,
+      encrypt = true,
       providerName,
       owner
     } = params;
     try {
-      let blob;
-      if (content instanceof Blob) {
-        blob = content;
-      } else if (typeof content === "string") {
-        blob = new Blob([content], { type: "text/plain" });
-      } else if (content instanceof Buffer) {
-        blob = new Blob([content], { type: "application/octet-stream" });
-      } else {
-        blob = new Blob([JSON.stringify(content)], {
-          type: "application/json"
-        });
-      }
       let isValid = true;
       let validationErrors = [];
       if (schemaId !== void 0) {
         try {
-          const schema = await this.getSchema(schemaId);
+          const schema = await fetchSchemaFromChain(this.context, schemaId);
           const response = await fetch(schema.definitionUrl);
           if (!response.ok) {
             throw new Error(
@@ -38437,37 +39711,15 @@ var DataController = class {
           ];
         }
       }
-      let finalBlob = blob;
-      if (encrypt2) {
-        const encryptionKey = await generateEncryptionKey(
-          this.context.walletClient,
-          this.context.platform,
-          DEFAULT_ENCRYPTION_SEED
-        );
-        finalBlob = await encryptBlobWithSignedKey(
-          blob,
-          encryptionKey,
-          this.context.platform
-        );
-      }
-      if (!this.context.storageManager) {
-        if (this.context.validateStorageRequired) {
-          this.context.validateStorageRequired();
-          throw new Error("Storage validation failed");
-        } else {
-          throw new Error(
-            "Storage manager not configured. Please provide storage providers in VanaConfig."
-          );
-        }
-      }
-      const uploadResult = await this.context.storageManager.upload(
-        finalBlob,
+      const uploadResult = await this.uploadToStorage(
+        content,
         filename,
+        encrypt,
         providerName
       );
       const userAddress = owner || await this.getUserAddress();
       let encryptedPermissions = [];
-      if (permissions.length > 0) {
+      if (permissions.length > 0 && encrypt) {
         const userEncryptionKey = await generateEncryptionKey(
           this.context.walletClient,
           this.context.platform,
@@ -39185,7 +40437,7 @@ var DataController = class {
       }
       const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
       const dataRegistryAbi = getAbi("DataRegistry");
-      const dataRegistry = getContract({
+      const dataRegistry = getContract2({
         address: dataRegistryAddress,
         abi: dataRegistryAbi,
         client: this.context.walletClient
@@ -39236,7 +40488,7 @@ var DataController = class {
       }
       const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
       const dataRegistryAbi = getAbi("DataRegistry");
-      const dataRegistry = getContract({
+      const dataRegistry = getContract2({
         address: dataRegistryAddress,
         abi: dataRegistryAbi,
         client: this.context.walletClient
@@ -39274,205 +40526,6 @@ var DataController = class {
       );
     }
   }
-  /**
-   * Uploads an encrypted file to storage and registers it on the blockchain.
-   *
-   * @deprecated Since v2.0.0 - Use vana.data.upload() instead for the high-level API with automatic encryption
-   *
-   * Migration guide:
-   * ```typescript
-   * // Old way (deprecated):
-   * const encrypted = await encryptBlob(data, key);
-   * const result = await vana.data.uploadEncryptedFile(encrypted, filename);
-   *
-   * // New way:
-   * const result = await vana.data.upload({
-   *   content: data,
-   *   filename: filename,
-   *   encrypt: true  // Handles encryption automatically
-   * });
-   * ```
-   * @param encryptedFile - The encrypted file blob to upload
-   * @param filename - Optional filename for the upload
-   * @param providerName - Optional storage provider to use
-   * @returns Promise resolving to upload result with file ID and storage URL
-   *
-   * This method handles the complete flow of:
-   * 1. Uploading the encrypted file to the specified storage provider
-   * 2. Registering the file URL on the DataRegistry contract via relayer
-   * 3. Returning the assigned file ID and storage URL
-   */
-  async uploadEncryptedFile(encryptedFile, filename, providerName) {
-    try {
-      if (!this.context.storageManager) {
-        throw new Error(
-          "Storage manager not configured. Please provide storage providers in VanaConfig."
-        );
-      }
-      const uploadResult = await this.context.storageManager.upload(
-        encryptedFile,
-        filename,
-        providerName
-      );
-      const userAddress = await this.getUserAddress();
-      if (this.context.relayerCallbacks?.submitFileAddition) {
-        const result = await this.context.relayerCallbacks.submitFileAddition(
-          uploadResult.url,
-          userAddress
-        );
-        return {
-          fileId: result.fileId,
-          url: uploadResult.url,
-          size: uploadResult.size,
-          transactionHash: result.transactionHash
-        };
-      } else {
-        const chainId = this.context.walletClient.chain?.id;
-        if (!chainId) {
-          throw new Error("Chain ID not available");
-        }
-        const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
-        const dataRegistryAbi = getAbi("DataRegistry");
-        const txHash = await this.context.walletClient.writeContract({
-          address: dataRegistryAddress,
-          abi: dataRegistryAbi,
-          functionName: "addFile",
-          args: [uploadResult.url],
-          account: this.context.walletClient.account || userAddress,
-          chain: this.context.walletClient.chain || null
-        });
-        const receipt = await this.context.publicClient.waitForTransactionReceipt({
-          hash: txHash,
-          timeout: 3e4
-          // 30 seconds timeout
-        });
-        let fileId = 0;
-        for (const log of receipt.logs) {
-          try {
-            const decoded = decodeEventLog({
-              abi: dataRegistryAbi,
-              data: log.data,
-              topics: log.topics
-            });
-            if (decoded.eventName === "FileAdded") {
-              fileId = Number(decoded.args.fileId);
-              break;
-            }
-          } catch {
-            continue;
-          }
-        }
-        return {
-          fileId,
-          url: uploadResult.url,
-          size: uploadResult.size,
-          transactionHash: txHash
-        };
-      }
-    } catch (error) {
-      console.error("Failed to upload encrypted file:", error);
-      throw new Error(
-        `Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Uploads an encrypted file to storage and registers it on the blockchain with a schema.
-   *
-   * @deprecated Since v2.0.0 - Use vana.data.upload() instead for the high-level API with automatic encryption and schema validation
-   *
-   * Migration guide:
-   * ```typescript
-   * // Old way (deprecated):
-   * const encrypted = await encryptBlob(data, key);
-   * const result = await vana.data.uploadEncryptedFileWithSchema(encrypted, schemaId, filename);
-   *
-   * // New way:
-   * const result = await vana.data.upload({
-   *   content: data,
-   *   filename: filename,
-   *   schemaId: schemaId,  // Automatic validation
-   *   encrypt: true
-   * });
-   * ```
-   * @param encryptedFile - The encrypted file blob to upload
-   * @param schemaId - The schema ID to associate with the file
-   * @param filename - Optional filename for the upload
-   * @param providerName - Optional storage provider to use
-   * @returns Promise resolving to upload result with file ID and storage URL
-   *
-   * This method handles the complete flow of:
-   * 1. Uploading the encrypted file to the specified storage provider
-   * 2. Registering the file URL on the DataRegistry contract with a schema ID
-   * 3. Returning the assigned file ID and storage URL
-   */
-  async uploadEncryptedFileWithSchema(encryptedFile, schemaId, filename, providerName) {
-    try {
-      if (!this.context.storageManager) {
-        throw new Error(
-          "Storage manager not configured. Please provide storage providers in VanaConfig."
-        );
-      }
-      const uploadResult = await this.context.storageManager.upload(
-        encryptedFile,
-        filename,
-        providerName
-      );
-      const userAddress = await this.getUserAddress();
-      if (this.context.relayerCallbacks?.submitFileAddition) {
-        throw new Error(
-          "Relayer does not yet support uploading files with schema. Please use direct transaction mode."
-        );
-      } else {
-        const chainId = this.context.walletClient.chain?.id;
-        if (!chainId) {
-          throw new Error("Chain ID not available");
-        }
-        const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
-        const dataRegistryAbi = getAbi("DataRegistry");
-        const txHash = await this.context.walletClient.writeContract({
-          address: dataRegistryAddress,
-          abi: dataRegistryAbi,
-          functionName: "addFileWithSchema",
-          args: [uploadResult.url, BigInt(schemaId)],
-          account: this.context.walletClient.account || userAddress,
-          chain: this.context.walletClient.chain || null
-        });
-        const receipt = await this.context.publicClient.waitForTransactionReceipt({
-          hash: txHash,
-          timeout: 3e4
-          // 30 seconds timeout
-        });
-        let fileId = 0;
-        for (const log of receipt.logs) {
-          try {
-            const decoded = decodeEventLog({
-              abi: dataRegistryAbi,
-              data: log.data,
-              topics: log.topics
-            });
-            if (decoded.eventName === "FileAdded") {
-              fileId = Number(decoded.args.fileId);
-              break;
-            }
-          } catch {
-            continue;
-          }
-        }
-        return {
-          fileId,
-          url: uploadResult.url,
-          size: uploadResult.size,
-          transactionHash: txHash
-        };
-      }
-    } catch (error) {
-      console.error("Failed to upload encrypted file with schema:", error);
-      throw new Error(
-        `Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
   /**
    * Registers a file URL directly on the blockchain with a schema ID.
    *
@@ -39527,214 +40580,74 @@ var DataController = class {
         transactionHash: txHash
       };
     } catch (error) {
-      console.error("Failed to register file with schema:", error);
-      throw new Error(
-        `Registration failed: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Gets the user's address from the wallet client.
-   *
-   * @returns Promise resolving to the user's wallet address
-   * @throws {Error} When no addresses are available in wallet client
-   */
-  async getUserAddress() {
-    const addresses = await this.context.walletClient.getAddresses();
-    if (addresses.length === 0) {
-      throw new Error("No addresses available in wallet client");
-    }
-    return addresses[0];
-  }
-  /**
-   * Adds a file with permissions to the DataRegistry contract.
-   *
-   * @param url - The file URL to register
-   * @param ownerAddress - The address of the file owner
-   * @param permissions - Array of permissions to set for the file
-   * @returns Promise resolving to file ID and transaction hash
-   * @throws {Error} When chain ID is not available
-   * @throws {ContractError} When contract execution fails
-   * @throws {Error} When transaction receipt is not available
-   * @throws {Error} When FileAdded event cannot be parsed
-   *
-   * This method handles the core logic of registering a file
-   * with specific permissions on the DataRegistry contract. It can be used
-   * by both direct transactions and relayer services.
-   */
-  async addFileWithPermissions(url, ownerAddress, permissions = []) {
-    try {
-      const chainId = this.context.walletClient.chain?.id;
-      if (!chainId) {
-        throw new Error("Chain ID not available");
-      }
-      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
-      const dataRegistryAbi = getAbi("DataRegistry");
-      const txHash = await this.context.walletClient.writeContract({
-        address: dataRegistryAddress,
-        abi: dataRegistryAbi,
-        functionName: "addFileWithPermissions",
-        args: [url, ownerAddress, permissions],
-        account: this.context.walletClient.account || ownerAddress,
-        chain: this.context.walletClient.chain || null
-      });
-      const receipt = await this.context.publicClient.waitForTransactionReceipt(
-        {
-          hash: txHash,
-          timeout: 3e4
-          // 30 seconds timeout
-        }
-      );
-      let fileId = 0;
-      for (const log of receipt.logs) {
-        try {
-          const decoded = decodeEventLog({
-            abi: dataRegistryAbi,
-            data: log.data,
-            topics: log.topics
-          });
-          if (decoded.eventName === "FileAdded") {
-            fileId = Number(decoded.args.fileId);
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
-      return {
-        fileId,
-        transactionHash: txHash
-      };
-    } catch (error) {
-      console.error("Failed to add file with permissions:", error);
-      throw new Error(
-        `Failed to add file with permissions: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Adds a file to the registry with permissions and schema.
-   * This combines the functionality of addFileWithPermissions and schema validation.
-   *
-   * @param url - The URL of the file to register
-   * @param ownerAddress - The address of the file owner
-   * @param permissions - Array of permissions to grant (account and encrypted key)
-   * @param schemaId - The schema ID to associate with the file (0 for no schema)
-   * @returns Promise resolving to object with fileId and transactionHash
-   * @throws {Error} When chain ID is not available
-   * @throws {ContractError} When contract execution fails
-   * @throws {Error} When transaction receipt is not available
-   * @throws {Error} When FileAdded event cannot be parsed
-   */
-  async addFileWithPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0) {
-    try {
-      const chainId = this.context.walletClient.chain?.id;
-      if (!chainId) {
-        throw new Error("Chain ID not available");
-      }
-      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
-      const dataRegistryAbi = getAbi("DataRegistry");
-      const txHash = await this.context.walletClient.writeContract({
-        address: dataRegistryAddress,
-        abi: dataRegistryAbi,
-        functionName: "addFileWithPermissionsAndSchema",
-        args: [url, ownerAddress, permissions, BigInt(schemaId)],
-        account: this.context.walletClient.account || ownerAddress,
-        chain: this.context.walletClient.chain || null
-      });
-      const receipt = await this.context.publicClient.waitForTransactionReceipt(
-        {
-          hash: txHash,
-          timeout: 3e4
-          // 30 seconds timeout
-        }
-      );
-      let fileId = 0;
-      for (const log of receipt.logs) {
-        try {
-          const decoded = decodeEventLog({
-            abi: dataRegistryAbi,
-            data: log.data,
-            topics: log.topics
-          });
-          if (decoded.eventName === "FileAdded") {
-            fileId = Number(decoded.args.fileId);
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
-      return {
-        fileId,
-        transactionHash: txHash
-      };
-    } catch (error) {
-      console.error("Failed to add file with permissions and schema:", error);
+      console.error("Failed to register file with schema:", error);
       throw new Error(
-        `Failed to add file with permissions and schema: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Registration failed: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   /**
-   * Adds a new schema to the DataRefinerRegistry.
+   * Gets the user's address from the wallet client.
    *
-   * @deprecated Since v2.0.0 - Use vana.schemas.create() instead for the high-level API with automatic IPFS upload
+   * @returns Promise resolving to the user's wallet address
+   * @throws {Error} When no addresses are available in wallet client
+   */
+  async getUserAddress() {
+    const addresses = await this.context.walletClient.getAddresses();
+    if (addresses.length === 0) {
+      throw new Error("No addresses available in wallet client");
+    }
+    return addresses[0];
+  }
+  /**
+   * Adds a file with permissions to the DataRegistry contract.
    *
-   * Migration guide:
-   * ```typescript
-   * // Old way (deprecated):
-   * const result = await vana.data.addSchema({
-   *   name: "UserProfile",
-   *   type: "JSON",
-   *   definitionUrl: "ipfs://..."
-   * });
+   * @param url - The file URL to register
+   * @param ownerAddress - The address of the file owner
+   * @param permissions - Array of permissions to set for the file
+   * @returns Promise resolving to file ID and transaction hash
+   * @throws {Error} When chain ID is not available
+   * @throws {ContractError} When contract execution fails
+   * @throws {Error} When transaction receipt is not available
+   * @throws {Error} When FileAdded event cannot be parsed
    *
-   * // New way:
-   * const result = await vana.schemas.create({
-   *   name: "UserProfile",
-   *   type: "JSON",
-   *   definition: schemaObject  // Automatically uploads to IPFS
-   * });
-   * ```
-   * @param params - Schema parameters including name, type, and definition URL
-   * @returns Promise resolving to the new schema ID and transaction hash
+   * This method handles the core logic of registering a file
+   * with specific permissions on the DataRegistry contract. It can be used
+   * by both direct transactions and relayer services.
    */
-  async addSchema(params) {
+  async addFileWithPermissions(url, ownerAddress, permissions = []) {
     try {
       const chainId = this.context.walletClient.chain?.id;
       if (!chainId) {
         throw new Error("Chain ID not available");
       }
-      const dataRefinerRegistryAddress = getContractAddress(
-        chainId,
-        "DataRefinerRegistry"
-      );
-      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
       const txHash = await this.context.walletClient.writeContract({
-        address: dataRefinerRegistryAddress,
-        abi: dataRefinerRegistryAbi,
-        functionName: "addSchema",
-        args: [params.name, params.type, params.definitionUrl],
-        account: this.context.walletClient.account || await this.getUserAddress(),
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        functionName: "addFileWithPermissions",
+        args: [url, ownerAddress, permissions],
+        account: this.context.walletClient.account || ownerAddress,
         chain: this.context.walletClient.chain || null
       });
       const receipt = await this.context.publicClient.waitForTransactionReceipt(
         {
           hash: txHash,
           timeout: 3e4
+          // 30 seconds timeout
         }
       );
-      let schemaId = 0;
+      let fileId = 0;
       for (const log of receipt.logs) {
         try {
           const decoded = decodeEventLog({
-            abi: dataRefinerRegistryAbi,
+            abi: dataRegistryAbi,
             data: log.data,
             topics: log.topics
           });
-          if (decoded.eventName === "SchemaAdded") {
-            schemaId = Number(decoded.args.schemaId);
+          if (decoded.eventName === "FileAdded") {
+            fileId = Number(decoded.args.fileId);
             break;
           }
         } catch {
@@ -39742,107 +40655,78 @@ var DataController = class {
         }
       }
       return {
-        schemaId,
+        fileId,
         transactionHash: txHash
       };
     } catch (error) {
-      console.error("Failed to add schema:", error);
+      console.error("Failed to add file with permissions:", error);
       throw new Error(
-        `Failed to add schema: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to add file with permissions: ${error instanceof Error ? error.message : "Unknown error"}`
       );
     }
   }
   /**
-   * Retrieves a schema by its ID.
-   *
-   * @deprecated Since v2.0.0 - Use vana.schemas.get() instead
-   *
-   * Migration guide:
-   * ```typescript
-   * // Old way (deprecated):
-   * const schema = await vana.data.getSchema(schemaId);
+   * Adds a file to the registry with permissions and schema.
+   * This combines the functionality of addFileWithPermissions and schema validation.
    *
-   * // New way:
-   * const schema = await vana.schemas.get(schemaId);
-   * ```
-   * @param schemaId - The schema ID to retrieve
-   * @returns Promise resolving to the schema information
+   * @param url - The URL of the file to register
+   * @param ownerAddress - The address of the file owner
+   * @param permissions - Array of permissions to grant (account and encrypted key)
+   * @param schemaId - The schema ID to associate with the file (0 for no schema)
+   * @returns Promise resolving to object with fileId and transactionHash
+   * @throws {Error} When chain ID is not available
+   * @throws {ContractError} When contract execution fails
+   * @throws {Error} When transaction receipt is not available
+   * @throws {Error} When FileAdded event cannot be parsed
    */
-  async getSchema(schemaId) {
+  async addFileWithPermissionsAndSchema(url, ownerAddress, permissions = [], schemaId = 0) {
     try {
       const chainId = this.context.walletClient.chain?.id;
       if (!chainId) {
         throw new Error("Chain ID not available");
       }
-      const dataRefinerRegistryAddress = getContractAddress(
-        chainId,
-        "DataRefinerRegistry"
-      );
-      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-      const dataRefinerRegistry = getContract({
-        address: dataRefinerRegistryAddress,
-        abi: dataRefinerRegistryAbi,
-        client: this.context.walletClient
+      const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
+      const dataRegistryAbi = getAbi("DataRegistry");
+      const txHash = await this.context.walletClient.writeContract({
+        address: dataRegistryAddress,
+        abi: dataRegistryAbi,
+        functionName: "addFileWithPermissionsAndSchema",
+        args: [url, ownerAddress, permissions, BigInt(schemaId)],
+        account: this.context.walletClient.account || ownerAddress,
+        chain: this.context.walletClient.chain || null
       });
-      const schemaData = await dataRefinerRegistry.read.schemas([
-        BigInt(schemaId)
-      ]);
-      if (!schemaData) {
-        throw new Error("Schema not found");
-      }
-      const schemaObj = schemaData;
-      if (!schemaObj.name || !schemaObj.typ || !schemaObj.definitionUrl) {
-        throw new Error("Incomplete schema data");
+      const receipt = await this.context.publicClient.waitForTransactionReceipt(
+        {
+          hash: txHash,
+          timeout: 3e4
+          // 30 seconds timeout
+        }
+      );
+      let fileId = 0;
+      for (const log of receipt.logs) {
+        try {
+          const decoded = decodeEventLog({
+            abi: dataRegistryAbi,
+            data: log.data,
+            topics: log.topics
+          });
+          if (decoded.eventName === "FileAdded") {
+            fileId = Number(decoded.args.fileId);
+            break;
+          }
+        } catch {
+          continue;
+        }
       }
       return {
-        id: schemaId,
-        name: schemaObj.name,
-        type: schemaObj.typ,
-        definitionUrl: schemaObj.definitionUrl
+        fileId,
+        transactionHash: txHash
       };
     } catch (error) {
-      console.error("Failed to get schema:", error);
+      console.error("Failed to add file with permissions and schema:", error);
       throw new Error(
-        `Failed to get schema ${schemaId}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
-  /**
-   * Gets the total number of schemas in the registry.
-   *
-   * @deprecated Since v2.0.0 - Use vana.schemas.count() instead
-   *
-   * Migration guide:
-   * ```typescript
-   * // Old way (deprecated):
-   * const count = await vana.data.getSchemasCount();
-   *
-   * // New way:
-   * const count = await vana.schemas.count();
-   * ```
-   * @returns Promise resolving to the total schema count
-   */
-  async getSchemasCount() {
-    try {
-      const chainId = this.context.walletClient.chain?.id;
-      if (!chainId) {
-        throw new Error("Chain ID not available");
-      }
-      const dataRefinerRegistryAddress = getContractAddress(
-        chainId,
-        "DataRefinerRegistry"
+        `Failed to add file with permissions and schema: ${error instanceof Error ? error.message : "Unknown error"}`
       );
-      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-      const dataRefinerRegistry = getContract({
-        address: dataRefinerRegistryAddress,
-        abi: dataRefinerRegistryAbi,
-        client: this.context.walletClient
-      });
-      const count = await dataRefinerRegistry.read.schemasCount();
-      return Number(count);
-    } catch (error) {
-      console.error("Failed to get schemas count:", error);
-      return 0;
     }
   }
   /**
@@ -39925,7 +40809,7 @@ var DataController = class {
         "DataRefinerRegistry"
       );
       const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-      const dataRefinerRegistry = getContract({
+      const dataRefinerRegistry = getContract2({
         address: dataRefinerRegistryAddress,
         abi: dataRefinerRegistryAbi,
         client: this.context.walletClient
@@ -39968,7 +40852,7 @@ var DataController = class {
         "DataRefinerRegistry"
       );
       const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-      const dataRefinerRegistry = getContract({
+      const dataRefinerRegistry = getContract2({
         address: dataRefinerRegistryAddress,
         abi: dataRefinerRegistryAbi,
         client: this.context.walletClient
@@ -39998,7 +40882,7 @@ var DataController = class {
         "DataRefinerRegistry"
       );
       const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-      const dataRefinerRegistry = getContract({
+      const dataRefinerRegistry = getContract2({
         address: dataRefinerRegistryAddress,
         abi: dataRefinerRegistryAbi,
         client: this.context.walletClient
@@ -40066,27 +40950,19 @@ var DataController = class {
    */
   async uploadFileWithPermissions(data, permissions, filename, providerName) {
     try {
-      const userEncryptionKey = await generateEncryptionKey(
-        this.context.walletClient,
-        this.context.platform,
-        DEFAULT_ENCRYPTION_SEED
-      );
-      const encryptedData = await encryptBlobWithSignedKey(
+      const uploadResult = await this.uploadToStorage(
         data,
-        userEncryptionKey,
-        this.context.platform
-      );
-      if (!this.context.storageManager) {
-        throw new Error(
-          "Storage manager not configured. Please provide storage providers in VanaConfig."
-        );
-      }
-      const uploadResult = await this.context.storageManager.upload(
-        encryptedData,
         filename,
+        true,
+        // Always encrypt for uploadFileWithPermissions
         providerName
       );
       const userAddress = await this.getUserAddress();
+      const userEncryptionKey = await generateEncryptionKey(
+        this.context.walletClient,
+        this.context.platform,
+        DEFAULT_ENCRYPTION_SEED
+      );
       const encryptedPermissions = await Promise.all(
         permissions.map(async (permission) => {
           const encryptedKey = await encryptWithWalletPublicKey(
@@ -40127,6 +41003,70 @@ var DataController = class {
       );
     }
   }
+  /**
+   * Uploads content to storage without registering it on the blockchain.
+   * This method only handles the storage upload and returns the file URL.
+   *
+   * @param content - The content to upload (string, Blob, Buffer, or object - objects will be JSON stringified)
+   * @param filename - Optional filename for the uploaded file (defaults to timestamp-based name)
+   * @param encrypt  - Optional flag to encrypt the content before upload
+   * @param providerName - Optional specific storage provider to use
+   * @returns Promise resolving to the storage upload result with url, size, and contentType
+   */
+  async uploadToStorage(content, filename, encrypt = false, providerName) {
+    try {
+      let blob;
+      if (content instanceof Blob) {
+        blob = content;
+      } else if (typeof content === "string") {
+        blob = new Blob([content], { type: "text/plain" });
+      } else if (content instanceof Buffer) {
+        const arrayBuffer = content.buffer.slice(
+          content.byteOffset,
+          content.byteOffset + content.byteLength
+        );
+        blob = new Blob([arrayBuffer], { type: "application/octet-stream" });
+      } else {
+        blob = new Blob([JSON.stringify(content)], {
+          type: "application/json"
+        });
+      }
+      let finalBlob = blob;
+      if (encrypt) {
+        const encryptionKey = await generateEncryptionKey(
+          this.context.walletClient,
+          this.context.platform,
+          DEFAULT_ENCRYPTION_SEED
+        );
+        finalBlob = await encryptBlobWithSignedKey(
+          blob,
+          encryptionKey,
+          this.context.platform
+        );
+      }
+      if (!this.context.storageManager) {
+        if (this.context.validateStorageRequired) {
+          this.context.validateStorageRequired();
+          throw new Error("Storage validation failed");
+        } else {
+          throw new Error(
+            "Storage manager not configured. Please provide storage providers in VanaConfig."
+          );
+        }
+      }
+      const finalFilename = filename || `upload-${Date.now()}.dat`;
+      const uploadResult = await this.context.storageManager.upload(
+        finalBlob,
+        finalFilename,
+        providerName
+      );
+      return uploadResult;
+    } catch (error) {
+      throw new Error(
+        `Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
   /**
    * Adds a permission for a party to access an existing file.
    *
@@ -40222,7 +41162,7 @@ var DataController = class {
       }
       const dataRegistryAddress = getContractAddress(chainId, "DataRegistry");
       const dataRegistryAbi = getAbi("DataRegistry");
-      const dataRegistry = getContract({
+      const dataRegistry = getContract2({
         address: dataRegistryAddress,
         abi: dataRegistryAbi,
         client: this.context.walletClient
@@ -40546,7 +41486,7 @@ var DataController = class {
    */
   async getValidatedSchema(schemaId) {
     try {
-      const schema = await this.getSchema(schemaId);
+      const schema = await fetchSchemaFromChain(this.context, schemaId);
       const dataSchema = await this.fetchAndValidateSchema(
         schema.definitionUrl
       );
@@ -40571,7 +41511,7 @@ var DataController = class {
 };
 
 // src/controllers/schemas.ts
-import { getContract as getContract2, decodeEventLog as decodeEventLog2 } from "viem";
+import { decodeEventLog as decodeEventLog2 } from "viem";
 var SchemaController = class {
   constructor(context) {
     this.context = context;
@@ -40723,36 +41663,7 @@ var SchemaController = class {
    */
   async get(schemaId) {
     try {
-      const chainId = this.context.walletClient.chain?.id;
-      if (!chainId) {
-        throw new Error("Chain ID not available");
-      }
-      const dataRefinerRegistryAddress = getContractAddress(
-        chainId,
-        "DataRefinerRegistry"
-      );
-      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-      const dataRefinerRegistry = getContract2({
-        address: dataRefinerRegistryAddress,
-        abi: dataRefinerRegistryAbi,
-        client: this.context.publicClient
-      });
-      const schemaData = await dataRefinerRegistry.read.schemas([
-        BigInt(schemaId)
-      ]);
-      if (!schemaData) {
-        throw new Error(`Schema with ID ${schemaId} not found`);
-      }
-      const schemaObj = schemaData;
-      if (!schemaObj.name || !schemaObj.typ || !schemaObj.definitionUrl) {
-        throw new Error("Incomplete schema data");
-      }
-      return {
-        id: schemaId,
-        name: schemaObj.name,
-        type: schemaObj.typ,
-        definitionUrl: schemaObj.definitionUrl
-      };
+      return await fetchSchemaFromChain(this.context, schemaId);
     } catch (error) {
       throw new Error(
         `Failed to get schema: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -40772,22 +41683,7 @@ var SchemaController = class {
    */
   async count() {
     try {
-      const chainId = this.context.walletClient.chain?.id;
-      if (!chainId) {
-        throw new Error("Chain ID not available");
-      }
-      const dataRefinerRegistryAddress = getContractAddress(
-        chainId,
-        "DataRefinerRegistry"
-      );
-      const dataRefinerRegistryAbi = getAbi("DataRefinerRegistry");
-      const dataRefinerRegistry = getContract2({
-        address: dataRefinerRegistryAddress,
-        abi: dataRefinerRegistryAbi,
-        client: this.context.publicClient
-      });
-      const count = await dataRefinerRegistry.read.schemasCount();
-      return Number(count);
+      return await fetchSchemaCountFromChain(this.context);
     } catch (error) {
       throw new Error(
         `Failed to get schemas count: ${error instanceof Error ? error.message : "Unknown error"}`