@onekeyfe/hardware-cli 1.2.0-alpha.33 → 1.2.0-alpha.34

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { createSDK } from './sdk';
 declare const program: Command;
 export declare function getLegacyFirmwareConnectTimeout(transport: 'usb' | 'ble'): 90000 | undefined;
 /**
@@ -11,6 +12,26 @@ export declare function getLegacyFirmwareConnectTimeout(transport: 'usb' | 'ble'
  * After this, globalOpts.passphraseState is set and getCommonParams will include it.
  */
 export declare function prepareSession(sdk: typeof import('@onekeyfe/hd-common-connect-sdk').default, globalOpts: Record<string, any>): Promise<string | undefined>;
+/**
+ * Unified command runner. All `.action(...)` handlers should wrap their body
+ * in this helper so every command goes through the same lifecycle:
+ *
+ *   1. (optional) create SDK
+ *   2. (optional) prepareSession — unlock + keychain preload + passphraseState
+ *   3. run the handler (which calls outputResult on success)
+ *   4. report uncaught errors as a structured failure result
+ *   5. dispose SDK
+ *   6. let Node exit naturally after all SDK resources are released
+ *
+ * This fixes three previous bugs:
+ *   - Most signing commands skipped prepareSession, so keychain sessions
+ *     were never actually reused.
+ *   - outputResult scheduled process.exit(200ms) before dispose completed,
+ *     racing USB release on slower transports.
+ *   - Errors thrown from SDK calls leaked as stack traces instead of the
+ *     CLI's structured `{ success: false, payload: { error } }` shape.
+ */
+type AnySdk = Awaited<ReturnType<typeof createSDK>>;
 export declare function buildWallpaperUploadMetrics({ totalBytes, transferredBytes, startedAt, endedAt, lastProgress, }: {
     totalBytes: number;
     transferredBytes: number;
@@ -24,4 +45,42 @@ export declare function buildWallpaperUploadMetrics({ totalBytes, transferredByt
     transferKiBPerSecond: number | null;
     lastProgress: number;
 };
+export declare function runFirmwareUpdateV4WithRetry({ sdk, globalOpts, params, retries, }: {
+    sdk: AnySdk;
+    globalOpts: Record<string, any>;
+    params: ReturnType<typeof buildFirmwareUpdateV4Params>;
+    retries?: number;
+}): Promise<unknown>;
+declare function buildFirmwareUpdateV4Params(opts: {
+    chunkSize?: string;
+    resourceBundle?: string[];
+    romloader?: string;
+    bootloader?: string;
+    applicationP1?: string;
+    applicationP2?: string;
+    coprocessor?: string;
+    se01?: string;
+    se02?: string;
+    se03?: string;
+    se04?: string;
+    forcedUpdateRes?: boolean;
+}): {
+    platform: "desktop";
+    connectProtocol: "V2";
+    chunkSize: number | undefined;
+    forcedUpdateRes: boolean | undefined;
+    resourceBundleFiles: {
+        binary: ArrayBuffer;
+        devicePath: string;
+    }[] | undefined;
+    romloaderBinary: ArrayBuffer | undefined;
+    bootloaderBinary: ArrayBuffer | undefined;
+    applicationP1Binary: ArrayBuffer | undefined;
+    applicationP2Binary: ArrayBuffer | undefined;
+    coprocessorBinary: ArrayBuffer | undefined;
+    se01Binary: ArrayBuffer | undefined;
+    se02Binary: ArrayBuffer | undefined;
+    se03Binary: ArrayBuffer | undefined;
+    se04Binary: ArrayBuffer | undefined;
+};
 export { program };

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.program = exports.buildWallpaperUploadMetrics = exports.prepareSession = exports.getLegacyFirmwareConnectTimeout = void 0;
+exports.program = exports.runFirmwareUpdateV4WithRetry = exports.buildWallpaperUploadMetrics = exports.prepareSession = exports.getLegacyFirmwareConnectTimeout = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const commander_1 = require("commander");
@@ -1069,128 +1069,134 @@ async function runFirmwareUpdateV4WithRetry({ sdk, globalOpts, params, retries,
     const totalBytes = getFirmwareUpdateV4TotalBytes(params);
     const maxAttempts = Math.max((retries ?? 2) + 1, 1);
     let currentSdk = sdk;
-    let lastResult;
     let retried = false;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        let progressEvents = 0;
-        let lastProgress = -1;
-        let transferStartedAt;
-        let transferEndedAt;
-        let installProgressEvents = 0;
-        let lastInstallProgress = -1;
-        let installStartedAt;
-        let installEndedAt;
-        let lastPrintedTransferProgress = -10;
-        let lastPrintedInstallProgress = -10;
-        const totalStartedAt = Date.now();
-        const connectId = retried && globalOpts.transport === 'usb' && globalOpts.connectId
-            ? undefined
-            : globalOpts.connectId;
-        const onUiEvent = (message) => {
-            if (!message || typeof message !== 'object')
-                return;
-            const messageType = message.type;
-            const payload = getFirmwareUpdatePayload(message);
-            if (messageType === hd_core_1.UI_REQUEST.FIRMWARE_TIP) {
-                const tipMessage = payload?.data?.message;
-                if (typeof tipMessage === 'string') {
-                    process.stderr.write(`[onekey-hw] Firmware: ${tipMessage}\n`);
-                }
-                return;
-            }
-            if (messageType === hd_core_1.UI_REQUEST.REQUEST_BUTTON) {
-                const code = typeof payload?.code === 'string' ? ` (${payload.code})` : '';
-                process.stderr.write(`[onekey-hw] Please confirm the firmware update on your device${code}.\n`);
-                return;
-            }
-            if (messageType !== hd_core_1.UI_REQUEST.FIRMWARE_PROGRESS || !payload)
-                return;
-            const progress = Number(payload.progress);
-            if (!Number.isFinite(progress))
-                return;
-            if (payload.progressType === 'transferData') {
-                progressEvents += 1;
-                lastProgress = Math.max(lastProgress, progress);
-                transferStartedAt ?? (transferStartedAt = Date.now());
-                lastPrintedTransferProgress = maybePrintFirmwareProgress({
-                    progressType: 'transfer',
-                    progress,
-                    payload,
-                    lastPrintedProgress: lastPrintedTransferProgress,
-                });
-                if (progress >= 100) {
-                    transferEndedAt ?? (transferEndedAt = Date.now());
-                }
-                return;
-            }
-            if (payload.progressType === 'installingFirmware') {
-                installProgressEvents += 1;
-                lastInstallProgress = Math.max(lastInstallProgress, progress);
-                installStartedAt ?? (installStartedAt = Date.now());
-                lastPrintedInstallProgress = maybePrintFirmwareProgress({
-                    progressType: 'install',
-                    progress,
-                    payload,
-                    lastPrintedProgress: lastPrintedInstallProgress,
-                });
-                if (progress >= 100) {
-                    installEndedAt ?? (installEndedAt = Date.now());
-                }
+    let attempt = 1;
+    let { connectId } = globalOpts;
+    if (globalOpts.transport === 'usb') {
+        for (; attempt <= maxAttempts; attempt += 1) {
+            const probeResult = await currentSdk.getDeviceState(connectId, {
+                scope: 'runtime',
+                connectProtocol: 'V2',
+                retryCount: 0,
+            });
+            if (isSuccessResult(probeResult))
+                break;
+            if (attempt >= maxAttempts || !isProtocolV2UsbProbeTransientResult(probeResult)) {
+                return probeResult;
             }
-        };
-        currentSdk.on(hd_core_1.UI_EVENT, onUiEvent);
-        try {
-            lastResult = await currentSdk.firmwareUpdateV4(connectId, params);
-        }
-        finally {
-            currentSdk.off?.(hd_core_1.UI_EVENT, onUiEvent);
+            retried = true;
+            process.stderr.write(`[onekey-hw] Protocol V2 USB probe was transient; retrying read-only probe (${attempt}/${maxAttempts})...\n`);
+            await (0, sdk_1.disposeSDK)();
+            await new Promise(resolve => {
+                setTimeout(resolve, 3000);
+            });
+            currentSdk = await (0, sdk_1.createSDK)(globalOpts);
+            if (globalOpts.connectId)
+                connectId = undefined;
         }
-        if (installStartedAt !== undefined && installEndedAt === undefined) {
-            installEndedAt = Date.now();
+    }
+    let progressEvents = 0;
+    let lastProgress = -1;
+    let transferStartedAt;
+    let transferEndedAt;
+    let installProgressEvents = 0;
+    let lastInstallProgress = -1;
+    let installStartedAt;
+    let installEndedAt;
+    let lastPrintedTransferProgress = -10;
+    let lastPrintedInstallProgress = -10;
+    const totalStartedAt = Date.now();
+    const onUiEvent = (message) => {
+        if (!message || typeof message !== 'object')
+            return;
+        const messageType = message.type;
+        const payload = getFirmwareUpdatePayload(message);
+        if (messageType === hd_core_1.UI_REQUEST.FIRMWARE_TIP) {
+            const tipMessage = payload?.data?.message;
+            if (typeof tipMessage === 'string') {
+                process.stderr.write(`[onekey-hw] Firmware: ${tipMessage}\n`);
+            }
+            return;
         }
-        const metrics = buildFirmwareUpdateV4Metrics({
-            attempt,
-            maxAttempts,
-            totalBytes,
-            totalStartedAt,
-            transferStartedAt,
-            transferEndedAt,
-            installStartedAt,
-            installEndedAt,
-            progressEvents,
-            lastProgress,
-            installProgressEvents,
-            lastInstallProgress,
-            retried,
-        });
-        if (lastResult && typeof lastResult === 'object') {
-            const payload = (lastResult.payload ?? {});
-            lastResult = {
-                ...lastResult,
-                payload: {
-                    ...payload,
-                    metrics,
-                },
-            };
+        if (messageType === hd_core_1.UI_REQUEST.REQUEST_BUTTON) {
+            const code = typeof payload?.code === 'string' ? ` (${payload.code})` : '';
+            process.stderr.write(`[onekey-hw] Please confirm the firmware update on your device${code}.\n`);
+            return;
         }
-        if (isSuccessResult(lastResult)) {
-            return lastResult;
+        if (messageType !== hd_core_1.UI_REQUEST.FIRMWARE_PROGRESS || !payload)
+            return;
+        const progress = Number(payload.progress);
+        if (!Number.isFinite(progress))
+            return;
+        if (payload.progressType === 'transferData') {
+            progressEvents += 1;
+            lastProgress = Math.max(lastProgress, progress);
+            transferStartedAt ?? (transferStartedAt = Date.now());
+            lastPrintedTransferProgress = maybePrintFirmwareProgress({
+                progressType: 'transfer',
+                progress,
+                payload,
+                lastPrintedProgress: lastPrintedTransferProgress,
+            });
+            if (progress >= 100) {
+                transferEndedAt ?? (transferEndedAt = Date.now());
+            }
+            return;
         }
-        if (attempt >= maxAttempts ||
-            globalOpts.transport !== 'usb' ||
-            !isProtocolV2UsbProbeTransientResult(lastResult)) {
-            return lastResult;
+        if (payload.progressType === 'installingFirmware') {
+            installProgressEvents += 1;
+            lastInstallProgress = Math.max(lastInstallProgress, progress);
+            installStartedAt ?? (installStartedAt = Date.now());
+            lastPrintedInstallProgress = maybePrintFirmwareProgress({
+                progressType: 'install',
+                progress,
+                payload,
+                lastPrintedProgress: lastPrintedInstallProgress,
+            });
+            if (progress >= 100) {
+                installEndedAt ?? (installEndedAt = Date.now());
+            }
         }
-        retried = true;
-        process.stderr.write(`[onekey-hw] Protocol V2 USB probe was transient; retrying firmwareUpdateV4 (${attempt}/${maxAttempts})...\n`);
-        await (0, sdk_1.disposeSDK)();
-        await new Promise(resolve => {
-            setTimeout(resolve, 3000);
-        });
-        currentSdk = await (0, sdk_1.createSDK)(globalOpts);
+    };
+    currentSdk.on(hd_core_1.UI_EVENT, onUiEvent);
+    let result;
+    try {
+        result = await currentSdk.firmwareUpdateV4(connectId, params);
+    }
+    finally {
+        currentSdk.off?.(hd_core_1.UI_EVENT, onUiEvent);
+    }
+    if (installStartedAt !== undefined && installEndedAt === undefined) {
+        installEndedAt = Date.now();
+    }
+    const metrics = buildFirmwareUpdateV4Metrics({
+        attempt,
+        maxAttempts,
+        totalBytes,
+        totalStartedAt,
+        transferStartedAt,
+        transferEndedAt,
+        installStartedAt,
+        installEndedAt,
+        progressEvents,
+        lastProgress,
+        installProgressEvents,
+        lastInstallProgress,
+        retried,
+    });
+    if (result && typeof result === 'object') {
+        const payload = (result.payload ?? {});
+        return {
+            ...result,
+            payload: {
+                ...payload,
+                metrics,
+            },
+        };
     }
-    return lastResult;
+    return result;
 }
+exports.runFirmwareUpdateV4WithRetry = runFirmwareUpdateV4WithRetry;
 function buildFirmwareUpdateV4Params(opts) {
     const params = {
         platform: 'desktop',

package/dist/transports/nobleBlePlugin.js

@@ -3,13 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNobleBlePlugin = void 0;
 const hd_shared_1 = require("@onekeyfe/hd-shared");
 const ONEKEY_SERVICE_UUIDS = [hd_shared_1.ONEKEY_SERVICE_UUID];
-const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
-const NORMALIZED_WRITE_UUID = '0002';
-const NORMALIZED_NOTIFY_UUID = '0003';
-const NORMALIZED_ONEKEY_SERVICE_UUIDS = new Set([
-    ...ONEKEY_SERVICE_UUIDS.map(uuid => getBleUuidKey(uuid)),
-    '0001',
-]);
+const ONEKEY_SERVICE_UUID_ALIASES = (0, hd_shared_1.createKnownBleUuidAliases)(hd_shared_1.ONEKEY_SERVICE_UUID);
+const ONEKEY_WRITE_UUID_ALIASES = (0, hd_shared_1.createKnownBleUuidAliases)(hd_shared_1.ONEKEY_WRITE_CHARACTERISTIC_UUID);
+const ONEKEY_NOTIFY_UUID_ALIASES = (0, hd_shared_1.createKnownBleUuidAliases)(hd_shared_1.ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
 const BLUETOOTH_INIT_TIMEOUT = 10000;
 const DEVICE_SCAN_TIMEOUT = 8000;
 const CONNECTION_TIMEOUT = 8000;
@@ -24,24 +20,14 @@ const connectedDevices = new Map();
 const deviceCharacteristics = new Map();
 const notificationStates = new Map();
 const notificationGenerations = new Map();
-function getBleUuidKey(uuid) {
-    const normalized = (uuid ?? '').replace(/-/g, '').toLowerCase();
-    return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
-}
-function isGenericBleService(uuid) {
-    return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
-}
-function hasOneKeyAdvertisementService(peripheral) {
-    const serviceUuids = peripheral.advertisement?.serviceUuids ?? [];
-    return serviceUuids.some(uuid => {
-        const uuidKey = getBleUuidKey(uuid);
-        return (NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
-            PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey));
-    });
-}
 function isOneKeyPeripheral(peripheral) {
-    const deviceName = peripheral.advertisement?.localName || null;
-    return (0, hd_shared_1.isOnekeyDevice)(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+    const serviceUuids = peripheral.advertisement?.serviceUuids;
+    return ((0, hd_shared_1.hasOnekeyCommunicationService)(serviceUuids) &&
+        (0, hd_shared_1.isOnekeyBluetoothDevice)({
+            id: peripheral.id,
+            localName: peripheral.advertisement?.localName,
+            serviceUuids,
+        }));
 }
 function enqueueNotification(deviceId, generation, data) {
     const state = notificationStates.get(deviceId);
@@ -171,7 +157,7 @@ async function scanDevices(targetDeviceId) {
         const onDiscover = (peripheral) => {
             if (targetDeviceId && peripheral.id !== targetDeviceId)
                 return;
-            if (!targetDeviceId && !isOneKeyPeripheral(peripheral))
+            if (!isOneKeyPeripheral(peripheral))
                 return;
             discoveredDevices.set(peripheral.id, peripheral);
             found.set(peripheral.id, peripheral);
@@ -220,13 +206,7 @@ async function discoverCharacteristics(peripheral) {
             resolve(discoveredServices);
         });
     });
-    let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
-    if (!service) {
-        service =
-            services.find(s => PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(getBleUuidKey(s.uuid))) ||
-                services.find(s => !isGenericBleService(s.uuid)) ||
-                services[0];
-    }
+    const service = services.find(s => (0, hd_shared_1.matchesKnownBleUuid)(s.uuid, ONEKEY_SERVICE_UUID_ALIASES));
     if (!service) {
         throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleServiceNotFound, 'No BLE service found');
     }
@@ -243,11 +223,10 @@ async function discoverCharacteristics(peripheral) {
     let writeCharacteristic;
     let notifyCharacteristic;
     for (const characteristic of characteristics) {
-        const uuidKey = getBleUuidKey(characteristic.uuid);
-        if (uuidKey === NORMALIZED_WRITE_UUID) {
+        if ((0, hd_shared_1.matchesKnownBleUuid)(characteristic.uuid, ONEKEY_WRITE_UUID_ALIASES)) {
             writeCharacteristic = characteristic;
         }
-        else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+        else if ((0, hd_shared_1.matchesKnownBleUuid)(characteristic.uuid, ONEKEY_NOTIFY_UUID_ALIASES)) {
             notifyCharacteristic = characteristic;
         }
     }
@@ -335,17 +314,25 @@ function createNobleBlePlugin() {
                 throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.DeviceNotFound, `BLE device not found: ${uuid}`);
             }
             await connectPeripheral(peripheral);
-            const characteristics = await discoverCharacteristics(peripheral);
-            const notificationState = createNotificationState(uuid);
+            let characteristics;
             try {
+                characteristics = await discoverCharacteristics(peripheral);
+                const notificationState = createNotificationState(uuid);
                 await subscribeNotifications(uuid, notificationState.generation, characteristics.notify);
+                connectedDevices.set(uuid, peripheral);
+                deviceCharacteristics.set(uuid, characteristics);
             }
             catch (error) {
                 clearNotificationState(uuid, `BLE notification subscription failed: ${uuid}`);
+                if (characteristics) {
+                    characteristics.notify.removeAllListeners('data');
+                    await waitForNobleCleanup(callback => characteristics?.notify.unsubscribe(callback));
+                }
+                if (peripheral.state !== 'disconnected') {
+                    await waitForNobleCleanup(callback => peripheral?.disconnect(callback));
+                }
                 throw error;
             }
-            connectedDevices.set(uuid, peripheral);
-            deviceCharacteristics.set(uuid, characteristics);
         },
         async disconnect(uuid) {
             await disconnectDevice(uuid);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hardware-cli",
-  "version": "1.2.0-alpha.33",
+  "version": "1.2.0-alpha.34",
   "description": "OneKey hardware wallet CLI for testing device communication",
   "author": "OneKey",
   "license": "Apache-2.0",
@@ -31,12 +31,12 @@
     "test": "jest"
   },
   "dependencies": {
-    "@onekeyfe/hd-common-connect-sdk": "1.2.0-alpha.33",
-    "@onekeyfe/hd-core": "1.2.0-alpha.33",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.33",
-    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.33",
+    "@onekeyfe/hd-common-connect-sdk": "1.2.0-alpha.34",
+    "@onekeyfe/hd-core": "1.2.0-alpha.34",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.34",
+    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.34",
     "@stoprocent/noble": "2.3.16",
     "commander": "^12.0.0"
   },
-  "gitHead": "965e837c93fc67225ccfac28d22c3403ff96ad25"
+  "gitHead": "07f10b4c9fab177da7c36d976ec18b075492b57f"
 }

package/src/__tests__/firmware-update-v4-command.test.ts

@@ -1,6 +1,34 @@
-import { program } from '../cli';
+import { createSDK, disposeSDK } from '../sdk';
+import { program, runFirmwareUpdateV4WithRetry } from '../cli';
+
+jest.mock('../sdk', () => ({
+  createSDK: jest.fn(),
+  disposeSDK: jest.fn(),
+}));
+
+const transientProbeFailure = {
+  success: false,
+  payload: {
+    error: 'Device protocol mismatch: expected V2; device did not respond to expected protocol',
+  },
+};
+
+const createSdkMock = () => ({
+  getDeviceState: jest.fn(),
+  firmwareUpdateV4: jest.fn(),
+  on: jest.fn(),
+  off: jest.fn(),
+});
 
 describe('firmware-update-v4 CLI command', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   test('exposes firmware-update-v4 as the formal command', () => {
     const command = program.commands.find(item => item.name() === 'firmware-update-v4');
 
@@ -16,4 +44,57 @@ describe('firmware-update-v4 CLI command', () => {
       false
     );
   });
+
+  test('retries only the read-only USB probe before starting the firmware update', async () => {
+    const firstSdk = createSdkMock();
+    const retrySdk = createSdkMock();
+    firstSdk.getDeviceState.mockResolvedValue(transientProbeFailure);
+    retrySdk.getDeviceState.mockResolvedValue({ success: true, payload: { protocol: 'V2' } });
+    retrySdk.firmwareUpdateV4.mockResolvedValue({ success: true, payload: {} });
+    jest.mocked(createSDK).mockResolvedValue(retrySdk as never);
+    jest.mocked(disposeSDK).mockResolvedValue(undefined);
+    jest.spyOn(global, 'setTimeout').mockImplementation(callback => {
+      callback();
+      return 0 as never;
+    });
+
+    const result = await runFirmwareUpdateV4WithRetry({
+      sdk: firstSdk as never,
+      globalOpts: { transport: 'usb', connectId: 'stale-connect-id' },
+      params: { applicationP1Binary: new ArrayBuffer(1) } as never,
+      retries: 1,
+    });
+
+    expect(firstSdk.firmwareUpdateV4).not.toHaveBeenCalled();
+    expect(disposeSDK).toHaveBeenCalledTimes(1);
+    expect(retrySdk.getDeviceState).toHaveBeenCalledWith(undefined, {
+      scope: 'runtime',
+      connectProtocol: 'V2',
+      retryCount: 0,
+    });
+    expect(retrySdk.firmwareUpdateV4).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({ success: true, payload: { metrics: { attempt: 2 } } });
+  });
+
+  test('does not replay firmwareUpdateV4 after the read-only probe succeeds', async () => {
+    const sdk = createSdkMock();
+    sdk.getDeviceState.mockResolvedValue({ success: true, payload: { protocol: 'V2' } });
+    sdk.firmwareUpdateV4.mockResolvedValue(transientProbeFailure);
+
+    const result = await runFirmwareUpdateV4WithRetry({
+      sdk: sdk as never,
+      globalOpts: { transport: 'usb', connectId: 'pro2-connect-id' },
+      params: { applicationP1Binary: new ArrayBuffer(1) } as never,
+      retries: 2,
+    });
+
+    expect(sdk.getDeviceState).toHaveBeenCalledTimes(1);
+    expect(sdk.firmwareUpdateV4).toHaveBeenCalledTimes(1);
+    expect(disposeSDK).not.toHaveBeenCalled();
+    expect(createSDK).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      success: false,
+      payload: { error: transientProbeFailure.payload.error, metrics: { attempt: 1 } },
+    });
+  });
 });

package/src/__tests__/noble-ble-plugin.test.ts

@@ -33,12 +33,13 @@ const createPeripheral = (id: string) => {
       state: 'connected',
       advertisement: {
         localName: `OneKey Pro 2 ${id}`,
-        serviceUuids: ['fffd'],
+        serviceUuids: ['0001'],
       },
       discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
       connect: jest.fn(callback => callback()),
       disconnect: jest.fn(callback => callback()),
     },
+    service,
     write,
     notify,
   };
@@ -46,10 +47,74 @@ const createPeripheral = (id: string) => {
 
 describe('Noble BLE plugin notification routing', () => {
   afterEach(() => {
+    jest.useRealTimers();
     jest.resetModules();
     jest.clearAllMocks();
   });
 
+  test('does not enumerate Find My advertisements that expose FFFD', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const oneKey = createPeripheral('onekey-device');
+    const findMy = createPeripheral('find-my-device');
+    findMy.peripheral.advertisement.localName = 'Find My';
+    findMy.peripheral.advertisement.serviceUuids = ['fffd'];
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', findMy.peripheral);
+      noble.emit('discover', oneKey.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    const devicesPromise = plugin.enumerate();
+    await Promise.resolve();
+    jest.runAllTimers();
+    await Promise.resolve();
+
+    await expect(devicesPromise).resolves.toEqual([
+      expect.objectContaining({ id: 'onekey-device' }),
+    ]);
+    jest.useRealTimers();
+  });
+
+  test('does not enumerate a name-only candidate without the communication service', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const nameOnly = createPeripheral('name-only-device');
+    nameOnly.peripheral.advertisement.serviceUuids = [];
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', nameOnly.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    const devicesPromise = plugin.enumerate();
+    await Promise.resolve();
+    jest.runAllTimers();
+    await Promise.resolve();
+
+    await expect(devicesPromise).resolves.toEqual([]);
+    jest.useRealTimers();
+  });
+
   test('routes notifications to the receiver waiting for the same device', async () => {
     const deviceA = createPeripheral('device-a');
     const deviceB = createPeripheral('device-b');
@@ -112,6 +177,82 @@ describe('Noble BLE plugin notification routing', () => {
     expect(result).toBe('completed');
   });
 
+  test('disconnects an untracked peripheral when service discovery fails', async () => {
+    const device = createPeripheral('device-a');
+    device.peripheral.discoverServices.mockImplementation((_uuids, callback) =>
+      callback(new Error('service discovery failed'))
+    );
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('service discovery failed');
+    expect(device.peripheral.disconnect).toHaveBeenCalledTimes(1);
+  });
+
+  test('rejects a vendor-specific service containing the OneKey short UUID', async () => {
+    const device = createPeripheral('device-a');
+    device.service.uuid = 'abcd0001-1234-5678-9012-abcdefabcdef';
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('No BLE service found');
+  });
+
+  test('unsubscribes and disconnects an untracked peripheral when notification setup fails', async () => {
+    const device = createPeripheral('device-a');
+    device.notify.subscribe.mockImplementation(callback =>
+      callback(new Error('notification setup failed'))
+    );
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('notification setup failed');
+    expect(device.notify.unsubscribe).toHaveBeenCalled();
+    expect(device.peripheral.disconnect).toHaveBeenCalledTimes(1);
+  });
+
   test('uses withoutResponse for normal and high-volume writes', async () => {
     const device = createPeripheral('device-a');
     const noble = new EventEmitter() as EventEmitter & {

package/src/cli.ts

@@ -1433,7 +1433,7 @@ function buildFirmwareUpdateV4Metrics({
   };
 }
 
-async function runFirmwareUpdateV4WithRetry({
+export async function runFirmwareUpdateV4WithRetry({
   sdk,
   globalOpts,
   params,
@@ -1447,147 +1447,143 @@ async function runFirmwareUpdateV4WithRetry({
   const totalBytes = getFirmwareUpdateV4TotalBytes(params);
   const maxAttempts = Math.max((retries ?? 2) + 1, 1);
   let currentSdk = sdk;
-  let lastResult: unknown;
   let retried = false;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    let progressEvents = 0;
-    let lastProgress = -1;
-    let transferStartedAt: number | undefined;
-    let transferEndedAt: number | undefined;
-    let installProgressEvents = 0;
-    let lastInstallProgress = -1;
-    let installStartedAt: number | undefined;
-    let installEndedAt: number | undefined;
-    let lastPrintedTransferProgress = -10;
-    let lastPrintedInstallProgress = -10;
-    const totalStartedAt = Date.now();
-    const connectId =
-      retried && globalOpts.transport === 'usb' && globalOpts.connectId
-        ? undefined
-        : globalOpts.connectId;
-
-    const onUiEvent = (message: unknown) => {
-      if (!message || typeof message !== 'object') return;
-      const messageType = (message as { type?: string }).type;
-      const payload = getFirmwareUpdatePayload(message);
-
-      if (messageType === UI_REQUEST.FIRMWARE_TIP) {
-        const tipMessage = (payload?.data as { message?: unknown } | undefined)?.message;
-        if (typeof tipMessage === 'string') {
-          process.stderr.write(`[onekey-hw] Firmware: ${tipMessage}\n`);
-        }
-        return;
-      }
-
-      if (messageType === UI_REQUEST.REQUEST_BUTTON) {
-        const code = typeof payload?.code === 'string' ? ` (${payload.code})` : '';
-        process.stderr.write(
-          `[onekey-hw] Please confirm the firmware update on your device${code}.\n`
-        );
-        return;
+  let attempt = 1;
+  let { connectId } = globalOpts;
+
+  if (globalOpts.transport === 'usb') {
+    for (; attempt <= maxAttempts; attempt += 1) {
+      const probeResult = await currentSdk.getDeviceState(connectId, {
+        scope: 'runtime',
+        connectProtocol: 'V2',
+        retryCount: 0,
+      });
+      if (isSuccessResult(probeResult)) break;
+      if (attempt >= maxAttempts || !isProtocolV2UsbProbeTransientResult(probeResult)) {
+        return probeResult;
       }
 
-      if (messageType !== UI_REQUEST.FIRMWARE_PROGRESS || !payload) return;
-      const progress = Number(payload.progress);
-      if (!Number.isFinite(progress)) return;
-
-      if (payload.progressType === 'transferData') {
-        progressEvents += 1;
-        lastProgress = Math.max(lastProgress, progress);
-        transferStartedAt ??= Date.now();
-        lastPrintedTransferProgress = maybePrintFirmwareProgress({
-          progressType: 'transfer',
-          progress,
-          payload,
-          lastPrintedProgress: lastPrintedTransferProgress,
-        });
-        if (progress >= 100) {
-          transferEndedAt ??= Date.now();
-        }
-        return;
-      }
+      retried = true;
+      process.stderr.write(
+        `[onekey-hw] Protocol V2 USB probe was transient; retrying read-only probe (${attempt}/${maxAttempts})...\n`
+      );
+      await disposeSDK();
+      await new Promise(resolve => {
+        setTimeout(resolve, 3000);
+      });
+      currentSdk = await createSDK(globalOpts);
+      if (globalOpts.connectId) connectId = undefined;
+    }
+  }
 
-      if (payload.progressType === 'installingFirmware') {
-        installProgressEvents += 1;
-        lastInstallProgress = Math.max(lastInstallProgress, progress);
-        installStartedAt ??= Date.now();
-        lastPrintedInstallProgress = maybePrintFirmwareProgress({
-          progressType: 'install',
-          progress,
-          payload,
-          lastPrintedProgress: lastPrintedInstallProgress,
-        });
-        if (progress >= 100) {
-          installEndedAt ??= Date.now();
-        }
+  let progressEvents = 0;
+  let lastProgress = -1;
+  let transferStartedAt: number | undefined;
+  let transferEndedAt: number | undefined;
+  let installProgressEvents = 0;
+  let lastInstallProgress = -1;
+  let installStartedAt: number | undefined;
+  let installEndedAt: number | undefined;
+  let lastPrintedTransferProgress = -10;
+  let lastPrintedInstallProgress = -10;
+  const totalStartedAt = Date.now();
+
+  const onUiEvent = (message: unknown) => {
+    if (!message || typeof message !== 'object') return;
+    const messageType = (message as { type?: string }).type;
+    const payload = getFirmwareUpdatePayload(message);
+
+    if (messageType === UI_REQUEST.FIRMWARE_TIP) {
+      const tipMessage = (payload?.data as { message?: unknown } | undefined)?.message;
+      if (typeof tipMessage === 'string') {
+        process.stderr.write(`[onekey-hw] Firmware: ${tipMessage}\n`);
       }
-    };
-
-    currentSdk.on(UI_EVENT, onUiEvent);
-    try {
-      lastResult = await currentSdk.firmwareUpdateV4(connectId, params);
-    } finally {
-      currentSdk.off?.(UI_EVENT, onUiEvent);
-    }
-    if (installStartedAt !== undefined && installEndedAt === undefined) {
-      installEndedAt = Date.now();
+      return;
     }
 
-    const metrics = buildFirmwareUpdateV4Metrics({
-      attempt,
-      maxAttempts,
-      totalBytes,
-      totalStartedAt,
-      transferStartedAt,
-      transferEndedAt,
-      installStartedAt,
-      installEndedAt,
-      progressEvents,
-      lastProgress,
-      installProgressEvents,
-      lastInstallProgress,
-      retried,
-    });
-
-    if (lastResult && typeof lastResult === 'object') {
-      const payload = ((lastResult as { payload?: unknown }).payload ?? {}) as Record<
-        string,
-        unknown
-      >;
-      lastResult = {
-        ...(lastResult as Record<string, unknown>),
-        payload: {
-          ...payload,
-          metrics,
-        },
-      };
+    if (messageType === UI_REQUEST.REQUEST_BUTTON) {
+      const code = typeof payload?.code === 'string' ? ` (${payload.code})` : '';
+      process.stderr.write(
+        `[onekey-hw] Please confirm the firmware update on your device${code}.\n`
+      );
+      return;
     }
 
-    if (isSuccessResult(lastResult)) {
-      return lastResult;
+    if (messageType !== UI_REQUEST.FIRMWARE_PROGRESS || !payload) return;
+    const progress = Number(payload.progress);
+    if (!Number.isFinite(progress)) return;
+
+    if (payload.progressType === 'transferData') {
+      progressEvents += 1;
+      lastProgress = Math.max(lastProgress, progress);
+      transferStartedAt ??= Date.now();
+      lastPrintedTransferProgress = maybePrintFirmwareProgress({
+        progressType: 'transfer',
+        progress,
+        payload,
+        lastPrintedProgress: lastPrintedTransferProgress,
+      });
+      if (progress >= 100) {
+        transferEndedAt ??= Date.now();
+      }
+      return;
     }
 
-    if (
-      attempt >= maxAttempts ||
-      globalOpts.transport !== 'usb' ||
-      !isProtocolV2UsbProbeTransientResult(lastResult)
-    ) {
-      return lastResult;
+    if (payload.progressType === 'installingFirmware') {
+      installProgressEvents += 1;
+      lastInstallProgress = Math.max(lastInstallProgress, progress);
+      installStartedAt ??= Date.now();
+      lastPrintedInstallProgress = maybePrintFirmwareProgress({
+        progressType: 'install',
+        progress,
+        payload,
+        lastPrintedProgress: lastPrintedInstallProgress,
+      });
+      if (progress >= 100) {
+        installEndedAt ??= Date.now();
+      }
     }
+  };
 
-    retried = true;
-    process.stderr.write(
-      `[onekey-hw] Protocol V2 USB probe was transient; retrying firmwareUpdateV4 (${attempt}/${maxAttempts})...\n`
-    );
-    await disposeSDK();
-    await new Promise(resolve => {
-      setTimeout(resolve, 3000);
-    });
-    currentSdk = await createSDK(globalOpts);
+  currentSdk.on(UI_EVENT, onUiEvent);
+  let result: unknown;
+  try {
+    result = await currentSdk.firmwareUpdateV4(connectId, params);
+  } finally {
+    currentSdk.off?.(UI_EVENT, onUiEvent);
+  }
+  if (installStartedAt !== undefined && installEndedAt === undefined) {
+    installEndedAt = Date.now();
+  }
+
+  const metrics = buildFirmwareUpdateV4Metrics({
+    attempt,
+    maxAttempts,
+    totalBytes,
+    totalStartedAt,
+    transferStartedAt,
+    transferEndedAt,
+    installStartedAt,
+    installEndedAt,
+    progressEvents,
+    lastProgress,
+    installProgressEvents,
+    lastInstallProgress,
+    retried,
+  });
+
+  if (result && typeof result === 'object') {
+    const payload = ((result as { payload?: unknown }).payload ?? {}) as Record<string, unknown>;
+    return {
+      ...(result as Record<string, unknown>),
+      payload: {
+        ...payload,
+        metrics,
+      },
+    };
   }
 
-  return lastResult;
+  return result;
 }
 
 function buildFirmwareUpdateV4Params(opts: {

package/src/transports/nobleBlePlugin.ts

@@ -1,8 +1,13 @@
 import {
   ERRORS,
   HardwareErrorCode,
+  ONEKEY_NOTIFY_CHARACTERISTIC_UUID,
   ONEKEY_SERVICE_UUID,
-  isOnekeyDevice,
+  ONEKEY_WRITE_CHARACTERISTIC_UUID,
+  createKnownBleUuidAliases,
+  hasOnekeyCommunicationService,
+  isOnekeyBluetoothDevice,
+  matchesKnownBleUuid,
 } from '@onekeyfe/hd-shared';
 
 import type { LowLevelDevice, LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
@@ -39,13 +44,9 @@ type NobleNotificationState = {
 };
 
 const ONEKEY_SERVICE_UUIDS = [ONEKEY_SERVICE_UUID];
-const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
-const NORMALIZED_WRITE_UUID = '0002';
-const NORMALIZED_NOTIFY_UUID = '0003';
-const NORMALIZED_ONEKEY_SERVICE_UUIDS = new Set([
-  ...ONEKEY_SERVICE_UUIDS.map(uuid => getBleUuidKey(uuid)),
-  '0001',
-]);
+const ONEKEY_SERVICE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_SERVICE_UUID);
+const ONEKEY_WRITE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_WRITE_CHARACTERISTIC_UUID);
+const ONEKEY_NOTIFY_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
 
 const BLUETOOTH_INIT_TIMEOUT = 10_000;
 const DEVICE_SCAN_TIMEOUT = 8_000;
@@ -63,29 +64,16 @@ const deviceCharacteristics = new Map<string, CharacteristicPair>();
 const notificationStates = new Map<string, NobleNotificationState>();
 const notificationGenerations = new Map<string, number>();
 
-function getBleUuidKey(uuid?: string | null) {
-  const normalized = (uuid ?? '').replace(/-/g, '').toLowerCase();
-  return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
-}
-
-function isGenericBleService(uuid?: string | null) {
-  return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
-}
-
-function hasOneKeyAdvertisementService(peripheral: Peripheral) {
-  const serviceUuids = peripheral.advertisement?.serviceUuids ?? [];
-  return serviceUuids.some(uuid => {
-    const uuidKey = getBleUuidKey(uuid);
-    return (
-      NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
-      PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey)
-    );
-  });
-}
-
 function isOneKeyPeripheral(peripheral: Peripheral) {
-  const deviceName = peripheral.advertisement?.localName || null;
-  return isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+  const serviceUuids = peripheral.advertisement?.serviceUuids;
+  return (
+    hasOnekeyCommunicationService(serviceUuids) &&
+    isOnekeyBluetoothDevice({
+      id: peripheral.id,
+      localName: peripheral.advertisement?.localName,
+      serviceUuids,
+    })
+  );
 }
 
 function enqueueNotification(deviceId: string, generation: number, data: Buffer) {
@@ -230,7 +218,7 @@ async function scanDevices(targetDeviceId?: string) {
 
     const onDiscover = (peripheral: Peripheral) => {
       if (targetDeviceId && peripheral.id !== targetDeviceId) return;
-      if (!targetDeviceId && !isOneKeyPeripheral(peripheral)) return;
+      if (!isOneKeyPeripheral(peripheral)) return;
 
       discoveredDevices.set(peripheral.id, peripheral);
       found.set(peripheral.id, peripheral);
@@ -285,13 +273,7 @@ async function discoverCharacteristics(peripheral: Peripheral): Promise<Characte
     });
   });
 
-  let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
-  if (!service) {
-    service =
-      services.find(s => PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(getBleUuidKey(s.uuid))) ||
-      services.find(s => !isGenericBleService(s.uuid)) ||
-      services[0];
-  }
+  const service = services.find(s => matchesKnownBleUuid(s.uuid, ONEKEY_SERVICE_UUID_ALIASES));
   if (!service) {
     throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No BLE service found');
   }
@@ -310,10 +292,9 @@ async function discoverCharacteristics(peripheral: Peripheral): Promise<Characte
   let writeCharacteristic: Characteristic | undefined;
   let notifyCharacteristic: Characteristic | undefined;
   for (const characteristic of characteristics) {
-    const uuidKey = getBleUuidKey(characteristic.uuid);
-    if (uuidKey === NORMALIZED_WRITE_UUID) {
+    if (matchesKnownBleUuid(characteristic.uuid, ONEKEY_WRITE_UUID_ALIASES)) {
       writeCharacteristic = characteristic;
-    } else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+    } else if (matchesKnownBleUuid(characteristic.uuid, ONEKEY_NOTIFY_UUID_ALIASES)) {
       notifyCharacteristic = characteristic;
     }
   }
@@ -437,16 +418,24 @@ export function createNobleBlePlugin(): LowlevelTransportSharedPlugin {
       }
 
       await connectPeripheral(peripheral);
-      const characteristics = await discoverCharacteristics(peripheral);
-      const notificationState = createNotificationState(uuid);
+      let characteristics: CharacteristicPair | undefined;
       try {
+        characteristics = await discoverCharacteristics(peripheral);
+        const notificationState = createNotificationState(uuid);
         await subscribeNotifications(uuid, notificationState.generation, characteristics.notify);
+        connectedDevices.set(uuid, peripheral);
+        deviceCharacteristics.set(uuid, characteristics);
       } catch (error) {
         clearNotificationState(uuid, `BLE notification subscription failed: ${uuid}`);
+        if (characteristics) {
+          characteristics.notify.removeAllListeners('data');
+          await waitForNobleCleanup(callback => characteristics?.notify.unsubscribe(callback));
+        }
+        if (peripheral.state !== 'disconnected') {
+          await waitForNobleCleanup(callback => peripheral?.disconnect(callback));
+        }
         throw error;
       }
-      connectedDevices.set(uuid, peripheral);
-      deviceCharacteristics.set(uuid, characteristics);
     },
 
     async disconnect(uuid: string) {