@sidhujag/sysweb3-keyring 1.0.628 → 2.1.0

package/cjs/hardware-wallet-manager.js

@@ -1,13 +1,42 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HardwareWalletManager = exports.ConnectionStatus = exports.HardwareWalletType = void 0;
-const hw_transport_webhid_1 = __importDefault(require("@ledgerhq/hw-transport-webhid"));
-const logs_1 = require("@ledgerhq/logs");
-const connect_webextension_1 = __importDefault(require("@trezor/connect-webextension"));
 const events_1 = require("events");
+const host_types_1 = require("./ledger/host-types");
+const connect_1 = __importStar(require("./trezor/connect"));
 var HardwareWalletType;
 (function (HardwareWalletType) {
     HardwareWalletType["LEDGER"] = "ledger";
@@ -24,11 +53,12 @@ var ConnectionStatus;
  * Hardware Wallet Manager with connection pooling, status monitoring, and error recovery
  */
 class HardwareWalletManager extends events_1.EventEmitter {
-    constructor() {
+    constructor(ledgerHost) {
         super();
+        this.ledgerHost = ledgerHost;
         this.connectionPool = new Map();
         this.statusMonitorInterval = null;
-        this.CONNECTION_TIMEOUT = 30000; // 30 seconds
+        this.lifecycleGeneration = 0;
         this.IDLE_TIMEOUT = 5 * 60 * 1000; // 5 minutes
         this.STATUS_CHECK_INTERVAL = 5000; // 5 seconds
         this.retryConfig = {
@@ -37,92 +67,109 @@ class HardwareWalletManager extends events_1.EventEmitter {
             maxDelay: 10000, // 10 seconds
             backoffMultiplier: 2,
         };
+        this.observeTrezor();
         this.startStatusMonitoring();
-        // Set up Ledger debug logging
-        if (process.env.NODE_ENV === 'development') {
-            (0, logs_1.listen)((log) => {
-                console.log(`[Ledger] ${log.type}: ${log.message}`);
-            });
-        }
     }
-    /**
-     * Get or create a Ledger connection with retry logic
-     */
+    observeTrezor() {
+        if (this.unsubscribeTrezor)
+            return;
+        this.unsubscribeTrezor = (0, connect_1.subscribeTrezorEvents)((event) => {
+            if (event.type === 'disconnected') {
+                // Our pre-init disposal and Connect initialization invalidate the
+                // adapter too. Keep this attempt owned until it settles or is revoked.
+                if (this.connectionPool.get('trezor-default')?.status ===
+                    ConnectionStatus.CONNECTING)
+                    return;
+                this.handleDisconnect('trezor-default', HardwareWalletType.TREZOR);
+            }
+        });
+    }
+    /** Raw transports are deliberately unavailable through the semantic host boundary. */
     async getLedgerConnection() {
+        throw (0, host_types_1.ledgerHostError)('HARDWARE_SIGNER_UNAVAILABLE', 'Ledger requires a semantic LedgerHost; raw Ledger transports are not supported');
+    }
+    async initializeLedger() {
+        const host = this.ledgerHost;
+        if (!host) {
+            throw (0, host_types_1.ledgerHostError)('HARDWARE_SIGNER_UNAVAILABLE', 'A semantic LedgerHost is required to connect Ledger');
+        }
+        if (this.destruction)
+            throw (0, host_types_1.ledgerCancelledError)();
+        this.startStatusMonitoring();
         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;
+        if (host.getStatus().connected) {
+            const existing = this.connectionPool.get(key);
+            if (existing)
+                existing.lastActivity = Date.now();
+            return;
         }
-        return this.createLedgerConnectionWithRetry(key);
-    }
-    /**
-     * Create Ledger connection with exponential backoff retry
-     */
-    async createLedgerConnectionWithRetry(key) {
+        if (this.ledgerInitialization)
+            return this.ledgerInitialization;
+        const generation = this.lifecycleGeneration;
         const entry = {
             status: ConnectionStatus.CONNECTING,
             lastActivity: Date.now(),
             retryCount: 0,
         };
         this.connectionPool.set(key, entry);
-        let lastError;
-        for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
-            try {
-                this.emit('connectionAttempt', {
+        const isCurrent = () => generation === this.lifecycleGeneration &&
+            this.connectionPool.get(key) === entry &&
+            !this.destruction;
+        const assertCurrent = () => {
+            if (!isCurrent())
+                throw (0, host_types_1.ledgerCancelledError)();
+        };
+        // Install the shared promise before any observer can re-enter this method.
+        const pending = Promise.resolve().then(async () => {
+            assertCurrent();
+            this.emit('connectionAttempt', {
+                type: HardwareWalletType.LEDGER,
+                attempt: 1,
+                maxAttempts: 1,
+            });
+            assertCurrent();
+            // Device selection happens in the visible host, never by a background chooser.
+            await host.connect({ useGrantedDevices: true });
+            assertCurrent();
+            if (!host.getStatus().connected)
+                throw (0, host_types_1.ledgerHostError)('HARDWARE_SIGNER_UNAVAILABLE', 'Connect a Ledger device in the Ledger window');
+            entry.status = ConnectionStatus.CONNECTED;
+            entry.lastActivity = Date.now();
+            this.emit('connected', { type: HardwareWalletType.LEDGER });
+            assertCurrent();
+        });
+        this.ledgerInitialization = pending;
+        try {
+            await pending;
+        }
+        catch (error) {
+            if (isCurrent()) {
+                entry.status = ConnectionStatus.ERROR;
+                entry.error = error;
+                this.emit('connectionFailed', {
                     type: HardwareWalletType.LEDGER,
-                    attempt: attempt + 1,
-                    maxAttempts: this.retryConfig.maxRetries + 1,
+                    error: entry.error.message,
                 });
-                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;
-                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);
-                }
             }
+            throw error;
+        }
+        finally {
+            if (this.ledgerInitialization === pending)
+                this.ledgerInitialization = undefined;
         }
-        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
-     */
-    async createLedgerTransport() {
-        return Promise.race([
-            hw_transport_webhid_1.default.create(),
-            this.createTimeoutPromise(this.CONNECTION_TIMEOUT, 'Ledger connection timeout'),
-        ]);
     }
     /**
      * Initialize Trezor with retry logic
      */
     async initializeTrezor() {
+        if (this.destruction) {
+            throw Object.assign(new Error('Trezor connection is closing'), {
+                code: 'Method_Interrupted',
+            });
+        }
+        const generation = this.lifecycleGeneration;
+        this.observeTrezor();
+        this.startStatusMonitoring();
         const key = `${HardwareWalletType.TREZOR}-default`;
         const existing = this.connectionPool.get(key);
         if (existing?.status === ConnectionStatus.CONNECTED) {
@@ -130,25 +177,40 @@ class HardwareWalletManager extends events_1.EventEmitter {
             return true;
         }
         // Check if we're already trying to connect
-        if (existing?.status === ConnectionStatus.CONNECTING) {
+        if (this.trezorInitialization ||
+            existing?.status === ConnectionStatus.CONNECTING) {
             console.log('[HardwareWalletManager] Trezor connection already in progress');
             // Wait a bit and check again
             await this.delay(1000);
+            if (generation !== this.lifecycleGeneration || this.destruction)
+                return false;
             const updated = this.connectionPool.get(key);
             return updated?.status === ConnectionStatus.CONNECTED || false;
         }
-        return this.initializeTrezorWithRetry(key);
+        const owner = {};
+        this.trezorInitialization = owner;
+        try {
+            return await this.initializeTrezorWithRetry(key, owner, generation);
+        }
+        finally {
+            if (this.trezorInitialization === owner)
+                this.trezorInitialization = undefined;
+        }
     }
     /**
      * Initialize Trezor with exponential backoff retry
      */
-    async initializeTrezorWithRetry(key) {
+    async initializeTrezorWithRetry(key, owner, generation) {
         const entry = {
             status: ConnectionStatus.CONNECTING,
             lastActivity: Date.now(),
             retryCount: 0,
         };
         this.connectionPool.set(key, entry);
+        const isCurrent = () => generation === this.lifecycleGeneration &&
+            this.trezorInitialization === owner &&
+            this.connectionPool.get(key) === entry &&
+            !this.destruction;
         let lastError;
         // Reduce retry attempts for Trezor to prevent repeated popups
         const trezorRetryConfig = {
@@ -156,73 +218,93 @@ class HardwareWalletManager extends events_1.EventEmitter {
             maxRetries: 1, // Only retry once for Trezor
         };
         for (let attempt = 0; attempt <= trezorRetryConfig.maxRetries; attempt++) {
+            if (!isCurrent())
+                return false;
             try {
                 this.emit('connectionAttempt', {
                     type: HardwareWalletType.TREZOR,
                     attempt: attempt + 1,
                     maxAttempts: trezorRetryConfig.maxRetries + 1,
                 });
-                // Dispose any existing iframe before initialization
+                if (!isCurrent())
+                    return false;
+                // Dispose the previous Suite connection before initialization
                 try {
-                    await connect_webextension_1.default.dispose();
+                    await connect_1.default.dispose();
                 }
                 catch (disposeError) {
                     console.log('[HardwareWalletManager] Dispose error (safe to ignore):', disposeError);
                 }
-                await connect_webextension_1.default.init({
+                if (!isCurrent())
+                    return false;
+                await connect_1.default.init({
                     manifest: {
                         appName: 'Pali Wallet',
                         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
-                    // Suite desktop handles newer devices; older devices retain the popup fallback.
+                    // Connect chooses Suite Desktop, then the supported Suite Web fallback.
                     coreMode: 'auto',
                 });
+                if (!isCurrent())
+                    return false;
                 entry.status = ConnectionStatus.CONNECTED;
                 entry.retryCount = 0;
                 entry.error = undefined;
                 this.emit('connected', { type: HardwareWalletType.TREZOR });
-                // Set up device event listeners
-                connect_webextension_1.default.on('DEVICE_EVENT', (event) => {
-                    if (event.type === 'device-disconnect') {
-                        this.handleDisconnect(key, HardwareWalletType.TREZOR);
-                    }
-                });
-                return true;
+                return isCurrent();
             }
             catch (error) {
+                // Teardown or a newer owner revoked this attempt. Its continuation
+                // must not mutate status, retry, or dispose the newer connection.
+                if (!isCurrent())
+                    return false;
                 lastError = error;
+                if (lastError.code === 'HARDWARE_SIGNER_BUSY') {
+                    entry.status = ConnectionStatus.ERROR;
+                    entry.error = lastError;
+                    this.emit('connectionFailed', {
+                        type: HardwareWalletType.TREZOR,
+                        error: lastError.message,
+                    });
+                    throw lastError;
+                }
+                if (lastError.code === 'HARDWARE_SIGNER_UNAVAILABLE')
+                    break;
                 // 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 connect_webextension_1.default.getFeatures();
+                        const testResponse = await connect_1.default.getFeatures();
+                        if (!isCurrent())
+                            return false;
                         if (testResponse.success) {
                             entry.status = ConnectionStatus.CONNECTED;
                             entry.retryCount = 0;
                             entry.error = undefined;
                             this.emit('connected', { type: HardwareWalletType.TREZOR });
-                            return true;
+                            return isCurrent();
                         }
                     }
                     catch (testError) {
                         console.log('[HardwareWalletManager] Trezor test connection failed:', testError);
                     }
+                    if (!isCurrent())
+                        return false;
                     // If test failed, dispose and retry
                     try {
-                        await connect_webextension_1.default.dispose();
+                        await connect_1.default.dispose();
+                        if (!isCurrent())
+                            return false;
                         await this.delay(500);
                     }
                     catch (disposeError) {
                         console.log('[HardwareWalletManager] Error disposing for retry:', disposeError);
                     }
+                    if (!isCurrent())
+                        return false;
                 }
                 entry.retryCount = attempt + 1;
                 entry.error = lastError;
@@ -232,17 +314,19 @@ class HardwareWalletManager extends events_1.EventEmitter {
                     console.log('[HardwareWalletManager] Trezor device is in use by another application');
                     // Try to dispose and reinitialize
                     try {
-                        await connect_webextension_1.default.dispose();
+                        await connect_1.default.dispose();
+                        if (!isCurrent())
+                            return false;
                         await this.delay(2000); // Wait 2 seconds before retry
                     }
                     catch (disposeError) {
                         console.log('[HardwareWalletManager] Error during dispose:', disposeError);
                     }
+                    if (!isCurrent())
+                        return false;
                 }
                 // Don't retry if user cancelled
-                if (lastError.message.includes('Popup closed') ||
-                    lastError.message.includes('cancelled') ||
-                    lastError.message.includes('denied')) {
+                if (this.isUserCancellationError(lastError)) {
                     console.log('[HardwareWalletManager] User cancelled Trezor connection');
                     break; // Exit retry loop
                 }
@@ -255,17 +339,23 @@ class HardwareWalletManager extends events_1.EventEmitter {
                         error: lastError.message,
                     });
                     await this.delay(delay);
+                    if (!isCurrent())
+                        return false;
                 }
             }
         }
+        if (!isCurrent())
+            return false;
         entry.status = ConnectionStatus.ERROR;
         this.emit('connectionFailed', {
             type: HardwareWalletType.TREZOR,
             error: lastError?.message,
         });
+        if (!isCurrent())
+            return false;
         // Clean up on failure
         try {
-            await connect_webextension_1.default.dispose();
+            await connect_1.default.dispose();
         }
         catch (disposeError) {
             console.log('[HardwareWalletManager] Failed to dispose on error:', disposeError);
@@ -279,7 +369,6 @@ class HardwareWalletManager extends events_1.EventEmitter {
         const entry = this.connectionPool.get(key);
         if (entry) {
             entry.status = ConnectionStatus.DISCONNECTED;
-            entry.transport = null;
             this.emit('disconnected', { type });
         }
     }
@@ -298,16 +387,29 @@ class HardwareWalletManager extends events_1.EventEmitter {
      * Check all connections and clean up idle ones
      */
     async checkAllConnections() {
+        const generation = this.lifecycleGeneration;
+        const isCurrent = () => generation === this.lifecycleGeneration && !this.destruction;
+        if (!isCurrent())
+            return;
         const now = Date.now();
         const statuses = [];
         for (const [key, entry] of this.connectionPool.entries()) {
+            if (!isCurrent())
+                return;
             const type = key.startsWith(HardwareWalletType.LEDGER)
                 ? HardwareWalletType.LEDGER
                 : HardwareWalletType.TREZOR;
+            if (type === HardwareWalletType.LEDGER &&
+                entry.status === ConnectionStatus.CONNECTED &&
+                !this.ledgerHost?.getStatus().connected) {
+                this.handleDisconnect(key, type);
+            }
             // Clean up idle connections
             if (entry.status === ConnectionStatus.CONNECTED &&
                 now - entry.lastActivity > this.IDLE_TIMEOUT) {
-                await this.closeConnection(key);
+                await this.closeConnection(key, entry);
+                if (!isCurrent())
+                    return;
                 continue;
             }
             // Build status
@@ -320,7 +422,8 @@ class HardwareWalletManager extends events_1.EventEmitter {
             };
             statuses.push(status);
         }
-        this.emit('statusUpdate', statuses);
+        if (isCurrent())
+            this.emit('statusUpdate', statuses);
     }
     /**
      * Get current status of all hardware wallets
@@ -329,10 +432,19 @@ class HardwareWalletManager extends events_1.EventEmitter {
         const statuses = [];
         // Check Ledger
         const ledgerEntry = this.connectionPool.get(`${HardwareWalletType.LEDGER}-default`);
+        const ledgerConnected = !this.destruction && this.ledgerHost?.getStatus().connected === true;
         statuses.push({
             type: HardwareWalletType.LEDGER,
-            status: ledgerEntry?.status || ConnectionStatus.DISCONNECTED,
-            connected: ledgerEntry?.status === ConnectionStatus.CONNECTED,
+            status: this.destruction
+                ? ConnectionStatus.DISCONNECTED
+                : ledgerConnected
+                    ? ConnectionStatus.CONNECTED
+                    : ledgerEntry?.status === ConnectionStatus.CONNECTING
+                        ? ConnectionStatus.CONNECTING
+                        : ledgerEntry?.status === ConnectionStatus.ERROR
+                            ? ConnectionStatus.ERROR
+                            : ConnectionStatus.DISCONNECTED,
+            connected: ledgerConnected,
             lastSeen: ledgerEntry?.lastActivity,
             error: ledgerEntry?.error?.message,
         });
@@ -351,6 +463,8 @@ class HardwareWalletManager extends events_1.EventEmitter {
      * Check if a specific device is connected
      */
     isConnected(type) {
+        if (type === HardwareWalletType.LEDGER)
+            return (!this.destruction && this.ledgerHost?.getStatus().connected === true);
         const key = `${type}-default`;
         const entry = this.connectionPool.get(key);
         return entry?.status === ConnectionStatus.CONNECTED;
@@ -360,7 +474,7 @@ class HardwareWalletManager extends events_1.EventEmitter {
      */
     async ensureConnection(type) {
         if (type === HardwareWalletType.LEDGER) {
-            await this.getLedgerConnection();
+            await this.initializeLedger();
         }
         else if (type === HardwareWalletType.TREZOR) {
             const initialized = await this.initializeTrezor();
@@ -372,42 +486,88 @@ class HardwareWalletManager extends events_1.EventEmitter {
     /**
      * Close a specific connection
      */
-    async closeConnection(key) {
-        const entry = this.connectionPool.get(key);
+    async closeConnection(key, entry = this.connectionPool.get(key)) {
+        if (!entry || this.connectionPool.get(key) !== entry)
+            return;
         // Handle Trezor connections
         if (key.startsWith(HardwareWalletType.TREZOR)) {
             try {
-                await connect_webextension_1.default.dispose();
+                await connect_1.default.dispose();
             }
             catch (error) {
                 console.error('Error disposing Trezor:', error);
             }
         }
-        // Handle Ledger connections
-        if (entry?.transport) {
+        if (key.startsWith(HardwareWalletType.LEDGER)) {
             try {
-                await entry.transport.close();
+                await this.ledgerHost?.disconnect();
             }
             catch (error) {
-                console.error('Error closing transport:', error);
+                console.error('Error disconnecting Ledger host:', error);
             }
         }
-        this.connectionPool.delete(key);
+        if (this.connectionPool.get(key) === entry)
+            this.connectionPool.delete(key);
     }
     /**
      * Close all connections and stop monitoring
      */
-    async destroy() {
+    destroy() {
+        if (this.destruction)
+            return this.destruction;
+        // Revoke pending initialization synchronously, before closing any transport.
+        this.lifecycleGeneration++;
+        this.trezorInitialization = undefined;
+        this.ledgerInitialization = undefined;
+        this.unsubscribeTrezor?.();
+        this.unsubscribeTrezor = undefined;
         // 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);
+        const entries = [...this.connectionPool.entries()];
+        const trezor = this.connectionPool.get('trezor-default');
+        if (trezor)
+            trezor.status = ConnectionStatus.DISCONNECTED;
+        let resolve;
+        let reject;
+        const destruction = new Promise((done, failed) => {
+            resolve = done;
+            reject = failed;
+        });
+        this.destruction = destruction;
+        // Revoke Trezor first, then Ledger in this same call stack. Awaiting either
+        // cleanup before revoking the other could admit an already-queued response.
+        const trezorCleanup = entries
+            .filter(([key]) => key.startsWith(HardwareWalletType.TREZOR))
+            .map(([key, entry]) => this.closeConnection(key, entry));
+        let ledgerCleanup;
+        try {
+            ledgerCleanup = Promise.resolve(this.ledgerHost?.disconnect()).catch((error) => {
+                console.error('Error disconnecting Ledger host:', error);
+            });
+        }
+        catch (error) {
+            console.error('Error disconnecting Ledger host:', error);
+            ledgerCleanup = Promise.resolve();
         }
-        this.removeAllListeners();
+        const close = async () => {
+            try {
+                await Promise.all([...trezorCleanup, ledgerCleanup]);
+                for (const [key, entry] of entries) {
+                    if (this.connectionPool.get(key) === entry)
+                        this.connectionPool.delete(key);
+                }
+                this.removeAllListeners();
+            }
+            finally {
+                if (this.destruction === destruction)
+                    this.destruction = undefined;
+            }
+        };
+        void close().then(resolve, reject);
+        return destruction;
     }
     /**
      * Calculate exponential backoff delay
@@ -419,14 +579,6 @@ class HardwareWalletManager extends events_1.EventEmitter {
         const jitter = delay * 0.2 * (Math.random() - 0.5);
         return Math.round(delay + jitter);
     }
-    /**
-     * Create a timeout promise
-     */
-    createTimeoutPromise(ms, message) {
-        return new Promise((_, reject) => {
-            setTimeout(() => reject(new Error(message)), ms);
-        });
-    }
     /**
      * Delay helper
      */
@@ -470,6 +622,27 @@ class HardwareWalletManager extends events_1.EventEmitter {
         const message = (err?.message || '').toLowerCase();
         const name = err?.name || '';
         const statusCode = err?.statusCode;
+        const code = err?.code;
+        if (code === 'HARDWARE_REQUEST_CANCELLED' ||
+            code === 'HARDWARE_CLEAR_SIGNING_UNAVAILABLE' ||
+            code === 'HARDWARE_ACCOUNT_MISMATCH' ||
+            code === 'LEDGER_INVALID_REQUEST' ||
+            code === 'LEDGER_INVALID_RESPONSE' ||
+            code === 'LEDGER_INVALID_SIGNATURE' ||
+            code === 'HARDWARE_SIGNER_UNAVAILABLE' ||
+            code === 'HARDWARE_SIGNER_BUSY' ||
+            code === 'Method_Cancel' ||
+            code === 'Method_Interrupted' ||
+            code === 'Method_PermissionsNotGranted' ||
+            code === 'Method_Unsupported' ||
+            code === 'Method_UnsupportedCoinForHost' ||
+            code === 'Device_Disconnected' ||
+            code === 'Device_NotFound' ||
+            code === 'Device_CallInProgress' ||
+            code === 'Transport_Missing' ||
+            code === 'Desktop_ConnectionMissing' ||
+            code === 'Browser_LocalNetworkPermissionMissing')
+            return true;
         // Ledger: 0x6985 (Conditions of use not satisfied) on rejection
         if (statusCode === 0x6985)
             return true;
@@ -480,6 +653,7 @@ class HardwareWalletManager extends events_1.EventEmitter {
                 message.includes('satisf')) ||
             message.includes('not allowed') ||
             message.includes('permission denied') ||
+            message.includes('permissions not granted') ||
             message.includes('user rejected') ||
             message.includes('denied by the user') ||
             message.includes('failure_actioncancelled') ||