@onekeyfe/hd-transport-react-native 1.2.0-alpha.32 → 1.2.0-alpha.34

package/src/__tests__/BleTransport.test.ts

@@ -0,0 +1,41 @@
+import { BleErrorCode } from 'react-native-ble-plx';
+
+import BleTransport from '../BleTransport';
+
+jest.mock(
+  'react-native-ble-plx',
+  () => ({
+    BleErrorCode: {
+      DeviceDisconnected: 205,
+      CharacteristicNotFound: 404,
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('@onekeyfe/hd-shared', () => ({
+  ...jest.requireActual('@onekeyfe/hd-shared'),
+  wait: jest.fn(() => Promise.resolve()),
+}));
+
+describe('BleTransport side-effecting writes', () => {
+  test('does not reconnect or replay after the device disconnects', async () => {
+    const error = Object.assign(new Error('device disconnected'), {
+      errorCode: BleErrorCode.DeviceDisconnected,
+    });
+    const writeCharacteristic = {
+      writeWithoutResponse: jest.fn(() => Promise.reject(error)),
+    };
+    const device = {
+      id: 'classic-id',
+      connect: jest.fn(() => Promise.resolve()),
+      discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(device as any, writeCharacteristic as any, {} as any);
+
+    await expect(transport.writeWithRetry('payload')).rejects.toBe(error);
+
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledTimes(1);
+    expect(device.connect).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/constants.test.ts

@@ -0,0 +1,20 @@
+import { getBluetoothServiceUuids, getInfosForServiceUuid } from '../constants';
+
+describe('React Native BLE service filters', () => {
+  test('does not scan or configure the ignored FFFD service', () => {
+    expect(getBluetoothServiceUuids()).not.toContain('fffd');
+    expect(getInfosForServiceUuid('fffd', 'classic')).toBeNull();
+    expect(getInfosForServiceUuid('0000fffd-0000-1000-8000-00805f9b34fb', 'classic')).toBeNull();
+  });
+
+  test('keeps the OneKey communication service configured', () => {
+    expect(getBluetoothServiceUuids()).toContain('00000001-0000-1000-8000-00805f9b34fb');
+    expect(getInfosForServiceUuid('0001', 'classic')).toMatchObject({
+      serviceUuid: '00000001-0000-1000-8000-00805f9b34fb',
+    });
+  });
+
+  test('does not match a vendor-specific UUID containing the OneKey short key', () => {
+    expect(getInfosForServiceUuid('abcd0001-1234-5678-9012-abcdefabcdef', 'classic')).toBeNull();
+  });
+});

package/src/__tests__/protocolV2Link.test.ts

@@ -5,10 +5,11 @@ import transportPackage, {
   TRANSPORT_EVENT,
   bytesToHex,
 } from '@onekeyfe/hd-transport';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
 import ReactNativeBleTransport, {
   configureProtocolV2BleTuning,
+  getFirmwareUploadWriteRetryType,
   resetProtocolV2BleTuning,
 } from '../index';
 
@@ -50,6 +51,7 @@ const { parseConfigure } = transportPackage;
 const protocolV1Schema = {
   nested: {
     Initialize: { fields: {} },
+    GetFeatures: { fields: {} },
     Success: {
       fields: {
         message: { type: 'string', id: 1 },
@@ -59,6 +61,7 @@ const protocolV1Schema = {
       values: {
         MessageType_Initialize: 1,
         MessageType_Success: 2,
+        MessageType_GetFeatures: 55,
       },
     },
   },
@@ -140,7 +143,7 @@ const createHarness = () => {
     id: uuid,
     name: 'OneKey Pro 2',
     localName: 'OneKey Pro 2',
-    serviceUUIDs: ['fffd'],
+    serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
     isConnected: jest.fn(() => Promise.resolve(true)),
     cancelConnection: jest.fn(() => Promise.resolve()),
     onDisconnected: jest.fn(callback => {
@@ -181,11 +184,140 @@ const createHarness = () => {
   };
 };
 
+const createV1Harness = () => {
+  const uuid = 'rn-classic-id';
+  let notifyCallback:
+    | ((error: Error | null, characteristic: { value: string } | null) => void)
+    | undefined;
+  const notifyCharacteristic = {
+    uuid: '0003',
+    deviceID: uuid,
+    isNotifiable: true,
+    monitor: jest.fn(callback => {
+      notifyCallback = callback;
+      return { remove: jest.fn() };
+    }),
+  };
+  let writeCount = 0;
+  const writeCharacteristic = {
+    uuid: '0002',
+    deviceID: uuid,
+    isWritableWithResponse: true,
+    isWritableWithoutResponse: true,
+    writeWithoutResponse: jest.fn(() => {
+      writeCount += 1;
+      if (writeCount === 1) {
+        notifyCallback?.(null, {
+          value: Buffer.from('3f23230002000000040a026f6b', 'hex').toString('base64'),
+        });
+      }
+      return Promise.resolve();
+    }),
+  };
+  const device = {
+    id: uuid,
+    name: 'OneKey Classic',
+    localName: 'OneKey Classic',
+    serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+    isConnected: jest.fn(() => Promise.resolve(true)),
+    cancelConnection: jest.fn(() => Promise.resolve()),
+    onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+  };
+  const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+  transport.blePlxManager = {
+    devices: jest.fn(() => Promise.resolve([device])),
+    connectedDevices: jest.fn(() => Promise.resolve([])),
+    cancelTransaction: jest.fn(() => Promise.resolve()),
+  } as any;
+  transport.resolveCharacteristics = jest.fn(() =>
+    Promise.resolve({ writeCharacteristic, notifyCharacteristic })
+  );
+  transport.init({ debug: jest.fn(), error: jest.fn() }, new EventEmitter());
+  transport.configure(protocolV1Schema);
+  transport.configureProtocolV2(protocolV2Schema);
+  return { transport, uuid, device };
+};
+
 describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
+  test('does not classify disconnects as retryable firmware writes', () => {
+    expect(
+      getFirmwareUploadWriteRetryType({
+        errorCode: 205,
+        message: 'Device disconnected after write',
+      })
+    ).toBeNull();
+  });
+
+  test('keeps another device reader when releasing a device with an active V1 call', async () => {
+    const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
+    const activeV1Call = createDeferred<string>();
+    const otherDeviceReader = createDeferred<Uint8Array>();
+    activeV1Call.promise.catch(() => undefined);
+    otherDeviceReader.promise.catch(() => undefined);
+    transport.runPromise = activeV1Call;
+    transport.runPromiseDeviceId = 'device-a';
+    transport.protocolV2FramePromises.set('device-b', otherDeviceReader);
+
+    await transport.releaseNative('device-a', true);
+
+    expect(transport.protocolV2FramePromises.get('device-b')).toBe(otherDeviceReader);
+  });
+
+  test('rejects a pending reader when its device frame state resets', async () => {
+    const transport = new ReactNativeBleTransport({ scanTimeout: 1 }) as any;
+    const reader = createDeferred<Uint8Array>();
+    transport.protocolV2FramePromises.set('device-a', reader);
+    const result = Promise.race([
+      reader.promise.then(
+        () => 'resolved',
+        () => 'rejected'
+      ),
+      new Promise(resolve => {
+        setTimeout(() => resolve('pending'), 20);
+      }),
+    ]);
+
+    transport.resetProtocolV2Frames('device-a');
+
+    await expect(result).resolves.toBe('rejected');
+  });
+
   test('keeps the legacy default BLE scan timeout', () => {
     expect(new ReactNativeBleTransport({}).scanTimeout).toBe(3000);
   });
 
+  test('reconnects before falling back to Protocol V1 after a fatal V2 probe failure', async () => {
+    const { transport, uuid } = createV1Harness();
+    const probeProtocolV2 = jest
+      .spyOn(transport as any, 'probeProtocolV2')
+      .mockImplementationOnce(async () => {
+        await (transport as any).releaseNative(uuid, true);
+        return false;
+      });
+    const resolveCharacteristics = jest.spyOn(transport as any, 'resolveCharacteristics');
+
+    await expect(transport.acquire({ uuid, protocolHint: 'V2' })).resolves.toEqual({
+      uuid,
+      protocolType: 'V1',
+    });
+
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(resolveCharacteristics).toHaveBeenCalledTimes(2);
+    expect(transport.getProtocolType(uuid)).toBe('V1');
+  });
+
+  test('disconnects and invalidates a Protocol V1 link after a response timeout', async () => {
+    const { transport, uuid, device } = createV1Harness();
+
+    await transport.acquire({ uuid, expectedProtocol: 'V1' });
+    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 5 })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
+
+    expect(device.cancelConnection).toHaveBeenCalled();
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
   afterEach(() => {
     resetProtocolV2BleTuning();
   });

package/src/constants.ts

@@ -12,7 +12,6 @@ type BluetoothServices = Record<
 >;
 
 const ClassicServiceUUID = '00000001-0000-1000-8000-00805f9b34fb';
-const Pro2ServiceUUID = 'fffd';
 
 const OneKeyServices: Record<string, BluetoothServices> = {
   classic: {
@@ -21,11 +20,6 @@ const OneKeyServices: Record<string, BluetoothServices> = {
       writeUuid: '00000002-0000-1000-8000-00805f9b34fb',
       notifyUuid: '00000003-0000-1000-8000-00805f9b34fb',
     },
-    [Pro2ServiceUUID]: {
-      serviceUuid: Pro2ServiceUUID,
-      writeUuid: '00000002-0000-1000-8000-00805f9b34fb',
-      notifyUuid: '00000003-0000-1000-8000-00805f9b34fb',
-    },
   },
 };
 
@@ -48,7 +42,7 @@ export const getInfosForServiceUuid = (serviceUuid: string, deviceType: 'classic
     Object.values(services).find(
       item =>
         normalizeBleUuid(item.serviceUuid) === normalizedServiceUuid ||
-        getBleUuidKey(item.serviceUuid) === getBleUuidKey(serviceUuid)
+        matchesKnownBleUuid(serviceUuid, createKnownBleUuidAliases(item.serviceUuid))
     );
   if (!service) {
     return null;
@@ -59,17 +53,8 @@ export const getInfosForServiceUuid = (serviceUuid: string, deviceType: 'classic
 export const normalizeBleUuid = (uuid?: string | null) =>
   (uuid ?? '').replace(/-/g, '').toLowerCase();
 
-export const getBleUuidKey = (uuid?: string | null) => {
-  const normalized = normalizeBleUuid(uuid);
-  return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
-};
-
 export const isSameBleUuid = (left?: string | null, right?: string | null) => {
-  const normalizedLeft = normalizeBleUuid(left);
-  const normalizedRight = normalizeBleUuid(right);
-
-  return (
-    normalizedLeft === normalizedRight ||
-    (getBleUuidKey(left) !== '' && getBleUuidKey(left) === getBleUuidKey(right))
-  );
+  if (!left || !right) return false;
+  return matchesKnownBleUuid(left, createKnownBleUuidAliases(right));
 };
+import { createKnownBleUuidAliases, matchesKnownBleUuid } from '@onekeyfe/hd-shared';

package/src/index.ts

@@ -23,7 +23,12 @@ import transport, {
   probeProtocolV2 as probeProtocolV2Helper,
   writeProtocolV2BleFrame,
 } from '@onekeyfe/hd-transport';
-import { ERRORS, HardwareErrorCode, createDeferred, isOnekeyDevice } from '@onekeyfe/hd-shared';
+import {
+  ERRORS,
+  HardwareErrorCode,
+  createDeferred,
+  isOnekeyBluetoothDevice,
+} from '@onekeyfe/hd-shared';
 
 import { getConnectedDeviceIds, onDeviceBondState, pairDevice } from './BleManager';
 import { hasWritableCapability, resolveProtocolV2PacketCapacity } from './bleStrategy';
@@ -31,7 +36,6 @@ import { subscribeBleOn } from './subscribeBleOn';
 import {
   ANDROID_PACKET_LENGTH,
   IOS_PACKET_LENGTH,
-  getBleUuidKey,
   getBluetoothServiceUuids,
   getInfosForServiceUuid,
   isSameBleUuid,
@@ -56,13 +60,12 @@ const FIRMWARE_UPLOAD_WRITE_BURST_SIZE = Platform.OS === 'ios' ? 4 : 5;
 const FIRMWARE_UPLOAD_WRITE_PAUSE_MS = Platform.OS === 'ios' ? 8 : 10;
 const FIRMWARE_UPLOAD_WRITE_FLUSH_DELAY_MS = Platform.OS === 'ios' ? 24 : 30;
 const FIRMWARE_UPLOAD_WRITE_MAX_RETRIES = 8;
-const FIRMWARE_UPLOAD_RECONNECT_RETRY_DELAY_MS = 2000;
 const ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH = 192;
 const FIRMWARE_UPLOAD_WRITE_PACKET_CAPACITY =
   Platform.OS === 'ios' ? IOS_PACKET_LENGTH : ANDROID_FIRMWARE_UPLOAD_PACKET_LENGTH;
 const ANDROID_GATT_CONGESTED_STATUS = 143;
 
-type FirmwareUploadWriteRetryType = 'congested' | 'reconnectable';
+type FirmwareUploadWriteRetryType = 'congested';
 type ResolvedBleCharacteristics = {
   writeCharacteristic: Characteristic;
   notifyCharacteristic: Characteristic;
@@ -73,7 +76,9 @@ const delay = (ms: number) =>
     setTimeout(resolve, ms);
   });
 
-const getFirmwareUploadWriteRetryType = (error: unknown): FirmwareUploadWriteRetryType | null => {
+export const getFirmwareUploadWriteRetryType = (
+  error: unknown
+): FirmwareUploadWriteRetryType | null => {
   if (!error || typeof error !== 'object') return null;
   const bleWriteError = error as {
     androidErrorCode?: unknown;
@@ -84,13 +89,6 @@ const getFirmwareUploadWriteRetryType = (error: unknown): FirmwareUploadWriteRet
     name?: unknown;
   };
 
-  if (
-    bleWriteError.errorCode === BleErrorCode.DeviceDisconnected ||
-    bleWriteError.errorCode === BleErrorCode.CharacteristicNotFound
-  ) {
-    return 'reconnectable';
-  }
-
   if (
     bleWriteError.androidErrorCode === ANDROID_GATT_CONGESTED_STATUS ||
     bleWriteError.status === ANDROID_GATT_CONGESTED_STATUS
@@ -162,16 +160,6 @@ function getDeviceDisplayName(device?: Device | null) {
   return device?.name || device?.localName || null;
 }
 
-function isGenericBleService(uuid?: string | null) {
-  return ['1800', '1801', '180a'].includes(getBleUuidKey(uuid));
-}
-
-function hasKnownOneKeyService(device?: Device | null) {
-  return (device?.serviceUUIDs ?? []).some(serviceUuid =>
-    getInfosForServiceUuid(serviceUuid, 'classic')
-  );
-}
-
 const ANDROID_REQUEST_MTU = 256;
 
 const connectOptions: Record<string, unknown> = {
@@ -259,6 +247,8 @@ export default class ReactNativeBleTransport {
 
   runPromise: Deferred<any> | null = null;
 
+  private runPromiseDeviceId: string | null = null;
+
   emitter?: EventEmitter;
 
   firmwareUploadWriteRecoveryIds = new Set<string>();
@@ -359,29 +349,15 @@ export default class ReactNativeBleTransport {
       }
     }
 
-    let fallbackServiceUuid: string | undefined;
-
     if (!infos) {
       const services = await device.services();
       Log?.debug(
         '[ReactNativeBleTransport] Known OneKey service UUID not found, discovered services:',
         services?.map(service => service.uuid)
       );
-
-      const knownService = services.find(service =>
-        getInfosForServiceUuid(service.uuid, 'classic')
-      );
-      const fallbackService =
-        knownService ?? services.find(service => !isGenericBleService(service.uuid)) ?? services[0];
-
-      if (fallbackService) {
-        fallbackServiceUuid = fallbackService.uuid;
-        characteristics = await device.characteristicsForService(fallbackService.uuid);
-        Log?.debug('[ReactNativeBleTransport] Using fallback BLE service:', fallbackService.uuid);
-      }
     }
 
-    if (!infos && !fallbackServiceUuid) {
+    if (!infos) {
       try {
         Log?.debug('cancel connection when service not found');
         await device.cancelConnection();
@@ -391,9 +367,7 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
     }
 
-    const serviceUuid = infos?.serviceUuid ?? fallbackServiceUuid;
-    const writeUuid = infos?.writeUuid ?? '00000002-0000-1000-8000-00805f9b34fb';
-    const notifyUuid = infos?.notifyUuid ?? '00000003-0000-1000-8000-00805f9b34fb';
+    const { serviceUuid, writeUuid, notifyUuid } = infos;
 
     if (!serviceUuid) {
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
@@ -461,10 +435,9 @@ export default class ReactNativeBleTransport {
       try {
         Log?.debug('device disconnect: ', device?.id);
         this.emitDeviceDisconnect(uuid, device?.name, monitorToken);
-        if (this.runPromise) {
+        if (this.runPromise && this.runPromiseDeviceId === uuid) {
           const error = ERRORS.TypedError(HardwareErrorCode.BleConnectedError);
           this.runPromise.reject(error);
-          this.rejectAllProtocolV2Frames(error);
         }
       } catch (e) {
         Log?.debug('device disconnect error: ', e);
@@ -607,10 +580,12 @@ export default class ReactNativeBleTransport {
           }
 
           const displayName = getDeviceDisplayName(device);
-          const isOneKey =
-            isOnekeyDevice(device?.name ?? null, device?.id) ||
-            isOnekeyDevice(device?.localName ?? null, device?.id) ||
-            hasKnownOneKeyService(device);
+          const isOneKey = isOnekeyBluetoothDevice({
+            id: device?.id,
+            name: device?.name,
+            localName: device?.localName,
+            serviceUuids: device?.serviceUUIDs,
+          });
           if (isOneKey) {
             addDevice(device as unknown as Device);
           } else if (displayName && /\bpro\s*2\b/i.test(displayName)) {
@@ -627,10 +602,18 @@ export default class ReactNativeBleTransport {
       getConnectedDeviceIds(Platform.OS === 'ios' ? getBluetoothServiceUuids() : []).then(
         devices => {
           for (const device of devices) {
-            const { serviceUUIDs } = device as { serviceUUIDs?: string[] };
-            const hasCachedServiceUuid = Boolean(serviceUUIDs?.length);
-            const keepDevice = Platform.OS === 'ios' || hasCachedServiceUuid;
-            if (keepDevice) {
+            const localName =
+              'localName' in device && typeof device.localName === 'string'
+                ? device.localName
+                : null;
+            if (
+              isOnekeyBluetoothDevice({
+                id: device.id,
+                name: device.name,
+                localName,
+                serviceUuids: device.serviceUUIDs,
+              })
+            ) {
               Log?.debug('search connected peripheral: ', device.id);
               addDevice(device as unknown as Device);
             }
@@ -699,8 +682,8 @@ export default class ReactNativeBleTransport {
     if (forceCleanRunPromise && this.runPromise) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
-      this.rejectAllProtocolV2Frames(error);
       this.runPromise = null;
+      this.runPromiseDeviceId = null;
       Log?.debug('Force clean Bluetooth run promise, forceCleanRunPromise: ', forceCleanRunPromise);
     }
 
@@ -793,7 +776,8 @@ export default class ReactNativeBleTransport {
 
     const protocolHint = expectedProtocol
       ? undefined
-      : this.deviceProtocolHints.get(uuid) ??
+      : input.protocolHint ??
+        this.deviceProtocolHints.get(uuid) ??
         inferProtocolHintFromDeviceName(getDeviceDisplayName(device));
 
     // release transport before new transport instance
@@ -887,7 +871,7 @@ export default class ReactNativeBleTransport {
           this.rejectProtocolV2Frames(uuid, ERRORS.TypedError(errorCode));
           return;
         }
-        if (this.runPromise) {
+        if (this.runPromise && this.runPromiseDeviceId === uuid) {
           let ERROR:
             | typeof HardwareErrorCode.BleDeviceBondError
             | typeof HardwareErrorCode.BleCharacteristicNotifyError
@@ -910,7 +894,6 @@ export default class ReactNativeBleTransport {
               HardwareErrorCode.BleCharacteristicNotifyChangeFailure
             );
             this.runPromise.reject(notifyError);
-            this.rejectAllProtocolV2Frames(notifyError);
             Log?.debug(
               `${HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`
             );
@@ -918,7 +901,6 @@ export default class ReactNativeBleTransport {
           }
           const notifyError = ERRORS.TypedError(ERROR);
           this.runPromise.reject(notifyError);
-          this.rejectAllProtocolV2Frames(notifyError);
           Log?.debug(': monitor notify error, and has unreleased Promise', Error);
         }
 
@@ -963,14 +945,16 @@ export default class ReactNativeBleTransport {
           // );
           bufferLength = 0;
           buffer = [];
-          this.runPromise?.resolve(value.toString('hex'));
+          if (this.runPromiseDeviceId === uuid) {
+            this.runPromise?.resolve(value.toString('hex'));
+          }
         }
       } catch (error) {
         Log?.debug('monitor data error: ', error);
         const notifyError = ERRORS.TypedError(HardwareErrorCode.BleWriteCharacteristicError);
         if (this.deviceProtocol.get(uuid) === 'V2') {
           this.rejectProtocolV2Frames(uuid, notifyError);
-        } else {
+        } else if (this.runPromiseDeviceId === uuid) {
           this.runPromise?.reject(notifyError);
         }
       }
@@ -986,11 +970,12 @@ export default class ReactNativeBleTransport {
 
   private async releaseNative(uuid: string, onclose = false) {
     const transport = transportCache[uuid];
-    if (this.runPromise) {
+    if (this.runPromise && this.runPromiseDeviceId === uuid) {
       const error = ERRORS.TypedError(HardwareErrorCode.BleForceCleanRunPromise);
       this.runPromise.reject(error);
       this.runPromise = null;
-      this.rejectAllProtocolV2Frames(error);
+      this.runPromiseDeviceId = null;
+      this.rejectProtocolV2Frames(uuid, error);
     } else {
       this.resetProtocolV2Frames(uuid);
     }
@@ -1098,6 +1083,7 @@ export default class ReactNativeBleTransport {
     const runPromise = createDeferred<string>();
     runPromise.promise.catch(() => undefined);
     this.runPromise = runPromise;
+    this.runPromiseDeviceId = uuid;
     const messages = this._messages;
     const buffers = ProtocolV1.encodeTransportPackets(messages, name, data);
     let timeout: ReturnType<typeof setTimeout> | undefined;
@@ -1197,31 +1183,14 @@ export default class ReactNativeBleTransport {
               if (!retryType || attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
                 throw error;
               }
-              const shouldReconnect = retryType === 'reconnectable';
-              const delayMs = shouldReconnect
-                ? FIRMWARE_UPLOAD_RECONNECT_RETRY_DELAY_MS
-                : resolveFirmwareUploadRetryDelay(attempt);
+              const delayMs = resolveFirmwareUploadRetryDelay(attempt);
               Log?.debug('[ReactNativeBleTransport] FirmwareUpload write retry:', {
                 attempt: attempt + 1,
                 delayMs,
-                reconnect: shouldReconnect,
                 error,
               });
-              if (shouldReconnect) {
-                this.firmwareUploadWriteRecoveryIds.add(uuid);
-              }
               await delay(delayMs);
               attempt += 1;
-              if (shouldReconnect) {
-                try {
-                  await this.reconnectFirmwareUploadTransport(uuid, transport);
-                } catch (e) {
-                  Log?.debug('[ReactNativeBleTransport] FirmwareUpload reconnect error:', e);
-                  if (attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
-                    throw e;
-                  }
-                }
-              }
             }
           }
         },
@@ -1274,16 +1243,25 @@ export default class ReactNativeBleTransport {
       const jsonData = ProtocolV1.decodeMessage(messages, response);
       return check.call(jsonData);
     } catch (e) {
-      if (name === 'Initialize' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS) {
-        Log?.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe call failed:', e);
+      if (name === 'GetFeatures' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS) {
+        Log?.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe call failed:', e);
       } else {
         Log?.error('call error: ', e);
       }
+      const isProbeTimeout =
+        name === 'GetFeatures' && options?.timeoutMs === PROTOCOL_PROBE_TIMEOUT_MS;
+      if (
+        !isProbeTimeout &&
+        (e as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleTimeoutError
+      ) {
+        await this.disconnect(uuid);
+      }
       throw e;
     } finally {
       if (timeout) clearTimeout(timeout);
       if (this.runPromise === runPromise) {
         this.runPromise = null;
+        this.runPromiseDeviceId = null;
       }
     }
   }
@@ -1376,6 +1354,7 @@ export default class ReactNativeBleTransport {
       // this.runPromise.reject(new Error('Transport_CallCanceled'));
     }
     this.runPromise = null;
+    this.runPromiseDeviceId = null;
   }
 
   private getCachedTransport(uuid: string) {
@@ -1396,7 +1375,7 @@ export default class ReactNativeBleTransport {
   private createProtocolDetectionError() {
     return ERRORS.TypedError(
       HardwareErrorCode.BleTimeoutError,
-      'Unable to detect BLE protocol: device did not respond to Protocol V1 Initialize or Protocol V2 Ping'
+      'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping'
     );
   }
 
@@ -1447,6 +1426,13 @@ export default class ReactNativeBleTransport {
       if (i > 0) {
         // Reset subscriptions and buffers after a failed probe before trying another protocol.
         await this.resetProbeStateAfterProtocolProbe(uuid, probeOrder[i - 1]);
+        if (!transportCache[uuid]) {
+          const reacquired = await this.acquire({
+            uuid,
+            expectedProtocol: protocol,
+          });
+          return reacquired.protocolType;
+        }
       }
       const detected =
         protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
@@ -1524,11 +1510,13 @@ export default class ReactNativeBleTransport {
 
     try {
       this.deviceProtocol.set(uuid, 'V1');
-      await this.callProtocolV1(uuid, 'Initialize', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
+      // GetFeatures identifies Protocol V1 without resetting an existing wallet
+      // session before Core has a chance to restore a hidden wallet.
+      await this.callProtocolV1(uuid, 'GetFeatures', {}, { timeoutMs: PROTOCOL_PROBE_TIMEOUT_MS });
       return true;
     } catch (error) {
       this.clearProbeProtocol(uuid, 'V1');
-      Log?.debug('[ReactNativeBleTransport] Protocol V1 Initialize probe failed:', error);
+      Log?.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe failed:', error);
       return false;
     }
   }
@@ -1603,17 +1591,8 @@ export default class ReactNativeBleTransport {
     this.getProtocolV2FrameQueue(uuid).push(frame);
   }
 
-  private rejectAllProtocolV2Frames(error: Error) {
-    this.protocolV2FrameQueues.clear();
-    for (const framePromise of this.protocolV2FramePromises.values()) {
-      framePromise.reject(error);
-    }
-    this.protocolV2FramePromises.clear();
-  }
-
   private resetProtocolV2Frames(uuid: string) {
-    this.protocolV2FrameQueues.delete(uuid);
-    this.protocolV2FramePromises.delete(uuid);
+    this.rejectProtocolV2Frames(uuid, new Error(`Protocol V2 frame state reset for ${uuid}`));
   }
 
   private rejectProtocolV2Frames(uuid: string, error: Error) {

package/src/types.ts

@@ -10,4 +10,5 @@ export type BleAcquireInput = {
   uuid: string;
   forceCleanRunPromise?: boolean;
   expectedProtocol?: ProtocolType;
+  protocolHint?: ProtocolType;
 };