LedgerBluetoothAdapter.test.ts

// Mock subscription for observeState
const mockBleStateSubscription = {
  unsubscribe: jest.fn(),
};

// Mock subscription for listen
const mockListenSubscription = {
  unsubscribe: jest.fn(),
};

// Mock the BLE transport
const mockTransportInstance = {
  on: jest.fn(),
  close: jest.fn().mockResolvedValue(undefined),
};

// Capture the BLE state observer so tests can trigger state changes
let capturedBleStateObserver: {
  next?: (event: { type: string; available: boolean }) => void;
  error?: (error: Error) => void;
  complete?: () => void;
} | null = null;

// Capture the listen observer so tests can trigger device found / scan error
let capturedListenObserver: {
  next?: (event: {
    type: string;
    descriptor: { id: string; name: string };
  }) => void;
  error?: (error: Error) => void;
  complete?: () => void;
} | null = null;

jest.mock('@ledgerhq/react-native-hw-transport-ble', () => ({
  __esModule: true,
  default: {
    open: jest.fn(),
    disconnectDevice: jest.fn().mockResolvedValue(undefined),
    observeState: jest.fn((observer) => {
      capturedBleStateObserver = observer;
      // Immediately trigger with PoweredOn state for most tests
      if (observer.next) {
        observer.next({ type: 'PoweredOn', available: true });
      }
      return mockBleStateSubscription;
    }),
    listen: jest.fn((observer: unknown) => {
      capturedListenObserver = observer as typeof capturedListenObserver;
      return mockListenSubscription;
    }),
  },
}));

// Mock the Eth app
const mockGetAddress = jest.fn();
jest.mock('@ledgerhq/hw-app-eth', () => ({
  __esModule: true,
  default: jest.fn().mockImplementation(() => ({
    getAddress: mockGetAddress,
  })),
}));

// Mock the Ledger module
jest.mock('../../Ledger/Ledger', () => ({
  connectLedgerHardware: jest.fn(),
  openEthereumAppOnLedger: jest.fn(),
  closeRunningAppOnLedger: jest.fn(),
}));

const mockRequestMultiple = jest.fn();
const mockRequest = jest.fn();
jest.mock('react-native-permissions', () => ({
  requestMultiple: (...args: unknown[]) => mockRequestMultiple(...args),
  request: (...args: unknown[]) => mockRequest(...args),
  PERMISSIONS: {
    ANDROID: {
      BLUETOOTH_CONNECT: 'android.permission.BLUETOOTH_CONNECT',
      BLUETOOTH_SCAN: 'android.permission.BLUETOOTH_SCAN',
      ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION',
    },
  },
  RESULTS: {
    GRANTED: 'granted',
    DENIED: 'denied',
    BLOCKED: 'blocked',
  },
}));

const mockGetSystemVersion = jest.fn().mockReturnValue('13');
jest.mock('react-native-device-info', () => ({
  getSystemVersion: () => mockGetSystemVersion(),
}));

import { Linking, Platform } from 'react-native';
import { LedgerBluetoothAdapter } from './LedgerBluetoothAdapter';
import { HardwareWalletType, DeviceEvent } from '@metamask/hw-wallet-sdk';
import { HardwareWalletAdapterOptions } from '../types';
import TransportBLE from '@ledgerhq/react-native-hw-transport-ble';
import { connectLedgerHardware } from '../../Ledger/Ledger';

const mockedTransportBLE = jest.mocked(TransportBLE);

