@agirails/sdk 2.3.0 → 2.3.3

package/src/protocol/ACTPKernel.ts

@@ -37,14 +37,25 @@ interface GasOptions {
 export class ACTPKernel {
   private contract: Contract;
   private readonly gasSettings?: GasOptions;
+  /**
+   * Number of block confirmations to wait after each state-changing tx.
+   * Default: 2 (Base L2 reorg safety — ~4-6 s on Base's 2 s blocks).
+   * Set to 1 for faster feedback on testnet; never set to 0 in production.
+   */
+  private readonly confirmations: number;
 
   constructor(
     private readonly address: string,
     signer: Signer,
-    gasSettings?: GasOptions
+    gasSettings?: GasOptions,
+    confirmations: number = 2
   ) {
+    if (confirmations < 1) {
+      throw new Error(`confirmations must be >= 1, got ${confirmations}`);
+    }
     this.contract = new Contract(address, ACTPKernelABI, signer);
     this.gasSettings = gasSettings;
+    this.confirmations = confirmations;
   }
 
   /**
@@ -213,7 +224,7 @@ export class ACTPKernel {
         txOptions
       );
 
-      const receipt = await tx.wait(2); // Wait for 2 confirmations (Base L2 reorg safety)
+      const receipt = await tx.wait(this.confirmations);
       if (!receipt) {
         throw new Error('Transaction receipt not available');
       }
@@ -280,7 +291,7 @@ export class ACTPKernel {
 
       const tx = await transitionFunc(txId, newState, proof, txOptions);
 
-      await tx.wait(2); // Wait for 2 confirmations (Base L2 reorg safety)
+      await tx.wait(this.confirmations);
     } catch (error: any) {
       throw new TransactionRevertedError(error.transactionHash, error.reason || error.message);
     }
@@ -400,8 +411,7 @@ export class ACTPKernel {
 
       const tx = await linkEscrowFunc(txId, escrowContract, escrowId, txOptions);
 
-      // Wait for 2 confirmations to ensure state is updated on RPC nodes (Base Sepolia reorg safety)
-      await tx.wait(2);
+      await tx.wait(this.confirmations);
     } catch (error: any) {
       throw new TransactionRevertedError(error.transactionHash, error.reason || error.message);
     }
@@ -437,7 +447,7 @@ export class ACTPKernel {
 
       const tx = await releaseMilestoneFunc(txId, amount, txOptions);
 
-      await tx.wait(2); // Wait for 2 confirmations (Base L2 reorg safety)
+      await tx.wait(this.confirmations);
     } catch (error: any) {
       throw new TransactionRevertedError(error.transactionHash, error.reason || error.message);
     }
@@ -521,7 +531,7 @@ export class ACTPKernel {
 
       const tx = await releaseEscrowFunc(txId, txOptions);
 
-      await tx.wait(2); // Wait for 2 confirmations (Base L2 reorg safety)
+      await tx.wait(this.confirmations);
     } catch (error: any) {
       throw new TransactionRevertedError(error.transactionHash, error.reason || error.message);
     }
@@ -669,7 +679,7 @@ export class ACTPKernel {
         txOptions
       );
 
-      await tx.wait(2); // Wait for 2 confirmations (Base L2 reorg safety)
+      await tx.wait(this.confirmations);
     } catch (error: any) {
       throw new TransactionRevertedError(error.transactionHash, error.reason || error.message);
     }
@@ -735,7 +745,7 @@ export class ACTPKernel {
         txOptions
       );
 
-      await tx.wait(2); // Wait for 2 confirmations (Base L2 reorg safety)
+      await tx.wait(this.confirmations);
     } catch (error: any) {
       throw new TransactionRevertedError(error.transactionHash, error.reason || error.message);
     }
@@ -789,7 +799,7 @@ export class ACTPKernel {
         txOptions
       );
 
-      await tx.wait(2); // Wait for 2 confirmations (Base L2 reorg safety)
+      await tx.wait(this.confirmations);
     } catch (error: any) {
       throw new TransactionRevertedError(error.transactionHash, error.reason || error.message);
     }

package/src/protocol/EventMonitor.ts

@@ -4,6 +4,20 @@ import { State, Transaction } from '../types';
 /**
  * EventMonitor - Listen to blockchain events
  *
+ * ## Confirmation Policy
+ *
+ * Events received by EventMonitor are already confirmed. ACTPKernel waits
+ * for N block confirmations (default 2, configurable via `confirmations`
+ * parameter in BlockchainRuntimeConfig) before returning from state-changing
+ * operations. On Base L2 (~2 s blocks), the default means events arrive
+ * ~4-6 s after submission and are safe from reorgs.
+ *
+ * Confirmation flow:
+ *   User calls ACTPKernel.createTransaction()
+ *     → tx.wait(confirmations) blocks until N confirmations
+ *     → Event emitted (already confirmed)
+ *     → EventMonitor receives event (instant)
+ *
  * SECURITY FIX (EVENT-MONITOR): Corrected event parameter order to match ABI.
  * Per ACTPKernel.json, TransactionCreated signature is:
  *   (bytes32 indexed transactionId, address indexed requester, address indexed provider, uint256 amount, bytes32 serviceHash)

package/src/runtime/BlockchainRuntime.ts

@@ -65,6 +65,11 @@ export interface BlockchainRuntimeConfig {
    * If provided, attestation replay protection will survive restarts
    */
   stateDirectory?: string;
+  /**
+   * Number of block confirmations to wait after each state-changing tx.
+   * Default: 2 (Base L2 reorg safety). Set to 1 on testnet for speed.
+   */
+  confirmations?: number;
 }
 
 /**
@@ -163,7 +168,8 @@ export class BlockchainRuntime implements IACTPRuntime {
     this.kernel = new ACTPKernel(
       this.networkConfig.contracts.actpKernel,
       this.signer,
-      config.gasSettings
+      config.gasSettings,
+      config.confirmations
     );
 
     this.escrow = new EscrowVault(

package/src/storage/ArchiveBundleBuilder.ts

@@ -15,14 +15,12 @@ import { ValidationError } from '../errors';
 import {
   ArchiveBundle,
   ArchiveChainId,
-  ArchiveFinalState,
   ArchiveParticipants,
   ArchiveReferences,
   ArchiveHashes,
   ArchiveSignatures,
   ArchiveAttestation,
   ArchiveSettlement,
-  EscrowRelease,
   ARCHIVE_BUNDLE_TYPE
 } from './types';
 

package/src/storage/ArweaveClient.ts

@@ -48,7 +48,6 @@ import {
 import { withRetry, RetryOptions } from '../utils/retry';
 import {
   GatewayCircuitBreaker,
-  CircuitBreakerConfig
 } from '../utils/circuitBreaker';
 
 // ============================================================================
@@ -538,6 +537,7 @@ export class ArweaveClient {
           const chunks: Uint8Array[] = [];
           let totalSize = 0;
 
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             const { done, value } = await reader.read();
             if (done) break;
@@ -671,6 +671,7 @@ export class ArweaveClient {
           const chunks: Uint8Array[] = [];
           let totalSize = 0;
 
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             const { done, value } = await reader.read();
             if (done) break;

package/src/storage/FilebaseClient.ts

@@ -14,7 +14,7 @@
  * @module storage/FilebaseClient
  */
 
-import { S3Client, PutObjectCommand, GetObjectCommand, HeadObjectCommand } from '@aws-sdk/client-s3';
+import { S3Client, PutObjectCommand, HeadObjectCommand } from '@aws-sdk/client-s3';
 import {
   StorageError,
   StorageAuthenticationError,
@@ -39,8 +39,6 @@ import {
 import { withRetry, RetryOptions } from '../utils/retry';
 import {
   GatewayCircuitBreaker,
-  CircuitBreakerConfig,
-  globalCircuitBreaker
 } from '../utils/circuitBreaker';
 
 // ============================================================================
@@ -329,6 +327,7 @@ export class FilebaseClient {
           const chunks: Uint8Array[] = [];
           let totalSize = 0;
 
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             const { done, value } = await reader.read();
             if (done) break;
@@ -516,6 +515,7 @@ export class FilebaseClient {
           const chunks: Uint8Array[] = [];
           let totalSize = 0;
 
+          // eslint-disable-next-line no-constant-condition
           while (true) {
             const { done, value } = await reader.read();
             if (done) break;

package/src/utils/ErrorRecoveryGuide.ts

@@ -7,6 +7,8 @@
  * @module utils/ErrorRecoveryGuide
  */
 
+import { sdkLogger } from './Logger';
+
 /**
  * Error severity levels for prioritization
  */
@@ -650,14 +652,14 @@ export async function withRecoveryGuidance<T>(
       }
 
       if (logGuidance) {
-        console.error(ErrorRecoveryGuide.formatGuidance(error));
+        sdkLogger.error(ErrorRecoveryGuide.formatGuidance(error));
       }
 
       if (autoRetry && recovery.retryable) {
         const retryParams = ErrorRecoveryGuide.getRetryParams(error);
         if (retryParams && attempts < retryParams.maxRetries) {
           attempts++;
-          console.log(
+          sdkLogger.info(
             `Retrying (${attempts}/${retryParams.maxRetries}) after ${retryParams.delayMs}ms...`
           );
           await new Promise((resolve) =>

package/src/utils/IPFSClient.ts

@@ -74,8 +74,8 @@ export interface IPFSClientConfig {
   allowedProtocols?: string[];
 
   /**
-   * SECURITY FIX (MEDIUM-3): Allow localhost URLs
-   * Default: true (required for local IPFS daemon)
+   * Allow localhost URLs (e.g., local IPFS daemon).
+   * Default: false (SSRF protection). Set to true explicitly for local development.
    */
   allowLocalhost?: boolean;
 }
@@ -85,7 +85,8 @@ export interface IPFSClientConfig {
  */
 export const IPFS_CONFIGS = {
   local: {
-    url: 'http://localhost:5001'
+    url: 'http://localhost:5001',
+    allowLocalhost: true, // Explicit opt-in for local development
   },
   infura: {
     url: 'https://ipfs.infura.io:5001/api/v0'
@@ -128,14 +129,14 @@ export class IPFSHTTPClientImpl implements IPFSClient {
     const url = config.url || 'http://localhost:5001';
 
     // SECURITY FIX (MEDIUM-3): Validate URL
-    this.validateUrl(url, config.allowLocalhost ?? true, config.allowedProtocols);
+    this.validateUrl(url, config.allowLocalhost ?? false, config.allowedProtocols);
 
     this.config = {
       url,
       timeout: config.timeout || 60000,
       maxSize: config.maxSize || IPFSHTTPClientImpl.DEFAULT_MAX_SIZE,
       allowedProtocols: config.allowedProtocols || IPFSHTTPClientImpl.DEFAULT_ALLOWED_PROTOCOLS,
-      allowLocalhost: config.allowLocalhost ?? true,
+      allowLocalhost: config.allowLocalhost ?? false,
       auth: config.auth,
       headers: config.headers,
     } as Required<IPFSClientConfig>;
@@ -359,8 +360,9 @@ export function createIPFSClient(): IPFSClient {
     });
   }
 
-  // Default to local IPFS daemon
+  // Default to local IPFS daemon (explicit localhost opt-in)
   return new IPFSHTTPClientImpl({
-    url: 'http://localhost:5001'
+    url: 'http://localhost:5001',
+    allowLocalhost: true,
   });
 }

package/src/utils/computeTypeHash.ts

@@ -44,7 +44,5 @@ if (require.main === module) {
   console.log(typeHash);
   console.log();
 
-  console.log('✅ Update this value in:');
-  console.log('- /Testnet/docs/AIP-4.md:204');
-  console.log('- /Testnet/docs/schemas/aip-4-delivery.eip712.json:11');
+  console.log('Use this type hash in your EIP-712 typed data configuration.');
 }

package/src/utils/retry.ts

@@ -236,7 +236,6 @@ export async function withRetry<T>(
   } = options;
 
   let lastError: unknown;
-  const startTime = Date.now();
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {

package/src/utils/validation.ts

@@ -320,7 +320,7 @@ export async function validateEndpointURL(endpoint: string, fieldName: string =
  * @param fieldName - Field name for error messages
  * @throws {InvalidCIDError} If CID is invalid
  */
-export function validateCID(cid: string, fieldName: string = 'cid'): void {
+export function validateCID(cid: string, _fieldName: string = 'cid'): void {
   if (!cid || typeof cid !== 'string') {
     throw new InvalidCIDError(String(cid), 'CID is required');
   }
@@ -337,7 +337,7 @@ export function validateCID(cid: string, fieldName: string = 'cid'): void {
  * @param fieldName - Field name for error messages
  * @throws {InvalidArweaveTxIdError} If TX ID is invalid
  */
-export function validateArweaveTxId(txId: string, fieldName: string = 'txId'): void {
+export function validateArweaveTxId(txId: string, _fieldName: string = 'txId'): void {
   if (!txId || typeof txId !== 'string') {
     throw new InvalidArweaveTxIdError(String(txId), 'TX ID is required');
   }

package/src/wallet/AutoWalletProvider.ts

@@ -0,0 +1,294 @@
+/**
+ * AutoWalletProvider — Tier 1 (Auto) wallet implementation.
+ *
+ * Creates a CoinbaseSmartWallet with gas-sponsored transactions:
+ *   1. Load/generate local encrypted key
+ *   2. Derive Smart Wallet address (counterfactual CREATE2)
+ *   3. Check AgentRegistry registration
+ *   4. Build UserOp with executeBatch
+ *   5. Get paymaster sponsorship (Coinbase → Pimlico fallback)
+ *   6. Submit via bundler
+ *
+ * If agent is NOT registered, falls back to EOA behavior with a warning.
+ *
+ * @module wallet/AutoWalletProvider
+ */
+
+import { ethers } from 'ethers';
+import {
+  IWalletProvider,
+  TransactionRequest,
+  TransactionReceipt,
+  WalletInfo,
+  BatchedPayParams,
+  BatchedPayResult,
+} from './IWalletProvider';
+import { computeSmartWalletAddress } from './aa/UserOpBuilder';
+import {
+  buildUserOp,
+  signUserOp,
+} from './aa/UserOpBuilder';
+import { SmartWalletCall } from './aa/constants';
+import { BundlerClient } from './aa/BundlerClient';
+import { PaymasterClient } from './aa/PaymasterClient';
+import { DualNonceManager } from './aa/DualNonceManager';
+import { buildACTPPayBatch } from './aa/TransactionBatcher';
+import { sdkLogger } from '../utils/Logger';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface AutoWalletConfig {
+  /** Ethers signer (the EOA that owns the Smart Wallet) */
+  signer: ethers.Wallet;
+  /** Ethers provider */
+  provider: ethers.JsonRpcProvider;
+  /** Chain ID */
+  chainId: number;
+  /** ACTPKernel contract address (for ACTP nonce reads) */
+  actpKernelAddress: string;
+  /** Bundler configuration */
+  bundler: {
+    primaryUrl: string;
+    backupUrl?: string;
+  };
+  /** Paymaster configuration */
+  paymaster: {
+    primaryUrl: string;
+    backupUrl?: string;
+  };
+}
+
+// ============================================================================
+// AutoWalletProvider
+// ============================================================================
+
+export class AutoWalletProvider implements IWalletProvider {
+  private readonly signer: ethers.Wallet;
+  private readonly provider: ethers.JsonRpcProvider;
+  private readonly chainId: number;
+  private readonly bundler: BundlerClient;
+  private readonly paymaster: PaymasterClient;
+  private readonly nonceManager: DualNonceManager;
+  private smartWalletAddress: string = '';
+  private isDeployed: boolean = false;
+
+  private constructor(
+    config: AutoWalletConfig,
+    smartWalletAddress: string,
+    isDeployed: boolean
+  ) {
+    this.signer = config.signer;
+    this.provider = config.provider;
+    this.chainId = config.chainId;
+    this.smartWalletAddress = smartWalletAddress;
+    this.isDeployed = isDeployed;
+
+    this.bundler = new BundlerClient({
+      primaryUrl: config.bundler.primaryUrl,
+      backupUrl: config.bundler.backupUrl,
+    });
+
+    this.paymaster = new PaymasterClient({
+      primaryUrl: config.paymaster.primaryUrl,
+      backupUrl: config.paymaster.backupUrl,
+      chainId: config.chainId,
+    });
+
+    this.nonceManager = new DualNonceManager(
+      config.provider,
+      smartWalletAddress,
+      config.actpKernelAddress
+    );
+  }
+
+  /**
+   * Factory method — computes counterfactual address and checks deployment.
+   */
+  static async create(config: AutoWalletConfig): Promise<AutoWalletProvider> {
+    const signerAddress = config.signer.address;
+    const smartWalletAddress = await computeSmartWalletAddress(
+      signerAddress,
+      config.provider
+    );
+
+    // Check if wallet is already deployed
+    const code = await config.provider.getCode(smartWalletAddress);
+    const isDeployed = code !== '0x';
+
+    sdkLogger.info('AutoWalletProvider initialized', {
+      signer: signerAddress,
+      smartWallet: smartWalletAddress,
+      deployed: isDeployed,
+    });
+
+    return new AutoWalletProvider(config, smartWalletAddress, isDeployed);
+  }
+
+  getAddress(): string {
+    return this.smartWalletAddress;
+  }
+
+  async sendTransaction(tx: TransactionRequest): Promise<TransactionReceipt> {
+    return this.sendBatchTransaction([tx]);
+  }
+
+  async sendBatchTransaction(
+    txs: TransactionRequest[]
+  ): Promise<TransactionReceipt> {
+    if (txs.length === 0) {
+      throw new Error('sendBatchTransaction requires at least one transaction');
+    }
+
+    // Convert to SmartWalletCall[]
+    const calls: SmartWalletCall[] = txs.map((tx) => ({
+      target: tx.to,
+      value: tx.value ? BigInt(tx.value) : 0n,
+      data: tx.data,
+    }));
+
+    // Use nonce manager for sequential ordering
+    // Note: We don't know if this specific batch increments ACTP nonce
+    // (that's handled at the ACTPClient level), so pass false here.
+    // The caller (ACTPClient.payBatched) manages ACTP nonce tracking.
+    return this.nonceManager.enqueue(
+      async ({ entryPointNonce }) => {
+        const receipt = await this.submitUserOp(calls, entryPointNonce);
+        return { result: receipt, success: receipt.success };
+      },
+      false // ACTP nonce management is done at ACTPClient level
+    );
+  }
+
+  getWalletInfo(): WalletInfo {
+    return {
+      address: this.smartWalletAddress,
+      tier: 'auto',
+      supportsBatching: true,
+      gasSponsored: true,
+      chainId: this.chainId,
+    };
+  }
+
+  /**
+   * Get the DualNonceManager (for ACTPClient to use for ACTP-aware batching).
+   */
+  getNonceManager(): DualNonceManager {
+    return this.nonceManager;
+  }
+
+  /**
+   * Check if the Smart Wallet is deployed on-chain.
+   */
+  getIsDeployed(): boolean {
+    return this.isDeployed;
+  }
+
+  /**
+   * Execute a batched ACTP payment atomically.
+   *
+   * Builds approve + createTransaction + linkEscrow as a single UserOp.
+   * Manages ACTP nonce inside the mutex queue for concurrent safety.
+   */
+  async payACTPBatched(params: BatchedPayParams): Promise<BatchedPayResult> {
+    return this.nonceManager.enqueue(
+      async ({ entryPointNonce, actpNonce }) => {
+        const batch = buildACTPPayBatch({
+          ...params,
+          actpNonce,
+        });
+
+        const receipt = await this.submitUserOp(batch.calls, entryPointNonce);
+
+        return {
+          result: {
+            txId: batch.txId,
+            hash: receipt.hash,
+            success: receipt.success,
+          },
+          success: receipt.success,
+        };
+      },
+      true // Increment ACTP nonce on success
+    );
+  }
+
+  // ==========================================================================
+  // Internal
+  // ==========================================================================
+
+  /**
+   * Build, sponsor, sign, and submit a UserOp.
+   */
+  private async submitUserOp(
+    calls: SmartWalletCall[],
+    entryPointNonce: bigint
+  ): Promise<TransactionReceipt> {
+    const signerAddress = this.signer.address;
+
+    // 1. Build unsigned UserOp
+    const userOp = buildUserOp({
+      sender: this.smartWalletAddress,
+      nonce: entryPointNonce,
+      calls,
+      isFirstDeploy: !this.isDeployed,
+      signerAddress,
+    });
+
+    // 2. Get fee data
+    const feeData = await this.provider.getFeeData();
+    userOp.maxFeePerGas = feeData.maxFeePerGas ?? 2_000_000_000n;
+    userOp.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas ?? 1_000_000_000n;
+
+    // 3. Get stub paymaster data (for gas estimation)
+    const stubData = await this.paymaster.getPaymasterStubData(userOp);
+    userOp.paymasterAndData = stubData.paymasterAndData;
+
+    // 4. Dummy signature for gas estimation
+    userOp.signature = dummySignature();
+
+    // 5. Estimate gas
+    const gasEstimate = await this.bundler.estimateUserOperationGas(userOp);
+    userOp.callGasLimit = gasEstimate.callGasLimit;
+    userOp.verificationGasLimit = gasEstimate.verificationGasLimit;
+    userOp.preVerificationGas = gasEstimate.preVerificationGas;
+
+    // 6. Get final paymaster data (with real gas values)
+    const finalPaymaster = await this.paymaster.getPaymasterData(userOp);
+    userOp.paymasterAndData = finalPaymaster.paymasterAndData;
+
+    // 7. Sign
+    userOp.signature = await signUserOp(userOp, this.signer, this.chainId);
+
+    // 8. Submit
+    const userOpHash = await this.bundler.sendUserOperation(userOp);
+    sdkLogger.info('UserOp submitted', { userOpHash });
+
+    // 9. Wait for receipt
+    const receipt = await this.bundler.waitForReceipt(userOpHash);
+
+    // Mark as deployed after first successful UserOp
+    if (!this.isDeployed && receipt.success) {
+      this.isDeployed = true;
+    }
+
+    return {
+      hash: receipt.transactionHash,
+      success: receipt.success,
+    };
+  }
+}
+
+/**
+ * Dummy signature for gas estimation.
+ * CoinbaseSmartWallet expects abi.encode(uint256 ownerIndex, bytes sig)
+ * where sig is 65 bytes (r,s,v).
+ */
+function dummySignature(): string {
+  const dummySig = '0x' + 'ff'.repeat(65);
+  return ethers.AbiCoder.defaultAbiCoder().encode(
+    ['uint256', 'bytes'],
+    [0, dummySig]
+  );
+}

package/src/wallet/EOAWalletProvider.ts

@@ -0,0 +1,69 @@
+/**
+ * EOAWalletProvider — Tier 2 (BYOW) wallet implementation.
+ *
+ * Wraps an ethers.Wallet for traditional EOA signing.
+ * sendBatchTransaction() executes calls sequentially (no atomic batching).
+ * This is the backward-compatible path for agents that don't register.
+ *
+ * @module wallet/EOAWalletProvider
+ */
+
+import { ethers } from 'ethers';
+import {
+  IWalletProvider,
+  TransactionRequest,
+  TransactionReceipt,
+  WalletInfo,
+} from './IWalletProvider';
+
+export class EOAWalletProvider implements IWalletProvider {
+  private readonly wallet: ethers.Wallet;
+  private readonly chainId: number;
+
+  constructor(wallet: ethers.Wallet, chainId: number) {
+    this.wallet = wallet;
+    this.chainId = chainId;
+  }
+
+  getAddress(): string {
+    return this.wallet.address;
+  }
+
+  async sendTransaction(tx: TransactionRequest): Promise<TransactionReceipt> {
+    const response = await this.wallet.sendTransaction({
+      to: tx.to,
+      data: tx.data,
+      value: tx.value ? BigInt(tx.value) : 0n,
+    });
+    const receipt = await response.wait();
+    return {
+      hash: receipt!.hash,
+      success: receipt!.status === 1,
+    };
+  }
+
+  async sendBatchTransaction(txs: TransactionRequest[]): Promise<TransactionReceipt> {
+    if (txs.length === 0) {
+      throw new Error('sendBatchTransaction requires at least one transaction');
+    }
+
+    let lastReceipt: TransactionReceipt | undefined;
+    for (const tx of txs) {
+      lastReceipt = await this.sendTransaction(tx);
+      if (!lastReceipt.success) {
+        return lastReceipt; // Fail fast
+      }
+    }
+    return lastReceipt!;
+  }
+
+  getWalletInfo(): WalletInfo {
+    return {
+      address: this.wallet.address,
+      tier: 'eoa',
+      supportsBatching: false,
+      gasSponsored: false,
+      chainId: this.chainId,
+    };
+  }
+}