@onekeyfe/hd-shared 1.2.0-alpha.17 → 1.2.0-alpha.171

package/dist/index.js

@@ -135,6 +135,7 @@ const HardwareErrorCode = {
     BleDeviceDisconnected: 720,
     BlePoweredOff: 721,
     BleUnsupported: 722,
+    BleUnavailableWhileUsbConnected: 723,
     RuntimeError: 800,
     PinInvalid: 801,
     PinCancelled: 802,
@@ -164,7 +165,9 @@ const HardwareErrorCode = {
     DeviceSettingsLanguageNotSupport: 826,
     TooManyInputs: 827,
     PinMismatch: 828,
-    DeviceLocked: 829,
+    DeviceLocked: 830,
+    WalletSessionInvalid: 831,
+    NftStorageLimitReached: 832,
     LowlevelTrasnportConnectError: 900,
     WebDeviceNotFoundOrNeedsPermission: 901,
     WebDevicePromptAccessError: 902,
@@ -240,6 +243,7 @@ const HardwareErrorCodeMessage = {
     [HardwareErrorCode.BleDeviceDisconnected]: 'Device disconnected',
     [HardwareErrorCode.BlePoweredOff]: 'Bluetooth is turned off',
     [HardwareErrorCode.BleUnsupported]: 'Bluetooth is not supported on this device',
+    [HardwareErrorCode.BleUnavailableWhileUsbConnected]: 'Bluetooth is unavailable while USB is connected. Unplug USB and try again.',
     [HardwareErrorCode.RuntimeError]: 'Runtime error',
     [HardwareErrorCode.PinInvalid]: 'Pin invalid',
     [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
@@ -270,6 +274,8 @@ const HardwareErrorCodeMessage = {
     [HardwareErrorCode.TooManyInputs]: 'Too many inputs',
     [HardwareErrorCode.PinMismatch]: 'PIN mismatch',
     [HardwareErrorCode.DeviceLocked]: 'Device locked',
+    [HardwareErrorCode.WalletSessionInvalid]: 'Wallet session is invalid or expired',
+    [HardwareErrorCode.NftStorageLimitReached]: 'NFT storage limit reached. Remove an NFT from the device and try again.',
     [HardwareErrorCode.LowlevelTrasnportConnectError]: 'Lowlevel transport connect error',
     [HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission]: 'Web-USB or Web-Bluetooth device not found or needs permission',
     [HardwareErrorCode.WebDevicePromptAccessError]: 'Web-USB or Web-Bluetooth device prompt access error',
@@ -393,6 +399,7 @@ const ONEKEY_WEBUSB_FILTER = [
     { vendorId: 0x1209, productId: 0x4f4b },
     { vendorId: 0x1209, productId: 0x4f4c },
 ];
+const ONEKEY_PROTOCOL_V2_USB_IDS = [{ vendorId: 0x1209, productId: 0x4f4c }];
 const TREZOR_WEBUSB_MANUFACTURER_NAMES = new Set(['trezor', 'trezor company', 'satoshilabs']);
 const isKnownTrezorWebUsbDevice = (descriptor) => {
     var _a;
@@ -434,13 +441,20 @@ exports.EOneKeyBleMessageKeys = void 0;
     EOneKeyBleMessageKeys["NOBLE_BLE_STOP_SCAN"] = "$onekey-noble-ble-stop-scan";
     EOneKeyBleMessageKeys["NOBLE_BLE_GET_DEVICE"] = "$onekey-noble-ble-get-device";
     EOneKeyBleMessageKeys["NOBLE_BLE_CONNECT"] = "$onekey-noble-ble-connect";
+    EOneKeyBleMessageKeys["NOBLE_BLE_RELEASE"] = "$onekey-noble-ble-release";
     EOneKeyBleMessageKeys["NOBLE_BLE_DISCONNECT"] = "$onekey-noble-ble-disconnect";
     EOneKeyBleMessageKeys["NOBLE_BLE_WRITE"] = "$onekey-noble-ble-write";
     EOneKeyBleMessageKeys["NOBLE_BLE_SUBSCRIBE"] = "$onekey-noble-ble-subscribe";
     EOneKeyBleMessageKeys["NOBLE_BLE_UNSUBSCRIBE"] = "$onekey-noble-ble-unsubscribe";
     EOneKeyBleMessageKeys["NOBLE_BLE_NOTIFICATION"] = "$onekey-noble-ble-notification";
+    EOneKeyBleMessageKeys["NOBLE_BLE_MTU_CHANGED"] = "$onekey-noble-ble-mtu-changed";
     EOneKeyBleMessageKeys["NOBLE_BLE_CANCEL_PAIRING"] = "$onekey-noble-ble-cancel-pairing";
 })(exports.EOneKeyBleMessageKeys || (exports.EOneKeyBleMessageKeys = {}));
+exports.EBleDisconnectReason = void 0;
+(function (EBleDisconnectReason) {
+    EBleDisconnectReason["DeviceDisconnected"] = "device-disconnected";
+    EBleDisconnectReason["IdleKeepAlive"] = "idle-keep-alive";
+})(exports.EBleDisconnectReason || (exports.EBleDisconnectReason = {}));
 const ONEKEY_SERVICE_UUID = '00000001-0000-1000-8000-00805f9b34fb';
 const ONEKEY_WRITE_CHARACTERISTIC_UUID = '00000002-0000-1000-8000-00805f9b34fb';
 const ONEKEY_NOTIFY_CHARACTERISTIC_UUID = '00000003-0000-1000-8000-00805f9b34fb';
@@ -487,11 +501,140 @@ const isOnekeyDevice = (name, id) => {
         return true;
     if (normalizedName.startsWith('touch ') ||
         normalizedName.startsWith('pro ') ||
-        normalizedName.startsWith('pro2 ')) {
+        normalizedName.startsWith('pro2') ||
+        normalizedName.startsWith('neo')) {
+        return true;
+    }
+    const compactName = compactBleName(normalizedName);
+    if (PRO2_COMPACT_NAME_PATTERN.test(compactName) || NEO_COMPACT_NAME_PATTERN.test(compactName)) {
         return true;
     }
     return isOneKeyShortName(normalizedName);
 };
+const inferProtocolHintFromUsbId = (vendorId, productId) => ONEKEY_PROTOCOL_V2_USB_IDS.some(id => id.vendorId === vendorId && id.productId === productId)
+    ? 'V2'
+    : undefined;
+const resolveOneKeyUsbDevicePath = (device) => {
+    var _a, _b, _c, _d;
+    const serial = (_a = device.serialNumber) === null || _a === void 0 ? void 0 : _a.trim();
+    if (serial)
+        return serial;
+    if (device.vendorId == null && device.productId == null && !device.productName) {
+        return undefined;
+    }
+    const vendorId = ((_b = device.vendorId) !== null && _b !== void 0 ? _b : 0).toString(16).padStart(4, '0');
+    const productId = ((_c = device.productId) !== null && _c !== void 0 ? _c : 0).toString(16).padStart(4, '0');
+    const product = ((_d = device.productName) !== null && _d !== void 0 ? _d : 'onekey')
+        .trim()
+        .toLowerCase()
+        .replace(/\s+/g, '-')
+        .replace(/[^a-z0-9-]/g, '');
+    return `usb-${vendorId}-${productId}-${product || 'onekey'}`;
+};
+const BLUETOOTH_BASE_UUID_SUFFIX = '00001000800000805f9b34fb';
+const normalizeBleUuid = (uuid) => (uuid !== null && uuid !== void 0 ? uuid : '').replace(/-/g, '').toLowerCase();
+const createKnownBleUuidAliases = (uuid) => {
+    const normalized = normalizeBleUuid(uuid);
+    const aliases = new Set([normalized]);
+    if (normalized.length !== 32 || !normalized.endsWith(BLUETOOTH_BASE_UUID_SUFFIX)) {
+        return aliases;
+    }
+    const assignedNumber = normalized.slice(0, 8);
+    aliases.add(assignedNumber);
+    if (assignedNumber.startsWith('0000')) {
+        aliases.add(assignedNumber.slice(4));
+    }
+    return aliases;
+};
+const matchesKnownBleUuid = (actualUuid, aliases) => aliases.has(normalizeBleUuid(actualUuid));
+const ONEKEY_COMMUNICATION_SERVICE_ALIASES = createKnownBleUuidAliases(ONEKEY_SERVICE_UUID);
+const FIDO_SERVICE_ALIASES = createKnownBleUuidAliases('0000fffd-0000-1000-8000-00805f9b34fb');
+const PRO2_COMPACT_NAME_PATTERN = /^(?:onekey)?pro2[a-f0-9]{4}$/i;
+const NEO_COMPACT_NAME_PATTERN = /^(?:onekey)?neo[a-f0-9]{4}$/i;
+const FIND_MY_COMPACT_SUFFIXES = [
+    'findemy',
+    'findem',
+    'finde',
+    'findmy',
+    'findm',
+    'find',
+    'fin',
+];
+const COMPLETE_FIND_MY_COMPACT_SUFFIXES = ['findemy', 'findmy'];
+const compactBleName = (value) => Array.from(value)
+    .filter(character => character !== '-' && character.trim() !== '')
+    .join('')
+    .toLowerCase();
+const getFindMyCompactSuffix = (compactName) => FIND_MY_COMPACT_SUFFIXES.find(candidate => compactName.endsWith(candidate));
+const getPro2FindMyBaseLength = (value) => {
+    const compactName = compactBleName(value);
+    const suffix = getFindMyCompactSuffix(compactName);
+    if (!suffix)
+        return undefined;
+    const compactBaseName = compactName.slice(0, -suffix.length);
+    return PRO2_COMPACT_NAME_PATTERN.test(compactBaseName) ? compactBaseName.length : undefined;
+};
+const isPro2FindMyAdvertisementName = (value) => {
+    if (!value)
+        return false;
+    if (getPro2FindMyBaseLength(value) !== undefined)
+        return true;
+    const compactName = compactBleName(value);
+    const suffix = COMPLETE_FIND_MY_COMPACT_SUFFIXES.find(candidate => compactName.endsWith(candidate));
+    if (!suffix)
+        return false;
+    return compactName.slice(0, -suffix.length).includes('pro2');
+};
+const normalizePro2FindMyAdvertisementName = (value) => {
+    const baseLength = getPro2FindMyBaseLength(value);
+    if (baseLength === undefined)
+        return value;
+    let compactLength = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (character !== '-' && character.trim() !== '') {
+            compactLength += 1;
+            if (compactLength === baseLength) {
+                return value.slice(0, index + 1).trimEnd();
+            }
+        }
+    }
+    return value;
+};
+const canonicalizePro2BleAdvertisementName = (value) => {
+    const withoutFindMy = normalizePro2FindMyAdvertisementName(value);
+    const compact = compactBleName(withoutFindMy);
+    if (!PRO2_COMPACT_NAME_PATTERN.test(compact))
+        return withoutFindMy;
+    const match = withoutFindMy.match(/^(onekey\s*)?pro\s*2\s*/i);
+    if (!match)
+        return withoutFindMy;
+    const rest = withoutFindMy.slice(match[0].length);
+    const prefix = match[1] ? 'OneKey Pro 2' : 'Pro 2';
+    return rest ? `${prefix} ${rest}` : prefix;
+};
+const isSameOnekeyBleName = (left, right) => {
+    if (!left || !right)
+        return false;
+    if (left === right)
+        return true;
+    return (compactBleName(canonicalizePro2BleAdvertisementName(left)) ===
+        compactBleName(canonicalizePro2BleAdvertisementName(right)));
+};
+const hasOnekeyCommunicationService = (serviceUuids) => (serviceUuids !== null && serviceUuids !== void 0 ? serviceUuids : []).some(uuid => matchesKnownBleUuid(uuid, ONEKEY_COMMUNICATION_SERVICE_ALIASES));
+const isOnekeyBluetoothDevice = ({ id, name, localName, serviceUuids, }) => {
+    const advertisedServiceUuids = serviceUuids !== null && serviceUuids !== void 0 ? serviceUuids : [];
+    if (hasOnekeyCommunicationService(advertisedServiceUuids)) {
+        return true;
+    }
+    if (isPro2FindMyAdvertisementName(name) || isPro2FindMyAdvertisementName(localName)) {
+        return false;
+    }
+    if (advertisedServiceUuids.some(uuid => matchesKnownBleUuid(uuid, FIDO_SERVICE_ALIASES))) {
+        return false;
+    }
+    return isOnekeyDevice(name !== null && name !== void 0 ? name : null, id) || isOnekeyDevice(localName !== null && localName !== void 0 ? localName : null, id);
+};
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -564,6 +707,7 @@ exports.EDeviceType = void 0;
     EDeviceType["Touch"] = "touch";
     EDeviceType["Pro"] = "pro";
     EDeviceType["Pro2"] = "pro2";
+    EDeviceType["Neo"] = "neo";
 })(exports.EDeviceType || (exports.EDeviceType = {}));
 
 exports.CreateErrorByMessage = CreateErrorByMessage;
@@ -576,19 +720,31 @@ exports.HardwareError = HardwareError;
 exports.HardwareErrorCode = HardwareErrorCode;
 exports.HardwareErrorCodeMessage = HardwareErrorCodeMessage;
 exports.ONEKEY_NOTIFY_CHARACTERISTIC_UUID = ONEKEY_NOTIFY_CHARACTERISTIC_UUID;
+exports.ONEKEY_PROTOCOL_V2_USB_IDS = ONEKEY_PROTOCOL_V2_USB_IDS;
 exports.ONEKEY_SERVICE_UUID = ONEKEY_SERVICE_UUID;
 exports.ONEKEY_WEBUSB_FILTER = ONEKEY_WEBUSB_FILTER;
 exports.ONEKEY_WRITE_CHARACTERISTIC_UUID = ONEKEY_WRITE_CHARACTERISTIC_UUID;
 exports.TypedError = TypedError;
+exports.canonicalizePro2BleAdvertisementName = canonicalizePro2BleAdvertisementName;
 exports.createDefectiveFirmwareError = createDefectiveFirmwareError;
 exports.createDeferred = createDeferred;
 exports.createDeprecatedHardwareError = createDeprecatedHardwareError;
 exports.createDeviceNotSupportMethodError = createDeviceNotSupportMethodError;
+exports.createKnownBleUuidAliases = createKnownBleUuidAliases;
 exports.createNeedUpgradeFirmwareHardwareError = createNeedUpgradeFirmwareHardwareError;
 exports.createNewFirmwareForceUpdateHardwareError = createNewFirmwareForceUpdateHardwareError;
 exports.createNewFirmwareUnReleaseHardwareError = createNewFirmwareUnReleaseHardwareError;
+exports.hasOnekeyCommunicationService = hasOnekeyCommunicationService;
+exports.inferProtocolHintFromUsbId = inferProtocolHintFromUsbId;
 exports.isHeaderChunk = isHeaderChunk;
 exports.isKnownTrezorWebUsbDevice = isKnownTrezorWebUsbDevice;
+exports.isOnekeyBluetoothDevice = isOnekeyBluetoothDevice;
 exports.isOnekeyDevice = isOnekeyDevice;
+exports.isPro2FindMyAdvertisementName = isPro2FindMyAdvertisementName;
+exports.isSameOnekeyBleName = isSameOnekeyBleName;
+exports.matchesKnownBleUuid = matchesKnownBleUuid;
+exports.normalizeBleUuid = normalizeBleUuid;
+exports.normalizePro2FindMyAdvertisementName = normalizePro2FindMyAdvertisementName;
+exports.resolveOneKeyUsbDevicePath = resolveOneKeyUsbDevicePath;
 exports.serializeError = serializeError;
 exports.wait = wait;

package/jest.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  preset: '../../jest.config.js',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['node_modules', '<rootDir>/dist'],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-shared",
-  "version": "1.2.0-alpha.17",
+  "version": "1.2.0-alpha.171",
   "description": "Hardware SDK's shared tool library",
   "keywords": [
     "Hardware-SDK",
@@ -22,8 +22,9 @@
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
     "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "test": "jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
-  "gitHead": "9027b743e4f73beb42e1a7950397504b4191f2a3"
+  "gitHead": "68de201cc95fe521936c74f828addb3fb5251c67"
 }

package/src/HardwareError.test.ts

@@ -0,0 +1,36 @@
+import {
+  HardwareErrorCode,
+  HardwareErrorCodeMessage,
+  TypedError,
+  serializeError,
+} from './HardwareError';
+
+describe('HardwareErrorCode compatibility', () => {
+  test('preserves published Protocol V2 values while leaving code 829 unused', () => {
+    expect(HardwareErrorCode).not.toHaveProperty('KaspaPrevTxIdMismatch');
+    expect(HardwareErrorCode.DeviceLocked).toBe(830);
+    expect(HardwareErrorCode.WalletSessionInvalid).toBe(831);
+  });
+
+  test('reserves the BLE and USB conflict code for app error mapping', () => {
+    expect(HardwareErrorCode.BleUnavailableWhileUsbConnected).toBe(723);
+    expect(HardwareErrorCodeMessage[HardwareErrorCode.BleUnavailableWhileUsbConnected]).toBe(
+      'Bluetooth is unavailable while USB is connected. Unplug USB and try again.'
+    );
+    expect(
+      serializeError({
+        error: TypedError(HardwareErrorCode.BleUnavailableWhileUsbConnected, undefined, {
+          failureCode: 'Failure_ProcessError',
+          firmwareMessage: 'link disabled',
+        }),
+      })
+    ).toEqual({
+      code: 723,
+      error: 'Bluetooth is unavailable while USB is connected. Unplug USB and try again.',
+      params: {
+        failureCode: 'Failure_ProcessError',
+        firmwareMessage: 'link disabled',
+      },
+    });
+  });
+});

package/src/HardwareError.ts

@@ -345,6 +345,7 @@ export const HardwareErrorCode = {
   BleDeviceDisconnected: 720,
   BlePoweredOff: 721,
   BleUnsupported: 722,
+  BleUnavailableWhileUsbConnected: 723,
 
   /**
    * Hardware runtiome errors
@@ -488,7 +489,19 @@ export const HardwareErrorCode = {
    * Protocol V2 device must be unlocked before the requested operation.
    * @params: { failureCode?: string; subcode?: number; firmwareMessage?: string }
    */
-  DeviceLocked: 829,
+  DeviceLocked: 830,
+
+  /**
+   * The cached wallet session is invalid or has expired.
+   * @params: { failureCode?: string; subcode?: number; firmwareMessage?: string }
+   */
+  WalletSessionInvalid: 831,
+
+  /**
+   * Pro2 NFT storage has reached its item limit.
+   * @params: { count: number; limit: number }
+   */
+  NftStorageLimitReached: 832,
 
   /**
    * Lowlevel transport connect error
@@ -607,6 +620,8 @@ export const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping = {
   [HardwareErrorCode.BleDeviceDisconnected]: 'Device disconnected',
   [HardwareErrorCode.BlePoweredOff]: 'Bluetooth is turned off',
   [HardwareErrorCode.BleUnsupported]: 'Bluetooth is not supported on this device',
+  [HardwareErrorCode.BleUnavailableWhileUsbConnected]:
+    'Bluetooth is unavailable while USB is connected. Unplug USB and try again.',
 
   /**
    * Runtime Error
@@ -642,6 +657,9 @@ export const HardwareErrorCodeMessage: HardwareErrorCodeMessageMapping = {
   [HardwareErrorCode.TooManyInputs]: 'Too many inputs',
   [HardwareErrorCode.PinMismatch]: 'PIN mismatch',
   [HardwareErrorCode.DeviceLocked]: 'Device locked',
+  [HardwareErrorCode.WalletSessionInvalid]: 'Wallet session is invalid or expired',
+  [HardwareErrorCode.NftStorageLimitReached]:
+    'NFT storage limit reached. Remove an NFT from the device and try again.',
 
   /**
    * Lowlevel transport

package/src/constants.test.ts

@@ -1,9 +1,28 @@
-import { isKnownTrezorWebUsbDevice, isOnekeyDevice } from './constants';
+import {
+  canonicalizePro2BleAdvertisementName,
+  createKnownBleUuidAliases,
+  hasOnekeyCommunicationService,
+  inferProtocolHintFromUsbId,
+  isKnownTrezorWebUsbDevice,
+  isOnekeyBluetoothDevice,
+  isOnekeyDevice,
+  isPro2FindMyAdvertisementName,
+  isSameOnekeyBleName,
+  matchesKnownBleUuid,
+  normalizePro2FindMyAdvertisementName,
+  resolveOneKeyUsbDevicePath,
+} from './constants';
 
 describe('hardware device identity filters', () => {
   it('accepts known OneKey BLE names', () => {
     expect(isOnekeyDevice('Touch A1B2')).toBe(true);
     expect(isOnekeyDevice('Pro A1B2')).toBe(true);
+    expect(isOnekeyDevice('Neo A1B2')).toBe(true);
+    expect(isOnekeyDevice('Pro2A1B2')).toBe(true);
+    expect(isOnekeyDevice('Pro 2 A1B2')).toBe(true);
+    expect(isOnekeyDevice('OneKeyPro2A1B2')).toBe(true);
+    expect(isOnekeyDevice('OneKey Pro 2 A1B2')).toBe(true);
+    expect(isOnekeyDevice('Neo22D8')).toBe(true);
     expect(isOnekeyDevice('K1234')).toBe(true);
     expect(isOnekeyDevice('S8')).toBe(true);
   });
@@ -13,6 +32,180 @@ describe('hardware device identity filters', () => {
     expect(isOnekeyDevice('Ledger Nano X')).toBe(false);
   });
 
+  it('does not identify an FFFD-only advertisement as OneKey', () => {
+    expect(isOnekeyBluetoothDevice({ name: 'Find My', serviceUuids: ['fffd'] })).toBe(false);
+    expect(
+      isOnekeyBluetoothDevice({ serviceUuids: ['0000fffd-0000-1000-8000-00805f9b34fb'] })
+    ).toBe(false);
+  });
+
+  it('identifies Pro2 communication advertisements independently of their display name', () => {
+    expect(
+      isOnekeyBluetoothDevice({
+        name: 'Pro2 A1B2',
+        serviceUuids: ['0001', 'fffd'],
+      })
+    ).toBe(true);
+    expect(
+      isOnekeyBluetoothDevice({
+        name: 'Pro 2 A1B2',
+        serviceUuids: ['0001', 'fffd'],
+      })
+    ).toBe(true);
+    expect(
+      isOnekeyBluetoothDevice({
+        localName: 'Pro2 A1B2 - Find My',
+        serviceUuids: ['0001', 'fffd'],
+      })
+    ).toBe(true);
+    expect(
+      isOnekeyBluetoothDevice({
+        name: 'Pro2 5E9D - Finde My',
+        serviceUuids: ['0001', 'fffd'],
+      })
+    ).toBe(true);
+  });
+
+  it('rejects Pro2 Find My entries when the communication service is absent', () => {
+    expect(
+      isOnekeyBluetoothDevice({
+        name: 'Pro2 A1B2 - Find My',
+      })
+    ).toBe(false);
+    expect(
+      isOnekeyBluetoothDevice({
+        localName: 'OneKey Pro 2 A1B2 - Find My',
+        serviceUuids: [],
+      })
+    ).toBe(false);
+    expect(
+      isOnekeyBluetoothDevice({
+        name: 'Pro2 5E9D - Finde My',
+        serviceUuids: ['fffd'],
+      })
+    ).toBe(false);
+    expect(isOnekeyBluetoothDevice({ name: 'Pro2 - Find My' })).toBe(false);
+    expect(isOnekeyBluetoothDevice({ name: 'Pro2 G12Z - Find My' })).toBe(false);
+  });
+
+  it('uses a broad Find My guard without broadening public name normalization', () => {
+    expect(isPro2FindMyAdvertisementName('Pro2 Griffin - Find My')).toBe(true);
+    expect(isPro2FindMyAdvertisementName('Pro2 Griffin')).toBe(false);
+    expect(isPro2FindMyAdvertisementName('Pro2 22D8 - Find My')).toBe(true);
+    expect(normalizePro2FindMyAdvertisementName('Pro2 Griffin - Find My')).toBe(
+      'Pro2 Griffin - Find My'
+    );
+    expect(normalizePro2FindMyAdvertisementName('Pro2 22D8 - Find My')).toBe('Pro2 22D8');
+  });
+
+  it.each([
+    ['Pro2 A1B2 - Find My', 'Pro2 A1B2'],
+    ['Pro2 5E9D - Finde My', 'Pro2 5E9D'],
+    ['  OneKey Pro 2 A1B2 Find My  ', '  OneKey Pro 2 A1B2'],
+    ['OneKey Pro-2 22D8--Find-My', 'OneKey Pro-2 22D8'],
+    ['Pro2 22D8FindMy', 'Pro2 22D8'],
+    ['Pro2 22D8 - Fin', 'Pro2 22D8'],
+    ['Pro2 22D8FindM', 'Pro2 22D8'],
+    [`Pro2 22D8${'\t'.repeat(10_000)}Find My`, 'Pro2 22D8'],
+    ['Pro2 A1B2', 'Pro2 A1B2'],
+    ['Pro2 Griffin', 'Pro2 Griffin'],
+    ['Find My', 'Find My'],
+  ])('normalizes the public Pro2 advertisement name %s', (name, expected) => {
+    expect(normalizePro2FindMyAdvertisementName(name)).toBe(expected);
+  });
+
+  it.each([
+    ['Pro2 A1B2', 'Pro 2 A1B2'],
+    ['Pro2A1B2', 'Pro 2 A1B2'],
+    ['Pro 2 A1B2', 'Pro 2 A1B2'],
+    ['Pro 2 0088', 'Pro 2 0088'],
+    ['Pro2 22D8 - Find My', 'Pro 2 22D8'],
+    ['Pro 2 A1B2 - Find My', 'Pro 2 A1B2'],
+    ['OneKeyPro2A1B2', 'OneKey Pro 2 A1B2'],
+    ['OneKey Pro 2 A1B2', 'OneKey Pro 2 A1B2'],
+    ['OneKey Pro 2', 'OneKey Pro 2'],
+    ['Pro A1B2', 'Pro A1B2'],
+    ['Pro 22D8', 'Pro 22D8'],
+    ['Pro 2D8F', 'Pro 2D8F'],
+    ['OneKey Pro 22D8', 'OneKey Pro 22D8'],
+    ['Neo 22D8', 'Neo 22D8'],
+  ])('canonicalizes the public Pro2 advertisement name %s', (name, expected) => {
+    expect(canonicalizePro2BleAdvertisementName(name)).toBe(expected);
+  });
+
+  it('treats compact and spaced Pro2 BLE names as the same device', () => {
+    expect(isSameOnekeyBleName('Pro2 6136', 'Pro 2 6136')).toBe(true);
+    expect(isSameOnekeyBleName('Pro2 6136 - Find My', 'Pro 2 6136')).toBe(true);
+    expect(isSameOnekeyBleName('Pro 2 6136', 'Pro 2 0088')).toBe(false);
+    expect(isSameOnekeyBleName('Pro A1B2', 'Pro 2 A1B2')).toBe(false);
+    expect(isSameOnekeyBleName('Pro 22D8', 'Pro 22D8')).toBe(true);
+    expect(isSameOnekeyBleName('Pro 22D8', 'Pro2 22D8')).toBe(false);
+    expect(isSameOnekeyBleName('Pro 22D8', 'Pro 2 22D8')).toBe(false);
+  });
+
+  it('keeps OneKey discovery on the communication service', () => {
+    expect(
+      isOnekeyBluetoothDevice({
+        name: 'OneKey Pro 2',
+        serviceUuids: ['00000001-0000-1000-8000-00805f9b34fb'],
+      })
+    ).toBe(true);
+  });
+
+  it('only aliases standard Bluetooth Base UUID representations', () => {
+    const aliases = createKnownBleUuidAliases('00000001-0000-1000-8000-00805f9b34fb');
+
+    expect(matchesKnownBleUuid('0001', aliases)).toBe(true);
+    expect(matchesKnownBleUuid('00000001', aliases)).toBe(true);
+    expect(matchesKnownBleUuid('abcd0001-1234-5678-9012-abcdefabcdef', aliases)).toBe(false);
+  });
+
+  it('does not treat vendor-specific UUID fragments as communication or FIDO services', () => {
+    expect(
+      isOnekeyBluetoothDevice({
+        name: 'OneKey Pro 2',
+        serviceUuids: ['abcdfffd-1234-5678-9012-abcdefabcdef'],
+      })
+    ).toBe(true);
+    expect(
+      isOnekeyBluetoothDevice({
+        serviceUuids: ['abcd0001-1234-5678-9012-abcdefabcdef'],
+      })
+    ).toBe(false);
+  });
+
+  it('requires an explicitly advertised communication service for strict discovery', () => {
+    expect(hasOnekeyCommunicationService([])).toBe(false);
+    expect(hasOnekeyCommunicationService(['0001'])).toBe(true);
+    expect(hasOnekeyCommunicationService(['abcd0001-1234-5678-9012-abcdefabcdef'])).toBe(false);
+  });
+
+  it('hints Protocol V2 from the current Pro2/Neo USB ID only', () => {
+    expect(inferProtocolHintFromUsbId(0x1209, 0x4f4c)).toBe('V2');
+    expect(inferProtocolHintFromUsbId(0x1209, 0x53c1)).toBeUndefined();
+    expect(inferProtocolHintFromUsbId(0x1209, 0x4f4a)).toBeUndefined();
+    expect(inferProtocolHintFromUsbId(0x1209, 0x4f4b)).toBeUndefined();
+  });
+
+  it('uses the USB serial when present and synthesizes a path when firmware omits it', () => {
+    expect(
+      resolveOneKeyUsbDevicePath({
+        vendorId: 0x1209,
+        productId: 0x4f4c,
+        productName: 'OneKey Pro 2',
+        serialNumber: 'PRO2-SERIAL',
+      })
+    ).toBe('PRO2-SERIAL');
+    expect(
+      resolveOneKeyUsbDevicePath({
+        vendorId: 0x1209,
+        productId: 0x4f4c,
+        productName: 'OneKey Neo',
+        serialNumber: '',
+      })
+    ).toBe('usb-1209-4f4c-onekey-neo');
+  });
+
   it('only filters WebUSB descriptors that are explicitly identified as Trezor', () => {
     expect(
       isKnownTrezorWebUsbDevice({