@hsuite/native-connect-angular 1.0.0

package/src/lib/providers/walletconnect/core/walletconnect-session-store.ts

@@ -0,0 +1,273 @@
+/**
+ * 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-session-store.ts
+ * @description Session storage and management for WalletConnect provider
+ *
+ * Extracted from WalletConnectV2Provider to reduce file size and improve maintainability.
+ *
+ * Responsibilities:
+ * - Store and retrieve WalletConnect sessions
+ * - Generate unique session keys
+ * - Aggregate accounts across sessions
+ * - Find sessions by account address
+ */
+
+import { signal } from '@angular/core';
+import { getLogger } from '@hsuite/native-connect-sdk';
+
+import type { UnifiedAccount } from '../../../models/unified-account.model';
+
+import type { IWalletConnectSigner } from './base-signer.interface';
+
+const logger = getLogger().scoped?.('WCSessionStore') ?? getLogger();
+
+/**
+ * Session data structure stored in the session store.
+ */
+export interface StoredSessionData {
+  /** Raw WalletConnect session object */
+  session: any;
+  /** Ledger identifier (hedera, xrpl) */
+  ledgerId: string;
+  /** Network identifier (hedera:testnet, xrpl:mainnet) */
+  networkId: string;
+  /**
+   * User's selected network from the connection modal.
+   * This is critical for respecting user intent - wallets may return accounts
+   * from multiple networks, but we should use the network the user selected.
+   *
+   * This value is set when connecting and persisted for session restoration.
+   * It takes precedence over the wallet-reported networkId for signing operations.
+   */
+  userSelectedNetwork: string;
+  /** Signer instance for this ledger */
+  signer: IWalletConnectSigner;
+  /** Unified accounts parsed from session */
+  accounts: UnifiedAccount[];
+}
+
+/**
+ * WalletConnect Session Store
+ *
+ * Manages the in-memory storage of WalletConnect sessions.
+ * Provides utility methods for session lookup and aggregation.
+ */
+export class WalletConnectSessionStore {
+  /**
+   * Map of session key to session data.
+   * Session key format: wc-{ledger}-{network}-{topicPrefix}
+   */
+  private readonly sessions = new Map<string, StoredSessionData>();
+
+  /**
+   * Aggregated accounts signal for reactive UI binding.
+   */
+  private readonly _accounts = signal<UnifiedAccount[]>([]);
+
+  /**
+   * Read-only accounts signal.
+   */
+  readonly accounts = this._accounts.asReadonly();
+
+  /**
+   * Get a session by key.
+   *
+   * @param sessionKey - Unique session key
+   * @returns Session data or undefined
+   */
+  getSession(sessionKey: string): StoredSessionData | undefined {
+    return this.sessions.get(sessionKey);
+  }
+
+  /**
+   * Store a session.
+   *
+   * @param sessionKey - Unique session key
+   * @param data - Session data to store
+   */
+  setSession(sessionKey: string, data: StoredSessionData): void {
+    this.sessions.set(sessionKey, data);
+    logger.debug('Session stored', { sessionKey, accountCount: data.accounts.length });
+  }
+
+  /**
+   * Delete a session by key.
+   *
+   * @param sessionKey - Session key to delete
+   * @returns true if session was deleted
+   */
+  deleteSession(sessionKey: string): boolean {
+    const deleted = this.sessions.delete(sessionKey);
+    if (deleted) {
+      logger.debug('Session deleted', { sessionKey });
+    }
+    return deleted;
+  }
+
+  /**
+   * Check if a session exists.
+   *
+   * @param sessionKey - Session key to check
+   */
+  hasSession(sessionKey: string): boolean {
+    return this.sessions.has(sessionKey);
+  }
+
+  /**
+   * Get the number of stored sessions.
+   */
+  get size(): number {
+    return this.sessions.size;
+  }
+
+  /**
+   * Clear all sessions.
+   */
+  clear(): void {
+    this.sessions.clear();
+    this._accounts.set([]);
+    logger.debug('All sessions cleared');
+  }
+
+  /**
+   * Get all session entries.
+   *
+   * @returns Iterator of [sessionKey, sessionData] pairs
+   */
+  entries(): IterableIterator<[string, StoredSessionData]> {
+    return this.sessions.entries();
+  }
+
+  /**
+   * Get all session values.
+   *
+   * @returns Iterator of session data
+   */
+  values(): IterableIterator<StoredSessionData> {
+    return this.sessions.values();
+  }
+
+  /**
+   * Generate a unique session key for tracking multiple sessions.
+   * Format: wc-{ledger}-{network}-{topicPrefix}
+   *
+   * @param ledgerId - Ledger identifier (hedera, xrpl)
+   * @param networkId - Network identifier (hedera:testnet, xrpl:mainnet)
+   * @param topic - WalletConnect session topic (optional)
+   * @returns Unique session key
+   */
+  generateSessionKey(ledgerId: string, networkId: string, topic?: string): string {
+    const topicPrefix = topic ? topic.substring(0, 8) : Date.now().toString();
+    const networkPart = networkId.split(':')[1] || 'unknown';
+    return `wc-${ledgerId}-${networkPart}-${topicPrefix}`;
+  }
+
+  /**
+   * Update the aggregated accounts signal from all sessions.
+   * Call this after session changes to keep accounts in sync.
+   */
+  updateAggregatedAccounts(): void {
+    const allAccounts: UnifiedAccount[] = [];
+
+    for (const sessionData of this.sessions.values()) {
+      allAccounts.push(...sessionData.accounts);
+    }
+
+    logger.debug('Aggregated accounts', {
+      sessionCount: this.sessions.size,
+      totalAccounts: allAccounts.length,
+    });
+    this._accounts.set(allAccounts);
+  }
+
+  /**
+   * Find the session containing a specific account address.
+   *
+   * @param accountAddress - Account address to find
+   * @returns Session, signer, and network info, or undefined if not found
+   */
+  findSessionByAccount(accountAddress: string):
+    | {
+        session: any;
+        signer: IWalletConnectSigner;
+        networkId: string;
+        userSelectedNetwork: string;
+      }
+    | undefined {
+    for (const sessionData of this.sessions.values()) {
+      const accountExists = sessionData.accounts.some((acc) => acc.address === accountAddress);
+      if (accountExists) {
+        return {
+          session: sessionData.session,
+          signer: sessionData.signer,
+          networkId: sessionData.networkId,
+          userSelectedNetwork: sessionData.userSelectedNetwork,
+        };
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Find and remove a session by its WalletConnect topic.
+   *
+   * @param topic - WalletConnect session topic
+   * @returns Removed session data, or undefined if not found
+   */
+  removeSessionByTopic(topic: string): { sessionKey: string; data: StoredSessionData } | undefined {
+    for (const [sessionKey, sessionData] of this.sessions.entries()) {
+      if (sessionData.session.topic === topic) {
+        this.sessions.delete(sessionKey);
+        logger.info('Session removed by topic', { sessionKey, topic: topic.substring(0, 16) });
+        return { sessionKey, data: sessionData };
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get all active sessions as an array.
+   * Useful for UI display.
+   *
+   * @returns Array of session information
+   */
+  getActiveSessions(): Array<{
+    sessionKey: string;
+    ledgerId: string;
+    networkId: string;
+    userSelectedNetwork: string;
+    accounts: UnifiedAccount[];
+    topic: string;
+  }> {
+    const sessions: Array<{
+      sessionKey: string;
+      ledgerId: string;
+      networkId: string;
+      userSelectedNetwork: string;
+      accounts: UnifiedAccount[];
+      topic: string;
+    }> = [];
+
+    for (const [sessionKey, sessionData] of this.sessions.entries()) {
+      sessions.push({
+        sessionKey,
+        ledgerId: sessionData.ledgerId,
+        networkId: sessionData.networkId,
+        userSelectedNetwork: sessionData.userSelectedNetwork,
+        accounts: sessionData.accounts,
+        topic: sessionData.session.topic,
+      });
+    }
+
+    return sessions;
+  }
+}

package/src/lib/providers/walletconnect/core/walletconnect-signing-orchestrator.ts

@@ -0,0 +1,299 @@
+/**
+ * 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-signing-orchestrator.ts
+ * @description Signing orchestration for WalletConnect provider
+ *
+ * Handles:
+ * - Finding sessions for accounts
+ * - Session validation in WC SDK
+ * - Routing sign/submit requests to appropriate signers
+ *
+ * Extracted from WalletConnectV2Provider to reduce file size.
+ */
+
+import { getLogger } from '@hsuite/native-connect-sdk';
+
+import type { WalletEventBus } from '../../../services/wallet-event-bus.service';
+import type {
+  SignTransactionOptions,
+  SubmitTransactionOptions,
+  SignResult,
+  SubmitResult,
+  SignMessageOptions,
+  SignMessageResult,
+} from '../../base-wallet-provider';
+
+import type { WalletConnectClientManager } from './walletconnect-client-manager';
+import type { WalletConnectSessionStore } from './walletconnect-session-store';
+
+const logger = getLogger().scoped?.('WCSigningOrchestrator') ?? getLogger();
+
+/**
+ * Signing orchestration configuration
+ */
+export interface SigningOrchestratorConfig {
+  providerId: string;
+  sessionStore: WalletConnectSessionStore;
+  clientManager: WalletConnectClientManager;
+  eventBus: WalletEventBus;
+}
+
+/**
+ * Signing Orchestrator
+ *
+ * Routes signing requests to the appropriate session and signer.
+ * Handles session validation and error emission.
+ */
+export class WalletConnectSigningOrchestrator {
+  private readonly providerId: string;
+  private readonly sessionStore: WalletConnectSessionStore;
+  private readonly clientManager: WalletConnectClientManager;
+  private readonly eventBus: WalletEventBus;
+
+  /**
+   *
+   * @param config
+   */
+  constructor(config: SigningOrchestratorConfig) {
+    this.providerId = config.providerId;
+    this.sessionStore = config.sessionStore;
+    this.clientManager = config.clientManager;
+    this.eventBus = config.eventBus;
+  }
+
+  /**
+   * Sign a transaction without submitting.
+   * Uses the user's selected network from the session for the signing request.
+   * @param options
+   */
+  async signTransaction(options: SignTransactionOptions): Promise<SignResult> {
+    const sessionInfo = this.findAndValidateSession(options.accountAddress, 'signTransaction');
+
+    // Use user's selected network from session, with fallback to options.networkId
+    const networkId = this.resolveNetworkId(sessionInfo, options.networkId);
+
+    logger.debug('Routing sign to signer', {
+      ledgerId: sessionInfo.signer.ledgerId,
+      topic: sessionInfo.session.topic.substring(0, 16) + '...',
+      networkId,
+      userSelectedNetwork: sessionInfo.userSelectedNetwork,
+    });
+
+    return sessionInfo.signer.signTransaction({
+      client: this.clientManager.getClient(),
+      topic: sessionInfo.session.topic,
+      accountAddress: options.accountAddress,
+      payload: options.payload,
+      networkId,
+    });
+  }
+
+  /**
+   * Sign and submit a transaction.
+   * Uses the user's selected network from the session for the signing request.
+   * @param options
+   */
+  async submitTransaction(options: SubmitTransactionOptions): Promise<SubmitResult> {
+    const sessionInfo = this.findAndValidateSession(options.accountAddress, 'submitTransaction');
+
+    // Use user's selected network from session, with fallback to options.networkId
+    const networkId = this.resolveNetworkId(sessionInfo, options.networkId);
+
+    logger.debug('Routing submit to signer', {
+      ledgerId: sessionInfo.signer.ledgerId,
+      topic: sessionInfo.session.topic.substring(0, 16) + '...',
+      networkId,
+      userSelectedNetwork: sessionInfo.userSelectedNetwork,
+    });
+
+    return sessionInfo.signer.submitTransaction({
+      client: this.clientManager.getClient(),
+      topic: sessionInfo.session.topic,
+      accountAddress: options.accountAddress,
+      payload: options.payload,
+      networkId,
+    });
+  }
+
+  /**
+   * Sign and execute a transaction (single wallet prompt).
+   * Uses the user's selected network from the session for the signing request.
+   * @param options
+   */
+  async signAndExecuteTransaction(options: SubmitTransactionOptions): Promise<SubmitResult> {
+    const sessionInfo = this.findAndValidateSession(
+      options.accountAddress,
+      'signAndExecuteTransaction',
+    );
+
+    // Use user's selected network from session, with fallback to options.networkId
+    const networkId = this.resolveNetworkId(sessionInfo, options.networkId);
+
+    logger.debug('Routing signAndExecute to signer', {
+      ledgerId: sessionInfo.signer.ledgerId,
+      topic: sessionInfo.session.topic.substring(0, 16) + '...',
+      networkId,
+      userSelectedNetwork: sessionInfo.userSelectedNetwork,
+    });
+
+    // Check if signer supports native signAndExecute
+    if (typeof sessionInfo.signer.signAndExecuteTransaction === 'function') {
+      return sessionInfo.signer.signAndExecuteTransaction({
+        client: this.clientManager.getClient(),
+        topic: sessionInfo.session.topic,
+        accountAddress: options.accountAddress,
+        payload: options.payload,
+        networkId,
+      });
+    }
+
+    // Fallback: sign then submit
+    const signResult = await sessionInfo.signer.signTransaction({
+      client: this.clientManager.getClient(),
+      topic: sessionInfo.session.topic,
+      accountAddress: options.accountAddress,
+      payload: options.payload,
+      networkId,
+    });
+
+    return sessionInfo.signer.submitTransaction({
+      client: this.clientManager.getClient(),
+      topic: sessionInfo.session.topic,
+      accountAddress: options.accountAddress,
+      payload: signResult.signedPayload || options.payload,
+      networkId,
+    });
+  }
+
+  /**
+   * Sign a message.
+   * Uses the user's selected network from the session for the signing request.
+   * @param options
+   */
+  async signMessage(options: SignMessageOptions): Promise<SignMessageResult> {
+    const sessionInfo = this.findAndValidateSession(options.accountAddress, 'signMessage');
+
+    // Use user's selected network from session, with fallback to options.networkId
+    const networkId = this.resolveNetworkId(sessionInfo, options.networkId);
+
+    logger.debug('Routing signMessage to signer', {
+      ledgerId: sessionInfo.signer.ledgerId,
+      topic: sessionInfo.session.topic.substring(0, 16) + '...',
+      networkId,
+      userSelectedNetwork: sessionInfo.userSelectedNetwork,
+    });
+
+    return sessionInfo.signer.signMessage({
+      client: this.clientManager.getClient(),
+      topic: sessionInfo.session.topic,
+      accountAddress: options.accountAddress,
+      payload: '',
+      networkId,
+      message: options.message,
+      encoding: options.encoding,
+    });
+  }
+
+  /**
+   * Resolve the network ID to use for signing.
+   *
+   * Priority:
+   * 1. User's selected network from session (userSelectedNetwork)
+   * 2. Session's networkId
+   * 3. options.networkId from the caller
+   * 4. Empty string (let signer handle default)
+   *
+   * This ensures we always use the network the user selected when connecting,
+   * regardless of what the caller passes in.
+   *
+   * @param sessionInfo - Session info containing network selections
+   * @param sessionInfo.userSelectedNetwork
+   * @param optionsNetworkId - Network ID from caller options
+   * @param sessionInfo.networkId
+   * @returns Resolved network ID to use
+   */
+  private resolveNetworkId(
+    sessionInfo: { userSelectedNetwork: string; networkId: string },
+    optionsNetworkId?: string,
+  ): string {
+    // Prefer user's selected network, then session network, then options
+    const resolvedNetwork =
+      sessionInfo.userSelectedNetwork || sessionInfo.networkId || optionsNetworkId || '';
+
+    // Log if there's a mismatch between options and session network
+    if (
+      optionsNetworkId &&
+      sessionInfo.userSelectedNetwork &&
+      optionsNetworkId !== sessionInfo.userSelectedNetwork
+    ) {
+      logger.warn('Network mismatch: using session network over caller-provided network', {
+        callerNetwork: optionsNetworkId,
+        sessionNetwork: sessionInfo.userSelectedNetwork,
+        using: resolvedNetwork,
+      });
+    }
+
+    return resolvedNetwork;
+  }
+
+  /**
+   * Find session for account and validate it exists in SDK.
+   * @param accountAddress
+   * @param context
+   */
+  private findAndValidateSession(accountAddress: string, context: string) {
+    const sessionInfo = this.sessionStore.findSessionByAccount(accountAddress);
+    if (!sessionInfo) {
+      throw new Error(`No WalletConnect session found for account: ${accountAddress}`);
+    }
+
+    // Validate session exists in WC SDK
+    if (!this.validateSessionInSdk(sessionInfo.session.topic)) {
+      logger.error('Session not found in WC SDK', {
+        topic: sessionInfo.session.topic.substring(0, 16) + '...',
+        account: accountAddress,
+      });
+      this.eventBus.providerError.emit({
+        providerId: this.providerId,
+        error: new Error('WalletConnect session expired or disconnected. Please reconnect.'),
+        context,
+        timestamp: Date.now(),
+      });
+      throw new Error(
+        'WalletConnect session expired or disconnected. Please reconnect your wallet.',
+      );
+    }
+
+    return sessionInfo;
+  }
+
+  /**
+   * Validate session exists in WC SDK storage.
+   * @param topic
+   */
+  private validateSessionInSdk(topic: string): boolean {
+    if (!this.clientManager.isInitialized()) {
+      return false;
+    }
+
+    try {
+      const session = this.clientManager.getSession(topic);
+      return !!session;
+    } catch (error) {
+      logger.warn('Session validation failed', {
+        topic: topic.substring(0, 16) + '...',
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return false;
+    }
+  }
+}

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

@@ -0,0 +1,48 @@
+/**
+ * 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-types.ts
+ * @description Shared types for WalletConnect integration
+ *
+ * Common types used across the WalletConnect provider and signers
+ */
+
+import type { ISignClient } from '@walletconnect/types';
+import type { WalletConnectModal } from '@walletconnect/modal';
+
+/**
+ * Represents an active WalletConnect session
+ */
+export interface WalletConnectSession {
+  topic: string;
+  namespaces: Record<string, unknown>;
+  ledgerId: string;
+}
+
+/**
+ * Context object containing all necessary WalletConnect instances
+ */
+export interface SignerContext {
+  client: ISignClient;
+  session: WalletConnectSession;
+  modal?: WalletConnectModal;
+}
+
+/**
+ * Metadata about a WalletConnect session for storage/restoration
+ */
+export interface SessionMetadata {
+  projectId: string;
+  ledgerId: string;
+  networkId: string;
+  topic: string;
+  connectedAt: number;
+}

package/src/lib/providers/walletconnect/index.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 index.ts
+ * @description Barrel export for WalletConnect module
+ *
+ * Provides a clean public API for the WalletConnect integration.
+ * Exports all necessary types, classes, and utilities.
+ */
+
+// Core
+export * from './core/walletconnect-provider';
+export * from './core/walletconnect-session-store';
+export * from './core/walletconnect-client-manager';
+export * from './core/walletconnect-signing-orchestrator';
+export * from './core/base-signer.interface';
+export * from './core/walletconnect-types';
+
+// Signers
+export * from './signers/hedera-signer';
+export * from './signers/xrpl-signer';
+export * from './signers/signer-factory';
+
+// Encoders - re-export from native-wallet-sdk for convenience
+export { HederaTransactionEncoder, XrplTransactionEncoder } from '@hsuite/native-connect-sdk';