@onekeyfe/hd-transport-web-device 1.2.2-alpha.12 → 1.2.2-alpha.120

package/README.md

@@ -26,4 +26,4 @@ yar update:protobuf to generate new ./messages.json and ./src/types/messages.ts
 
 ## Docs
 
-Documentation is available [hardware-js-sdk](https://developer.onekey.so/connect-to-hardware/hardware-sdk/start)
+Documentation is available [Hardware SDK Getting Started](https://developer.onekey.so/en/hardware-sdk/getting-started)

package/__tests__/electron-ble-transport.test.ts

@@ -182,6 +182,40 @@ describe('ElectronBleTransport protocol detection', () => {
     jest.clearAllMocks();
   });
 
+  test('does not treat an error envelope from a legacy preload as a successful connect', async () => {
+    const device = { id: 'stale-bond-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    nobleBle.connect.mockResolvedValue({
+      type: 'NobleBleIpcError',
+      success: false,
+      error: {
+        name: 'HardwareError',
+        message: 'Bluetooth pairing information is no longer valid',
+        errorCode: HardwareErrorCode.BleBondInvalid,
+      },
+    } as never);
+    const bleTransport = configureTransport(nobleBle);
+
+    await expect(
+      bleTransport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleBondInvalid,
+    });
+    expect(nobleBle.subscribe).not.toHaveBeenCalled();
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+  });
+
+  test('sends a native disconnect even before acquire marks the device connected', async () => {
+    const device = { id: 'pending-connect-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    const bleTransport = configureTransport(nobleBle) as any;
+
+    await bleTransport.releaseNative(device.id);
+
+    expect(nobleBle.unsubscribe).not.toHaveBeenCalled();
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+  });
+
   test('keeps raw BLE lifecycle payloads off the public device event channel', async () => {
     const device = { id: 'lifecycle-pro2-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);
@@ -464,7 +498,7 @@ describe('ElectronBleTransport protocol detection', () => {
     await expect(result).resolves.toBe('rejected');
   });
 
-  test('throws when both protocol probes fail', async () => {
+  test('disconnects when both protocol probes fail and reconnects for the next acquire', async () => {
     const device = { id: 'dead-device-id', name: 'Unknown Device' };
     const nobleBle = createNobleBle(device);
 
@@ -476,7 +510,25 @@ describe('ElectronBleTransport protocol detection', () => {
     await expect(transport.acquire({ uuid: device.id })).rejects.toThrow(
       /Unable to detect BLE protocol/
     );
+    expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
     expect(transport.getProtocolType(device.id)).toBeUndefined();
+
+    echoProtocolV2(nobleBle, device.id);
+    await expect(
+      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).resolves.toMatchObject({ uuid: device.id });
+    expect(nobleBle.connect).toHaveBeenCalledTimes(2);
+    expect(nobleBle.disconnect.mock.invocationCallOrder.at(-1)).toBeLessThan(
+      nobleBle.connect.mock.invocationCallOrder[1]
+    );
+    await expect(
+      transport.call(device.id, 'Ping', { message: 'after-reconnect' })
+    ).resolves.toMatchObject({
+      type: 'Success',
+      message: { message: 'ok' },
+    });
+    await transport.release(device.id);
   });
 
   test('surfaces Protocol V2 link disabled while the initial V1 probe is active', async () => {
@@ -553,14 +605,19 @@ describe('ElectronBleTransport protocol detection', () => {
   test('fails Protocol V2 acquire immediately when subscribe reports insufficient encryption', async () => {
     const device = { id: 'stale-bond-pro2-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);
-    nobleBle.subscribe.mockRejectedValue(new Error('Encryption is insufficient'));
+    nobleBle.subscribe.mockRejectedValue({
+      name: 'HardwareError',
+      message: 'Bluetooth pairing information is no longer valid',
+      errorCode: HardwareErrorCode.BleBondInvalid,
+      params: { nativeErrorMessage: 'Encryption is insufficient' },
+    });
     const transport = configureTransport(nobleBle);
     const probe = jest.spyOn(transport as any, 'probeProtocolV2');
 
     await expect(
       transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
     ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleDeviceBondError,
+      errorCode: HardwareErrorCode.BleBondInvalid,
     });
 
     expect(probe).not.toHaveBeenCalled();
@@ -568,21 +625,40 @@ describe('ElectronBleTransport protocol detection', () => {
     expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
   });
 
-  test('maps macOS CoreBluetooth peer-removed pairing failures to the precise error', async () => {
-    const device = { id: 'reset-pro2-macos-id', name: 'OneKey Pro 2' };
+  test('rehydrates a structured stale-bond error before the protocol is known', async () => {
+    const device = { id: 'reset-unknown-protocol-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);
-    nobleBle.connect.mockRejectedValue(
-      new Error('CBErrorDomain:14 Peer removed pairing information on the device side')
-    );
+    nobleBle.connect.mockRejectedValue({
+      name: 'HardwareError',
+      message: 'Bluetooth pairing information is no longer valid',
+      errorCode: HardwareErrorCode.BleBondInvalid,
+      params: { nativeErrorMessage: 'CBErrorDomain:14 native message' },
+    });
     const transport = configureTransport(nobleBle);
 
-    await expect(
-      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
-    ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    await expect(transport.acquire({ uuid: device.id })).rejects.toMatchObject({
+      name: 'HardwareError',
+      errorCode: HardwareErrorCode.BleBondInvalid,
+      params: { nativeErrorMessage: 'CBErrorDomain:14 native message' },
     });
   });
 
+  test('does not infer hardware errors from native error text in the renderer', async () => {
+    const device = { id: 'reset-pro2-localized-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    nobleBle.connect.mockRejectedValue(new Error('CBATTErrorDomain:14 localized native message'));
+    const transport = configureTransport(nobleBle);
+
+    try {
+      await transport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+      throw new Error('Expected acquire to fail');
+    } catch (error) {
+      expect(error).toBeInstanceOf(Error);
+      expect((error as Error).message).toBe('CBATTErrorDomain:14 localized native message');
+      expect((error as { errorCode?: unknown }).errorCode).toBeUndefined();
+    }
+  });
+
   test('does not classify a generic macOS connection failure as a stale bond', async () => {
     const device = { id: 'offline-pro2-macos-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);
@@ -615,7 +691,7 @@ describe('ElectronBleTransport protocol detection', () => {
     }
   });
 
-  test('reports a stale bond when a previously confirmed Protocol V2 device stops responding', async () => {
+  test('keeps a probe miss retryable after a previously confirmed Protocol V2 connection', async () => {
     const device = { id: 'reset-pro2-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);
     const transport = configureTransport(nobleBle);
@@ -628,7 +704,7 @@ describe('ElectronBleTransport protocol detection', () => {
     await expect(
       transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
     ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleDeviceBondError,
+      errorCode: HardwareErrorCode.RuntimeError,
     });
 
     expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
@@ -636,6 +712,52 @@ describe('ElectronBleTransport protocol detection', () => {
     expect(transport.getProtocolType(device.id)).toBeUndefined();
   });
 
+  test.each([false, true])(
+    'preserves an expected Protocol V2 Ping timeout with a prior successful connection: %s',
+    async previouslyConnected => {
+      const device = { id: 'timeout-pro2-id', name: 'OneKey Pro 2' };
+      const nobleBle = createNobleBle(device);
+      const transport = configureTransport(nobleBle);
+
+      if (previouslyConnected) {
+        echoProtocolV2(nobleBle, device.id);
+        await transport.acquire({ uuid: device.id, expectedProtocol: 'V2' });
+        await transport.release(device.id);
+      }
+      // Keep the real probe and response timer, but drop its notification.
+      nobleBle.write.mockImplementation(() => Promise.resolve());
+
+      await expect(
+        transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleTimeoutError,
+        message: 'BLE response timeout after 5000ms for Ping',
+      });
+
+      expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
+      expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+      expect(transport.getProtocolType(device.id)).toBeUndefined();
+    }
+  );
+
+  test('preserves a native stale-bond error during an expected Protocol V2 probe', async () => {
+    const device = { id: 'stale-bond-probe-id', name: 'OneKey Pro 2' };
+    const nobleBle = createNobleBle(device);
+    nobleBle.write.mockRejectedValue({
+      name: 'HardwareError',
+      message: 'Bluetooth pairing information is no longer valid',
+      errorCode: HardwareErrorCode.BleBondInvalid,
+    });
+    const transport = configureTransport(nobleBle);
+
+    await expect(
+      transport.acquire({ uuid: device.id, expectedProtocol: 'V2' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.BleBondInvalid });
+
+    expect(nobleBle.unsubscribe).toHaveBeenCalledWith(device.id);
+    expect(nobleBle.disconnect).toHaveBeenCalledWith(device.id);
+  });
+
   test('does not take a Protocol V2 hint from the BLE name', async () => {
     const device = { id: 'named-pro2-id', name: 'OneKey Pro 2' };
     const nobleBle = createNobleBle(device);

package/dist/electron-ble-transport.d.ts

@@ -27,7 +27,6 @@ export default class ElectronBleTransport {
     private connectedDevices;
     private deviceProtocol;
     private deviceProtocolHints;
-    private confirmedProtocolV2;
     private deviceMtus;
     private devicePacketCapacities;
     private v1Buffers;
@@ -41,7 +40,7 @@ export default class ElectronBleTransport {
     private hostDisconnectCleanup?;
     private notificationTokens;
     private nextNotificationToken;
-    private toStaleBondError;
+    private normalizeBluetoothError;
     private handleBluetoothError;
     private cleanupDeviceState;
     init(logger: any, emitter?: EventEmitter): void;

package/dist/electron-ble-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"electron-ble-transport.d.ts","sourceRoot":"","sources":["../src/electron-ble-transport.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -218,8 +218,6 @@ declare class ElectronBleTransport {
     private connectedDevices;
     private deviceProtocol;
     private deviceProtocolHints;
-    /** Endpoints that answered a V2 probe in this transport lifetime. Survives disconnect. */
-    private confirmedProtocolV2;
     private deviceMtus;
     private devicePacketCapacities;
     private v1Buffers;
@@ -242,7 +240,7 @@ declare class ElectronBleTransport {
     private hostDisconnectCleanup?;
     private notificationTokens;
     private nextNotificationToken;
-    private toStaleBondError;
+    private normalizeBluetoothError;
     private handleBluetoothError;
     private cleanupDeviceState;
     init(logger: any, emitter?: EventEmitter): void;

package/dist/index.js

@@ -823,6 +823,19 @@ function resolveBlePacketCapacity(mtu, maximumPacketCapacity, fallbackPacketCapa
 
 const { parseConfigure, ProtocolV1, check } = transport__default["default"];
 const toBleDescriptor = (device, protocolType) => (Object.assign({ id: device.id, name: device.name, path: device.id, debug: false, commType: 'electron-ble' }, (protocolType ? { protocolType } : {})));
+const invokeNobleBle = (request) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield request;
+    if (response &&
+        typeof response === 'object' &&
+        'type' in response &&
+        response.type === 'NobleBleIpcError' &&
+        'success' in response &&
+        response.success === false &&
+        'error' in response) {
+        return Promise.reject(response.error);
+    }
+    return response;
+});
 const BLE_PACKET_SIZE_FALLBACK = 192;
 const BLE_PACKET_SIZE_MAXIMUM = 244;
 const BLE_WRITE_DELAY_MS = 5;
@@ -837,7 +850,6 @@ class ElectronBleTransport {
         this.connectedDevices = new Set();
         this.deviceProtocol = new Map();
         this.deviceProtocolHints = new Map();
-        this.confirmedProtocolV2 = new Set();
         this.deviceMtus = new Map();
         this.devicePacketCapacities = new Map();
         this.v1Buffers = new Map();
@@ -871,40 +883,20 @@ class ElectronBleTransport {
         this.notificationTokens = new Map();
         this.nextNotificationToken = 1;
     }
-    toStaleBondError(error) {
-        var _a;
-        if (hdShared.isBleStaleBondHardwareError(error)) {
-            return error;
-        }
-        const errorMessage = error && typeof error === 'object' && 'message' in error
-            ? String((_a = error.message) !== null && _a !== void 0 ? _a : '')
-            : String(error !== null && error !== void 0 ? error : '');
-        if (!hdShared.isBleStaleBondErrorText(errorMessage)) {
-            return null;
-        }
-        const normalizedErrorMessage = errorMessage.toLowerCase();
-        return hdShared.ERRORS.TypedError(normalizedErrorMessage.includes('peer removed pairing information') ||
-            normalizedErrorMessage.includes('cberrordomain:14')
-            ? hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation
-            : hdShared.HardwareErrorCode.BleDeviceBondError, errorMessage);
-    }
-    handleBluetoothError(error, mapProtocolV2StaleBond = false) {
-        if (mapProtocolV2StaleBond) {
-            const staleBondError = this.toStaleBondError(error);
-            if (staleBondError) {
-                throw staleBondError;
-            }
-        }
+    normalizeBluetoothError(error) {
         if (error && typeof error === 'object') {
+            if (typeof error.errorCode === 'number') {
+                return hdShared.ERRORS.TypedError(error.errorCode, typeof error.message === 'string' ? error.message : undefined, error.params);
+            }
             if ('code' in error) {
                 if (error.code === hdShared.HardwareErrorCode.BlePoweredOff) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
+                    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
                 }
                 if (error.code === hdShared.HardwareErrorCode.BleUnsupported) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
+                    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
                 }
                 if (error.code === hdShared.HardwareErrorCode.BlePermissionError) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
+                    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
                 }
             }
             const errorMessage = error.message || String(error);
@@ -912,16 +904,19 @@ class ElectronBleTransport {
             const unsupportedMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BleUnsupported];
             const permissionMessage = hdShared.HardwareErrorCodeMessage[hdShared.HardwareErrorCode.BlePermissionError];
             if (errorMessage.includes(poweredOffMessage) || errorMessage.includes('poweredOff')) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
+                return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePoweredOff);
             }
             if (errorMessage.includes(unsupportedMessage) || errorMessage.includes('unsupported')) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
+                return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleUnsupported);
             }
             if (errorMessage.includes(permissionMessage) || errorMessage.includes('unauthorized')) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
+                return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePermissionError);
             }
         }
-        throw error;
+        return error;
+    }
+    handleBluetoothError(error) {
+        throw this.normalizeBluetoothError(error);
     }
     cleanupDeviceState(deviceId) {
         this.protocolV2Links
@@ -1008,7 +1003,7 @@ class ElectronBleTransport {
                 if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
                     throw new Error('Noble BLE API not available');
                 }
-                const devices = yield window.desktopApi.nobleBle.enumerate();
+                const devices = yield invokeNobleBle(window.desktopApi.nobleBle.enumerate());
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Electron BLE] enumerate found ${devices.length} device(s):`);
                 for (const dev of devices) {
                     (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Electron BLE]   id="${dev.id}" name="${dev.name}"`);
@@ -1025,9 +1020,6 @@ class ElectronBleTransport {
         var _a, _b, _c, _d, _e, _f, _g;
         return __awaiter(this, void 0, void 0, function* () {
             const { uuid, forceCleanRunPromise, expectedProtocol } = input;
-            const shouldMapProtocolV2StaleBond = expectedProtocol
-                ? expectedProtocol === 'V2'
-                : this.confirmedProtocolV2.has(uuid);
             if (!uuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
             }
@@ -1044,7 +1036,7 @@ class ElectronBleTransport {
                 if (!((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle)) {
                     throw new Error('Noble BLE API not available');
                 }
-                const device = yield window.desktopApi.nobleBle.getDevice(uuid);
+                const device = yield invokeNobleBle(window.desktopApi.nobleBle.getDevice(uuid));
                 if (!device) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${uuid} not found`);
                 }
@@ -1055,11 +1047,11 @@ class ElectronBleTransport {
                     this.deviceProtocolHints.set(uuid, protocolHint);
                 }
                 try {
-                    yield window.desktopApi.nobleBle.connect(uuid);
+                    yield invokeNobleBle(window.desktopApi.nobleBle.connect(uuid));
                     this.connectedDevices.add(uuid);
                 }
                 catch (error) {
-                    this.handleBluetoothError(error, shouldMapProtocolV2StaleBond);
+                    this.handleBluetoothError(error);
                 }
                 const mtuCleanup = this.createMtuSubscription(uuid);
                 if (mtuCleanup) {
@@ -1068,10 +1060,10 @@ class ElectronBleTransport {
                 this.v1Buffers.set(uuid, { buffer: [], bufferLength: 0 });
                 this.v2Assemblers.set(uuid, new transport.ProtocolV2FrameAssembler(transport.PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
                 try {
-                    yield window.desktopApi.nobleBle.subscribe(uuid);
+                    yield invokeNobleBle(window.desktopApi.nobleBle.subscribe(uuid));
                 }
                 catch (error) {
-                    this.handleBluetoothError(error, shouldMapProtocolV2StaleBond);
+                    this.handleBluetoothError(error);
                 }
                 yield this.refreshBlePacketCapacity(uuid);
                 const cleanup = this.createNotificationSubscription(uuid);
@@ -1089,16 +1081,22 @@ class ElectronBleTransport {
             catch (error) {
                 (_e = this.Log) === null || _e === void 0 ? void 0 : _e.error('[Electron BLE] acquire failed:', error);
                 try {
-                    if (((_f = window.desktopApi) === null || _f === void 0 ? void 0 : _f.nobleBle) && this.connectedDevices.has(uuid)) {
-                        yield window.desktopApi.nobleBle.unsubscribe(uuid);
-                        yield window.desktopApi.nobleBle.disconnect(uuid);
+                    const nobleBle = (_f = window.desktopApi) === null || _f === void 0 ? void 0 : _f.nobleBle;
+                    if (nobleBle) {
+                        if (this.connectedDevices.has(uuid)) {
+                            yield invokeNobleBle(nobleBle.unsubscribe(uuid)).catch(cleanupError => {
+                                var _a;
+                                (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] acquire unsubscribe failed:', cleanupError);
+                            });
+                        }
+                        yield invokeNobleBle(nobleBle.disconnect(uuid));
                     }
                 }
                 catch (cleanupError) {
                     (_g = this.Log) === null || _g === void 0 ? void 0 : _g.debug('[Electron BLE] acquire cleanup failed:', cleanupError);
                 }
                 this.cleanupDeviceState(uuid);
-                throw error;
+                this.handleBluetoothError(error);
             }
         });
     }
@@ -1124,13 +1122,17 @@ class ElectronBleTransport {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this.connectedDevices.has(id)) {
-                    if ((_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) {
-                        yield window.desktopApi.nobleBle.unsubscribe(id);
-                        yield window.desktopApi.nobleBle.disconnect(id);
+                const nobleBle = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle;
+                if (nobleBle) {
+                    if (this.connectedDevices.has(id)) {
+                        yield invokeNobleBle(nobleBle.unsubscribe(id)).catch(error => {
+                            var _a;
+                            (_a = this.Log) === null || _a === void 0 ? void 0 : _a.debug('[Electron BLE] release unsubscribe failed:', error);
+                        });
                     }
-                    this.cleanupDeviceState(id);
+                    yield invokeNobleBle(nobleBle.disconnect(id));
                 }
+                this.cleanupDeviceState(id);
             }
             catch (error) {
                 (_b = this.Log) === null || _b === void 0 ? void 0 : _b.error('[Electron BLE] release failed:', error);
@@ -1154,7 +1156,7 @@ class ElectronBleTransport {
                     }
                     return;
                 }
-                yield release(id, keepSession);
+                yield invokeNobleBle(release(id, keepSession));
             }
             catch (error) {
                 (_d = this.Log) === null || _d === void 0 ? void 0 : _d.error('[Electron BLE] logical release failed:', error);
@@ -1162,9 +1164,8 @@ class ElectronBleTransport {
             }
         });
     }
-    createProtocolMismatchError(expected, uuid) {
-        const isStaleV2Bond = expected === 'V2' && this.confirmedProtocolV2.has(uuid);
-        return hdShared.ERRORS.TypedError(isStaleV2Bond ? hdShared.HardwareErrorCode.BleDeviceBondError : hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
     }
     createProtocolDetectionError() {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping');
@@ -1183,13 +1184,12 @@ class ElectronBleTransport {
                 return 'V1';
             }
             if (expectedProtocol === 'V2') {
-                if (yield this.probeProtocolV2(uuid)) {
+                if (yield this.probeProtocolV2(uuid, expectedProtocol)) {
                     this.deviceProtocol.set(uuid, 'V2');
-                    this.confirmedProtocolV2.add(uuid);
                     (_b = this.Log) === null || _b === void 0 ? void 0 : _b.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
                     return 'V2';
                 }
-                throw this.createProtocolMismatchError(expectedProtocol, uuid);
+                throw this.createProtocolMismatchError(expectedProtocol);
             }
             const probeOrder = protocolHint === 'V2' || this.deviceProtocol.get(uuid) === 'V2' ? ['V2', 'V1'] : ['V1', 'V2'];
             for (let i = 0; i < probeOrder.length; i += 1) {
@@ -1200,9 +1200,6 @@ class ElectronBleTransport {
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
                 if (detected) {
                     this.deviceProtocol.set(uuid, protocol);
-                    if (protocol === 'V2') {
-                        this.confirmedProtocolV2.add(uuid);
-                    }
                     (_c = this.Log) === null || _c === void 0 ? void 0 : _c.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> ${protocol}`);
                     return protocol;
                 }
@@ -1265,7 +1262,7 @@ class ElectronBleTransport {
             }
         });
     }
-    probeProtocolV2(uuid) {
+    probeProtocolV2(uuid, expectedProtocol) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages || !this._messagesV2) {
@@ -1283,7 +1280,9 @@ class ElectronBleTransport {
                     (_a = this.v2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
                     this.resetProtocolV2Frames(uuid);
                 },
-                shouldRethrow: error => hdShared.isBleStaleBondHardwareError(error) || transport.isProtocolV2LinkDisabledError(error),
+                shouldRethrow: error => expectedProtocol === 'V2' ||
+                    hdShared.isBleStaleBondHardwareError(error) ||
+                    transport.isProtocolV2LinkDisabledError(error),
             });
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');
@@ -1299,21 +1298,18 @@ class ElectronBleTransport {
                 throw new Error('Noble BLE API not available');
             }
             try {
-                yield nobleBle.write(uuid, hexData, { pacingDelayMs: 0 });
+                yield invokeNobleBle(nobleBle.write(uuid, hexData, { pacingDelayMs: 0 }));
             }
             catch (error) {
-                const staleBondError = this.toStaleBondError(error);
-                if (staleBondError) {
-                    throw staleBondError;
-                }
-                throw error;
+                this.handleBluetoothError(error);
             }
         });
     }
     refreshBlePacketCapacity(uuid) {
-        var _a, _b;
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const device = yield ((_b = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle) === null || _b === void 0 ? void 0 : _b.getDevice(uuid));
+            const nobleBle = (_a = window.desktopApi) === null || _a === void 0 ? void 0 : _a.nobleBle;
+            const device = nobleBle ? yield invokeNobleBle(nobleBle.getDevice(uuid)) : undefined;
             this.updateBlePacketCapacity(uuid, device === null || device === void 0 ? void 0 : device.mtu);
         });
     }
@@ -1536,7 +1532,7 @@ class ElectronBleTransport {
                     if (hexString.length === 0) {
                         throw new Error(`Buffer ${i + 1} is empty`);
                     }
-                    yield window.desktopApi.nobleBle.write(uuid, hexString);
+                    yield invokeNobleBle(window.desktopApi.nobleBle.write(uuid, hexString));
                 }
                 const response = yield Promise.race([
                     runPromise.promise,
@@ -1569,7 +1565,7 @@ class ElectronBleTransport {
                         yield this.releaseNative(uuid);
                     }
                 }
-                throw e;
+                throw this.normalizeBluetoothError(e);
             }
             finally {
                 if (timeout)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-web-device",
-  "version": "1.2.2-alpha.12",
+  "version": "1.2.2-alpha.120",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -21,13 +21,13 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.2-alpha.12",
-    "@onekeyfe/hd-transport": "1.2.2-alpha.12"
+    "@onekeyfe/hd-shared": "1.2.2-alpha.120",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.120"
   },
   "devDependencies": {
-    "@onekeyfe/hd-transport-electron": "1.2.2-alpha.12",
+    "@onekeyfe/hd-transport-electron": "1.2.2-alpha.120",
     "@types/w3c-web-usb": "^1.0.6",
     "@types/web-bluetooth": "^0.0.17"
   },
-  "gitHead": "9b5a45bc55819d22ed752899b4c40aad70de4527"
+  "gitHead": "26958fa2be6aa34a07f42403fb7022d2785e70b9"
 }

package/src/electron-ble-transport.ts

@@ -18,7 +18,6 @@ import {
   HardwareErrorCode,
   HardwareErrorCodeMessage,
   createDeferred,
-  isBleStaleBondErrorText,
   isBleStaleBondHardwareError,
   isHeaderChunk,
 } from '@onekeyfe/hd-shared';
@@ -26,7 +25,7 @@ import {
 import { resolveBlePacketCapacity } from './ble-packet-capacity';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type { DesktopAPI } from '@onekeyfe/hd-transport-electron';
+import type { DesktopAPI, NobleBleIpcErrorResponse } from '@onekeyfe/hd-transport-electron';
 import type {
   OneKeyDeviceInfo,
   ProtocolType,
@@ -69,6 +68,22 @@ const toBleDescriptor = (
     ...(protocolType ? { protocolType } : {}),
   } as OneKeyDeviceInfo);
 
+const invokeNobleBle = async <T>(request: Promise<T>): Promise<T> => {
+  const response = await (request as Promise<T | NobleBleIpcErrorResponse>);
+  if (
+    response &&
+    typeof response === 'object' &&
+    'type' in response &&
+    response.type === 'NobleBleIpcError' &&
+    'success' in response &&
+    response.success === false &&
+    'error' in response
+  ) {
+    return Promise.reject(response.error);
+  }
+  return response as T;
+};
+
 const BLE_PACKET_SIZE_FALLBACK = 192;
 const BLE_PACKET_SIZE_MAXIMUM = 244;
 const BLE_WRITE_DELAY_MS = 5;
@@ -106,9 +121,6 @@ export default class ElectronBleTransport {
 
   private deviceProtocolHints: Map<string, ProtocolType> = new Map();
 
-  /** Endpoints that answered a V2 probe in this transport lifetime. Survives disconnect. */
-  private confirmedProtocolV2 = new Set<string>();
-
   private deviceMtus: Map<string, number> = new Map();
 
   private devicePacketCapacities: Map<string, number> = new Map();
@@ -163,44 +175,24 @@ export default class ElectronBleTransport {
 
   private nextNotificationToken = 1;
 
-  private toStaleBondError(error: unknown): Error | null {
-    if (isBleStaleBondHardwareError(error)) {
-      return error as Error;
-    }
-    const errorMessage =
-      error && typeof error === 'object' && 'message' in error
-        ? String((error as { message?: unknown }).message ?? '')
-        : String(error ?? '');
-    if (!isBleStaleBondErrorText(errorMessage)) {
-      return null;
-    }
-    const normalizedErrorMessage = errorMessage.toLowerCase();
-    return ERRORS.TypedError(
-      normalizedErrorMessage.includes('peer removed pairing information') ||
-        normalizedErrorMessage.includes('cberrordomain:14')
-        ? HardwareErrorCode.BlePeerRemovedPairingInformation
-        : HardwareErrorCode.BleDeviceBondError,
-      errorMessage
-    );
-  }
-
-  private handleBluetoothError(error: any, mapProtocolV2StaleBond = false): never {
-    if (mapProtocolV2StaleBond) {
-      const staleBondError = this.toStaleBondError(error);
-      if (staleBondError) {
-        throw staleBondError;
-      }
-    }
+  private normalizeBluetoothError(error: any): any {
     if (error && typeof error === 'object') {
+      if (typeof error.errorCode === 'number') {
+        return ERRORS.TypedError(
+          error.errorCode,
+          typeof error.message === 'string' ? error.message : undefined,
+          error.params
+        );
+      }
       if ('code' in error) {
         if (error.code === HardwareErrorCode.BlePoweredOff) {
-          throw ERRORS.TypedError(HardwareErrorCode.BlePoweredOff);
+          return ERRORS.TypedError(HardwareErrorCode.BlePoweredOff);
         }
         if (error.code === HardwareErrorCode.BleUnsupported) {
-          throw ERRORS.TypedError(HardwareErrorCode.BleUnsupported);
+          return ERRORS.TypedError(HardwareErrorCode.BleUnsupported);
         }
         if (error.code === HardwareErrorCode.BlePermissionError) {
-          throw ERRORS.TypedError(HardwareErrorCode.BlePermissionError);
+          return ERRORS.TypedError(HardwareErrorCode.BlePermissionError);
         }
       }
       const errorMessage = error.message || String(error);
@@ -209,16 +201,20 @@ export default class ElectronBleTransport {
       const permissionMessage = HardwareErrorCodeMessage[HardwareErrorCode.BlePermissionError];
 
       if (errorMessage.includes(poweredOffMessage) || errorMessage.includes('poweredOff')) {
-        throw ERRORS.TypedError(HardwareErrorCode.BlePoweredOff);
+        return ERRORS.TypedError(HardwareErrorCode.BlePoweredOff);
       }
       if (errorMessage.includes(unsupportedMessage) || errorMessage.includes('unsupported')) {
-        throw ERRORS.TypedError(HardwareErrorCode.BleUnsupported);
+        return ERRORS.TypedError(HardwareErrorCode.BleUnsupported);
       }
       if (errorMessage.includes(permissionMessage) || errorMessage.includes('unauthorized')) {
-        throw ERRORS.TypedError(HardwareErrorCode.BlePermissionError);
+        return ERRORS.TypedError(HardwareErrorCode.BlePermissionError);
       }
     }
-    throw error;
+    return error;
+  }
+
+  private handleBluetoothError(error: any): never {
+    throw this.normalizeBluetoothError(error);
   }
 
   private cleanupDeviceState(deviceId: string): void {
@@ -337,7 +333,7 @@ export default class ElectronBleTransport {
       if (!window.desktopApi?.nobleBle) {
         throw new Error('Noble BLE API not available');
       }
-      const devices = await window.desktopApi.nobleBle.enumerate();
+      const devices = await invokeNobleBle(window.desktopApi.nobleBle.enumerate());
       this.Log?.debug(`[Electron BLE] enumerate found ${devices.length} device(s):`);
       for (const dev of devices) {
         this.Log?.debug(`[Electron BLE]   id="${dev.id}" name="${dev.name}"`);
@@ -351,9 +347,6 @@ export default class ElectronBleTransport {
 
   async acquire(input: BleAcquireInput) {
     const { uuid, forceCleanRunPromise, expectedProtocol } = input;
-    const shouldMapProtocolV2StaleBond = expectedProtocol
-      ? expectedProtocol === 'V2'
-      : this.confirmedProtocolV2.has(uuid);
 
     if (!uuid) {
       throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
@@ -375,7 +368,7 @@ export default class ElectronBleTransport {
         throw new Error('Noble BLE API not available');
       }
 
-      const device = await window.desktopApi.nobleBle.getDevice(uuid);
+      const device = await invokeNobleBle(window.desktopApi.nobleBle.getDevice(uuid));
       if (!device) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `Device ${uuid} not found`);
       }
@@ -387,10 +380,10 @@ export default class ElectronBleTransport {
       }
 
       try {
-        await window.desktopApi.nobleBle.connect(uuid);
+        await invokeNobleBle(window.desktopApi.nobleBle.connect(uuid));
         this.connectedDevices.add(uuid);
       } catch (error) {
-        this.handleBluetoothError(error, shouldMapProtocolV2StaleBond);
+        this.handleBluetoothError(error);
       }
 
       const mtuCleanup = this.createMtuSubscription(uuid);
@@ -402,9 +395,9 @@ export default class ElectronBleTransport {
       this.v2Assemblers.set(uuid, new ProtocolV2FrameAssembler(PROTOCOL_V2_BLE_FRAME_MAX_BYTES));
 
       try {
-        await window.desktopApi.nobleBle.subscribe(uuid);
+        await invokeNobleBle(window.desktopApi.nobleBle.subscribe(uuid));
       } catch (error) {
-        this.handleBluetoothError(error, shouldMapProtocolV2StaleBond);
+        this.handleBluetoothError(error);
       }
       await this.refreshBlePacketCapacity(uuid);
 
@@ -427,15 +420,20 @@ export default class ElectronBleTransport {
     } catch (error) {
       this.Log?.error('[Electron BLE] acquire failed:', error);
       try {
-        if (window.desktopApi?.nobleBle && this.connectedDevices.has(uuid)) {
-          await window.desktopApi.nobleBle.unsubscribe(uuid);
-          await window.desktopApi.nobleBle.disconnect(uuid);
+        const nobleBle = window.desktopApi?.nobleBle;
+        if (nobleBle) {
+          if (this.connectedDevices.has(uuid)) {
+            await invokeNobleBle(nobleBle.unsubscribe(uuid)).catch(cleanupError => {
+              this.Log?.debug('[Electron BLE] acquire unsubscribe failed:', cleanupError);
+            });
+          }
+          await invokeNobleBle(nobleBle.disconnect(uuid));
         }
       } catch (cleanupError) {
         this.Log?.debug('[Electron BLE] acquire cleanup failed:', cleanupError);
       }
       this.cleanupDeviceState(uuid);
-      throw error;
+      this.handleBluetoothError(error);
     }
   }
 
@@ -458,13 +456,16 @@ export default class ElectronBleTransport {
   // Hard teardown, error paths only: a link presumed dead must not be reused.
   private async releaseNative(id: string) {
     try {
-      if (this.connectedDevices.has(id)) {
-        if (window.desktopApi?.nobleBle) {
-          await window.desktopApi.nobleBle.unsubscribe(id);
-          await window.desktopApi.nobleBle.disconnect(id);
+      const nobleBle = window.desktopApi?.nobleBle;
+      if (nobleBle) {
+        if (this.connectedDevices.has(id)) {
+          await invokeNobleBle(nobleBle.unsubscribe(id)).catch(error => {
+            this.Log?.debug('[Electron BLE] release unsubscribe failed:', error);
+          });
         }
-        this.cleanupDeviceState(id);
+        await invokeNobleBle(nobleBle.disconnect(id));
       }
+      this.cleanupDeviceState(id);
     } catch (error) {
       this.Log?.error('[Electron BLE] release failed:', error);
       this.cleanupDeviceState(id);
@@ -490,19 +491,16 @@ export default class ElectronBleTransport {
         }
         return;
       }
-      await release(id, keepSession);
+      await invokeNobleBle(release(id, keepSession));
     } catch (error) {
       this.Log?.error('[Electron BLE] logical release failed:', error);
       this.cleanupDeviceState(id);
     }
   }
 
-  private createProtocolMismatchError(expected: ProtocolType, uuid: string) {
-    // A generic Ping miss is not a bond failure. Only a later miss after this
-    // endpoint already answered V2, or a native encryption/pairing error, is.
-    const isStaleV2Bond = expected === 'V2' && this.confirmedProtocolV2.has(uuid);
+  private createProtocolMismatchError(expected: ProtocolType) {
     return ERRORS.TypedError(
-      isStaleV2Bond ? HardwareErrorCode.BleDeviceBondError : HardwareErrorCode.RuntimeError,
+      HardwareErrorCode.RuntimeError,
       `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
     );
   }
@@ -542,13 +540,12 @@ export default class ElectronBleTransport {
     }
 
     if (expectedProtocol === 'V2') {
-      if (await this.probeProtocolV2(uuid)) {
+      if (await this.probeProtocolV2(uuid, expectedProtocol)) {
         this.deviceProtocol.set(uuid, 'V2');
-        this.confirmedProtocolV2.add(uuid);
         this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> V2 (expected)`);
         return 'V2';
       }
-      throw this.createProtocolMismatchError(expectedProtocol, uuid);
+      throw this.createProtocolMismatchError(expectedProtocol);
     }
 
     // Protocol must be actively probed after connection. Name, PID, and descriptors only
@@ -567,9 +564,6 @@ export default class ElectronBleTransport {
         protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
       if (detected) {
         this.deviceProtocol.set(uuid, protocol);
-        if (protocol === 'V2') {
-          this.confirmedProtocolV2.add(uuid);
-        }
         this.Log?.debug(`[Electron BLE] detectProtocol: uuid=${uuid} -> ${protocol}`);
         return protocol;
       }
@@ -640,7 +634,7 @@ export default class ElectronBleTransport {
     }
   }
 
-  private async probeProtocolV2(uuid: string) {
+  private async probeProtocolV2(uuid: string, expectedProtocol?: ProtocolType) {
     if (!this._messages || !this._messagesV2) {
       return false;
     }
@@ -656,8 +650,11 @@ export default class ElectronBleTransport {
         this.v2Assemblers.get(uuid)?.reset();
         this.resetProtocolV2Frames(uuid);
       },
+      // A declared V2 protocol needs no fallback; preserve the actual link failure.
       shouldRethrow: error =>
-        isBleStaleBondHardwareError(error) || isProtocolV2LinkDisabledError(error),
+        expectedProtocol === 'V2' ||
+        isBleStaleBondHardwareError(error) ||
+        isProtocolV2LinkDisabledError(error),
     });
     if (!detected) {
       this.clearProbeProtocol(uuid, 'V2');
@@ -672,18 +669,15 @@ export default class ElectronBleTransport {
     }
 
     try {
-      await nobleBle.write(uuid, hexData, { pacingDelayMs: 0 });
+      await invokeNobleBle(nobleBle.write(uuid, hexData, { pacingDelayMs: 0 }));
     } catch (error) {
-      const staleBondError = this.toStaleBondError(error);
-      if (staleBondError) {
-        throw staleBondError;
-      }
-      throw error;
+      this.handleBluetoothError(error);
     }
   }
 
   private async refreshBlePacketCapacity(uuid: string): Promise<void> {
-    const device = await window.desktopApi?.nobleBle?.getDevice(uuid);
+    const nobleBle = window.desktopApi?.nobleBle;
+    const device = nobleBle ? await invokeNobleBle(nobleBle.getDevice(uuid)) : undefined;
     this.updateBlePacketCapacity(uuid, device?.mtu);
   }
 
@@ -941,7 +935,7 @@ export default class ElectronBleTransport {
         if (hexString.length === 0) {
           throw new Error(`Buffer ${i + 1} is empty`);
         }
-        await window.desktopApi.nobleBle.write(uuid, hexString);
+        await invokeNobleBle(window.desktopApi.nobleBle.write(uuid, hexString));
       }
 
       const response = await Promise.race([
@@ -979,7 +973,7 @@ export default class ElectronBleTransport {
           await this.releaseNative(uuid);
         }
       }
-      throw e;
+      throw this.normalizeBluetoothError(e);
     } finally {
       if (timeout) clearTimeout(timeout);
       if (this.runPromise === runPromise) {