fix: Ledger "Something went wrong" error on reconnect during send/sign

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

@@ -451,13 +451,14 @@ describe('LedgerBluetoothAdapter', () => {
       );
     });
 
-    it('returns false when no transport after connect', async () => {
+    it('throws DisconnectedDevice when no transport after connect', async () => {
       mockedTransportBLE.open.mockResolvedValueOnce(
         null as unknown as TransportBLE,
       );
 
-      const result = await adapter.ensureDeviceReady('device-123');
-      expect(result).toBe(false);
+      await expect(adapter.ensureDeviceReady('device-123')).rejects.toMatchObject(
+        { name: 'DisconnectedDevice' },
+      );
     });
 
     it('retries on disconnect during check and eventually succeeds', async () => {

app/core/HardwareWallet/adapters/LedgerBluetoothAdapter.ts

@@ -406,7 +406,12 @@ export class LedgerBluetoothAdapter implements HardwareWalletAdapter {
 
     if (!this.#transport) {
       DevLogger.log('[LedgerBluetoothAdapter] No transport after connect');
-      return false;
+      // Transport was cleared by a disconnect event immediately after
+      // connect(). Throw a named disconnect error so the retry loop can
+      // treat it as transient and retry rather than silently returning false.
+      const err = new Error('Transport disconnected after connect');
+      err.name = 'DisconnectedDevice';
+      throw err;
     }
 
     try {
@@ -452,7 +457,12 @@ export class LedgerBluetoothAdapter implements HardwareWalletAdapter {
 
     try {
       if (!this.#transport) {
-        throw new Error('Transport not available');
+        // Transport was cleared by a disconnect event between connect() and
+        // this verification step. Throw a named disconnect error so the
+        // ensureDeviceReady retry loop can treat it as transient and retry.
+        const err = new Error('Transport disconnected during verification');
+        err.name = 'DisconnectedDeviceDuringOperation';
+        throw err;
       }
       const eth = new Eth(this.#transport);
       await this.#withTimeout(

app/core/HardwareWallet/hooks/useDeviceConnectionFlow.test.ts

@@ -116,4 +116,80 @@ describe('useDeviceConnectionFlow', () => {
       });
     });
   });
+
+  describe('retryEnsureDeviceReady with stored device ID', () => {
+    it('uses pendingTargetDeviceId when state.deviceId is null', async () => {
+      const mockEnsureDeviceReady = jest.fn().mockResolvedValue(true);
+      const mockAdapter = {
+        walletType: HardwareWalletType.Ledger,
+        resetFlowState: jest.fn(),
+        ensurePermissions: jest.fn().mockResolvedValue(true),
+        ensureDeviceReady: mockEnsureDeviceReady,
+        markFlowComplete: jest.fn(),
+        isFlowComplete: jest.fn().mockReturnValue(false),
+        requiresDeviceDiscovery: false,
+      };
+      const refs = createMockRefs();
+      refs.adapterRef.current = mockAdapter as unknown as Parameters<
+        typeof useDeviceConnectionFlow
+      >[0]['refs']['adapterRef']['current'];
+
+      const options = createDefaultOptions({
+        refs,
+        // state.deviceId is null – retry must fall back to stored target ID
+        deviceId: null,
+        checkTransportEnabledOrShowError: jest.fn().mockResolvedValue(false),
+      });
+
+      const { result } = renderHook(() => useDeviceConnectionFlow(options));
+
+      // Simulate ensureDeviceReady being called with a device ID (stores it)
+      await act(async () => {
+        result.current.ensureDeviceReady('device-from-nav-params');
+        // Don't await the blocking promise; just let the inner IIFE start
+        await Promise.resolve();
+      });
+
+      // Now retry – state.deviceId is still null but stored ID should be used
+      await act(async () => {
+        await result.current.retryEnsureDeviceReady();
+      });
+
+      expect(mockEnsureDeviceReady).toHaveBeenCalledWith(
+        'device-from-nav-params',
+      );
+      expect(options.updateConnectionState).toHaveBeenCalledWith(
+        expect.objectContaining({ status: ConnectionStatus.Connecting }),
+      );
+    });
+
+    it('falls through to scanning when both state.deviceId and stored ID are null', async () => {
+      const mockAdapter = {
+        walletType: HardwareWalletType.Ledger,
+        resetFlowState: jest.fn(),
+        ensurePermissions: jest.fn().mockResolvedValue(true),
+        requiresDeviceDiscovery: true,
+      };
+      const refs = createMockRefs();
+      refs.adapterRef.current = mockAdapter as unknown as Parameters<
+        typeof useDeviceConnectionFlow
+      >[0]['refs']['adapterRef']['current'];
+
+      const options = createDefaultOptions({
+        refs,
+        deviceId: null,
+        checkTransportEnabledOrShowError: jest.fn().mockResolvedValue(false),
+      });
+
+      const { result } = renderHook(() => useDeviceConnectionFlow(options));
+
+      await act(async () => {
+        await result.current.retryEnsureDeviceReady();
+      });
+
+      expect(options.updateConnectionState).toHaveBeenCalledWith(
+        expect.objectContaining({ status: ConnectionStatus.Scanning }),
+      );
+    });
+  });
 });

app/core/HardwareWallet/hooks/useDeviceConnectionFlow.ts

@@ -62,6 +62,15 @@ export const useDeviceConnectionFlow = ({
 
   const connectionSuccessCallbackRef = useRef<(() => void) | null>(null);
 
+  /**
+   * Stores the deviceId passed to the most recent `ensureDeviceReady` call.
+   * Used by `retryEnsureDeviceReady` to connect to the correct device even
+   * when `state.deviceId` has not been populated yet (e.g. the initial BLE
+   * open failed before `DeviceEvent.Connected` was emitted, or on a fresh
+   * app launch where state was never hydrated).
+   */
+  const pendingTargetDeviceIdRef = useRef<string | null>(null);
+
   /**
    * Resolve an existing adapter or create a new one if the wallet type
    * doesn't match. Named replacement for the inline IIFE that was previously
@@ -208,6 +217,10 @@ export const useDeviceConnectionFlow = ({
 
       if (!targetDeviceId) {
         setters.setDeviceId(null);
+      } else {
+        // Remember the device ID so retryEnsureDeviceReady can use it even
+        // when state.deviceId has not been populated yet.
+        pendingTargetDeviceIdRef.current = targetDeviceId;
       }
 
       const adapter = resolveOrCreateAdapter(targetType);
@@ -276,10 +289,15 @@ export const useDeviceConnectionFlow = ({
       return;
     }
 
-    if (deviceId && adapter) {
+    // Prefer the runtime state deviceId; fall back to the id stored when
+    // ensureDeviceReady was last called (covers the case where the initial
+    // BLE open failed before DeviceEvent.Connected could set state.deviceId).
+    const retryDeviceId = deviceId ?? pendingTargetDeviceIdRef.current;
+
+    if (retryDeviceId && adapter) {
       updateConnectionState({ status: ConnectionStatus.Connecting });
       try {
-        await tryEnsureReady(adapter, deviceId);
+        await tryEnsureReady(adapter, retryDeviceId);
       } catch (error) {
         handleError(error);
       }
@@ -300,6 +318,7 @@ export const useDeviceConnectionFlow = ({
       pendingReadyResolveRef.current(false);
       pendingReadyResolveRef.current = null;
     }
+    pendingTargetDeviceIdRef.current = null;
     setters.setTargetWalletType(null);
     updateConnectionState({ status: ConnectionStatus.Disconnected });
   }, [setters, updateConnectionState]);