@sidhujag/sysweb3-keyring 1.0.544 → 1.0.547

package/src/hardware-wallet-manager.ts

@@ -0,0 +1,655 @@
+import Transport from '@ledgerhq/hw-transport';
+import HIDTransport from '@ledgerhq/hw-transport-webhid';
+import { listen } from '@ledgerhq/logs';
+import TrezorConnect from '@trezor/connect-webextension';
+import { EventEmitter } from 'events';
+
+export enum HardwareWalletType {
+  LEDGER = 'ledger',
+  TREZOR = 'trezor',
+}
+
+export enum ConnectionStatus {
+  DISCONNECTED = 'disconnected',
+  CONNECTING = 'connecting',
+  CONNECTED = 'connected',
+  ERROR = 'error',
+}
+
+interface ConnectionPoolEntry {
+  transport?: Transport | null;
+  status: ConnectionStatus;
+  lastActivity: number;
+  retryCount: number;
+  error?: Error;
+}
+
+interface RetryConfig {
+  maxRetries: number;
+  baseDelay: number;
+  maxDelay: number;
+  backoffMultiplier: number;
+}
+
+export interface HardwareWalletStatus {
+  type: HardwareWalletType;
+  status: ConnectionStatus;
+  connected: boolean;
+  lastSeen?: number;
+  error?: string;
+  deviceInfo?: {
+    model?: string;
+    firmwareVersion?: string;
+  };
+}
+
+/**
+ * Hardware Wallet Manager with connection pooling, status monitoring, and error recovery
+ */
+export class HardwareWalletManager extends EventEmitter {
+  private connectionPool: Map<string, ConnectionPoolEntry> = new Map();
+  private statusMonitorInterval: NodeJS.Timeout | null = null;
+  private readonly CONNECTION_TIMEOUT = 30000; // 30 seconds
+  private readonly IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+  private readonly STATUS_CHECK_INTERVAL = 5000; // 5 seconds
+
+  private readonly retryConfig: RetryConfig = {
+    maxRetries: 3,
+    baseDelay: 1000, // 1 second
+    maxDelay: 10000, // 10 seconds
+    backoffMultiplier: 2,
+  };
+
+  constructor() {
+    super();
+    this.startStatusMonitoring();
+
+    // Set up Ledger debug logging
+    if (process.env.NODE_ENV === 'development') {
+      listen((log) => {
+        console.log(`[Ledger] ${log.type}: ${log.message}`);
+      });
+    }
+  }
+
+  /**
+   * Get or create a Ledger connection with retry logic
+   */
+  async getLedgerConnection(): Promise<Transport> {
+    const key = `${HardwareWalletType.LEDGER}-default`;
+    const existing = this.connectionPool.get(key);
+
+    if (existing?.transport && existing.status === ConnectionStatus.CONNECTED) {
+      existing.lastActivity = Date.now();
+      return existing.transport;
+    }
+
+    return this.createLedgerConnectionWithRetry(key);
+  }
+
+  /**
+   * Create Ledger connection with exponential backoff retry
+   */
+  private async createLedgerConnectionWithRetry(
+    key: string
+  ): Promise<Transport> {
+    const entry: ConnectionPoolEntry = {
+      status: ConnectionStatus.CONNECTING,
+      lastActivity: Date.now(),
+      retryCount: 0,
+    };
+    this.connectionPool.set(key, entry);
+
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        this.emit('connectionAttempt', {
+          type: HardwareWalletType.LEDGER,
+          attempt: attempt + 1,
+          maxAttempts: this.retryConfig.maxRetries + 1,
+        });
+
+        const transport = await this.createLedgerTransport();
+
+        entry.transport = transport;
+        entry.status = ConnectionStatus.CONNECTED;
+        entry.retryCount = 0;
+        entry.error = undefined;
+
+        this.emit('connected', { type: HardwareWalletType.LEDGER });
+
+        // Set up disconnect handler
+        transport.on('disconnect', () => {
+          this.handleDisconnect(key, HardwareWalletType.LEDGER);
+        });
+
+        return transport;
+      } catch (error) {
+        lastError = error as Error;
+        entry.retryCount = attempt + 1;
+        entry.error = lastError;
+
+        if (attempt < this.retryConfig.maxRetries) {
+          const delay = this.calculateBackoffDelay(attempt);
+
+          this.emit('retrying', {
+            type: HardwareWalletType.LEDGER,
+            attempt: attempt + 1,
+            nextRetryIn: delay,
+            error: lastError.message,
+          });
+
+          await this.delay(delay);
+        }
+      }
+    }
+
+    entry.status = ConnectionStatus.ERROR;
+    this.emit('connectionFailed', {
+      type: HardwareWalletType.LEDGER,
+      error: lastError?.message,
+    });
+
+    throw new Error(
+      `Failed to connect to Ledger after ${
+        this.retryConfig.maxRetries + 1
+      } attempts: ${lastError?.message || 'Unknown error'}`
+    );
+  }
+
+  /**
+   * Create Ledger transport with timeout
+   */
+  private async createLedgerTransport(): Promise<Transport> {
+    return Promise.race([
+      HIDTransport.create(),
+      this.createTimeoutPromise<Transport>(
+        this.CONNECTION_TIMEOUT,
+        'Ledger connection timeout'
+      ),
+    ]);
+  }
+
+  /**
+   * Initialize Trezor with retry logic
+   */
+  async initializeTrezor(): Promise<boolean> {
+    const key = `${HardwareWalletType.TREZOR}-default`;
+    const existing = this.connectionPool.get(key);
+
+    if (existing?.status === ConnectionStatus.CONNECTED) {
+      existing.lastActivity = Date.now();
+      return true;
+    }
+
+    // Check if we're already trying to connect
+    if (existing?.status === ConnectionStatus.CONNECTING) {
+      console.log(
+        '[HardwareWalletManager] Trezor connection already in progress'
+      );
+      // Wait a bit and check again
+      await this.delay(1000);
+      const updated = this.connectionPool.get(key);
+      return updated?.status === ConnectionStatus.CONNECTED || false;
+    }
+
+    return this.initializeTrezorWithRetry(key);
+  }
+
+  /**
+   * Initialize Trezor with exponential backoff retry
+   */
+  private async initializeTrezorWithRetry(key: string): Promise<boolean> {
+    const entry: ConnectionPoolEntry = {
+      status: ConnectionStatus.CONNECTING,
+      lastActivity: Date.now(),
+      retryCount: 0,
+    };
+    this.connectionPool.set(key, entry);
+
+    let lastError: Error | undefined;
+
+    // Reduce retry attempts for Trezor to prevent repeated popups
+    const trezorRetryConfig = {
+      ...this.retryConfig,
+      maxRetries: 1, // Only retry once for Trezor
+    };
+
+    for (let attempt = 0; attempt <= trezorRetryConfig.maxRetries; attempt++) {
+      try {
+        this.emit('connectionAttempt', {
+          type: HardwareWalletType.TREZOR,
+          attempt: attempt + 1,
+          maxAttempts: trezorRetryConfig.maxRetries + 1,
+        });
+
+        // Dispose any existing iframe before initialization
+        try {
+          await TrezorConnect.dispose();
+        } catch (disposeError) {
+          console.log(
+            '[HardwareWalletManager] Dispose error (safe to ignore):',
+            disposeError
+          );
+        }
+
+        await TrezorConnect.init({
+          manifest: {
+            appUrl: 'https://paliwallet.com/',
+            email: 'support@syscoin.org',
+          },
+          lazyLoad: true,
+          popup: true,
+          connectSrc: 'https://connect.trezor.io/9/',
+          _extendWebextensionLifetime: true,
+          transports: ['BridgeTransport', 'WebUsbTransport'],
+          debug: false, // Disable debug mode to prevent extra logs
+          coreMode: 'popup', // Use popup mode for webUSB support in Chrome extension
+        });
+
+        entry.status = ConnectionStatus.CONNECTED;
+        entry.retryCount = 0;
+        entry.error = undefined;
+
+        this.emit('connected', { type: HardwareWalletType.TREZOR });
+
+        // Set up device event listeners
+        TrezorConnect.on('DEVICE_EVENT', (event: any) => {
+          if (event.type === 'device-disconnect') {
+            this.handleDisconnect(key, HardwareWalletType.TREZOR);
+          }
+        });
+
+        return true;
+      } catch (error) {
+        lastError = error as Error;
+
+        // Check if already initialized - this is actually OK
+        if (
+          lastError.message.includes(
+            'TrezorConnect has been already initialized'
+          )
+        ) {
+          // Instead of just marking as connected, verify the connection
+          try {
+            // Test the connection with a simple call
+            const testResponse = await TrezorConnect.getFeatures();
+            if (testResponse.success) {
+              entry.status = ConnectionStatus.CONNECTED;
+              entry.retryCount = 0;
+              entry.error = undefined;
+              this.emit('connected', { type: HardwareWalletType.TREZOR });
+              return true;
+            }
+          } catch (testError) {
+            console.log(
+              '[HardwareWalletManager] Trezor test connection failed:',
+              testError
+            );
+          }
+
+          // If test failed, dispose and retry
+          try {
+            await TrezorConnect.dispose();
+            await this.delay(500);
+          } catch (disposeError) {
+            console.log(
+              '[HardwareWalletManager] Error disposing for retry:',
+              disposeError
+            );
+          }
+        }
+
+        entry.retryCount = attempt + 1;
+        entry.error = lastError;
+
+        // Check for specific Trezor errors
+        if (
+          lastError.message.includes('device is already in use') ||
+          lastError.message.includes('Device is being used in another window')
+        ) {
+          console.log(
+            '[HardwareWalletManager] Trezor device is in use by another application'
+          );
+
+          // Try to dispose and reinitialize
+          try {
+            await TrezorConnect.dispose();
+            await this.delay(2000); // Wait 2 seconds before retry
+          } catch (disposeError) {
+            console.log(
+              '[HardwareWalletManager] Error during dispose:',
+              disposeError
+            );
+          }
+        }
+
+        // Don't retry if user cancelled
+        if (
+          lastError.message.includes('Popup closed') ||
+          lastError.message.includes('cancelled') ||
+          lastError.message.includes('denied')
+        ) {
+          console.log(
+            '[HardwareWalletManager] User cancelled Trezor connection'
+          );
+          break; // Exit retry loop
+        }
+
+        if (attempt < trezorRetryConfig.maxRetries) {
+          const delay = this.calculateBackoffDelay(attempt);
+
+          this.emit('retrying', {
+            type: HardwareWalletType.TREZOR,
+            attempt: attempt + 1,
+            nextRetryIn: delay,
+            error: lastError.message,
+          });
+
+          await this.delay(delay);
+        }
+      }
+    }
+
+    entry.status = ConnectionStatus.ERROR;
+    this.emit('connectionFailed', {
+      type: HardwareWalletType.TREZOR,
+      error: lastError?.message,
+    });
+
+    // Clean up on failure
+    try {
+      await TrezorConnect.dispose();
+    } catch (disposeError) {
+      console.log(
+        '[HardwareWalletManager] Failed to dispose on error:',
+        disposeError
+      );
+    }
+
+    return false;
+  }
+
+  /**
+   * Handle device disconnect
+   */
+  private handleDisconnect(key: string, type: HardwareWalletType): void {
+    const entry = this.connectionPool.get(key);
+    if (entry) {
+      entry.status = ConnectionStatus.DISCONNECTED;
+      entry.transport = null;
+      this.emit('disconnected', { type });
+    }
+  }
+
+  /**
+   * Start real-time status monitoring
+   */
+  private startStatusMonitoring(): void {
+    if (this.statusMonitorInterval) {
+      return;
+    }
+
+    this.statusMonitorInterval = setInterval(() => {
+      this.checkAllConnections();
+    }, this.STATUS_CHECK_INTERVAL);
+  }
+
+  /**
+   * Check all connections and clean up idle ones
+   */
+  private async checkAllConnections(): Promise<void> {
+    const now = Date.now();
+    const statuses: HardwareWalletStatus[] = [];
+
+    for (const [key, entry] of this.connectionPool.entries()) {
+      const type = key.startsWith(HardwareWalletType.LEDGER)
+        ? HardwareWalletType.LEDGER
+        : HardwareWalletType.TREZOR;
+
+      // Clean up idle connections
+      if (
+        entry.status === ConnectionStatus.CONNECTED &&
+        now - entry.lastActivity > this.IDLE_TIMEOUT
+      ) {
+        await this.closeConnection(key);
+        continue;
+      }
+
+      // Build status
+      const status: HardwareWalletStatus = {
+        type,
+        status: entry.status,
+        connected: entry.status === ConnectionStatus.CONNECTED,
+        lastSeen: entry.lastActivity,
+        error: entry.error?.message,
+      };
+
+      statuses.push(status);
+    }
+
+    this.emit('statusUpdate', statuses);
+  }
+
+  /**
+   * Get current status of all hardware wallets
+   */
+  getStatus(): HardwareWalletStatus[] {
+    const statuses: HardwareWalletStatus[] = [];
+
+    // Check Ledger
+    const ledgerEntry = this.connectionPool.get(
+      `${HardwareWalletType.LEDGER}-default`
+    );
+    statuses.push({
+      type: HardwareWalletType.LEDGER,
+      status: ledgerEntry?.status || ConnectionStatus.DISCONNECTED,
+      connected: ledgerEntry?.status === ConnectionStatus.CONNECTED,
+      lastSeen: ledgerEntry?.lastActivity,
+      error: ledgerEntry?.error?.message,
+    });
+
+    // Check Trezor
+    const trezorEntry = this.connectionPool.get(
+      `${HardwareWalletType.TREZOR}-default`
+    );
+    statuses.push({
+      type: HardwareWalletType.TREZOR,
+      status: trezorEntry?.status || ConnectionStatus.DISCONNECTED,
+      connected: trezorEntry?.status === ConnectionStatus.CONNECTED,
+      lastSeen: trezorEntry?.lastActivity,
+      error: trezorEntry?.error?.message,
+    });
+
+    return statuses;
+  }
+
+  /**
+   * Check if a specific device is connected
+   */
+  isConnected(type: HardwareWalletType): boolean {
+    const key = `${type}-default`;
+    const entry = this.connectionPool.get(key);
+    return entry?.status === ConnectionStatus.CONNECTED;
+  }
+
+  /**
+   * Ensure connection before operation
+   */
+  async ensureConnection(type: HardwareWalletType): Promise<void> {
+    if (type === HardwareWalletType.LEDGER) {
+      await this.getLedgerConnection();
+    } else if (type === HardwareWalletType.TREZOR) {
+      const initialized = await this.initializeTrezor();
+      if (!initialized) {
+        throw new Error('Failed to initialize Trezor');
+      }
+    }
+  }
+
+  /**
+   * Close a specific connection
+   */
+  private async closeConnection(key: string): Promise<void> {
+    const entry = this.connectionPool.get(key);
+
+    // Handle Trezor connections
+    if (key.startsWith(HardwareWalletType.TREZOR)) {
+      try {
+        await TrezorConnect.dispose();
+      } catch (error) {
+        console.error('Error disposing Trezor:', error);
+      }
+    }
+
+    // Handle Ledger connections
+    if (entry?.transport) {
+      try {
+        await entry.transport.close();
+      } catch (error) {
+        console.error('Error closing transport:', error);
+      }
+    }
+
+    this.connectionPool.delete(key);
+  }
+
+  /**
+   * Close all connections and stop monitoring
+   */
+  async destroy(): Promise<void> {
+    // Stop monitoring
+    if (this.statusMonitorInterval) {
+      clearInterval(this.statusMonitorInterval);
+      this.statusMonitorInterval = null;
+    }
+
+    // Close all connections
+    for (const key of this.connectionPool.keys()) {
+      await this.closeConnection(key);
+    }
+
+    this.removeAllListeners();
+  }
+
+  /**
+   * Calculate exponential backoff delay
+   */
+  private calculateBackoffDelay(attempt: number): number {
+    const delay = Math.min(
+      this.retryConfig.baseDelay *
+        Math.pow(this.retryConfig.backoffMultiplier, attempt),
+      this.retryConfig.maxDelay
+    );
+    // Add jitter (±20%)
+    const jitter = delay * 0.2 * (Math.random() - 0.5);
+    return Math.round(delay + jitter);
+  }
+
+  /**
+   * Create a timeout promise
+   */
+  private createTimeoutPromise<T>(ms: number, message: string): Promise<T> {
+    return new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(message)), ms);
+    });
+  }
+
+  /**
+   * Delay helper
+   */
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Retry an operation with exponential backoff
+   */
+  async retryOperation<T>(
+    operation: () => Promise<T>,
+    operationName: string,
+    customRetryConfig?: Partial<RetryConfig>
+  ): Promise<T> {
+    const config = { ...this.retryConfig, ...customRetryConfig };
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error as Error;
+
+        // Do not retry on explicit user cancellations (Ledger/Trezor)
+        if (this.isUserCancellationError(lastError)) {
+          throw lastError;
+        }
+
+        if (attempt < config.maxRetries) {
+          const delay = this.calculateBackoffDelay(attempt);
+
+          this.emit('operationRetry', {
+            operation: operationName,
+            attempt: attempt + 1,
+            nextRetryIn: delay,
+            error: lastError.message,
+          });
+
+          await this.delay(delay);
+        }
+      }
+    }
+
+    throw new Error(
+      `${operationName} failed after ${config.maxRetries + 1} attempts: ${
+        lastError?.message || 'Unknown error'
+      }`
+    );
+  }
+
+  /**
+   * Detects common user-cancellation errors to avoid pointless retries
+   */
+  private isUserCancellationError(err: Error): boolean {
+    const message = (err?.message || '').toLowerCase();
+    const name = (err as any)?.name || '';
+    const statusCode = (err as any)?.statusCode;
+
+    // Ledger: 0x6985 (Conditions of use not satisfied) on rejection
+    if (statusCode === 0x6985) return true;
+
+    // Message-based heuristics across vendors
+    if (
+      message.includes('0x6985') ||
+      (message.includes('condition') &&
+        message.includes('not') &&
+        message.includes('satisf')) ||
+      message.includes('not allowed') ||
+      message.includes('permission denied') ||
+      message.includes('user rejected') ||
+      message.includes('denied by the user') ||
+      message.includes('failure_actioncancelled') ||
+      message.includes('denied') ||
+      message.includes('rejected') ||
+      message.includes('refused') ||
+      message.includes('cancelled') ||
+      message.includes('canceled') ||
+      message.includes('popup closed')
+    ) {
+      return true;
+    }
+
+    // Name-based checks (align with frontend utilities)
+    if (
+      name === 'NotAllowedError' ||
+      name === 'AbortError' ||
+      name === 'UserCancel' ||
+      name === 'TransportError' ||
+      name === 'DOMException'
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from './transactions';
+export * from './trezor';
+export * from './types';
+export * from './storage';
+export * from './signers';
+export * from './initial-state';
+export * from './keyring-manager';
+export * from './providers';
+export * from './utils/derivation-paths';
+export * from './network-utils';
+export * from './hardware-wallet-manager';
+export { PsbtUtils } from './utils/psbt';