fix: improve Ledger error handling for disconnect, retry, and pagination cp-7.77.0

app/components/Views/LedgerSelectAccount/index.test.tsx

@@ -818,5 +818,129 @@ describe('LedgerSelectAccount', () => {
         expect(queryByText('Network error')).toBeOnTheScreen();
       });
     });
+
+    it('calls ensureDeviceReady before nextPage pagination', async () => {
+      const { getByTestId } = await renderAndWaitForAccounts();
+
+      mockEnsureDeviceReady.mockClear();
+      mockGetLedgerAccountsByOperation.mockClear();
+      mockGetLedgerAccountsByOperation.mockResolvedValue(mockAccounts);
+
+      await act(async () => {
+        fireEvent.press(getByTestId(AccountSelectorSelectorsIDs.NEXT_BUTTON));
+      });
+
+      await waitFor(() => {
+        expect(mockEnsureDeviceReady).toHaveBeenCalledWith('test-device-id');
+      });
+    });
+
+    it('calls ensureDeviceReady before prevPage pagination', async () => {
+      const { getByTestId } = await renderAndWaitForAccounts();
+
+      mockEnsureDeviceReady.mockClear();
+      mockGetLedgerAccountsByOperation.mockClear();
+      mockGetLedgerAccountsByOperation.mockResolvedValue(mockAccounts);
+
+      await act(async () => {
+        fireEvent.press(
+          getByTestId(AccountSelectorSelectorsIDs.PREVIOUS_BUTTON),
+        );
+      });
+
+      await waitFor(() => {
+        expect(mockEnsureDeviceReady).toHaveBeenCalledWith('test-device-id');
+      });
+    });
+
+    it('skips pagination when ensureDeviceReady returns false on nextPage', async () => {
+      const { getByTestId } = await renderAndWaitForAccounts();
+
+      mockEnsureDeviceReady.mockResolvedValue(false);
+      mockGetLedgerAccountsByOperation.mockClear();
+
+      await act(async () => {
+        fireEvent.press(getByTestId(AccountSelectorSelectorsIDs.NEXT_BUTTON));
+      });
+
+      await waitFor(() => {
+        expect(mockEnsureDeviceReady).toHaveBeenCalled();
+      });
+
+      expect(mockGetLedgerAccountsByOperation).not.toHaveBeenCalled();
+    });
+
+    it('skips pagination when ensureDeviceReady returns false on prevPage', async () => {
+      const { getByTestId } = await renderAndWaitForAccounts();
+
+      mockEnsureDeviceReady.mockResolvedValue(false);
+      mockGetLedgerAccountsByOperation.mockClear();
+
+      await act(async () => {
+        fireEvent.press(
+          getByTestId(AccountSelectorSelectorsIDs.PREVIOUS_BUTTON),
+        );
+      });
+
+      await waitFor(() => {
+        expect(mockEnsureDeviceReady).toHaveBeenCalled();
+      });
+
+      expect(mockGetLedgerAccountsByOperation).not.toHaveBeenCalled();
+    });
+
+    it('shows inline error when ensureDeviceReady throws during nextPage without blocking modal', async () => {
+      mockEnsureDeviceReady
+        .mockResolvedValueOnce(true)
+        .mockRejectedValueOnce(new Error('Device readiness check failed'));
+
+      const { getByTestId, queryByText } = await renderAndWaitForAccounts();
+
+      await act(async () => {
+        fireEvent.press(getByTestId(AccountSelectorSelectorsIDs.NEXT_BUTTON));
+      });
+
+      await waitFor(() => {
+        expect(queryByText('Device readiness check failed')).toBeOnTheScreen();
+      });
+      expect(queryByText('Please wait')).not.toBeOnTheScreen();
+    });
+
+    it('shows inline error when ensureDeviceReady throws during prevPage without blocking modal', async () => {
+      mockEnsureDeviceReady
+        .mockResolvedValueOnce(true)
+        .mockRejectedValueOnce(new Error('Bluetooth adapter unavailable'));
+
+      const { getByTestId, queryByText } = await renderAndWaitForAccounts();
+
+      await act(async () => {
+        fireEvent.press(
+          getByTestId(AccountSelectorSelectorsIDs.PREVIOUS_BUTTON),
+        );
+      });
+
+      await waitFor(() => {
+        expect(queryByText('Bluetooth adapter unavailable')).toBeOnTheScreen();
+      });
+      expect(queryByText('Please wait')).not.toBeOnTheScreen();
+    });
+
+    it('does not show blocking modal when ensureDeviceReady returns false on nextPage', async () => {
+      mockEnsureDeviceReady
+        .mockResolvedValueOnce(true)
+        .mockResolvedValueOnce(false);
+
+      const { getByTestId, queryByText } = await renderAndWaitForAccounts();
+
+      await act(async () => {
+        fireEvent.press(getByTestId(AccountSelectorSelectorsIDs.NEXT_BUTTON));
+      });
+
+      await waitFor(() => {
+        expect(mockEnsureDeviceReady).toHaveBeenCalled();
+      });
+
+      expect(queryByText('Please wait')).not.toBeOnTheScreen();
+    });
   });
 });