describe('LedgerBluetoothAdapter', () => {
  let adapter: LedgerBluetoothAdapter;
  let mockOptions: HardwareWalletAdapterOptions;
  let onDisconnect: jest.Mock;
  let onDeviceEvent: jest.Mock;

  beforeEach(() => {
    jest.clearAllMocks();

    onDisconnect = jest.fn();
    onDeviceEvent = jest.fn();

    mockOptions = {
      onDisconnect,
      onDeviceEvent,
    };

    adapter = new LedgerBluetoothAdapter(mockOptions);

    // Setup transport mock to return our mockTransportInstance
    mockedTransportBLE.open.mockResolvedValue(
      mockTransportInstance as unknown as TransportBLE,
    );
  });

  afterEach(() => {
    adapter.destroy();
  });

  describe('constructor', () => {
    it('creates an instance', () => {
      expect(adapter).toBeInstanceOf(LedgerBluetoothAdapter);
    });

    it('has Ledger walletType', () => {
      expect(adapter.walletType).toBe(HardwareWalletType.Ledger);
    });

    it('is not connected initially', () => {
      expect(adapter.isConnected()).toBe(false);
      expect(adapter.getConnectedDeviceId()).toBeNull();
    });
  });

  describe('connect', () => {
    it('establishes BLE connection', async () => {
      await adapter.connect('device-123');

      expect(mockedTransportBLE.open).toHaveBeenCalledWith('device-123');
      expect(adapter.isConnected()).toBe(true);
      expect(adapter.getConnectedDeviceId()).toBe('device-123');
    });

    it('emits Connected event on success', async () => {
      await adapter.connect('device-123');

      expect(onDeviceEvent).toHaveBeenCalledWith({
        event: DeviceEvent.Connected,
        deviceId: 'device-123',
      });
    });

    it('sets up disconnect handler', async () => {
      await adapter.connect('device-123');

      expect(mockTransportInstance.on).toHaveBeenCalledWith(
        'disconnect',
        expect.any(Function),
      );
    });

    it('does not reconnect if already connected to same device', async () => {
      await adapter.connect('device-123');
      await adapter.connect('device-123');

      // Should only open once
      expect(mockedTransportBLE.open).toHaveBeenCalledTimes(1);
    });

    it('disconnects and reconnects if connecting to different device', async () => {
      await adapter.connect('device-123');
      await adapter.connect('device-456');

      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
      expect(mockedTransportBLE.open).toHaveBeenCalledTimes(2);
    });

    it('throws and clears state on connect error', async () => {
      const error = new Error('BLE connection failed');
      mockedTransportBLE.open.mockRejectedValueOnce(error);

      await expect(adapter.connect('device-123')).rejects.toThrow(error);

      expect(adapter.isConnected()).toBe(false);
      expect(adapter.getConnectedDeviceId()).toBeNull();
    });

    it('throws if adapter is destroyed', async () => {
      adapter.destroy();

      await expect(adapter.connect('device-123')).rejects.toThrow(
        'Adapter has been destroyed',
      );
    });

    it('does not emit Connected when destroy() is called while connect is in flight', async () => {
      let resolveOpen: (value: typeof mockTransportInstance) => void;
      const openPromise = new Promise<typeof mockTransportInstance>(
        (resolve) => {
          resolveOpen = resolve;
        },
      );
      mockedTransportBLE.open.mockReturnValue(
        openPromise as unknown as ReturnType<typeof mockedTransportBLE.open>,
      );

      const connectPromise = adapter.connect('device-123');
      adapter.destroy();
      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
      resolveOpen!(mockTransportInstance);

      await connectPromise;

      expect(onDeviceEvent).not.toHaveBeenCalledWith(
        expect.objectContaining({ event: DeviceEvent.Connected }),
      );
      expect(adapter.isConnected()).toBe(false);
    });

    it('throws non-Error values as-is on connect failure', async () => {
      mockedTransportBLE.open.mockRejectedValueOnce('connection failed');

      await expect(adapter.connect('device-123')).rejects.toBe(
        'connection failed',
      );

      expect(adapter.isConnected()).toBe(false);
    });

    it('ignores transport error event when flow is complete', async () => {
      await adapter.connect('device-123');
      adapter.markFlowComplete();
      onDisconnect.mockClear();
      onDeviceEvent.mockClear();

      const errorHandler = mockTransportInstance.on.mock.calls.find(
        (call: [string, (err: Error) => void]) => call[0] === 'error',
      )?.[1];
      expect(errorHandler).toBeDefined();
      errorHandler?.(new Error('Transport error'));

      expect(onDisconnect).not.toHaveBeenCalled();
    });

    it('handles transport error event as disconnect when flow not complete', async () => {
      await adapter.connect('device-123');
      onDisconnect.mockClear();

      const errorHandler = mockTransportInstance.on.mock.calls.find(
        (call: [string, (err: Error) => void]) => call[0] === 'error',
      )?.[1];
      errorHandler?.(new Error('Transport error'));

      expect(onDisconnect).not.toHaveBeenCalled();
      expect(adapter.isConnected()).toBe(false);
    });
  });

  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();

      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
      expect(adapter.isConnected()).toBe(false);
      expect(adapter.getConnectedDeviceId()).toBeNull();
    });

    it('emits Disconnected event', async () => {
      await adapter.connect('device-123');
      onDeviceEvent.mockClear();

      await adapter.disconnect();

      expect(onDeviceEvent).toHaveBeenCalledWith({
        event: DeviceEvent.Disconnected,
        deviceId: 'device-123',
      });
    });

    it('does not emit Disconnected when flow is complete', async () => {
      await adapter.connect('device-123');
      adapter.markFlowComplete();
      onDeviceEvent.mockClear();

      await adapter.disconnect();

      expect(onDeviceEvent).not.toHaveBeenCalled();
    });

    it('handles disconnect when not connected', async () => {
      await expect(adapter.disconnect()).resolves.toBeUndefined();
    });

    it('closes transport without throwing when close rejects', async () => {
      await adapter.connect('device-123');
      mockTransportInstance.close.mockRejectedValueOnce(
        new Error('Close failed'),
      );

      await expect(adapter.disconnect()).resolves.toBeUndefined();

      expect(adapter.isConnected()).toBe(false);
    });
  });

  describe('handleDisconnect (via transport events)', () => {
    it('clears transport without calling onDisconnect', async () => {
      await adapter.connect('device-123');
      onDisconnect.mockClear();

      const disconnectHandler = mockTransportInstance.on.mock.calls.find(
        (call: [string, () => void]) => call[0] === 'disconnect',
      )?.[1];
      expect(disconnectHandler).toBeDefined();

      disconnectHandler?.();

      expect(onDisconnect).not.toHaveBeenCalled();
      expect(adapter.isConnected()).toBe(false);
    });

    it('ignores stale events from a replaced transport', async () => {
      await adapter.connect('device-123');

      const oldDisconnectHandler = mockTransportInstance.on.mock.calls.find(
        (call: [string, () => void]) => call[0] === 'disconnect',
      )?.[1];

      const newTransport = {
        on: jest.fn(),
        close: jest.fn().mockResolvedValue(undefined),
      };
      mockedTransportBLE.open.mockResolvedValueOnce(
        newTransport as unknown as TransportBLE,
      );
      await adapter.connect('device-456');

      expect(adapter.isConnected()).toBe(true);

      oldDisconnectHandler?.();

      expect(adapter.isConnected()).toBe(true);
    });
  });

  describe('ensureDeviceReady', () => {
    beforeEach(async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
      mockGetAddress.mockResolvedValue({ address: '0x1234' });
    });

    it('throws when adapter is destroyed', async () => {
      adapter.destroy();

      await expect(adapter.ensureDeviceReady('device-123')).rejects.toThrow(
        'Adapter has been destroyed',
      );
    });

    it('connects if not already connected', async () => {
      await adapter.ensureDeviceReady('device-123');

      expect(mockedTransportBLE.open).toHaveBeenCalledWith('device-123');
    });

    it('returns true when Ethereum app is open and unlocked', async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
      mockGetAddress.mockResolvedValue({ address: '0x1234' });

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(true);
      expect(mockGetAddress).toHaveBeenCalled();
    });

    it('emits AppOpened event when correct app is detected and unlocked', async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
      mockGetAddress.mockResolvedValue({ address: '0x1234' });

      await adapter.ensureDeviceReady('device-123');

      expect(onDeviceEvent).toHaveBeenCalledWith(
        expect.objectContaining({
          event: DeviceEvent.AppOpened,
          currentAppName: 'Ethereum',
        }),
      );
    });

    it('returns false and emits AppNotOpen when wrong app is open', async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('Bitcoin');

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(false);
      // AppNotOpen event always uses 'Ethereum' as the required app (what we want opened)
      expect(onDeviceEvent).toHaveBeenCalledWith(
        expect.objectContaining({
          event: DeviceEvent.AppNotOpen,
          currentAppName: 'Ethereum',
        }),
      );
    });

    it('returns false and emits AppNotOpen when on BOLOS screen', async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('BOLOS');

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(false);
      // AppNotOpen event always uses 'Ethereum' as the required app
      expect(onDeviceEvent).toHaveBeenCalledWith(
        expect.objectContaining({
          event: DeviceEvent.AppNotOpen,
          currentAppName: 'Ethereum',
        }),
      );
    });

    it('emits DeviceLocked when device is locked', async () => {
      const lockedError = new Error('Device locked');
      (lockedError as { statusCode?: number }).statusCode = 0x6b0c;
      (lockedError as { name?: string }).name = 'TransportStatusError';
      mockGetAddress.mockRejectedValueOnce(lockedError);
      jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(false);
      expect(onDeviceEvent).toHaveBeenCalledWith(
        expect.objectContaining({
          event: DeviceEvent.DeviceLocked,
        }),
      );
    });

    it('returns false 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);
    });

    it('retries on disconnect during check and eventually succeeds', async () => {
      const disconnectError = new Error('Disconnected');
      (disconnectError as { name?: string }).name = 'DisconnectedDevice';
      jest
        .mocked(connectLedgerHardware)
        .mockRejectedValueOnce(disconnectError)
        .mockResolvedValueOnce('Ethereum');
      mockGetAddress.mockResolvedValue({ address: '0x1234' });

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(true);
      expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
    });

    it.each(['PairingFailed', 'PeerRemovedPairing', 'BleError'])(
      'retries on transient BLE error "%s" during check and eventually succeeds',
      async (errorName) => {
        const bleError = new Error(`BLE failure: ${errorName}`);
        bleError.name = errorName;
        jest
          .mocked(connectLedgerHardware)
          .mockRejectedValueOnce(bleError)
          .mockResolvedValueOnce('Ethereum');
        mockGetAddress.mockResolvedValue({ address: '0x1234' });

        const result = await adapter.ensureDeviceReady('device-123');

        expect(result).toBe(true);
        expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
      },
    );

    it('throws when non-disconnect error during check', async () => {
      jest
        .mocked(connectLedgerHardware)
        .mockRejectedValueOnce(new Error('Device busy'));

      await expect(adapter.ensureDeviceReady('device-123')).rejects.toThrow(
        'Device busy',
      );
    });

    it('returns false and emits AppNotOpen when BOLOS and openEthereumAppOnLedger rejects', async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('BOLOS');
      const { openEthereumAppOnLedger } = jest.requireMock(
        '../../Ledger/Ledger',
      ) as { openEthereumAppOnLedger: jest.Mock };
      openEthereumAppOnLedger.mockRejectedValueOnce(new Error('Open failed'));

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(false);
      expect(onDeviceEvent).toHaveBeenCalledWith(
        expect.objectContaining({
          event: DeviceEvent.AppNotOpen,
          currentAppName: 'Ethereum',
        }),
      );
    });

    it('closes transport when opening Ethereum app times out', async () => {
      jest.useFakeTimers();
      jest.mocked(connectLedgerHardware).mockResolvedValue('BOLOS');
      const { openEthereumAppOnLedger } = jest.requireMock(
        '../../Ledger/Ledger',
      ) as { openEthereumAppOnLedger: jest.Mock };
      openEthereumAppOnLedger.mockImplementationOnce(
        // eslint-disable-next-line no-empty-function
        () => new Promise(() => {}),
      );

      const resultPromise = adapter.ensureDeviceReady('device-123');
      await jest.advanceTimersByTimeAsync(11000);

      await expect(resultPromise).resolves.toBe(false);
      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
      expect(adapter.isConnected()).toBe(false);

      jest.useRealTimers();
    });

    it('returns false when wrong app open and closeRunningAppOnLedger rejects', async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('Bitcoin');
      const { closeRunningAppOnLedger } = jest.requireMock(
        '../../Ledger/Ledger',
      ) as { closeRunningAppOnLedger: jest.Mock };
      closeRunningAppOnLedger.mockRejectedValueOnce(new Error('Close failed'));

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(false);
    });

    it('closes transport when closing the current app times out', async () => {
      jest.useFakeTimers();
      jest.mocked(connectLedgerHardware).mockResolvedValue('Bitcoin');
      const { closeRunningAppOnLedger } = jest.requireMock(
        '../../Ledger/Ledger',
      ) as { closeRunningAppOnLedger: jest.Mock };
      closeRunningAppOnLedger.mockImplementationOnce(
        // eslint-disable-next-line no-empty-function
        () => new Promise(() => {}),
      );

      const resultPromise = adapter.ensureDeviceReady('device-123');
      await jest.advanceTimersByTimeAsync(11000);

      await expect(resultPromise).resolves.toBe(false);
      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
      expect(adapter.isConnected()).toBe(false);

      jest.useRealTimers();
    });

    it('emits DeviceLocked and throws when connectLedgerHardware throws device locked', async () => {
      const lockedError = new Error('Locked');
      (lockedError as { statusCode?: number }).statusCode = 0x6b0c;
      (lockedError as { name?: string }).name = 'TransportStatusError';
      jest.mocked(connectLedgerHardware).mockRejectedValueOnce(lockedError);

      await expect(adapter.ensureDeviceReady('device-123')).rejects.toThrow(
        lockedError,
      );

      expect(onDeviceEvent).toHaveBeenCalledWith(
        expect.objectContaining({
          event: DeviceEvent.DeviceLocked,
        }),
      );
    });

    it('returns false when verification fails with non-disconnect non-locked error', async () => {
      jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
      mockGetAddress.mockRejectedValueOnce(new Error('User cancelled'));

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(false);
      expect(onDeviceEvent).not.toHaveBeenCalledWith(
        expect.objectContaining({ event: DeviceEvent.DeviceLocked }),
      );
    });

    it.each(['PairingFailed', 'PeerRemovedPairing', 'BleError'])(
      'retries when verification fails with transient BLE error "%s"',
      async (errorName) => {
        const bleError = new Error(`BLE failure: ${errorName}`);
        bleError.name = errorName;
        jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
        mockGetAddress
          .mockRejectedValueOnce(bleError)
          .mockResolvedValueOnce({ address: '0x1234' });

        const result = await adapter.ensureDeviceReady('device-123');

        expect(result).toBe(true);
        expect(connectLedgerHardware).toHaveBeenCalledTimes(2);
      },
    );

    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(
        Object.assign(new Error('Locked device'), { name: 'Other' }),
      );

      const result = await adapter.ensureDeviceReady('device-123');

      expect(result).toBe(false);
      expect(onDeviceEvent).toHaveBeenCalledWith(
        expect.objectContaining({
          event: DeviceEvent.DeviceLocked,
        }),
      );
    });

    it('throws LedgerTimeoutError when device unresponsive during app check', async () => {
      jest.useFakeTimers();
      jest.mocked(connectLedgerHardware).mockImplementation(
        // eslint-disable-next-line no-empty-function
        () => new Promise(() => {}),
      );

      const resultPromise = adapter.ensureDeviceReady('device-123').then(
        () => undefined,
        (err: Error) => err,
      );

      await jest.advanceTimersByTimeAsync(11000);
      const result = await resultPromise;

      expect(result).toMatchObject({
        name: 'LedgerTimeoutError',
        message: 'Device unresponsive',
      });
      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
      expect(adapter.isConnected()).toBe(false);

      jest.useRealTimers();
    });

    it('closes transport when device verification times out', async () => {
      jest.useFakeTimers();
      jest.mocked(connectLedgerHardware).mockResolvedValue('Ethereum');
      mockGetAddress.mockImplementation(
        // eslint-disable-next-line no-empty-function
        () => new Promise(() => {}),
      );

      const resultPromise = adapter.ensureDeviceReady('device-123');
      await jest.advanceTimersByTimeAsync(11000);

      await expect(resultPromise).resolves.toBe(false);
      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
      expect(adapter.isConnected()).toBe(false);

      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', () => {
    it('resets adapter state', async () => {
      await adapter.connect('device-123');
      adapter.markFlowComplete();

      adapter.reset();

      expect(adapter.isConnected()).toBe(false);
      expect(adapter.getConnectedDeviceId()).toBeNull();
      expect(adapter.isFlowComplete()).toBe(false);
    });
  });

  describe('markFlowComplete', () => {
    it('marks flow as complete', () => {
      expect(adapter.isFlowComplete()).toBe(false);

      adapter.markFlowComplete();

      expect(adapter.isFlowComplete()).toBe(true);
    });
  });

  describe('resetFlowState', () => {
    it('resets flow complete flag', () => {
      adapter.markFlowComplete();
      expect(adapter.isFlowComplete()).toBe(true);

      adapter.resetFlowState();

      expect(adapter.isFlowComplete()).toBe(false);
    });

    it('closes stale transport to force fresh BLE connection on retry', async () => {
      await adapter.connect('device-123');
      expect(adapter.isConnected()).toBe(true);

      adapter.resetFlowState();

      expect(adapter.isConnected()).toBe(false);
      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
    });

    it('is safe to call when no transport exists', () => {
      expect(adapter.isConnected()).toBe(false);
      expect(() => adapter.resetFlowState()).not.toThrow();
    });
  });

  describe('startDeviceDiscovery', () => {
    it('throws when adapter is destroyed', () => {
      adapter.destroy();

      expect(() => adapter.startDeviceDiscovery(jest.fn(), jest.fn())).toThrow(
        'Adapter has been destroyed',
      );
    });

    it('starts BLE scanning', () => {
      const onDeviceFound = jest.fn();
      const onError = jest.fn();

      adapter.startDeviceDiscovery(onDeviceFound, onError);

      // Should have subscribed to the listen observable
      expect(mockListenSubscription.unsubscribe).not.toHaveBeenCalled();
    });

    it('calls onDeviceFound when BLE listen emits add event', () => {
      const onDeviceFound = jest.fn();
      const onError = jest.fn();

      adapter.startDeviceDiscovery(onDeviceFound, onError);

      expect(capturedListenObserver?.next).toBeDefined();
      capturedListenObserver?.next?.({
        type: 'add',
        descriptor: { id: 'device-ble-1', name: 'Ledger Nano X' },
      });

      expect(onDeviceFound).toHaveBeenCalledWith({
        id: 'device-ble-1',
        name: 'Ledger Nano X',
      });
    });

    it('calls onDeviceFound with Unknown Device when descriptor has no name', () => {
      const onDeviceFound = jest.fn();
      const onError = jest.fn();

      adapter.startDeviceDiscovery(onDeviceFound, onError);

      capturedListenObserver?.next?.({
        type: 'add',
        descriptor: { id: 'device-ble-2', name: '' },
      });

      expect(onDeviceFound).toHaveBeenCalledWith({
        id: 'device-ble-2',
        name: 'Unknown Device',
      });
    });

    it('calls onError when BLE listen emits error', () => {
      const onDeviceFound = jest.fn();
      const onError = jest.fn();
      const scanError = new Error('BLE scan failed');

      adapter.startDeviceDiscovery(onDeviceFound, onError);

      capturedListenObserver?.error?.(scanError);

      expect(onError).toHaveBeenCalledWith(scanError);
    });

    it('stops discovery on BLE listen error so timeout does not emit duplicate onError', async () => {
      jest.useFakeTimers();
      const onDeviceFound = jest.fn();
      const onError = jest.fn();
      const scanError = new Error('BLE scan failed');

      adapter.startDeviceDiscovery(onDeviceFound, onError);
      capturedListenObserver?.error?.(scanError);

      expect(onError).toHaveBeenCalledTimes(1);
      expect(onError).toHaveBeenCalledWith(scanError);

      await jest.advanceTimersByTimeAsync(31000);

      expect(onError).toHaveBeenCalledTimes(1);

      jest.useRealTimers();
    });

    it('calls onError with timeout message when no devices found before timeout', async () => {
      jest.useFakeTimers();
      const onDeviceFound = jest.fn();
      const onError = jest.fn();

      adapter.startDeviceDiscovery(onDeviceFound, onError);

      await jest.advanceTimersByTimeAsync(31000);

      expect(onError).toHaveBeenCalledWith(
        expect.objectContaining({
          message: expect.stringContaining('Scan timeout'),
        }),
      );

      jest.useRealTimers();
    });

    it('returns cleanup function', () => {
      const onDeviceFound = jest.fn();
      const onError = jest.fn();

      const cleanup = adapter.startDeviceDiscovery(onDeviceFound, onError);

      expect(typeof cleanup).toBe('function');
      cleanup();
      expect(mockListenSubscription.unsubscribe).toHaveBeenCalled();
    });
  });

  describe('stopDeviceDiscovery', () => {
    it('stops any active scan', () => {
      const onDeviceFound = jest.fn();
      const onError = jest.fn();

      adapter.startDeviceDiscovery(onDeviceFound, onError);
      adapter.stopDeviceDiscovery();

      expect(mockListenSubscription.unsubscribe).toHaveBeenCalled();
    });

    it('handles being called when no scan is active', () => {
      // Should not throw
      expect(() => adapter.stopDeviceDiscovery()).not.toThrow();
    });
  });

  describe('isTransportAvailable', () => {
    it('returns current Bluetooth state', async () => {
      // Mock fires with PoweredOn immediately, so should return true
      const result = await adapter.isTransportAvailable();

      expect(result).toBe(true);
    });

    it('returns false when Bluetooth is off', async () => {
      // Create a new adapter and manually trigger PoweredOff state
      const newAdapter = new LedgerBluetoothAdapter(mockOptions);

      // The mock triggers PoweredOn by default, but we can check the behavior
      // by verifying the adapter responds to state changes
      if (capturedBleStateObserver?.next) {
        capturedBleStateObserver.next({ type: 'PoweredOff', available: false });
      }

      const result = await newAdapter.isTransportAvailable();
      expect(result).toBe(false);

      newAdapter.destroy();
    });
  });

  describe('onTransportStateChange', () => {
    it('registers callback and calls immediately with current state', () => {
      const callback = jest.fn();

      adapter.onTransportStateChange(callback);

      // Should be called immediately with current state
      expect(callback).toHaveBeenCalledWith(expect.any(Boolean));
    });

    it('returns cleanup function', () => {
      const callback = jest.fn();

      const cleanup = adapter.onTransportStateChange(callback);

      expect(typeof cleanup).toBe('function');
    });

    it('unsubscribes when cleanup is called', () => {
      const callback = jest.fn();

      const cleanup = adapter.onTransportStateChange(callback);
      cleanup();

      // Callback should only have been called once (initial call)
      expect(callback).toHaveBeenCalledTimes(1);
    });

    it('catches and does not throw when callback throws on state change', () => {
      let callCount = 0;
      const throwingCallback = jest.fn(() => {
        callCount++;
        if (callCount === 2) {
          throw new Error('Callback error');
        }
      });
      adapter.onTransportStateChange(throwingCallback);

      expect(() => {
        capturedBleStateObserver?.next?.({
          type: 'PoweredOff',
          available: false,
        });
      }).not.toThrow();

      expect(throwingCallback).toHaveBeenCalledTimes(2);
    });
  });

  describe('getRequiredAppName', () => {
    it('returns Ethereum', () => {
      expect(adapter.getRequiredAppName()).toBe('Ethereum');
    });
  });

  describe('requiresDeviceDiscovery', () => {
    it('is true for Ledger adapter', () => {
      expect(adapter.requiresDeviceDiscovery).toBe(true);
    });
  });

  describe('ensurePermissions', () => {
    const originalOS = Platform.OS;

    afterEach(() => {
      Platform.OS = originalOS;
    });

    it('returns true on iOS without requesting permissions', async () => {
      Platform.OS = 'ios';

      const result = await adapter.ensurePermissions();

      expect(result).toBe(true);
      expect(mockRequestMultiple).not.toHaveBeenCalled();
      expect(mockRequest).not.toHaveBeenCalled();
    });

    it('returns true on Android 12+ when BLE permissions are granted', async () => {
      Platform.OS = 'android';
      mockGetSystemVersion.mockReturnValue('12');
      mockRequestMultiple.mockResolvedValue({
        'android.permission.BLUETOOTH_CONNECT': 'granted',
        'android.permission.BLUETOOTH_SCAN': 'granted',
      });

      const result = await adapter.ensurePermissions();

      expect(result).toBe(true);
    });

    it('opens settings on Android 12+ when BLE permissions are denied', async () => {
      Platform.OS = 'android';
      mockGetSystemVersion.mockReturnValue('13');
      mockRequestMultiple.mockResolvedValue({
        'android.permission.BLUETOOTH_CONNECT': 'denied',
        'android.permission.BLUETOOTH_SCAN': 'granted',
      });
      jest.spyOn(Linking, 'openSettings').mockResolvedValue(undefined);

      const result = await adapter.ensurePermissions();

      expect(result).toBe(false);
      expect(Linking.openSettings).toHaveBeenCalled();
    });

    it('returns true on older Android when location permission is granted', async () => {
      Platform.OS = 'android';
      mockGetSystemVersion.mockReturnValue('11');
      mockRequest.mockResolvedValue('granted');

      const result = await adapter.ensurePermissions();

      expect(result).toBe(true);
    });

    it('opens settings on older Android when location permission is denied', async () => {
      Platform.OS = 'android';
      mockGetSystemVersion.mockReturnValue('10');
      mockRequest.mockResolvedValue('blocked');
      jest.spyOn(Linking, 'openSettings').mockResolvedValue(undefined);

      const result = await adapter.ensurePermissions();

      expect(result).toBe(false);
      expect(Linking.openSettings).toHaveBeenCalled();
    });
  });

  describe('destroy', () => {
    it('closes transport and marks as destroyed', async () => {
      await adapter.connect('device-123');
      adapter.destroy();

      expect(mockedTransportBLE.disconnectDevice).toHaveBeenCalledWith(
        'device-123',
      );
    });

    it('prevents further operations', async () => {
      adapter.destroy();

      await expect(adapter.connect('device-123')).rejects.toThrow(
        'Adapter has been destroyed',
      );
    });

    it('does not hang isTransportAvailable when destroyed before BLE state arrives', async () => {
      // Override observeState to NOT immediately fire the observer
      mockedTransportBLE.observeState.mockImplementationOnce(
        () =>
          // Don't call observer.next — simulate slow BLE init
          mockBleStateSubscription,
      );

      const freshAdapter = new LedgerBluetoothAdapter(mockOptions);
      freshAdapter.destroy();

      // This would hang forever without the fix
      const result = await freshAdapter.isTransportAvailable();
      expect(result).toBe(false);
    });
  });
});