@hsuite/native-connect-angular 1.0.0

package/src/lib/providers/walletconnect/core/walletconnect-provider.ts

@@ -0,0 +1,826 @@
+/**
+ * HSuite Native Connect
+ * Copyright 2024-2025 HSuite (https://hsuite.finance)
+ *
+ * SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+ *
+ * This file is part of HSuite Native Connect. For commercial licensing,
+ * visit https://hsuite.finance/licensing
+ */
+
+/**
+ * @file walletconnect-provider.ts
+ * @description Refactored WalletConnect v2 provider using Strategy Pattern
+ *
+ * Multi-chain WalletConnect v2 provider that delegates ledger-specific logic
+ * to specialized signer implementations.
+ *
+ * Architecture:
+ * - Provider: Orchestrates connection, session management, and UI
+ * - Signers: Handle ledger-specific transaction signing and formatting
+ * - Encoders: Convert between SDK formats and WalletConnect formats
+ *
+ * Benefits:
+ * - Clean separation of concerns
+ * - Easy to add new ledgers (just implement IWalletConnectSigner)
+ * - Testable (mock signers for unit tests)
+ * - Maintainable (ledger logic is isolated)
+ */
+
+import { Injectable, signal, inject, NgZone } from '@angular/core';
+import { getLogger } from '@hsuite/native-connect-sdk';
+
+import type {
+  ConnectionStatus,
+  ProviderMetadata,
+  ConnectionConfig,
+  WalletConnectV2Config,
+} from '../../../models/provider-types';
+import type { UnifiedAccount } from '../../../models/unified-account.model';
+import { WalletEventBus } from '../../../services/wallet-event-bus.service';
+import { BaseWalletProvider } from '../../base-wallet-provider';
+import type {
+  SignTransactionOptions,
+  SubmitTransactionOptions,
+  SignResult,
+  SubmitResult,
+  SignMessageOptions,
+  SignMessageResult,
+} from '../../base-wallet-provider';
+import { SignerFactory } from '../signers/signer-factory';
+
+import { WalletConnectClientManager } from './walletconnect-client-manager';
+import { WalletConnectSessionStore } from './walletconnect-session-store';
+import { WalletConnectSigningOrchestrator } from './walletconnect-signing-orchestrator';
+
+const logger = getLogger().scoped?.('WalletConnectV2Provider') ?? getLogger();
+
+/**
+ * Storage key prefix for persisting user's network selection per session topic.
+ * This is critical for proper session restoration after page reload.
+ */
+const NETWORK_SELECTION_STORAGE_KEY = 'wc_user_network_selection_';
+
+/**
+ * WalletConnect v2 provider with multi-chain support.
+ *
+ * Uses Strategy Pattern to delegate ledger-specific operations to
+ * specialized signer implementations (HederaSigner, XrplSigner, etc.).
+ *
+ * Features:
+ * - Automatic session restoration from IndexedDB
+ * - QR code modal for wallet connection
+ * - Support for multiple ledgers (Hedera, XRPL, extensible)
+ * - Clean separation of orchestration vs ledger logic
+ * - **Multi-session support**: Connect multiple wallets across different ledgers/networks
+ */
+@Injectable({ providedIn: 'root' })
+export class WalletConnectV2Provider extends BaseWalletProvider {
+  override readonly id = 'walletconnect-v2';
+
+  override readonly metadata: ProviderMetadata = {
+    id: 'walletconnect-v2',
+    name: 'WalletConnect',
+    type: 'walletconnect-v2',
+    description: 'Connect via QR code to Hedera, XRPL, and other wallets',
+    supportsMultipleAccounts: true, // Changed to true for multi-session
+  };
+
+  /**
+   * Client manager - handles SignClient lifecycle.
+   */
+  private readonly clientManager = new WalletConnectClientManager();
+
+  /**
+   * Session store - handles session Map and account aggregation.
+   */
+  private readonly sessionStore = new WalletConnectSessionStore();
+
+  /**
+   * Signing orchestrator - handles transaction signing routing.
+   */
+  private signingOrchestrator!: WalletConnectSigningOrchestrator;
+
+  // Track session_delete listener registration
+  private sessionDeleteListenerRegistered = false;
+
+  // Reactive state
+  private _status = signal<ConnectionStatus>('disconnected');
+  private _error = signal<string | null>(null);
+
+  override readonly status = this._status.asReadonly();
+  override readonly accounts = this.sessionStore.accounts;
+  override readonly error = this._error.asReadonly();
+
+  // Event bus for emitting wallet events
+  private readonly eventBus = inject(WalletEventBus);
+
+  // NgZone for ensuring change detection runs after WalletConnect events
+  private readonly zone = inject(NgZone);
+
+  /**
+   *
+   */
+  constructor() {
+    super();
+
+    // Initialize signing orchestrator
+    this.signingOrchestrator = new WalletConnectSigningOrchestrator({
+      providerId: this.id,
+      sessionStore: this.sessionStore,
+      clientManager: this.clientManager,
+      eventBus: this.eventBus,
+    });
+
+    logger.info('Initializing - will attempt session restoration');
+    void this.restoreSession();
+  }
+
+  /**
+   * Ensure that a previously restored WalletConnect session is present in memory.
+   * Useful for UI flows that want to re-select a session after reload without forcing a new pairing flow.
+   * @param sessionKey
+   */
+  async resumeSession(sessionKey: string): Promise<boolean> {
+    if (this.sessionStore.hasSession(sessionKey)) {
+      this.sessionStore.updateAggregatedAccounts();
+      return true;
+    }
+
+    await this.restoreSession();
+    const exists = this.sessionStore.hasSession(sessionKey);
+    if (exists) {
+      this.sessionStore.updateAggregatedAccounts();
+    }
+    return exists;
+  }
+
+  /**
+   * Restore existing WalletConnect sessions from IndexedDB.
+   * Automatically called during provider initialization.
+   * Uses clientManager for client lifecycle.
+   */
+  private async restoreSession(): Promise<void> {
+    try {
+      logger.debug('Attempting to restore sessions...');
+
+      // Restore client from stored projectId
+      const client = await this.clientManager.restoreClient({
+        name: 'HSuite Demo',
+        description: 'Multi-chain wallet connection',
+        url: window.location.origin,
+        icons: [],
+      });
+
+      if (!client) {
+        return;
+      }
+
+      // Register session_delete listener
+      this.registerSessionDeleteListener();
+
+      // Get all active sessions
+      const activeSessions = this.clientManager.getActiveSessions();
+      logger.info('Found active sessions', { count: activeSessions.length });
+
+      if (activeSessions.length === 0) {
+        return;
+      }
+
+      // Restore each session
+      for (const session of activeSessions) {
+        try {
+          await this.restoreSingleSession(session);
+        } catch (error) {
+          logger.error('Failed to restore session', {
+            topic: session.topic,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+
+      // Update aggregated accounts
+      this.sessionStore.updateAggregatedAccounts();
+
+      if (this.sessionStore.size > 0) {
+        this._status.set('connected');
+        logger.info('Restored sessions', { count: this.sessionStore.size });
+      }
+    } catch (error) {
+      logger.error('Failed to restore sessions', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  /**
+   * Restore a single WalletConnect session.
+   * Internal helper for multi-session restoration.
+   *
+   * IMPORTANT: Reads user's network selection from localStorage to ensure
+   * restored sessions use the correct network the user originally selected.
+   *
+   * @param session - WalletConnect session object from IndexedDB
+   */
+  private async restoreSingleSession(session: any): Promise<void> {
+    logger.debug('Restoring session', { topic: session.topic });
+    logger.debug('Session namespaces', { namespaces: Object.keys(session.namespaces) });
+
+    // Determine ledger from session namespaces
+    let ledgerId: string | undefined;
+    let walletReportedNetwork: string | undefined;
+
+    if (session.namespaces.hedera) {
+      ledgerId = 'hedera';
+      walletReportedNetwork = session.namespaces.hedera.chains?.[0] || 'hedera:testnet';
+      logger.debug('Found Hedera namespace', { chains: session.namespaces.hedera.chains });
+    } else if (session.namespaces.xrpl) {
+      ledgerId = 'xrpl';
+      walletReportedNetwork = session.namespaces.xrpl.chains?.[0] || 'xrpl:testnet';
+      logger.debug('Found XRPL namespace', { chains: session.namespaces.xrpl.chains });
+    }
+
+    if (!ledgerId || !walletReportedNetwork) {
+      logger.warn('Could not determine ledger for session', {
+        topic: session.topic,
+        availableNamespaces: Object.keys(session.namespaces),
+      });
+      return;
+    }
+
+    // CRITICAL: Retrieve user's original network selection from localStorage
+    // This ensures we restore the session with the network the user actually selected
+    const userSelectedNetwork = this.getUserNetworkSelection(session.topic);
+    const networkId = userSelectedNetwork || walletReportedNetwork;
+
+    if (userSelectedNetwork) {
+      logger.debug('Restored user network selection', {
+        userSelectedNetwork,
+        walletReportedNetwork,
+        topic: session.topic.substring(0, 16),
+      });
+    } else {
+      logger.warn('No stored network selection found, using wallet-reported network', {
+        walletReportedNetwork,
+        topic: session.topic.substring(0, 16),
+      });
+    }
+
+    // Get the appropriate signer
+    const signer = SignerFactory.getSigner(ledgerId);
+
+    // Generate session key using the user's selected network
+    const sessionKey = this.sessionStore.generateSessionKey(ledgerId, networkId, session.topic);
+
+    // Parse accounts from session, filtering by user's selected network
+    const namespace = session.namespaces[ledgerId];
+    logger.debug('Namespace for restoration', {
+      ledgerId,
+      accountCount: (namespace as { accounts?: any[] })?.accounts?.length || 0,
+    });
+
+    // Pass the user's selected network to filter accounts appropriately
+    const parsedAccounts = signer.parseAccounts(namespace, userSelectedNetwork);
+    logger.debug('Parsed accounts from restored session', {
+      count: parsedAccounts.length,
+      userSelectedNetwork,
+    });
+
+    if (parsedAccounts.length === 0) {
+      logger.warn('Restored session has no accounts for selected network', {
+        userSelectedNetwork,
+        walletReportedNetwork,
+      });
+    }
+
+    // Create UnifiedAccount objects with user's selected network
+    const accounts: UnifiedAccount[] = parsedAccounts.map((acc, index) => ({
+      id: `${this.id}-${ledgerId}-${acc.address}`,
+      address: acc.address,
+      label: `Account ${index + 1}`,
+      ledgerId: ledgerId as 'hedera' | 'xrpl',
+      networkId: networkId, // Use user's selected network
+      providerId: this.id,
+      providerType: 'walletconnect-v2',
+      metadata: {
+        topic: session.topic,
+        ledger: ledgerId,
+        sessionKey,
+        peer: session.peer?.metadata,
+        walletReportedChainId: acc.chainId, // Keep original for debugging
+        userSelectedNetwork: networkId,
+      },
+    }));
+
+    // Store session data with user's network selection
+    this.sessionStore.setSession(sessionKey, {
+      session,
+      ledgerId,
+      networkId,
+      userSelectedNetwork: networkId,
+      signer,
+      accounts,
+    });
+
+    logger.info('Restored session', {
+      sessionKey,
+      ledgerId,
+      networkId,
+      userSelectedNetwork: networkId,
+      accountCount: accounts.length,
+    });
+
+    // Emit session restored event
+    this.eventBus.sessionRestored.emit({
+      providerId: this.id,
+      sessionKey,
+      accounts,
+      metadata: { topic: session.topic, ledgerId, networkId, userSelectedNetwork: networkId },
+      timestamp: Date.now(),
+    });
+  }
+
+  // NOTE: generateSessionKey and updateAggregatedAccounts have been moved to WalletConnectSessionStore
+
+  /**
+   * Store user's network selection in localStorage for session restoration.
+   * This ensures the user's network choice persists across page reloads.
+   *
+   * @param sessionTopic - WalletConnect session topic
+   * @param networkId - User's selected network (e.g., 'hedera:mainnet')
+   */
+  private storeUserNetworkSelection(sessionTopic: string, networkId: string): void {
+    try {
+      localStorage.setItem(`${NETWORK_SELECTION_STORAGE_KEY}${sessionTopic}`, networkId);
+      logger.debug('Stored user network selection', {
+        topic: sessionTopic.substring(0, 16),
+        networkId,
+      });
+    } catch (e) {
+      logger.warn('Failed to store network selection', { error: (e as Error).message });
+    }
+  }
+
+  /**
+   * Retrieve user's network selection from localStorage for session restoration.
+   *
+   * @param sessionTopic - WalletConnect session topic
+   * @returns User's selected network, or undefined if not found
+   */
+  private getUserNetworkSelection(sessionTopic: string): string | undefined {
+    try {
+      return localStorage.getItem(`${NETWORK_SELECTION_STORAGE_KEY}${sessionTopic}`) || undefined;
+    } catch (e) {
+      logger.warn('Failed to retrieve network selection', { error: (e as Error).message });
+      return undefined;
+    }
+  }
+
+  /**
+   * Clean up stored network selection for a session.
+   *
+   * @param sessionTopic - WalletConnect session topic
+   */
+  private clearUserNetworkSelection(sessionTopic: string): void {
+    try {
+      localStorage.removeItem(`${NETWORK_SELECTION_STORAGE_KEY}${sessionTopic}`);
+    } catch (_e) {
+      // Ignore cleanup errors
+    }
+  }
+
+  /**
+   * Connect to a wallet via WalletConnect QR code.
+   *
+   * Multi-session support:
+   * - Each connect() call creates a NEW session
+   * - Sessions are tracked separately in the sessions Map
+   * - Multiple sessions can coexist for different ledgers/networks
+   *
+   * Process:
+   * 1. Get appropriate signer for the ledger
+   * 2. Initialize WalletConnect client and modal
+   * 3. Build namespace configuration using signer
+   * 4. Generate QR code and wait for wallet approval
+   * 5. Store session and update aggregated accounts
+   *
+   * @param config - Connection configuration including ledger and network
+   */
+  async connect(config: ConnectionConfig): Promise<void> {
+    const wcConfig = config as WalletConnectV2Config;
+
+    try {
+      this._status.set('connecting');
+      this._error.set(null);
+
+      // Validate configuration
+      const projectId = wcConfig.projectId;
+      if (!projectId) {
+        throw new Error(
+          'WalletConnect projectId is required. Get one from https://cloud.walletconnect.com',
+        );
+      }
+
+      // Get the appropriate signer for this ledger (Strategy Pattern)
+      const signer = SignerFactory.getSigner(wcConfig.ledgerId);
+      logger.debug('Using signer for ledger', { ledgerId: wcConfig.ledgerId });
+
+      // Initialize client via manager
+      await this.clientManager.initialize(projectId, {
+        name: wcConfig.appName || 'HSuite Demo',
+        description: wcConfig.appDescription || 'Multi-chain wallet connection',
+        url: window.location.origin,
+        icons: wcConfig.appIconUrl ? [wcConfig.appIconUrl] : [],
+      });
+      this.registerSessionDeleteListener();
+
+      // Create modal for QR code display
+      const modal = this.clientManager.createModal(projectId, [wcConfig.networkId]);
+
+      // Build namespace configuration using signer
+      const namespaceConfig = signer.buildNamespace(wcConfig.networkId);
+      const optionalNamespaces = { [wcConfig.ledgerId]: namespaceConfig };
+      logger.debug('Namespace config', { ledgerId: wcConfig.ledgerId });
+
+      // Build session properties to pass user's preferred network to wallet
+      // This tells the wallet which network accounts to show in the picker
+      const sessionProperties = {
+        preferredNetwork: wcConfig.networkId,
+        preferredLedger: wcConfig.ledgerId,
+      };
+
+      logger.info('Connecting with preferred network', {
+        preferredNetwork: wcConfig.networkId,
+        preferredLedger: wcConfig.ledgerId,
+      });
+
+      // Connect and show QR code
+      const { uri, approval } = await this.clientManager.connect(
+        optionalNamespaces,
+        sessionProperties,
+      );
+
+      if (uri) {
+        await modal.openModal({ uri });
+      }
+
+      // Wait for wallet approval
+      logger.info('Waiting for wallet approval...');
+      const session = await approval();
+      this.clientManager.closeModal();
+
+      logger.info('[WC:DAPP:APPROVED] Session approved by wallet', {
+        topic: session.topic.substring(0, 16) + '...',
+        fullTopic: session.topic,
+        namespaces: Object.keys(session.namespaces),
+        expiry: session.expiry,
+      });
+
+      // Generate session key
+      const sessionKey = this.sessionStore.generateSessionKey(
+        wcConfig.ledgerId,
+        wcConfig.networkId,
+        session.topic,
+      );
+
+      // Parse accounts from session
+      const sessionNamespace = session.namespaces[wcConfig.ledgerId];
+      logger.debug('Session namespace for ledger', {
+        ledgerId: wcConfig.ledgerId,
+        accountCount: (sessionNamespace as { accounts?: any[] })?.accounts?.length || 0,
+      });
+
+      if (!sessionNamespace) {
+        logger.error('No namespace found for ledger', {
+          ledgerId: wcConfig.ledgerId,
+          availableNamespaces: Object.keys(session.namespaces),
+        });
+        throw new Error(
+          `Wallet did not approve ${wcConfig.ledgerId} namespace. Available: ${Object.keys(session.namespaces).join(', ')}`,
+        );
+      }
+
+      // Parse accounts from session namespace, filtering by user's selected network
+      // This ensures we only show accounts that match the network the user selected
+      const parsedAccounts = signer.parseAccounts(sessionNamespace, wcConfig.networkId);
+      logger.debug('Parsed accounts', {
+        count: parsedAccounts.length,
+        userSelectedNetwork: wcConfig.networkId,
+      });
+
+      if (parsedAccounts.length === 0) {
+        logger.warn('No accounts returned from wallet - possible causes:', {
+          reason1: 'Wallet has no accounts for the requested network',
+          reason2: 'Wallet denied account sharing',
+          reason3: 'Wallet returned accounts in unexpected format',
+          userSelectedNetwork: wcConfig.networkId,
+        });
+      }
+
+      // Create UnifiedAccount objects
+      // IMPORTANT: Use wcConfig.networkId (user's selection) for account networkId
+      // This respects user intent rather than relying on wallet-reported chain
+      const accounts: UnifiedAccount[] = parsedAccounts.map((acc, index) => ({
+        id: `${this.id}-${wcConfig.ledgerId}-${acc.address}`,
+        address: acc.address,
+        label: `Account ${index + 1}`,
+        ledgerId: wcConfig.ledgerId,
+        networkId: wcConfig.networkId, // Use user's selected network, not wallet-reported
+        providerId: this.id,
+        providerType: 'walletconnect-v2',
+        metadata: {
+          topic: session.topic,
+          ledger: wcConfig.ledgerId,
+          sessionKey,
+          walletReportedChainId: acc.chainId, // Keep original for debugging
+          userSelectedNetwork: wcConfig.networkId, // Store for session restoration
+        },
+      }));
+
+      // Store session data with user's selected network
+      this.sessionStore.setSession(sessionKey, {
+        session,
+        ledgerId: wcConfig.ledgerId,
+        networkId: wcConfig.networkId,
+        userSelectedNetwork: wcConfig.networkId, // Store user's selection for restoration
+        signer,
+        accounts,
+      });
+
+      // Persist user's network selection for session restoration after page reload
+      this.storeUserNetworkSelection(session.topic, wcConfig.networkId);
+
+      // Verify session exists in WC SDK after storing
+      const sdkSession = this.clientManager.getSession(session.topic);
+
+      logger.info('[WC:DAPP:STORED] Session stored locally', {
+        sessionKey,
+        topic: session.topic.substring(0, 16) + '...',
+        fullTopic: session.topic,
+        accountCount: accounts.length,
+        totalSessions: this.sessionStore.size,
+        existsInSdkSession: !!sdkSession,
+      });
+
+      // Update aggregated accounts
+      this.sessionStore.updateAggregatedAccounts();
+      this._status.set('connected');
+
+      // Emit session created event
+      this.eventBus.sessionCreated.emit({
+        providerId: this.id,
+        sessionKey,
+        accounts,
+        metadata: {
+          topic: session.topic,
+          ledgerId: wcConfig.ledgerId,
+          networkId: wcConfig.networkId,
+        },
+        timestamp: Date.now(),
+      });
+
+      // Register session_delete listener (idempotent)
+      this.registerSessionDeleteListener();
+    } catch (error) {
+      this._status.set('error');
+      this._error.set(error instanceof Error ? error.message : 'Connection failed');
+      logger.error('Connection failed', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+
+      // Emit provider error event
+      this.eventBus.providerError.emit({
+        providerId: this.id,
+        error: error instanceof Error ? error : String(error),
+        context: 'connection',
+        timestamp: Date.now(),
+      });
+
+      this.clientManager.closeModal();
+      throw error;
+    }
+  }
+
+  /**
+   * Remove a session by its WalletConnect topic.
+   * Internal helper for session_delete event handling.
+   *
+   * @param topic - WalletConnect session topic
+   */
+  private removeSessionByTopic(topic: string): void {
+    // Find and remove the session using session store
+    const removed = this.sessionStore.removeSessionByTopic(topic);
+
+    // Clean up stored network selection
+    this.clearUserNetworkSelection(topic);
+
+    // Update aggregated accounts
+    this.sessionStore.updateAggregatedAccounts();
+
+    // Update status
+    if (this.sessionStore.size === 0) {
+      this._status.set('disconnected');
+    }
+
+    // Emit events if session was found
+    if (removed) {
+      // Emit session deleted event
+      this.eventBus.sessionDeleted.emit({
+        providerId: this.id,
+        sessionKey: removed.sessionKey,
+        accounts: removed.data.accounts,
+        metadata: { topic, reason: 'wallet_initiated' },
+        timestamp: Date.now(),
+      });
+
+      // Emit disconnection event
+      this.eventBus.disconnected.emit({
+        providerId: this.id,
+        providerType: 'walletconnect-v2',
+        sessionKey: removed.sessionKey,
+        reason: 'wallet_initiated_disconnect',
+        timestamp: Date.now(),
+      });
+    }
+  }
+
+  /**
+   * Register session_delete event listener to handle wallet-initiated disconnects.
+   * Idempotent - only registers once even if called multiple times.
+   *
+   * @private
+   */
+  private registerSessionDeleteListener(): void {
+    if (!this.clientManager.isInitialized() || this.sessionDeleteListenerRegistered) {
+      return;
+    }
+
+    // ✅ CRITICAL: Run inside NgZone to trigger Angular's change detection
+    // WalletConnect events arrive outside Angular's zone
+    this.clientManager.on('session_delete', (event: any) => {
+      this.zone.run(() => {
+        logger.info('� Session deleted by wallet (session_delete event)', {
+          topic: (event as { topic: string }).topic,
+        });
+        this.removeSessionByTopic((event as { topic: string }).topic);
+      });
+    });
+
+    this.sessionDeleteListenerRegistered = true;
+    logger.debug('session_delete listener registered');
+  }
+
+  /**
+   * Disconnect from WalletConnect sessions.
+   * Supports disconnecting all sessions or a specific session.
+   *
+   * @param sessionKey - Optional session key to disconnect specific session
+   */
+  async disconnect(sessionKey?: string): Promise<void> {
+    if (!this.clientManager.isInitialized()) {
+      logger.warn('No client to disconnect');
+      return;
+    }
+
+    if (sessionKey) {
+      // Disconnect specific session
+      const sessionData = this.sessionStore.getSession(sessionKey);
+      if (sessionData) {
+        try {
+          await this.clientManager.disconnect(sessionData.session.topic, {
+            code: 6000,
+            message: 'User disconnected session',
+          });
+          logger.info('Disconnected session', { sessionKey });
+        } catch (e) {
+          logger.error('Disconnect error for session', {
+            sessionKey,
+            error: e instanceof Error ? e.message : String(e),
+          });
+        }
+
+        // Clean up stored network selection
+        this.clearUserNetworkSelection(sessionData.session.topic);
+
+        this.sessionStore.deleteSession(sessionKey);
+        this.sessionStore.updateAggregatedAccounts();
+
+        if (this.sessionStore.size === 0) {
+          this._status.set('disconnected');
+        }
+      }
+    } else {
+      // Disconnect all sessions
+      const disconnectPromises: Promise<void>[] = [];
+
+      for (const [_key, sessionData] of this.sessionStore.entries()) {
+        // Clean up stored network selection for each session
+        this.clearUserNetworkSelection(sessionData.session.topic);
+
+        disconnectPromises.push(
+          this.clientManager
+            .disconnect(sessionData.session.topic, {
+              code: 6000,
+              message: 'User disconnected all sessions',
+            })
+            .catch((err: Error) =>
+              logger.error('Disconnect error', {
+                error: err.message,
+              }),
+            ),
+        );
+      }
+
+      await Promise.all(disconnectPromises);
+
+      this.sessionStore.clear();
+      this._status.set('disconnected');
+
+      logger.info('Disconnected all sessions');
+    }
+
+    this.clientManager.closeModal();
+  }
+
+  // NOTE: findSessionForAccount and validateSessionInSdk moved to WalletConnectSigningOrchestrator
+
+  /**
+   * Sign a transaction without submitting (delegates to SigningOrchestrator).
+   * @param options
+   */
+  async signTransaction(options: SignTransactionOptions): Promise<SignResult> {
+    if (!this.clientManager.isInitialized()) {
+      throw new Error('Not connected to WalletConnect');
+    }
+    return this.signingOrchestrator.signTransaction(options);
+  }
+
+  /**
+   * Sign and submit a transaction (delegates to SigningOrchestrator).
+   * @param options
+   */
+  async submitTransaction(options: SubmitTransactionOptions): Promise<SubmitResult> {
+    if (!this.clientManager.isInitialized()) {
+      throw new Error('Not connected to WalletConnect');
+    }
+    return this.signingOrchestrator.submitTransaction(options);
+  }
+
+  /**
+   * Sign and execute transaction in one call (delegates to SigningOrchestrator).
+   * @param options
+   */
+  async signAndExecuteTransaction(options: SubmitTransactionOptions): Promise<SubmitResult> {
+    if (!this.clientManager.isInitialized()) {
+      throw new Error('Not connected to WalletConnect');
+    }
+    return this.signingOrchestrator.signAndExecuteTransaction(options);
+  }
+
+  /**
+   * Sign an arbitrary message (delegates to SigningOrchestrator).
+   * @param options
+   */
+  async signMessage(options: SignMessageOptions): Promise<SignMessageResult> {
+    if (!this.clientManager.isInitialized()) {
+      throw new Error('Not connected to WalletConnect');
+    }
+    return this.signingOrchestrator.signMessage(options);
+  }
+
+  /**
+   * Check if WalletConnect is available.
+   * Always returns true as WalletConnect is browser-based.
+   */
+  async isAvailable(): Promise<boolean> {
+    return true;
+  }
+
+  /**
+   * Get all active WalletConnect sessions.
+   * Useful for displaying session information in UI and managing multiple connections.
+   * Delegates to session store.
+   *
+   * @returns Array of session information objects
+   */
+  getActiveSessions(): Array<{
+    sessionKey: string;
+    ledgerId: string;
+    networkId: string;
+    userSelectedNetwork: string;
+    accounts: UnifiedAccount[];
+    topic: string;
+  }> {
+    return this.sessionStore.getActiveSessions();
+  }
+
+  /**
+   * Disconnect a specific session by session key.
+   * Public wrapper for the private disconnect method.
+   *
+   * @param sessionKey - The session key to disconnect
+   */
+  async disconnectSession(sessionKey: string): Promise<void> {
+    await this.disconnect(sessionKey);
+  }
+}