app/components/Views/LedgerSelectAccount/index.tsx

@@ -222,32 +222,46 @@ const LedgerSelectAccount = () => {
   }, [selectedOption]);
 
   const nextPage = useCallback(async () => {
-    showLoadingModal();
+    let modalShown = false;
     try {
+      const isReady = await ensureDeviceReady(deviceId);
+      if (!isReady) return;
+
+      showLoadingModal();
+      modalShown = true;
       const _accounts = await getLedgerAccountsByOperation(
         PAGINATION_OPERATIONS.GET_NEXT_PAGE,
       );
       setAccounts(_accounts);
     } catch (e) {
       setErrorMsg((e as Error).message);
     } finally {
-      setBlockingModalVisible(false);
+      if (modalShown) {
+        setBlockingModalVisible(false);
+      }
     }
-  }, []);
+  }, [ensureDeviceReady, deviceId]);
 
   const prevPage = useCallback(async () => {
-    showLoadingModal();
+    let modalShown = false;
     try {
+      const isReady = await ensureDeviceReady(deviceId);
+      if (!isReady) return;
+
+      showLoadingModal();
+      modalShown = true;
       const _accounts = await getLedgerAccountsByOperation(
         PAGINATION_OPERATIONS.GET_PREVIOUS_PAGE,
       );
       setAccounts(_accounts);
     } catch (e) {
       setErrorMsg((e as Error).message);
     } finally {
-      setBlockingModalVisible(false);
+      if (modalShown) {
+        setBlockingModalVisible(false);
+      }
     }
-  }, []);
+  }, [ensureDeviceReady, deviceId]);
 
   const updateNewLegacyAccountsLabel = useCallback(async () => {
     if (LEDGER_LEGACY_PATH === (await getHDPath())) {

app/core/HardwareWallet/adapters/LedgerBluetoothAdapter.test.ts

@@ -271,6 +271,27 @@ describe('LedgerBluetoothAdapter', () => {
   });
 
   describe('disconnect', () => {
+    it('forces disconnectDevice when BLE disconnect already cleared transport but deviceId remains', async () => {
+      await adapter.connect('device-123');
+      mockedTransportBLE.disconnectDevice.mockClear();
+
+      const disconnectHandler = mockTransportInstance.on.mock.calls.find(
+        (call: [string, () => void]) => call[0] === 'disconnect',
+      )?.[1];
+      expect(disconnectHandler).toBeDefined();
+      disconnectHandler?.();
+
+      expect(adapter.isConnected()).toBe(false);
+      expect(adapter.getConnectedDeviceId()).toBe('device-123');
+
+      await adapter.disconnect();
+
+      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
+        'device-123',
+      );
+      expect(adapter.getConnectedDeviceId()).toBeNull();
+    });
+
     it('closes transport and resets state', async () => {
       await adapter.connect('device-123');
       await adapter.disconnect();
@@ -625,6 +646,21 @@ describe('LedgerBluetoothAdapter', () => {
       },
     );
 
+    it('retries when address verification fails with message-based transient GATT error', async () => {
+      jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
+      const gattError = new Error('GATT server disconnected');
+      gattError.name = 'Error';
+      mockGetAddress
+        .mockRejectedValueOnce(gattError)
+        .mockResolvedValueOnce({ address: '0x1234' });
+
+      const result = await adapter.ensureDeviceReady('device-123');
+
+      expect(result).toBe(true);
+      expect(mockGetAddress).toHaveBeenCalledTimes(2);
+      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
+    });
+
     it('emits DeviceLocked when getAddress fails with Locked device message', async () => {
       jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
       mockGetAddress.mockRejectedValueOnce(
@@ -687,6 +723,160 @@ describe('LedgerBluetoothAdapter', () => {
 
       jest.useRealTimers();
     });
+
+    it('retries when error message contains "disconnected" even with generic Error name', async () => {
+      const genericBleError = new Error('Device disconnected during operation');
+      genericBleError.name = 'Error';
+      jest
+        .mocked(connectLedgerHardware)
+        .mockRejectedValueOnce(genericBleError)
+        .mockResolvedValueOnce('Ethereum');
+      mockGetAddress.mockResolvedValue({ address: '0x1234' });
+
+      const result = await adapter.ensureDeviceReady('device-123');
+
+      expect(result).toBe(true);
+      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
+    });
+
+    it('retries when error message contains "bluetooth connection" even with generic Error name', async () => {
+      const genericBleError = new Error('Bluetooth connection failed');
+      genericBleError.name = 'Error';
+      jest
+        .mocked(connectLedgerHardware)
+        .mockRejectedValueOnce(genericBleError)
+        .mockResolvedValueOnce('Ethereum');
+      mockGetAddress.mockResolvedValue({ address: '0x1234' });
+
+      const result = await adapter.ensureDeviceReady('device-123');
+
+      expect(result).toBe(true);
+      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
+    });
+
+    it('retries when error message contains "bluetooth transfer" even with generic Error name', async () => {
+      const genericBleError = new Error('Bluetooth transfer interrupted');
+      genericBleError.name = 'Error';
+      jest
+        .mocked(connectLedgerHardware)
+        .mockRejectedValueOnce(genericBleError)
+        .mockResolvedValueOnce('Ethereum');
+      mockGetAddress.mockResolvedValue({ address: '0x1234' });
+
+      const result = await adapter.ensureDeviceReady('device-123');
+
+      expect(result).toBe(true);
+      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
+    });
+
+    it('retries when error message contains "connection lost" even with generic Error name', async () => {
+      const genericBleError = new Error('The connection lost unexpectedly');
+      genericBleError.name = 'Error';
+      jest
+        .mocked(connectLedgerHardware)
+        .mockRejectedValueOnce(genericBleError)
+        .mockResolvedValueOnce('Ethereum');
+      mockGetAddress.mockResolvedValue({ address: '0x1234' });
+
+      const result = await adapter.ensureDeviceReady('device-123');
+
+      expect(result).toBe(true);
+      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
+    });
+
+    it('retries when error message contains "gatt" even with generic Error name', async () => {
+      const genericBleError = new Error('GATT operation failed');
+      genericBleError.name = 'Error';
+      jest
+        .mocked(connectLedgerHardware)
+        .mockRejectedValueOnce(genericBleError)
+        .mockResolvedValueOnce('Ethereum');
+      mockGetAddress.mockResolvedValue({ address: '0x1234' });
+
+      const result = await adapter.ensureDeviceReady('device-123');
+
+      expect(result).toBe(true);
+      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
+    });
+
+    it('retries when error message contains "ble error" even with generic Error name', async () => {
+      const genericBleError = new Error('Native BLE error on channel');
+      genericBleError.name = 'Error';
+      jest
+        .mocked(connectLedgerHardware)
+        .mockRejectedValueOnce(genericBleError)
+        .mockResolvedValueOnce('Ethereum');
+      mockGetAddress.mockResolvedValue({ address: '0x1234' });
+
+      const result = await adapter.ensureDeviceReady('device-123');
+
+      expect(result).toBe(true);
+      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
+    });
+
+    it.each([
+      'Bluetooth is off',
+      'Bluetooth not supported',
+      'Not authorized to use Bluetooth',
+      'Bluetooth permission denied',
+      'Bluetooth scan failed',
+    ])(
+      'does not retry for non-transient bluetooth error: "%s"',
+      async (errorMessage) => {
+        const nonTransientError = new Error(errorMessage);
+        nonTransientError.name = 'Error';
+        jest.mocked(connectLedgerHardware).mockRejectedValue(nonTransientError);
+
+        await expect(adapter.ensureDeviceReady('device-123')).rejects.toThrow();
+        expect(connectLedgerHardware).toHaveBeenCalledTimes(1);
+      },
+    );
+
+    it('forces BLE cleanup when transport is null but deviceId exists during retry', async () => {
+      const disconnectError = new Error('Disconnected');
+      disconnectError.name = 'DisconnectedDevice';
+      jest
+        .mocked(connectLedgerHardware)
+        .mockRejectedValueOnce(disconnectError)
+        .mockResolvedValueOnce('Ethereum');
+      mockGetAddress.mockResolvedValue({ address: '0x1234' });
+
+      await adapter.ensureDeviceReady('device-123');
+
+      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalled();
+    });
+
+    it('closes transport when openEthereumAppOnLedger fails', async () => {
+      jest.mocked(connectLedgerHardware).mockResolvedValue('BOLOS');
+      const { openEthereumAppOnLedger } = jest.requireMock(
+        '../../Ledger/Ledger',
+      ) as { openEthereumAppOnLedger: jest.Mock };
+      openEthereumAppOnLedger.mockRejectedValueOnce(
+        new Error('User cancelled'),
+      );
+
+      await adapter.ensureDeviceReady('device-123');
+
+      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
+        'device-123',
+      );
+    });
+
+    it('closes transport when closeRunningAppOnLedger fails', async () => {
+      jest.mocked(connectLedgerHardware).mockResolvedValue('Bitcoin');
+      const { closeRunningAppOnLedger } = jest.requireMock(
+        '../../Ledger/Ledger',
+      ) as { closeRunningAppOnLedger: jest.Mock };
+      closeRunningAppOnLedger.mockRejectedValueOnce(
+        new Error('User cancelled'),
+      );
+
+      await adapter.ensureDeviceReady('device-123');
+
+      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
+        'device-123',
+      );
+    });
   });
 
   describe('reset', () => {