@opendatalabs/vana-sdk 0.1.0-alpha.7ee7635 → 0.1.0-alpha.8117ac2

package/dist/controllers/permissions.cjs

@@ -41,9 +41,10 @@ var import_grantValidation = require("../utils/grantValidation");
 var import_signatureCache = require("../utils/signatureCache");
 var import_signatureFormatter = require("../utils/signatureFormatter");
 var import_typedDataConverter = require("../utils/typedDataConverter");
-class PermissionsController {
+var import_base = require("./base");
+class PermissionsController extends import_base.BaseController {
   constructor(context) {
-    this.context = context;
+    super(context);
   }
   /**
    * Grants permission for an application to access user data with gasless transactions.
@@ -79,9 +80,14 @@ class PermissionsController {
    * await vana.permissions.revoke({ permissionId: result.permissionId });
    * ```
    */
-  async grant(params) {
+  async grant(params, options) {
+    this.assertWallet();
     const { typedData, signature } = await this.createAndSign(params);
-    const result = await this.submitSignedGrantWithEvents(typedData, signature);
+    const result = await this.submitSignedGrantWithEvents(
+      typedData,
+      signature,
+      options
+    );
     return result;
   }
   /**
@@ -109,9 +115,10 @@ class PermissionsController {
    * console.log(`Permission ID: ${eventData.permissionId}`);
    * ```
    */
-  async submitPermissionGrant(params) {
+  async submitPermissionGrant(params, options) {
+    this.assertWallet();
     const { typedData, signature } = await this.createAndSign(params);
-    return await this.submitSignedGrant(typedData, signature);
+    return await this.submitSignedGrant(typedData, signature, options);
   }
   /**
    * Prepares a permission grant with preview before signing.
@@ -138,14 +145,19 @@ class PermissionsController {
    * const transactionHash = await confirm();
    * ```
    */
-  async prepareGrant(params) {
+  async prepareGrant(params, options) {
+    this.assertWallet();
     try {
       const grantFile = (0, import_grantFiles.createGrantFile)(params);
       (0, import_grantValidation.validateGrant)(grantFile);
       return {
         preview: grantFile,
         confirm: async () => {
-          return await this.confirmGrantInternalWithEvents(params, grantFile);
+          return await this.confirmGrantInternalWithEvents(
+            params,
+            grantFile,
+            options
+          );
         }
       };
     } catch (error) {
@@ -177,22 +189,36 @@ class PermissionsController {
    * @throws {NetworkError} When IPFS upload fails
    * @throws {SignatureError} When user rejects the signature
    */
-  async confirmGrantInternal(params, grantFile) {
+  async confirmGrantInternal(params, grantFile, options) {
     try {
-      let grantUrl = params.grantUrl;
+      let { grantUrl } = params;
       console.debug("\u{1F50D} Debug - Grant URL from params:", grantUrl);
       if (!grantUrl) {
-        if (!this.context.relayerCallbacks?.storeGrantFile && !this.context.storageManager) {
+        const canStoreViaRelayer = this.context.relayer !== void 0;
+        if (!canStoreViaRelayer && !this.context.storageManager) {
           if (this.context.validateStorageRequired) {
             this.context.validateStorageRequired();
           } else {
             throw new Error(
-              "No storage available. Provide a grantUrl, configure relayerCallbacks.storeGrantFile, or storageManager."
+              "No storage available. Provide a grantUrl, configure relayer, or storageManager."
             );
           }
         }
-        if (this.context.relayerCallbacks?.storeGrantFile) {
-          grantUrl = await this.context.relayerCallbacks.storeGrantFile(grantFile);
+        if (canStoreViaRelayer && this.context.relayer) {
+          const request = {
+            type: "direct",
+            operation: "storeGrantFile",
+            params: grantFile
+          };
+          const response = await this.context.relayer(request);
+          if (response.type === "error") {
+            throw new Error(response.error);
+          }
+          if (response.type === "direct" && typeof response.result === "object" && response.result !== null && "url" in response.result) {
+            grantUrl = response.result.url;
+          } else {
+            throw new Error("Invalid response from relayer for grant storage");
+          }
         } else if (this.context.storageManager) {
           const blob = new Blob([JSON.stringify(grantFile)], {
             type: "application/json"
@@ -224,7 +250,7 @@ class PermissionsController {
         nonce
       });
       const signature = await this.signTypedData(typedData);
-      return await this.submitSignedGrant(typedData, signature);
+      return await this.submitSignedGrant(typedData, signature, options);
     } catch (error) {
       if (error instanceof Error) {
         if (error instanceof import_errors.RelayerError || error instanceof import_errors.UserRejectedRequestError || error instanceof import_errors.SerializationError || error instanceof import_errors.SignatureError || error instanceof import_errors.NetworkError || error instanceof import_errors.NonceError) {
@@ -269,23 +295,38 @@ class PermissionsController {
    * ```
    */
   async createAndSign(params) {
+    this.assertWallet();
     try {
       const grantFile = (0, import_grantFiles.createGrantFile)(params);
       (0, import_grantValidation.validateGrant)(grantFile);
-      let grantUrl = params.grantUrl;
+      let { grantUrl } = params;
       console.debug("\u{1F50D} Debug - Grant URL from params:", grantUrl);
       if (!grantUrl) {
-        if (!this.context.relayerCallbacks?.storeGrantFile && !this.context.storageManager) {
+        const canStoreViaRelayer = this.context.relayer !== void 0;
+        if (!canStoreViaRelayer && !this.context.storageManager) {
           if (this.context.validateStorageRequired) {
             this.context.validateStorageRequired();
           } else {
             throw new Error(
-              "No storage available. Provide a grantUrl, configure relayerCallbacks.storeGrantFile, or storageManager."
+              "No storage available. Provide a grantUrl, configure relayer, or storageManager."
             );
           }
         }
-        if (this.context.relayerCallbacks?.storeGrantFile) {
-          grantUrl = await this.context.relayerCallbacks.storeGrantFile(grantFile);
+        if (canStoreViaRelayer && this.context.relayer) {
+          const request = {
+            type: "direct",
+            operation: "storeGrantFile",
+            params: grantFile
+          };
+          const response = await this.context.relayer(request);
+          if (response.type === "error") {
+            throw new Error(response.error);
+          }
+          if (response.type === "direct" && typeof response.result === "object" && response.result !== null && "url" in response.result) {
+            grantUrl = response.result.url;
+          } else {
+            throw new Error("Invalid response from relayer for grant storage");
+          }
         } else if (this.context.storageManager) {
           const blob = new Blob([JSON.stringify(grantFile)], {
             type: "application/json"
@@ -354,31 +395,58 @@ class PermissionsController {
    * );
    * ```
    */
-  async submitSignedGrant(typedData, signature) {
+  async submitSignedGrant(typedData, signature, options) {
     try {
       console.debug(
         "\u{1F50D} Debug - submitSignedGrant called with typed data:",
         JSON.stringify(
           typedData,
-          (key, value) => typeof value === "bigint" ? value.toString() : value,
+          (_key, value) => typeof value === "bigint" ? value.toString() : value,
           2
         )
       );
-      if (this.context.relayerCallbacks?.submitPermissionGrant) {
-        const hash = await this.context.relayerCallbacks.submitPermissionGrant(
+      if (this.context.relayer) {
+        const response = await this.context.relayer({
+          type: "signed",
+          operation: "submitAddPermission",
           typedData,
-          signature
-        );
-        const account = this.context.walletClient.account || await this.getUserAddress();
+          signature,
+          expectedUserAddress: this.context.userAddress
+        });
+        if (response.type === "error") {
+          throw new Error(`Relayer error: ${response.error}`);
+        }
+        let finalHash;
+        if (response.type === "submitted") {
+          finalHash = response.hash;
+        } else if (response.type === "pending") {
+          const pollResult = await this.pollRelayerForConfirmation(
+            response.operationId
+          );
+          finalHash = pollResult.hash;
+        } else if (response.type === "confirmed") {
+          finalHash = response.hash;
+        } else if (response.type === "signed") {
+          finalHash = response.hash;
+        } else {
+          throw new Error(
+            "Invalid response from relayer: unexpected response type"
+          );
+        }
+        const account = this.context.walletClient?.account ?? this.context.userAddress;
         const { tx } = await import("../utils/transactionHelpers");
         return tx({
-          hash,
+          hash: finalHash,
           from: typeof account === "string" ? account : account.address,
           contract: "DataPortabilityPermissions",
           fn: "addPermission"
         });
       } else {
-        return await this.submitDirectTransaction(typedData, signature);
+        return await this.submitDirectTransaction(
+          typedData,
+          signature,
+          options
+        );
       }
     } catch (error) {
       if (error instanceof import_errors.RelayerError || error instanceof import_errors.NetworkError || error instanceof import_errors.UserRejectedRequestError || error instanceof import_errors.SignatureError || error instanceof import_errors.NonceError) {
@@ -411,7 +479,7 @@ class PermissionsController {
    * const result = await txHandle.waitForEvents();
    * ```
    */
-  async submitSignedTrustServer(typedData, signature) {
+  async submitSignedTrustServer(typedData, signature, options) {
     try {
       const trustServerInput = {
         nonce: BigInt(typedData.message.nonce),
@@ -419,13 +487,14 @@ class PermissionsController {
       };
       const hash = await this.submitTrustServerTransaction(
         trustServerInput,
-        signature
+        signature,
+        options
       );
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
-        from: typeof account === "string" ? account : account.address,
+        from: account,
         contract: "DataPortabilityServers",
         fn: "trustServerWithSignature"
       });
@@ -474,7 +543,7 @@ class PermissionsController {
    * const result = await txHandle.waitForEvents();
    * ```
    */
-  async submitSignedAddAndTrustServer(typedData, signature) {
+  async submitSignedAddAndTrustServer(typedData, signature, _options) {
     try {
       const addAndTrustServerInput = {
         nonce: BigInt(typedData.message.nonce),
@@ -486,7 +555,7 @@ class PermissionsController {
         addAndTrustServerInput,
         signature
       );
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -506,21 +575,27 @@ class PermissionsController {
   }
   /**
    * Internal method to submit a signed grant and wait for events.
-   * 
+   *
    * @internal
    * @param typedData - The EIP-712 typed data for the permission grant
    * @param signature - The user's signature authorizing the transaction
    * @returns Promise resolving to PermissionGrantResult with parsed events
    */
-  async submitSignedGrantWithEvents(typedData, signature) {
-    const txResult = await this.submitSignedGrant(typedData, signature);
+  async submitSignedGrantWithEvents(typedData, signature, options) {
+    const txResult = await this.submitSignedGrant(
+      typedData,
+      signature,
+      options
+    );
     if (!this.context.waitForTransactionEvents) {
       throw new import_errors.BlockchainError("waitForTransactionEvents not configured");
     }
     const result = await this.context.waitForTransactionEvents(txResult);
     const event = result.expectedEvents.PermissionAdded;
     if (!event) {
-      throw new import_errors.BlockchainError("PermissionAdded event not found in transaction");
+      throw new import_errors.BlockchainError(
+        "PermissionAdded event not found in transaction"
+      );
     }
     const receipt = await this.context.publicClient.getTransactionReceipt({
       hash: result.hash
@@ -537,21 +612,27 @@ class PermissionsController {
   }
   /**
    * Internal method for confirm grant with events.
-   * 
+   *
    * @internal
    * @param params - The permission grant parameters
    * @param grantFile - The pre-created grant file object
    * @returns Promise resolving to PermissionGrantResult with parsed events
    */
-  async confirmGrantInternalWithEvents(params, grantFile) {
-    const txResult = await this.confirmGrantInternal(params, grantFile);
+  async confirmGrantInternalWithEvents(params, grantFile, options) {
+    const txResult = await this.confirmGrantInternal(
+      params,
+      grantFile,
+      options
+    );
     if (!this.context.waitForTransactionEvents) {
       throw new import_errors.BlockchainError("waitForTransactionEvents not configured");
     }
     const result = await this.context.waitForTransactionEvents(txResult);
     const event = result.expectedEvents.PermissionAdded;
     if (!event) {
-      throw new import_errors.BlockchainError("PermissionAdded event not found in transaction");
+      throw new import_errors.BlockchainError(
+        "PermissionAdded event not found in transaction"
+      );
     }
     const receipt = await this.context.publicClient.getTransactionReceipt({
       hash: result.hash
@@ -567,32 +648,37 @@ class PermissionsController {
     };
   }
   /**
-   * Internal method to submit a signed revoke and wait for events.
-   * 
+   * Polls the relayer for confirmation of a pending operation.
+   *
+   * @param operationId - The operation ID to poll
+   * @returns Promise resolving to the confirmed hash
+   * @throws {Error} When the operation fails or times out
    * @internal
-   * @param typedData - The EIP-712 typed data for the permission revoke
-   * @param signature - The user's signature authorizing the transaction  
-   * @returns Promise resolving to PermissionRevokeResult with parsed events
    */
-  async submitSignedRevokeWithEvents(typedData, signature) {
-    const txResult = await this.submitSignedRevoke(typedData, signature);
-    if (!this.context.waitForTransactionEvents) {
-      throw new import_errors.BlockchainError("waitForTransactionEvents not configured");
-    }
-    const result = await this.context.waitForTransactionEvents(txResult);
-    const event = result.expectedEvents.PermissionRevoked;
-    if (!event) {
-      throw new import_errors.BlockchainError("PermissionRevoked event not found in transaction");
+  async pollRelayerForConfirmation(operationId, options = {}) {
+    const timeout = options.timeout ?? 3e4;
+    let interval = options.pollingInterval ?? 1e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      if (!this.context.relayer) {
+        throw new Error("Relayer not configured for polling");
+      }
+      const statusResponse = await this.context.relayer({
+        type: "status_check",
+        operationId
+      });
+      if (statusResponse.type === "confirmed") {
+        return { hash: statusResponse.hash };
+      }
+      if (statusResponse.type === "error") {
+        throw new Error(
+          `Operation ${operationId} failed: ${statusResponse.error}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+      interval = Math.min(interval * 1.5, 5e3);
     }
-    const receipt = await this.context.publicClient.getTransactionReceipt({
-      hash: result.hash
-    });
-    return {
-      transactionHash: result.hash,
-      blockNumber: receipt.blockNumber,
-      gasUsed: receipt.gasUsed,
-      permissionId: event.permissionId
-    };
+    throw new Error(`Operation ${operationId} timed out after ${timeout}ms`);
   }
   /**
    * Submits an already-signed permission revoke transaction to the blockchain.
@@ -615,18 +701,43 @@ class PermissionsController {
    * const result = await txHandle.waitForEvents();
    * ```
    */
-  async submitSignedRevoke(typedData, signature) {
+  async submitSignedRevoke(typedData, signature, _options) {
     try {
       let hash;
-      if (this.context.relayerCallbacks?.submitPermissionRevoke) {
-        hash = await this.context.relayerCallbacks.submitPermissionRevoke(
+      if (this.context.relayer) {
+        const response = await this.context.relayer({
+          type: "signed",
+          operation: "submitPermissionRevoke",
+          typedData,
+          signature,
+          expectedUserAddress: this.context.userAddress
+        });
+        if (response.type === "error") {
+          throw new Error(`Relayer error: ${response.error}`);
+        }
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "pending") {
+          const pollResult = await this.pollRelayerForConfirmation(
+            response.operationId
+          );
+          hash = pollResult.hash;
+        } else if (response.type === "confirmed") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else {
+          throw new Error(
+            "Invalid response from relayer: unexpected response type"
+          );
+        }
+      } else {
+        hash = await this.submitDirectRevokeTransaction(
           typedData,
           signature
         );
-      } else {
-        hash = await this.submitDirectRevokeTransaction(typedData, signature);
       }
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -665,18 +776,35 @@ class PermissionsController {
    * const result = await txHandle.waitForEvents();
    * ```
    */
-  async submitSignedUntrustServer(typedData, signature) {
+  async submitSignedUntrustServer(typedData, signature, _options) {
     try {
       let hash;
-      if (this.context.relayerCallbacks?.submitUntrustServer) {
-        hash = await this.context.relayerCallbacks.submitUntrustServer(
+      if (this.context.relayer) {
+        const response = await this.context.relayer({
+          type: "signed",
+          operation: "submitUntrustServer",
+          typedData,
+          signature,
+          expectedUserAddress: this.context.userAddress
+        });
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else if (response.type === "error") {
+          throw new Error(`Relayer error: ${response.error}`);
+        } else {
+          throw new Error(
+            "Invalid response from relayer: expected signed transaction"
+          );
+        }
+      } else {
+        hash = await this.submitSignedUntrustTransaction(
           typedData,
           signature
         );
-      } else {
-        hash = await this.submitSignedUntrustTransaction(typedData, signature);
       }
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -706,8 +834,9 @@ class PermissionsController {
    * @returns Promise resolving to the transaction hash
    * @throws {BlockchainError} When contract submission fails
    */
-  async submitDirectTransaction(typedData, signature) {
-    const chainId = await this.context.walletClient.getChainId();
+  async submitDirectTransaction(typedData, signature, options) {
+    this.assertWallet();
+    const chainId = await this.context.publicClient.getChainId();
     const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
       chainId,
       "DataPortabilityPermissions"
@@ -727,17 +856,18 @@ class PermissionsController {
     console.debug("\u{1F50D} Debug - Grant field value:", typedData.message.grant);
     console.debug(
       "\u{1F50D} Debug - Grant field length:",
-      typedData.message.grant?.length || 0
+      typedData.message.grant?.length ?? 0
     );
     const formattedSignature = (0, import_signatureFormatter.formatSignatureForContract)(signature);
-    const account = this.context.walletClient.account || await this.getUserAddress();
+    const account = this.context.walletClient?.account ?? this.context.userAddress;
     const txHash = await this.context.walletClient.writeContract({
       address: DataPortabilityPermissionsAddress,
       abi: DataPortabilityPermissionsAbi,
       functionName: "addPermission",
       args: [permissionInput, formattedSignature],
       account,
-      chain: this.context.walletClient.chain || null
+      chain: this.context.walletClient?.chain ?? null,
+      ...this.spreadTransactionOptions(options)
     });
     const { tx } = await import("../utils/transactionHelpers");
     return tx({
@@ -772,6 +902,7 @@ class PermissionsController {
    * ```
    */
   async revoke(params) {
+    this.assertWallet();
     const txResult = await this.submitPermissionRevoke(params);
     if (!this.context.waitForTransactionEvents) {
       throw new import_errors.BlockchainError("waitForTransactionEvents not configured");
@@ -779,7 +910,9 @@ class PermissionsController {
     const result = await this.context.waitForTransactionEvents(txResult);
     const event = result.expectedEvents.PermissionRevoked;
     if (!event) {
-      throw new import_errors.BlockchainError("PermissionRevoked event not found in transaction");
+      throw new import_errors.BlockchainError(
+        "PermissionRevoked event not found in transaction"
+      );
     }
     const receipt = await this.context.publicClient.getTransactionReceipt({
       hash: result.hash
@@ -798,6 +931,7 @@ class PermissionsController {
    * Use this when you want to handle transaction confirmation and event parsing separately.
    *
    * @param params - Parameters for revoking the permission
+   * @param options - Optional transaction options for gas parameters and timeout
    * @returns Promise resolving to the transaction hash when successfully submitted
    * @throws {BlockchainError} When revocation transaction fails
    * @throws {UserRejectedRequestError} When user rejects the transaction
@@ -810,12 +944,13 @@ class PermissionsController {
    * console.log(`Revocation submitted: ${txHash}`);
    * ```
    */
-  async submitPermissionRevoke(params) {
+  async submitPermissionRevoke(params, options) {
+    this.assertWallet();
     try {
-      if (!this.context.walletClient.chain?.id) {
+      if (!this.context.walletClient?.chain?.id) {
         throw new import_errors.BlockchainError("Chain ID not available");
       }
-      const chainId = await this.context.walletClient.getChainId();
+      const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
         chainId,
         "DataPortabilityPermissions"
@@ -823,14 +958,25 @@ class PermissionsController {
       const DataPortabilityPermissionsAbi = (0, import_abi.getAbi)(
         "DataPortabilityPermissions"
       );
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const txHash = await this.context.walletClient.writeContract({
         address: DataPortabilityPermissionsAddress,
         abi: DataPortabilityPermissionsAbi,
         functionName: "revokePermission",
         args: [params.permissionId],
         account,
-        chain: this.context.walletClient.chain || null
+        chain: this.context.walletClient?.chain ?? null,
+        ...options?.gas && { gas: options.gas },
+        ...options?.nonce && { nonce: options.nonce },
+        // Use EIP-1559 if available, otherwise fall back to legacy gasPrice
+        ...options?.maxFeePerGas || options?.maxPriorityFeePerGas ? {
+          ...options.maxFeePerGas && {
+            maxFeePerGas: options.maxFeePerGas
+          },
+          ...options.maxPriorityFeePerGas && {
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+          }
+        } : options?.gasPrice && { gasPrice: options.gasPrice }
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -878,8 +1024,9 @@ class PermissionsController {
    * ```
    */
   async submitRevokeWithSignature(params) {
+    this.assertWallet();
     try {
-      if (!this.context.walletClient.chain?.id) {
+      if (!this.context.walletClient?.chain?.id) {
         throw new import_errors.BlockchainError("Chain ID not available");
       }
       const nonce = await this.getPermissionsUserNonce();
@@ -900,15 +1047,32 @@ class PermissionsController {
       };
       const signature = await this.signTypedData(typedData);
       let hash;
-      if (this.context.relayerCallbacks?.submitPermissionRevoke) {
-        hash = await this.context.relayerCallbacks.submitPermissionRevoke(
+      if (this.context.relayer) {
+        const response = await this.context.relayer({
+          type: "signed",
+          operation: "submitPermissionRevoke",
+          typedData,
+          signature,
+          expectedUserAddress: this.context.userAddress
+        });
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else if (response.type === "error") {
+          throw new Error(`Relayer error: ${response.error}`);
+        } else {
+          throw new Error(
+            "Invalid response from relayer: expected signed transaction"
+          );
+        }
+      } else {
+        hash = await this.submitDirectRevokeTransaction(
           typedData,
           signature
         );
-      } else {
-        hash = await this.submitDirectRevokeTransaction(typedData, signature);
       }
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -923,64 +1087,6 @@ class PermissionsController {
       );
     }
   }
-  /**
-   * @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.
-   *
-   * @returns Promise resolving to the user's current nonce value as a bigint
-   * @throws {Error} When wallet account is not available
-   * @throws {Error} When chain ID is not available
-   * @throws {NonceError} When reading nonce from contract fails
-   * @private
-   * @example
-   * ```typescript
-   * // Deprecated - use specific methods instead
-   * const nonce = await this.getUserNonce();
-   *
-   * // Use these instead:
-   * const permissionsNonce = await this.getPermissionsUserNonce();
-   * const serversNonce = await this.getServersUserNonce();
-   * ```
-   */
-  /**
-   * @deprecated Use getPermissionsUserNonce() for permission operations or getServersUserNonce() for server operations
-   *
-   * Retrieves the user's current nonce from the DataPortabilityServers contract.
-   *
-   * @remarks
-   * This method is deprecated in favor of more specific nonce methods that target
-   * the appropriate contract for the operation being performed.
-   *
-   * @returns Promise resolving to the user's current nonce as a bigint
-   * @throws {NonceError} When retrieving the nonce fails
-   */
-  async getUserNonce() {
-    try {
-      const userAddress = await this.getUserAddress();
-      const chainId = await this.context.walletClient.getChainId();
-      const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
-        chainId,
-        "DataPortabilityServers"
-      );
-      const DataPortabilityServersAbi = (0, import_abi.getAbi)("DataPortabilityServers");
-      const nonce = await this.context.publicClient.readContract({
-        address: DataPortabilityServersAddress,
-        abi: DataPortabilityServersAbi,
-        functionName: "userNonce",
-        args: [userAddress]
-      });
-      return nonce;
-    } catch (error) {
-      throw new import_errors.NonceError(
-        `Failed to retrieve user nonce: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-  }
   /**
    * Retrieves the user's current nonce from the DataPortabilityServers contract.
    * This nonce is used for server-related operations (AddAndTrustServer, TrustServer, UntrustServer).
@@ -1007,8 +1113,8 @@ class PermissionsController {
    */
   async getServersUserNonce() {
     try {
-      const userAddress = await this.getUserAddress();
-      const chainId = await this.context.walletClient.getChainId();
+      const userAddress = this.context.userAddress;
+      const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
         "DataPortabilityServers"
@@ -1053,8 +1159,8 @@ class PermissionsController {
    */
   async getPermissionsUserNonce() {
     try {
-      const userAddress = await this.getUserAddress();
-      const chainId = await this.context.walletClient.getChainId();
+      const userAddress = this.context.userAddress;
+      const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
         chainId,
         "DataPortabilityPermissions"
@@ -1093,7 +1199,7 @@ class PermissionsController {
       "\u{1F50D} Debug - Composing permission message with grantUrl:",
       params.grantUrl
     );
-    const chainId = await this.context.walletClient.getChainId();
+    const chainId = await this.context.publicClient.getChainId();
     const DataPortabilityGranteesAddress = (0, import_addresses.getContractAddress)(
       chainId,
       "DataPortabilityGrantees"
@@ -1202,7 +1308,7 @@ class PermissionsController {
    * @returns Promise resolving to the EIP-712 domain configuration
    */
   async getPermissionDomain() {
-    const chainId = await this.context.walletClient.getChainId();
+    const chainId = await this.context.publicClient.getChainId();
     const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
       chainId,
       "DataPortabilityPermissions"
@@ -1221,8 +1327,9 @@ class PermissionsController {
    * @returns Promise resolving to the cryptographic signature
    */
   async signTypedData(typedData) {
+    this.assertWallet();
     try {
-      const walletAddress = this.context.walletClient.account?.address || await this.getUserAddress();
+      const walletAddress = this.context.walletClient.account?.address ?? this.context.userAddress;
       return await (0, import_signatureCache.withSignatureCache)(
         this.context.platform.cache,
         walletAddress,
@@ -1231,9 +1338,9 @@ class PermissionsController {
           const viemCompatibleTypedData = (0, import_typedDataConverter.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
+            // Use the account if available, otherwise use the wallet address
+            // This follows the same pattern used throughout this file
+            account: this.context.walletClient.account ?? walletAddress
           });
         }
       );
@@ -1248,17 +1355,10 @@ class PermissionsController {
     }
   }
   /**
-   * Gets the user's address from the wallet client.
+   * Gets the user's address from the context.
    *
-   * @returns Promise resolving to the user's wallet address
+   * @returns The user's address
    */
-  async getUserAddress() {
-    const addresses = await this.context.walletClient.getAddresses();
-    if (addresses.length === 0) {
-      throw new import_errors.BlockchainError("No addresses available in wallet client");
-    }
-    return addresses[0];
-  }
   /**
    * Gets on-chain permission grant data without expensive off-chain resolution.
    *
@@ -1295,20 +1395,22 @@ class PermissionsController {
    * ```
    */
   async getUserPermissionGrantsOnChain(options = {}) {
-    const { limit = 50, subgraphUrl } = options;
+    const { limit = 50, fetchAll = false, subgraphUrl } = options;
+    const pageSize = fetchAll ? 100 : limit;
+    const maxResults = fetchAll ? 1e4 : limit;
     try {
-      const userAddress = await this.getUserAddress();
-      const graphqlEndpoint = subgraphUrl || this.context.subgraphUrl;
+      const userAddress = this.context.userAddress;
+      const graphqlEndpoint = subgraphUrl ?? this.context.subgraphUrl;
       if (!graphqlEndpoint) {
         throw new import_errors.BlockchainError(
           "subgraphUrl is required. Please provide a valid subgraph endpoint or configure it in Vana constructor."
         );
       }
       const query = `
-        query GetUserPermissions($userId: ID!) {
+        query GetUserPermissions($userId: ID!, $first: Int!, $skip: Int!) {
           user(id: $userId) {
             id
-            permissions {
+            permissions(first: $first, skip: $skip, orderBy: addedAtBlock, orderDirection: desc) {
               id
               grant
               nonce
@@ -1326,34 +1428,82 @@ class PermissionsController {
           }
         }
       `;
-      const response = await fetch(graphqlEndpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          query,
-          variables: {
-            userId: userAddress.toLowerCase()
+      const allPermissions = [];
+      let currentOffset = 0;
+      if (!fetchAll) {
+        const response = await fetch(graphqlEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            query,
+            variables: {
+              userId: userAddress.toLowerCase(),
+              first: limit,
+              skip: 0
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new import_errors.BlockchainError(
+            `Subgraph request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        const result = await response.json();
+        if (result.errors) {
+          throw new import_errors.BlockchainError(
+            `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+          );
+        }
+        const userData = result.data?.user;
+        if (!userData?.permissions?.length) {
+          return [];
+        }
+        allPermissions.push(...userData.permissions);
+      } else {
+        while (allPermissions.length < maxResults) {
+          const currentLimit = Math.min(
+            pageSize,
+            maxResults - allPermissions.length
+          );
+          const response = await fetch(graphqlEndpoint, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              query,
+              variables: {
+                userId: userAddress.toLowerCase(),
+                first: currentLimit,
+                skip: currentOffset
+              }
+            })
+          });
+          if (!response.ok) {
+            throw new import_errors.BlockchainError(
+              `Subgraph request failed: ${response.status} ${response.statusText}`
+            );
           }
-        })
-      });
-      if (!response.ok) {
-        throw new import_errors.BlockchainError(
-          `Subgraph request failed: ${response.status} ${response.statusText}`
-        );
-      }
-      const result = await response.json();
-      if (result.errors) {
-        throw new import_errors.BlockchainError(
-          `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
-        );
-      }
-      const userData = result.data?.user;
-      if (!userData || !userData.permissions?.length) {
-        return [];
+          const result = await response.json();
+          if (result.errors) {
+            throw new import_errors.BlockchainError(
+              `Subgraph errors: ${result.errors.map((e) => e.message).join(", ")}`
+            );
+          }
+          const userData = result.data?.user;
+          if (!userData?.permissions?.length) {
+            break;
+          }
+          allPermissions.push(...userData.permissions);
+          if (userData.permissions.length < currentLimit) {
+            break;
+          }
+          currentOffset += userData.permissions.length;
+        }
       }
-      const onChainGrants = userData.permissions.slice(0, limit).map(
+      const onChainGrants = allPermissions.map(
         (permission) => ({
           id: BigInt(permission.id),
           grantUrl: permission.grant,
@@ -1361,8 +1511,8 @@ class PermissionsController {
           nonce: BigInt(permission.nonce),
           startBlock: BigInt(permission.startBlock),
           addedAtBlock: BigInt(permission.addedAtBlock),
-          addedAtTimestamp: BigInt(permission.addedAtTimestamp || "0"),
-          transactionHash: permission.transactionHash || "",
+          addedAtTimestamp: BigInt(permission.addedAtTimestamp ?? "0"),
+          transactionHash: permission.transactionHash ?? "",
           grantor: userAddress,
           grantee: permission.grantee,
           active: !permission.endBlock || BigInt(permission.endBlock) === 0n
@@ -1383,26 +1533,6 @@ class PermissionsController {
       );
     }
   }
-  /**
-   * Normalizes grant ID to hex format.
-   * Handles conversion from permission ID (bigint/number/string) to proper hex hash format.
-   *
-   * @param grantId - Permission ID or grant hash in various formats
-   * @returns Normalized hex hash
-   */
-  normalizeGrantId(grantId) {
-    if (typeof grantId === "string" && grantId.startsWith("0x") && grantId.length === 66) {
-      return grantId;
-    }
-    try {
-      const bigIntId = BigInt(grantId);
-      return `0x${bigIntId.toString(16).padStart(64, "0")}`;
-    } catch {
-      throw new Error(
-        `Invalid grant ID format: ${grantId}. Must be a permission ID (number/bigint/string) or a 32-byte hex hash.`
-      );
-    }
-  }
   /**
    * Registers a new server and immediately trusts it in the DataPortabilityServers contract.
    *
@@ -1411,7 +1541,6 @@ class PermissionsController {
    * Trusted servers can handle data export and portability requests from the user.
    *
    * @param params - Parameters for adding and trusting the server
-   * @param params.owner - Ethereum address that will own this server registration
    * @param params.serverAddress - Ethereum address of the server
    * @param params.serverUrl - HTTPS URL where the server can be reached
    * @param params.publicKey - Server's public key for encryption (hex string)
@@ -1438,6 +1567,7 @@ class PermissionsController {
    * ```
    */
   async addAndTrustServer(params) {
+    this.assertWallet();
     try {
       const chainId = await this.context.walletClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
@@ -1445,7 +1575,7 @@ class PermissionsController {
         "DataPortabilityServers"
       );
       const DataPortabilityServersAbi = (0, import_abi.getAbi)("DataPortabilityServers");
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const userAddress = typeof account === "string" ? account : account.address;
       const normalizedUserAddress = (0, import_viem.getAddress)(userAddress);
       const normalizedServerAddress = (0, import_viem.getAddress)(params.serverAddress);
@@ -1462,7 +1592,7 @@ class PermissionsController {
           }
         ],
         account,
-        chain: this.context.walletClient.chain || null
+        chain: this.context.walletClient?.chain ?? null
       });
       const { tx } = await import("../utils/transactionHelpers");
       const txResult = tx({
@@ -1477,9 +1607,13 @@ class PermissionsController {
       const result = await this.context.waitForTransactionEvents(txResult);
       const event = result.expectedEvents.ServerTrusted;
       if (!event) {
-        throw new import_errors.BlockchainError("ServerTrusted event not found in transaction");
+        throw new import_errors.BlockchainError(
+          "ServerTrusted event not found in transaction"
+        );
       }
-      const receipt = await this.context.publicClient.getTransactionReceipt({ hash: txHash });
+      const receipt = await this.context.publicClient.getTransactionReceipt({
+        hash: txHash
+      });
       return {
         transactionHash: txHash,
         blockNumber: receipt.blockNumber,
@@ -1510,6 +1644,7 @@ class PermissionsController {
    * @deprecated Use addAndTrustServer instead
    */
   async submitTrustServer(params) {
+    this.assertWallet();
     try {
       const chainId = await this.context.walletClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
@@ -1517,14 +1652,14 @@ class PermissionsController {
         "DataPortabilityServers"
       );
       const DataPortabilityServersAbi = (0, import_abi.getAbi)("DataPortabilityServers");
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const txHash = await this.context.walletClient.writeContract({
         address: DataPortabilityServersAddress,
         abi: DataPortabilityServersAbi,
         functionName: "trustServer",
         args: [BigInt(params.serverId)],
         account,
-        chain: this.context.walletClient.chain || null
+        chain: this.context.walletClient?.chain ?? null
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -1550,6 +1685,7 @@ class PermissionsController {
    * @returns Promise resolving to TransactionResult with ServerTrustResult event data
    */
   async submitAddAndTrustServerWithSignature(params) {
+    this.assertWallet();
     try {
       const nonce = await this.getServersUserNonce();
       const serverAddress = (0, import_viem.getAddress)(params.serverAddress);
@@ -1573,18 +1709,31 @@ class PermissionsController {
       const signature = await this.signTypedData(typedData);
       console.debug("\u{1F50D} Generated signature:", signature);
       let hash;
-      if (this.context.relayerCallbacks?.submitAddAndTrustServer) {
-        hash = await this.context.relayerCallbacks.submitAddAndTrustServer(
+      if (this.context.relayer) {
+        const request = {
+          type: "signed",
+          operation: "submitAddAndTrustServer",
           typedData,
           signature
-        );
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new import_errors.RelayerError(response.error);
+        }
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else {
+          throw new Error("Unexpected response type from relayer");
+        }
       } else {
         hash = await this.submitAddAndTrustServerTransaction(
           addAndTrustServerInput,
           signature
         );
       }
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -1621,6 +1770,7 @@ class PermissionsController {
    * @throws {BlockchainError} When trust operation fails for any other reason
    */
   async submitTrustServerWithSignature(params) {
+    this.assertWallet();
     try {
       const nonce = await this.getServersUserNonce();
       const trustServerInput = {
@@ -1630,18 +1780,31 @@ class PermissionsController {
       const typedData = await this.composeTrustServerMessage(trustServerInput);
       const signature = await this.signTypedData(typedData);
       let hash;
-      if (this.context.relayerCallbacks?.submitTrustServer) {
-        hash = await this.context.relayerCallbacks.submitTrustServer(
+      if (this.context.relayer) {
+        const request = {
+          type: "signed",
+          operation: "submitTrustServer",
           typedData,
           signature
-        );
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new import_errors.RelayerError(response.error);
+        }
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else {
+          throw new Error("Unexpected response type from relayer");
+        }
       } else {
         hash = await this.submitTrustServerTransaction(
           trustServerInput,
           signature
         );
       }
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -1679,7 +1842,8 @@ class PermissionsController {
    * @returns Promise resolving to TransactionResult for transaction tracking
    * @throws {BlockchainError} When contract submission fails
    */
-  async submitDirectUntrustTransaction(params) {
+  async submitDirectUntrustTransaction(params, options) {
+    this.assertWallet();
     try {
       const chainId = await this.context.walletClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
@@ -1687,14 +1851,25 @@ class PermissionsController {
         "DataPortabilityServers"
       );
       const DataPortabilityServersAbi = (0, import_abi.getAbi)("DataPortabilityServers");
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const txHash = await this.context.walletClient.writeContract({
         address: DataPortabilityServersAddress,
         abi: DataPortabilityServersAbi,
         functionName: "untrustServer",
         args: [BigInt(params.serverId)],
         account,
-        chain: this.context.walletClient.chain || null
+        chain: this.context.walletClient?.chain ?? null,
+        ...options?.gas && { gas: options.gas },
+        ...options?.nonce && { nonce: options.nonce },
+        // Use EIP-1559 if available, otherwise fall back to legacy gasPrice
+        ...options?.maxFeePerGas || options?.maxPriorityFeePerGas ? {
+          ...options.maxFeePerGas && {
+            maxFeePerGas: options.maxFeePerGas
+          },
+          ...options.maxPriorityFeePerGas && {
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+          }
+        } : options?.gasPrice && { gasPrice: options.gasPrice }
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -1721,6 +1896,7 @@ class PermissionsController {
    *
    * @param params - Parameters for untrusting the server
    * @param params.serverId - The numeric ID of the server to untrust
+   * @param options - Optional transaction options for gas parameters and timeout
    * @returns Promise resolving to transaction hash
    * @throws {Error} When wallet account is not available
    * @throws {NonceError} When retrieving user nonce fails
@@ -1741,13 +1917,17 @@ class PermissionsController {
    * console.log('Still trusting servers:', trustedServers);
    * ```
    */
-  async submitUntrustServer(params) {
+  async submitUntrustServer(params, options) {
+    this.assertWallet();
     const nonce = await this.getServersUserNonce();
     const untrustServerInput = {
       nonce,
       serverId: params.serverId
     };
-    return await this.submitDirectUntrustTransaction(untrustServerInput);
+    return await this.submitDirectUntrustTransaction(
+      untrustServerInput,
+      options
+    );
   }
   /**
    * Untrusts a server using a signature (gasless transaction).
@@ -1762,6 +1942,7 @@ class PermissionsController {
    * @throws {BlockchainError} When untrust transaction fails
    */
   async submitUntrustServerWithSignature(params) {
+    this.assertWallet();
     try {
       const nonce = await this.getServersUserNonce();
       const untrustServerInput = {
@@ -1771,15 +1952,28 @@ class PermissionsController {
       const typedData = await this.composeUntrustServerMessage(untrustServerInput);
       const signature = await this.signTypedData(typedData);
       let hash;
-      if (this.context.relayerCallbacks?.submitUntrustServer) {
-        hash = await this.context.relayerCallbacks.submitUntrustServer(
+      if (this.context.relayer) {
+        const request = {
+          type: "signed",
+          operation: "submitUntrustServer",
           typedData,
           signature
-        );
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new import_errors.RelayerError(response.error);
+        }
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else {
+          throw new Error("Unexpected response type from relayer");
+        }
       } else {
         hash = await this.submitSignedUntrustTransaction(typedData, signature);
       }
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -1824,8 +2018,8 @@ class PermissionsController {
    */
   async getTrustedServers(userAddress) {
     try {
-      const user = userAddress || await this.getUserAddress();
-      const chainId = await this.context.walletClient.getChainId();
+      const user = userAddress ?? this.context.userAddress;
+      const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
         "DataPortabilityServers"
@@ -1854,8 +2048,8 @@ class PermissionsController {
    */
   async getTrustedServersCount(userAddress) {
     try {
-      const user = userAddress || await this.getUserAddress();
-      const chainId = await this.context.walletClient.getChainId();
+      const user = userAddress ?? this.context.userAddress;
+      const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
         "DataPortabilityServers"
@@ -1884,10 +2078,10 @@ class PermissionsController {
    */
   async getTrustedServersPaginated(options = {}) {
     try {
-      const user = options.userAddress || await this.getUserAddress();
-      const limit = options.limit || 50;
-      const offset = options.offset || 0;
-      const chainId = await this.context.walletClient.getChainId();
+      const user = options.userAddress ?? this.context.userAddress;
+      const limit = options.limit ?? 50;
+      const offset = options.offset ?? 0;
+      const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
         "DataPortabilityServers"
@@ -2033,7 +2227,7 @@ class PermissionsController {
       };
     }
     try {
-      const chainId = await this.context.walletClient.getChainId();
+      const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
         "DataPortabilityServers"
@@ -2108,7 +2302,7 @@ class PermissionsController {
    */
   async checkServerTrustStatus(serverId, userAddress) {
     try {
-      const user = userAddress || await this.getUserAddress();
+      const user = userAddress ?? this.context.userAddress;
       const trustedServers = await this.getTrustedServers(user);
       const trustIndex = trustedServers.findIndex(
         (server) => server === serverId
@@ -2198,7 +2392,7 @@ class PermissionsController {
    * @returns Promise resolving to the EIP-712 domain configuration
    */
   async getServersDomain() {
-    const chainId = await this.context.walletClient.getChainId();
+    const chainId = await this.context.publicClient.getChainId();
     const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
       chainId,
       "DataPortabilityServers"
@@ -2218,6 +2412,7 @@ class PermissionsController {
    * @returns Promise resolving to the transaction hash
    */
   async submitAddAndTrustServerTransaction(addAndTrustServerInput, signature) {
+    this.assertWallet();
     const chainId = await this.context.walletClient.getChainId();
     const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
       chainId,
@@ -2249,8 +2444,8 @@ class PermissionsController {
         },
         formattedSignature
       ],
-      account: this.context.walletClient.account || await this.getUserAddress(),
-      chain: this.context.walletClient.chain || null
+      account: this.context.walletClient?.account ?? this.context.userAddress,
+      chain: this.context.walletClient?.chain ?? null
     });
     return txHash;
   }
@@ -2261,7 +2456,8 @@ class PermissionsController {
    * @param signature - The cryptographic signature for the transaction
    * @returns Promise resolving to the transaction hash
    */
-  async submitTrustServerTransaction(trustServerInput, signature) {
+  async submitTrustServerTransaction(trustServerInput, signature, options) {
+    this.assertWallet();
     const chainId = await this.context.walletClient.getChainId();
     const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
       chainId,
@@ -2280,8 +2476,9 @@ class PermissionsController {
         },
         formattedSignature
       ],
-      account: this.context.walletClient.account || await this.getUserAddress(),
-      chain: this.context.walletClient.chain || null
+      account: this.context.walletClient?.account ?? this.context.userAddress,
+      chain: this.context.walletClient?.chain ?? null,
+      ...this.spreadTransactionOptions(options)
     });
     return txHash;
   }
@@ -2293,6 +2490,7 @@ class PermissionsController {
    * @returns Promise resolving to the transaction hash
    */
   async submitDirectRevokeTransaction(typedData, signature) {
+    this.assertWallet();
     const chainId = await this.context.walletClient.getChainId();
     const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
       chainId,
@@ -2304,10 +2502,9 @@ class PermissionsController {
       address: DataPortabilityPermissionsAddress,
       abi: DataPortabilityPermissionsAbi,
       functionName: "revokePermissionWithSignature",
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       args: [typedData.message, formattedSignature],
-      account: this.context.walletClient.account || await this.getUserAddress(),
-      chain: this.context.walletClient.chain || null
+      account: this.context.walletClient?.account ?? this.context.userAddress,
+      chain: this.context.walletClient?.chain ?? null
     });
     return txHash;
   }
@@ -2318,7 +2515,8 @@ class PermissionsController {
    * @param signature - The cryptographic signature authorizing the untrust
    * @returns Promise resolving to the transaction hash
    */
-  async submitSignedUntrustTransaction(typedData, signature) {
+  async submitSignedUntrustTransaction(typedData, signature, _options) {
+    this.assertWallet();
     const chainId = await this.context.walletClient.getChainId();
     const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
       chainId,
@@ -2326,14 +2524,17 @@ class PermissionsController {
     );
     const DataPortabilityServersAbi = (0, import_abi.getAbi)("DataPortabilityServers");
     const formattedSignature = (0, import_signatureFormatter.formatSignatureForContract)(signature);
+    const contractMessage = {
+      nonce: typedData.message.nonce,
+      serverId: BigInt(typedData.message.serverId)
+    };
     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, formattedSignature],
-      account: this.context.walletClient.account || await this.getUserAddress(),
-      chain: this.context.walletClient.chain || null
+      args: [contractMessage, formattedSignature],
+      account: this.context.walletClient?.account ?? this.context.userAddress,
+      chain: this.context.walletClient?.chain ?? null
     });
     return txHash;
   }
@@ -2346,14 +2547,18 @@ class PermissionsController {
    * A grantee is an entity (like an application) that can receive data permissions
    * from users. Once registered, users can grant the grantee access to their data.
    *
+   * This method supports gasless transactions via relayer when configured.
+   * If no relayer is available, it falls back to direct wallet transactions.
+   *
    * @param params - Parameters for registering the grantee
    * @param params.owner - The Ethereum address that will own this grantee registration
    * @param params.granteeAddress - The Ethereum address of the grantee (application)
    * @param params.publicKey - The public key used for data encryption/decryption (hex string)
+   * @param options - Optional transaction options for gas parameters and timeout
    * @returns Promise resolving to the transaction hash
    * @throws {BlockchainError} When the grantee registration transaction fails
    * @throws {UserRejectedRequestError} When user rejects the transaction
-   * @throws {ContractError} When grantee is already registered
+   * @throws {RelayerError} When gasless transaction submission fails
    *
    * @example
    * ```typescript
@@ -2365,98 +2570,88 @@ class PermissionsController {
    * console.log(`Grantee registered in transaction: ${txHash}`);
    * ```
    */
-  async submitRegisterGrantee(params) {
-    const chainId = await this.context.walletClient.getChainId();
-    const DataPortabilityGranteesAddress = (0, import_addresses.getContractAddress)(
-      chainId,
-      "DataPortabilityGrantees"
-    );
-    const DataPortabilityGranteesAbi = (0, import_abi.getAbi)("DataPortabilityGrantees");
-    const ownerAddress = (0, import_viem.getAddress)(params.owner);
-    const granteeAddress = (0, import_viem.getAddress)(params.granteeAddress);
-    const account = this.context.walletClient.account || await this.getUserAddress();
-    const txHash = await this.context.walletClient.writeContract({
-      address: DataPortabilityGranteesAddress,
-      abi: DataPortabilityGranteesAbi,
-      functionName: "registerGrantee",
-      args: [ownerAddress, granteeAddress, params.publicKey],
-      account,
-      chain: this.context.walletClient.chain || null
-    });
-    const { tx } = await import("../utils/transactionHelpers");
-    return tx({
-      hash: txHash,
-      from: typeof account === "string" ? account : account.address,
-      contract: "DataPortabilityGrantees",
-      fn: "registerGrantee"
-    });
-  }
-  /**
-   * Registers a grantee with a signature (gasless transaction)
-   *
-   * @param params - Parameters for registering the grantee
-   * @returns Promise resolving to the transaction hash
-   *
-   * @example
-   * ```typescript
-   * const txHash = await vana.permissions.registerGranteeWithSignature({
-   *   owner: "0x742d35Cc6558Fd4D9e9E0E888F0462ef6919Bd36",
-   *   granteeAddress: "0xApp1234567890123456789012345678901234567890",
-   *   publicKey: "0x1234567890abcdef..."
-   * });
-   * ```
-   */
-  async submitRegisterGranteeWithSignature(params) {
-    const nonce = await this.getServersUserNonce();
-    const owner = (0, import_viem.getAddress)(params.owner);
-    const granteeAddress = (0, import_viem.getAddress)(params.granteeAddress);
-    const registerGranteeInput = {
-      nonce,
-      owner,
-      granteeAddress,
-      publicKey: params.publicKey
-    };
-    const typedData = await this.buildRegisterGranteeTypedData(registerGranteeInput);
-    const signature = await this.signTypedData(typedData);
-    const hash = await this.submitSignedRegisterGranteeTransaction(
-      typedData,
-      signature
-    );
-    const account = this.context.walletClient.account || await this.getUserAddress();
-    const { tx } = await import("../utils/transactionHelpers");
-    return tx({
-      hash,
-      from: typeof account === "string" ? account : account.address,
-      contract: "DataPortabilityGrantees",
-      fn: "registerGrantee"
-    });
-  }
-  /**
-   * Submits a signed register grantee transaction via relayer
-   *
-   * @param typedData - The EIP-712 typed data for register grantee
-   * @param signature - The cryptographic signature
-   * @returns Promise resolving to the transaction hash
-   *
-   * @example
-   * ```typescript
-   * const result = await vana.permissions.submitSignedRegisterGrantee(typedData, signature);
-   * ```
-   */
-  async submitSignedRegisterGrantee(typedData, signature) {
-    const hash = await this.submitSignedRegisterGranteeTransaction(
-      typedData,
-      signature
-    );
-    const account = this.context.walletClient.account || await this.getUserAddress();
-    const { tx } = await import("../utils/transactionHelpers");
-    return tx({
-      hash,
-      from: typeof account === "string" ? account : account.address,
-      contract: "DataPortabilityGrantees",
-      fn: "registerGrantee"
-    });
+  async submitRegisterGrantee(params, options) {
+    try {
+      let hash;
+      if (this.context.relayer) {
+        const request = {
+          type: "direct",
+          operation: "submitRegisterGrantee",
+          params: {
+            owner: params.owner,
+            granteeAddress: params.granteeAddress,
+            publicKey: params.publicKey
+          }
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new import_errors.RelayerError(response.error);
+        }
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "direct") {
+          const result = response.result;
+          hash = result.transactionHash;
+        } else {
+          throw new Error("Unexpected response type from relayer");
+        }
+      } else {
+        this.assertWallet();
+        const chainId = await this.context.walletClient.getChainId();
+        const DataPortabilityGranteesAddress = (0, import_addresses.getContractAddress)(
+          chainId,
+          "DataPortabilityGrantees"
+        );
+        const DataPortabilityGranteesAbi = (0, import_abi.getAbi)("DataPortabilityGrantees");
+        const ownerAddress = (0, import_viem.getAddress)(params.owner);
+        const granteeAddress = (0, import_viem.getAddress)(params.granteeAddress);
+        const account2 = this.context.walletClient?.account ?? this.context.userAddress;
+        hash = await this.context.walletClient.writeContract({
+          address: DataPortabilityGranteesAddress,
+          abi: DataPortabilityGranteesAbi,
+          functionName: "registerGrantee",
+          args: [ownerAddress, granteeAddress, params.publicKey],
+          account: account2,
+          chain: this.context.walletClient?.chain ?? null,
+          ...this.spreadTransactionOptions(options)
+        });
+      }
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
+      const { tx } = await import("../utils/transactionHelpers");
+      return tx({
+        hash,
+        from: typeof account === "string" ? account : account.address,
+        contract: "DataPortabilityGrantees",
+        fn: "registerGrantee"
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error instanceof import_errors.RelayerError || error instanceof import_errors.UserRejectedRequestError || error instanceof import_errors.SerializationError || error instanceof import_errors.SignatureError || error instanceof import_errors.BlockchainError) {
+          throw error;
+        }
+        if (error.name === "ContractFunctionExecutionError") {
+          throw new import_errors.BlockchainError(
+            `Grantee registration failed: ${error.message}`,
+            error
+          );
+        }
+        if (error.name === "UserRejectedRequestError") {
+          throw new import_errors.UserRejectedRequestError(
+            "User rejected the grantee registration transaction"
+          );
+        }
+        throw new import_errors.BlockchainError(
+          `Failed to register grantee: ${error.message}`,
+          error
+        );
+      }
+      throw new import_errors.BlockchainError(`Failed to register grantee: ${String(error)}`);
+    }
   }
+  // TODO: When DataPortabilityGrantees contract adds registerGranteeWithSignature function,
+  // implement submitRegisterGranteeWithSignature and submitSignedRegisterGrantee methods
+  // to support EIP-712 signed gasless transactions via relayer.
+  // Current implementation above supports direct gasless transactions (relayer pays gas directly).
   /**
    * Retrieves all registered grantees from the DataPortabilityGrantees contract.
    *
@@ -2502,8 +2697,8 @@ class PermissionsController {
       functionName: "granteesCount"
     });
     const total = Number(totalCount);
-    const limit = options.limit || 50;
-    const offset = options.offset || 0;
+    const limit = options.limit ?? 50;
+    const offset = options.offset ?? 0;
     const grantees = [];
     const endIndex = Math.min(offset + limit, total);
     for (let i = offset; i < endIndex; i++) {
@@ -2643,67 +2838,6 @@ class PermissionsController {
       return null;
     }
   }
-  /**
-   * Builds EIP-712 typed data for grantee registration
-   *
-   * @param input - The register grantee input
-   * @returns Promise resolving to the typed data structure
-   * @private
-   */
-  async buildRegisterGranteeTypedData(input) {
-    const chainId = await this.context.walletClient.getChainId();
-    const verifyingContract = (0, import_addresses.getContractAddress)(
-      chainId,
-      "DataPortabilityGrantees"
-    );
-    return {
-      domain: {
-        name: "DataPortabilityGrantees",
-        version: "1",
-        chainId,
-        verifyingContract
-      },
-      types: {
-        RegisterGrantee: [
-          { name: "nonce", type: "uint256" },
-          { name: "owner", type: "address" },
-          { name: "granteeAddress", type: "address" },
-          { name: "publicKey", type: "string" }
-        ]
-      },
-      primaryType: "RegisterGrantee",
-      message: input
-    };
-  }
-  /**
-   * Submits a register grantee transaction with signature.
-   *
-   * @param typedData - The EIP-712 typed data structure for the registration
-   * @param _signature - The cryptographic signature authorizing the registration (currently unused)
-   * @returns Promise resolving to the transaction hash
-   * @private
-   */
-  async submitSignedRegisterGranteeTransaction(typedData, _signature) {
-    const chainId = await this.context.walletClient.getChainId();
-    const DataPortabilityGranteesAddress = (0, import_addresses.getContractAddress)(
-      chainId,
-      "DataPortabilityGrantees"
-    );
-    const DataPortabilityGranteesAbi = (0, import_abi.getAbi)("DataPortabilityGrantees");
-    const txHash = await this.context.walletClient.writeContract({
-      address: DataPortabilityGranteesAddress,
-      abi: DataPortabilityGranteesAbi,
-      functionName: "registerGrantee",
-      args: [
-        typedData.message.owner,
-        typedData.message.granteeAddress,
-        typedData.message.publicKey
-      ],
-      account: this.context.walletClient.account || await this.getUserAddress(),
-      chain: this.context.walletClient.chain || null
-    });
-    return txHash;
-  }
   // ===========================
   // DATA PORTABILITY SERVERS HELPER METHODS
   // ===========================
@@ -2715,7 +2849,7 @@ class PermissionsController {
    */
   async getUserServerIds(userAddress) {
     try {
-      const targetAddress = userAddress || await this.getUserAddress();
+      const targetAddress = userAddress ?? this.context.userAddress;
       const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
@@ -2773,7 +2907,7 @@ class PermissionsController {
    */
   async getUserServerCount(userAddress) {
     try {
-      const targetAddress = userAddress || await this.getUserAddress();
+      const targetAddress = userAddress ?? this.context.userAddress;
       const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
@@ -2802,7 +2936,7 @@ class PermissionsController {
    */
   async getUserTrustedServers(userAddress) {
     try {
-      const targetAddress = userAddress || await this.getUserAddress();
+      const targetAddress = userAddress ?? this.context.userAddress;
       const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
         chainId,
@@ -2919,7 +3053,7 @@ class PermissionsController {
    */
   async getUserPermissionIds(userAddress) {
     try {
-      const targetAddress = userAddress || await this.getUserAddress();
+      const targetAddress = userAddress ?? this.context.userAddress;
       const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
         chainId,
@@ -2981,7 +3115,7 @@ class PermissionsController {
    */
   async getUserPermissionCount(userAddress) {
     try {
-      const targetAddress = userAddress || await this.getUserAddress();
+      const targetAddress = userAddress ?? this.context.userAddress;
       const chainId = await this.context.publicClient.getChainId();
       const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
         chainId,
@@ -3423,9 +3557,11 @@ class PermissionsController {
    *
    * @param serverId - Server ID to update
    * @param url - New URL for the server
+   * @param options - Optional transaction options for gas parameters and timeout
    * @returns Promise resolving to transaction hash
    */
-  async submitUpdateServer(serverId, url) {
+  async submitUpdateServer(serverId, url, options) {
+    this.assertWallet();
     try {
       const chainId = await this.context.walletClient.getChainId();
       const DataPortabilityServersAddress = (0, import_addresses.getContractAddress)(
@@ -3433,14 +3569,25 @@ class PermissionsController {
         "DataPortabilityServers"
       );
       const DataPortabilityServersAbi = (0, import_abi.getAbi)("DataPortabilityServers");
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const hash = await this.context.walletClient.writeContract({
         address: DataPortabilityServersAddress,
         abi: DataPortabilityServersAbi,
         functionName: "updateServer",
         args: [serverId, url],
-        chain: this.context.walletClient.chain,
-        account
+        chain: this.context.walletClient?.chain,
+        account,
+        ...options?.gas && { gas: options.gas },
+        ...options?.nonce && { nonce: options.nonce },
+        // Use EIP-1559 if available, otherwise fall back to legacy gasPrice
+        ...options?.maxFeePerGas || options?.maxPriorityFeePerGas ? {
+          ...options.maxFeePerGas && {
+            maxFeePerGas: options.maxFeePerGas
+          },
+          ...options.maxPriorityFeePerGas && {
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+          }
+        } : options?.gasPrice && { gasPrice: options.gasPrice }
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -3598,6 +3745,7 @@ class PermissionsController {
    * @throws {NetworkError} When network communication fails
    */
   async submitAddPermission(params) {
+    this.assertWallet();
     try {
       const nonce = await this.getPermissionsUserNonce();
       const addPermissionInput = {
@@ -3635,21 +3783,36 @@ class PermissionsController {
    * @throws {BlockchainError} When permission addition fails
    * @throws {NetworkError} When network communication fails
    */
-  async submitSignedAddPermission(typedData, signature) {
+  async submitSignedAddPermission(typedData, signature, options) {
+    this.assertWallet();
     try {
       let hash;
-      if (this.context.relayerCallbacks?.submitAddPermission) {
-        hash = await this.context.relayerCallbacks.submitAddPermission(
+      if (this.context.relayer) {
+        const request = {
+          type: "signed",
+          operation: "submitAddPermission",
           typedData,
           signature
-        );
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new import_errors.RelayerError(response.error);
+        }
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else {
+          throw new Error("Unexpected response type from relayer");
+        }
       } else {
         hash = await this.submitDirectAddPermissionTransaction(
           typedData,
-          signature
+          signature,
+          options
         );
       }
-      const account = this.context.walletClient.account || await this.getUserAddress();
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
         hash,
@@ -3685,8 +3848,11 @@ class PermissionsController {
    * @param params.serverAddress - Server wallet address for decryption permissions
    * @param params.serverUrl - Server endpoint URL
    * @param params.serverPublicKey - Server's public key for encryption.
-   *   Obtain via `vana.server.getIdentity(userAddress).public_key`.
+   *   Obtain via `vana.server.getIdentity(userAddress).publicKey`.
    * @param params.filePermissions - Nested array of permissions for each file
+   * @param options - Optional transaction options for gas parameters and timeout.
+   *   Note: These options are only applied for direct blockchain transactions.
+   *   When using relayer callbacks (gasless transactions), these options are ignored.
    * @returns TransactionResult with immediate hash access and optional event data
    * @throws {Error} When schemaIds array length doesn't match fileUrls array length
    * @throws {SchemaValidationError} When file data doesn't match the specified schema.
@@ -3700,6 +3866,7 @@ class PermissionsController {
    *
    * @example
    * ```typescript
+   * // Submit with custom gas parameters and timeout
    * const result = await vana.permissions.submitAddServerFilesAndPermissions({
    *   granteeId: BigInt(1),
    *   grant: "ipfs://QmXxx...",
@@ -3707,17 +3874,25 @@ class PermissionsController {
    *   schemaIds: [123], // LinkedIn profile schema ID
    *   serverAddress: "0x742d35Cc6634C0532925a3b844Bc9e7595f0b0Bb",
    *   serverUrl: "https://server.example.com",
-   *   serverPublicKey: serverInfo.public_key,
+   *   serverPublicKey: serverInfo.publicKey,
    *   filePermissions: [[{
    *     account: "0x742d35Cc6634C0532925a3b844Bc9e7595f0b0Bb",
    *     key: encryptedKey
    *   }]]
+   * }, {
+   *   maxFeePerGas: 100n * 10n ** 9n, // 100 gwei
+   *   maxPriorityFeePerGas: 2n * 10n ** 9n, // 2 gwei tip
    * });
-   * const events = await result.waitForEvents();
-   * console.log(`Permission ID: ${events.permissionId}`);
+   *
+   * // Wait for confirmation with custom timeout
+   * const receipt = await vana.waitForTransactionReceipt(result, {
+   *   timeout: 180000 // 3 minutes
+   * });
+   * console.log(`Transaction confirmed: ${receipt.transactionHash}`);
    * ```
    */
-  async submitAddServerFilesAndPermissions(params) {
+  async submitAddServerFilesAndPermissions(params, options) {
+    this.assertWallet();
     try {
       if (params.schemaIds.length !== params.fileUrls.length) {
         throw new Error(
@@ -3742,7 +3917,8 @@ class PermissionsController {
       const signature = await this.signTypedData(typedData);
       return await this.submitSignedAddServerFilesAndPermissions(
         typedData,
-        signature
+        signature,
+        options
       );
     } catch (error) {
       if (error instanceof import_errors.RelayerError || error instanceof import_errors.UserRejectedRequestError || error instanceof import_errors.SerializationError || error instanceof import_errors.SignatureError || error instanceof import_errors.NetworkError || error instanceof import_errors.NonceError) {
@@ -3763,6 +3939,9 @@ class PermissionsController {
    *
    * @param typedData - The EIP-712 typed data for AddServerFilesAndPermissions
    * @param signature - The user's signature
+   * @param options - Optional transaction options for gas parameters and timeout.
+   *   Note: These options are only applied for direct blockchain transactions.
+   *   When using relayer callbacks (gasless transactions), these options are ignored.
    * @returns TransactionResult with immediate hash access and optional event data
    * @throws {RelayerError} When gasless transaction submission fails
    * @throws {BlockchainError} When server files and permissions addition fails
@@ -3781,46 +3960,49 @@ class PermissionsController {
    * console.log(`Permission created with ID: ${permissionId}`);
    * ```
    */
-  async submitSignedAddServerFilesAndPermissions(typedData, signature) {
+  async submitSignedAddServerFilesAndPermissions(typedData, signature, options) {
+    this.assertWallet();
     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) {
+      let hash;
+      if (this.context.relayer) {
         console.debug(
           "\u{1F680} Using relayer for submitAddServerFilesAndPermissions"
         );
-        const hash = await this.context.relayerCallbacks.submitAddServerFilesAndPermissions(
+        const request = {
+          type: "signed",
+          operation: "submitAddServerFilesAndPermissions",
           typedData,
           signature
-        );
-        const account = this.context.walletClient.account || await this.getUserAddress();
-        const { tx } = await import("../utils/transactionHelpers");
-        return tx({
-          hash,
-          from: typeof account === "string" ? account : account.address,
-          contract: "DataPortabilityPermissions",
-          fn: "addServerFilesAndPermissions"
-        });
+        };
+        const response = await this.context.relayer(request);
+        if (response.type === "error") {
+          throw new import_errors.RelayerError(response.error);
+        }
+        if (response.type === "submitted") {
+          hash = response.hash;
+        } else if (response.type === "signed") {
+          hash = response.hash;
+        } else {
+          throw new Error("Unexpected response type from relayer");
+        }
       } else {
         console.debug(
           "\u{1F4DD} Using direct transaction for submitAddServerFilesAndPermissions"
         );
-        const hash = await this.submitDirectAddServerFilesAndPermissionsTransaction(
+        hash = await this.submitDirectAddServerFilesAndPermissionsTransaction(
           typedData,
-          signature
+          signature,
+          options
         );
-        const account = this.context.walletClient.account || await this.getUserAddress();
-        const { tx } = await import("../utils/transactionHelpers");
-        return tx({
-          hash,
-          from: typeof account === "string" ? account : account.address,
-          contract: "DataPortabilityPermissions",
-          fn: "addServerFilesAndPermissions"
-        });
       }
+      const account = this.context.walletClient?.account ?? this.context.userAddress;
+      const { tx } = await import("../utils/transactionHelpers");
+      return tx({
+        hash,
+        from: typeof account === "string" ? account : account.address,
+        contract: "DataPortabilityPermissions",
+        fn: "addServerFilesAndPermissions"
+      });
     } catch (error) {
       if (error instanceof import_errors.RelayerError || error instanceof import_errors.NetworkError || error instanceof import_errors.UserRejectedRequestError || error instanceof import_errors.SignatureError || error instanceof import_errors.NonceError) {
         throw error;
@@ -3835,9 +4017,11 @@ class PermissionsController {
    * Submit permission revocation with signature to the blockchain
    *
    * @param permissionId - Permission ID to revoke
+   * @param options - Optional transaction options for gas parameters and timeout
    * @returns Promise resolving to transaction hash
    */
-  async submitRevokePermission(permissionId) {
+  async submitRevokePermission(permissionId, options) {
+    this.assertWallet();
     try {
       const chainId = await this.context.walletClient.getChainId();
       const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
@@ -3847,7 +4031,7 @@ class PermissionsController {
       const DataPortabilityPermissionsAbi = (0, import_abi.getAbi)(
         "DataPortabilityPermissions"
       );
-      const account = this.context.walletClient.account;
+      const { account } = this.context.walletClient;
       if (!account) {
         throw new Error("No wallet account connected");
       }
@@ -3856,8 +4040,19 @@ class PermissionsController {
         abi: DataPortabilityPermissionsAbi,
         functionName: "revokePermission",
         args: [permissionId],
-        chain: this.context.walletClient.chain,
-        account
+        chain: this.context.walletClient?.chain,
+        account,
+        ...options?.gas && { gas: options.gas },
+        ...options?.nonce && { nonce: options.nonce },
+        // Use EIP-1559 if available, otherwise fall back to legacy gasPrice
+        ...options?.maxFeePerGas || options?.maxPriorityFeePerGas ? {
+          ...options.maxFeePerGas && {
+            maxFeePerGas: options.maxFeePerGas
+          },
+          ...options.maxPriorityFeePerGas && {
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+          }
+        } : options?.gasPrice && { gasPrice: options.gasPrice }
       });
       const { tx } = await import("../utils/transactionHelpers");
       return tx({
@@ -3880,7 +4075,8 @@ class PermissionsController {
    * @param signature - The cryptographic signature authorizing the transaction
    * @returns Promise resolving to the transaction hash
    */
-  async submitDirectAddPermissionTransaction(typedData, signature) {
+  async submitDirectAddPermissionTransaction(typedData, signature, options) {
+    this.assertWallet();
     const chainId = await this.context.walletClient.getChainId();
     const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
       chainId,
@@ -3891,7 +4087,7 @@ class PermissionsController {
       nonce: typedData.message.nonce,
       granteeId: typedData.message.granteeId,
       grant: typedData.message.grant,
-      fileIds: typedData.message.fileIds || []
+      fileIds: typedData.message.fileIds ?? []
     };
     const formattedSignature = (0, import_signatureFormatter.formatSignatureForContract)(signature);
     const hash = await this.context.walletClient.writeContract({
@@ -3899,8 +4095,9 @@ class PermissionsController {
       abi: DataPortabilityPermissionsAbi,
       functionName: "addPermission",
       args: [permissionInput, formattedSignature],
-      account: this.context.walletClient.account || await this.getUserAddress(),
-      chain: this.context.walletClient.chain || null
+      account: this.context.walletClient?.account ?? this.context.userAddress,
+      chain: this.context.walletClient?.chain ?? null,
+      ...this.spreadTransactionOptions(options)
     });
     return hash;
   }
@@ -3911,8 +4108,9 @@ class PermissionsController {
    * @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();
+  async submitDirectAddServerFilesAndPermissionsTransaction(typedData, signature, options) {
+    this.assertWallet();
+    const chainId = await this.context.publicClient.getChainId();
     const DataPortabilityPermissionsAddress = (0, import_addresses.getContractAddress)(
       chainId,
       "DataPortabilityPermissions"
@@ -3934,10 +4132,11 @@ class PermissionsController {
       address: DataPortabilityPermissionsAddress,
       abi: DataPortabilityPermissionsAbi,
       functionName: "addServerFilesAndPermissions",
-      // @ts-expect-error - Viem's type inference for nested Permission[][] arrays is incompatible with our Permission type
       args: [serverFilesAndPermissionInput, formattedSignature],
-      account: this.context.walletClient.account || await this.getUserAddress(),
-      chain: this.context.walletClient.chain || null
+      account: this.context.walletClient?.account ?? this.context.userAddress,
+      chain: this.context.walletClient?.chain ?? null,
+      ...options?.value && { value: options.value },
+      ...this.spreadTransactionOptions(options)
     });
     return hash;
   }