@onekeyfe/hd-transport-electron 1.2.0-alpha.4 → 1.2.0-alpha.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.2.0-alpha.4",
+  "version": "1.2.0-alpha.41",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -25,9 +25,9 @@
     "electron-log": ">=4.0.0"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.0-alpha.4",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.4",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.4",
+    "@onekeyfe/hd-core": "1.2.0-alpha.41",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.41",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.41",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "6f83d130f022a75003385bc4b2386cd0b2b539b5"
+  "gitHead": "17fd02ad56766b4b576ea48503f92083f2101c29"
 }

package/src/__tests__/ble-ops.test.ts

@@ -0,0 +1,21 @@
+import { runBleCallbackOperation } from '../ble-ops';
+
+describe('Electron Noble callback operations', () => {
+  test('settles when Noble never invokes the callback', async () => {
+    const result = await runBleCallbackOperation(() => undefined, {
+      timeoutMs: 5,
+      timeoutBehavior: 'resolve',
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  test('rejects callback errors before the timeout', async () => {
+    await expect(
+      runBleCallbackOperation(callback => callback(new Error('operation failed')), {
+        timeoutMs: 50,
+        timeoutBehavior: 'reject',
+      })
+    ).rejects.toThrow('operation failed');
+  });
+});

package/src/ble-ops.ts

@@ -1,6 +1,40 @@
 import type { Characteristic } from '@stoprocent/noble';
 import type { Logger } from './types/noble-extended';
 
+type BleCallback = (error?: Error) => void;
+
+export function runBleCallbackOperation(
+  operation: (callback: BleCallback) => void,
+  options: { timeoutMs: number; timeoutBehavior: 'resolve' | 'reject' }
+): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    let settled = false;
+    const settle = (error?: Error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    };
+    const timeout = setTimeout(() => {
+      if (options.timeoutBehavior === 'reject') {
+        settle(new Error(`BLE operation timed out after ${options.timeoutMs}ms`));
+      } else {
+        settle();
+      }
+    }, options.timeoutMs);
+
+    try {
+      operation(settle);
+    } catch (error) {
+      settle(error instanceof Error ? error : new Error(String(error)));
+    }
+  });
+}
+
 export interface SoftRefreshParams {
   deviceId: string;
   notifyCharacteristic: Characteristic | null | undefined;
@@ -30,18 +64,14 @@ export async function softRefreshSubscription(params: SoftRefreshParams): Promis
 
   subscriptionOperations.set(deviceId, 'subscribing');
 
-  await new Promise<void>(resolve => {
-    notifyCharacteristic.unsubscribe(() => resolve());
+  await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+    timeoutMs: 250,
+    timeoutBehavior: 'resolve',
   });
 
-  await new Promise<void>((resolve, reject) => {
-    notifyCharacteristic.subscribe((error?: Error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
+  await runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
+    timeoutMs: 8_000,
+    timeoutBehavior: 'reject',
   });
 
   notifyCharacteristic.removeAllListeners('data');