@onekeyfe/hd-core 1.2.2-alpha.9 → 1.2.2

package/src/core/index.ts

@@ -10,6 +10,7 @@ import {
   isProtocolV2LinkDisabledError,
 } from '@onekeyfe/hd-transport';
 import {
+  EDeviceType,
   ERRORS,
   ERROR_CODES_REQUIRE_DISCONNECT,
   ERROR_CODES_REQUIRE_RELEASE,
@@ -22,6 +23,7 @@ import {
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
+  isBleStaleBondHardwareError,
 } from '@onekeyfe/hd-shared';
 
 import { LoggerNames, enableLog, getLogger, setLoggerPostMessage, wait } from '../utils';
@@ -82,7 +84,8 @@ import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
 const PRE_INITIALIZE_TTL_MS = 60 * 1000;
-const PRE_PENDING_CALL_TIMEOUT_MS = 15 * 1000;
+const PRE_PENDING_CALL_TIMEOUT_MS = 5 * 1000;
+const PRO2_USB_SIGNING_COOLDOWN_MS = 1000;
 
 // Dedup/coalesce state for "pre-warm signal" methods (isPreWarmSignal),
 // keyed by getPreWarmKey(): coalesce in-flight, skip if warmed within TTL.
@@ -180,6 +183,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
       }
     };
     method.setContext?.(context);
+    method.context = context;
 
     method.requestContext = createRequestContext(method.responseID, method.name, {
       sdkInstanceId: context.sdkInstanceId,
@@ -200,7 +204,12 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   if (!method.useDevice) {
     updateMethodRequestContext(method, { status: 'running' });
     try {
-      const response = await method.run();
+      const env = DataManager.getSettings('env');
+      const response =
+        method.name === 'searchDevices' &&
+        (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env))
+          ? await context.methodSynchronize(() => method.run(), 'webusb-discovery')
+          : await method.run();
       completeMethodRequestContext(method);
       return createResponseMessage(method.responseID, true, response);
     } catch (error) {
@@ -313,6 +322,7 @@ const waitForPendingPromise = async (
     Log.debug('pre pending call promise before call method, wait for it');
     let timer: ReturnType<typeof setTimeout> | undefined;
     let timedOut = false;
+    let completed = false;
     try {
       await Promise.race([
         pendingPromise,
@@ -323,11 +333,12 @@ const waitForPendingPromise = async (
           }, PRE_PENDING_CALL_TIMEOUT_MS);
         }),
       ]);
-    } catch (error) {
-      // Cancellation is best-effort; the transport teardown owns recovery.
+      completed = !timedOut;
     } finally {
       if (timer) clearTimeout(timer);
-      removePrePendingCallPromise?.(connectId, pendingPromise);
+      // Keep a rejected cleanup barrier for the next caller's safety check;
+      // only a completed cleanup or a timeout may clear it.
+      if (timedOut || completed) removePrePendingCallPromise?.(connectId, pendingPromise);
     }
     if (timedOut) {
       Log.warn('pre pending call promise timed out before call method', { connectId });
@@ -336,6 +347,20 @@ const waitForPendingPromise = async (
   }
 };
 
+export function getPostCallPendingPromise(method: BaseMethod, device: Device): Promise<void> {
+  const cleanupPromise = device.waitForRunCleanup();
+  const env = DataManager.getSettings('env');
+  const deviceType = device.getCurrentDeviceType();
+  const requiresSigningCooldown =
+    method.name.includes('Sign') &&
+    (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) &&
+    (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env) || env === 'node-usb');
+
+  return requiresSigningCooldown
+    ? cleanupPromise.then(() => wait(PRO2_USB_SIGNING_COOLDOWN_MS)).then(() => undefined)
+    : cleanupPromise;
+}
+
 const onCallDevice = async (
   context: CoreContext,
   message: CoreMessage,
@@ -366,42 +391,57 @@ const onCallDevice = async (
     DevicePool.clearDeviceCache(method.payload.connectId);
   }
 
-  // wait for previous callback tasks to complete (ensure device does not call concurrently)
-  if (method.connectId) {
-    await context.waitForCallbackTasks(method.connectId);
-  }
-
-  await waitForPendingPromise(
-    method.connectId ?? '',
-    getPrePendingCallPromise,
-    removePrePendingCallPromise
-  );
-
+  // Register before waiting so cancellation also covers queued requests.
   const task = requestQueue.createTask(method);
 
   // Pre-warm holds the device as a per-connectId callback task so a concurrent
   // real call waits (before ensureConnected) instead of racing its Initialize.
   // Only covers pre-warm -> real-call ordering; the reverse is fail-closed.
   let preWarmCallbackTask: Deferred<void> | undefined;
-  if (method.isPreWarmSignal && method.connectId) {
-    preWarmCallbackTask = createDeferred<void>();
-    context.registerCallbackTask(method.connectId, preWarmCallbackTask);
-  }
-
   let device: Device;
   try {
+    const connectId = method.connectId ?? '';
+    if (connectId) {
+      await requestQueue.waitForTask(task, () => context.waitForCallbackTasks(connectId));
+    }
+    await requestQueue.waitForTask(task, () =>
+      waitForPendingPromise(
+        method.connectId ?? '',
+        getPrePendingCallPromise,
+        removePrePendingCallPromise
+      )
+    );
+    if (method.isPreWarmSignal && method.connectId) {
+      preWarmCallbackTask = createDeferred<void>();
+      context.registerCallbackTask(method.connectId, preWarmCallbackTask);
+    }
     /**
      * Polling to ensure successful connection
      */
-    const connectId = method.connectId ?? '';
     const pollingId = pollingManager.start(connectId);
-    device = await ensureConnected(
-      context,
-      method,
-      connectId,
-      pollingId,
-      task.abortController?.signal
-    );
+    const env = DataManager.getSettings('env');
+    const connect = () =>
+      ensureConnected(context, method, connectId, pollingId, method.abortSignal);
+    // Discovery may acquire USB endpoints. Finish it before initializing a public
+    // request; once registered, that request makes discovery use cached state only.
+    if (DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env)) {
+      // Synchronization can keep the connect action queued after the caller is
+      // cancelled. Observe that promise so a late device-not-found error does
+      // not become an unhandled rejection.
+      const connectPromise = context.methodSynchronize(async () => {
+        if (method.abortSignal?.aborted) {
+          throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+        }
+        return connect();
+      }, 'webusb-discovery');
+      connectPromise.catch(() => undefined);
+      device = await requestQueue.waitForTask(task, () => connectPromise);
+    } else {
+      device = await connect();
+    }
+    if (method.abortSignal?.aborted) {
+      throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+    }
   } catch (e) {
     preWarmCallbackTask?.resolve();
     Log.debug('ensureConnected error: ', e);
@@ -477,14 +517,19 @@ const onCallDevice = async (
 
   try {
     // Wait for any pending task except our own (self-wait would deadlock).
-    if (method.connectId) {
-      await context.waitForCallbackTasks(method.connectId, preWarmCallbackTask);
+    const { connectId } = method;
+    if (connectId) {
+      await requestQueue.waitForTask(task, () =>
+        context.waitForCallbackTasks(connectId, preWarmCallbackTask)
+      );
     }
 
-    await waitForPendingPromise(
-      method.connectId ?? '',
-      getPrePendingCallPromise,
-      removePrePendingCallPromise
+    await requestQueue.waitForTask(task, () =>
+      waitForPendingPromise(
+        method.connectId ?? '',
+        getPrePendingCallPromise,
+        removePrePendingCallPromise
+      )
     );
 
     const inner = async (): Promise<void> => {
@@ -689,6 +734,13 @@ const onCallDevice = async (
           },
         });
         messageResponse = createResponseMessage(method.responseID, true, response);
+        // Preserve the acknowledged result while the next call waits for cleanup and cooldown.
+        if (method.connectId) {
+          context.setPrePendingCallPromise(
+            method.connectId,
+            getPostCallPendingPromise(method, device)
+          );
+        }
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
       } catch (error) {
@@ -700,6 +752,12 @@ const onCallDevice = async (
         }
         Log.debug(`Call API - Inner Method Run Error`, error);
         messageResponse = createResponseMessage(method.responseID, false, { error });
+        if (method.connectId) {
+          context.setPrePendingCallPromise(
+            method.connectId,
+            getPostCallPendingPromise(method, device)
+          );
+        }
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method, error);
 
@@ -726,6 +784,9 @@ const onCallDevice = async (
       skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
+    if (method.abortSignal?.aborted) {
+      throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+    }
     const deviceRun = () => device.run(inner, runOptions);
     task.callPromise = createDeferred<any>(deviceRun);
 
@@ -746,6 +807,7 @@ const onCallDevice = async (
     );
     Log.debug('Call API - Run Error: ', error);
     completeMethodRequestContext(method, error);
+    return messageResponse;
   } finally {
     // Release the pre-warm callback task so the next real call can proceed.
     preWarmCallbackTask?.resolve();
@@ -945,7 +1007,16 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   if (method.device?.wasInterruptedByUser()) {
     return false;
   }
-  const typedError = error as { errorCode?: unknown };
+  const typedError = error as {
+    errorCode?: unknown;
+    params?: { acquireDeadlineExceeded?: unknown };
+  };
+  if (
+    typedError?.errorCode === HardwareErrorCode.BleTimeoutError &&
+    typedError.params?.acquireDeadlineExceeded === true
+  ) {
+    return false;
+  }
   return (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError ||
     typedError?.errorCode === HardwareErrorCode.BleConnectedError ||
@@ -964,11 +1035,13 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
-export function isProtocolV2PeerRemovedPairingError(method: BaseMethod, error: unknown) {
+export function isTerminalBleStaleBondError(error: unknown) {
+  return isBleStaleBondHardwareError(error);
+}
+
+export function isDeviceIdentityMismatchError(error: unknown) {
   return (
-    method.payload.connectProtocol === 'V2' &&
-    (error as { errorCode?: unknown })?.errorCode ===
-      HardwareErrorCode.BlePeerRemovedPairingInformation
+    (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.DeviceCheckDeviceIdError
   );
 }
 
@@ -1001,7 +1074,8 @@ function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal
           reject(
             ERRORS.TypedError(
               HardwareErrorCode.BleTimeoutError,
-              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
+              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`,
+              { acquireDeadlineExceeded: true }
             )
           )
         ),
@@ -1031,7 +1105,7 @@ async function connectDeviceForBle(
   retryCount = 0
 ) {
   try {
-    if (device.wasInterruptedByUser()) {
+    if (abortSignal?.aborted || device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
     }
     if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
@@ -1100,6 +1174,9 @@ async function connectDeviceForBle(
       DevicePool.emitter.emit(DEVICE.CONNECT, device);
     }
   } catch (err) {
+    if (abortSignal?.aborted || device.wasInterruptedByUser()) {
+      throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
+    }
     const requiresColdReconnect = isMissingDetectedProtocolV2Error(method, err);
     // Device.run()'s REQUIRE_DISCONNECT handling never sees acquire/initialize
     // failures, so with keep-alive a wedged link would be reused by every retry
@@ -1150,6 +1227,7 @@ const ensureConnected = async (
   const POLL_INTERVAL_TIME = (method.payload && method.payload.pollIntervalTime) || 1000;
   const TIME_OUT = (method.payload && method.payload.timeout) || 10000;
   let timer: ReturnType<typeof setTimeout> | null = null;
+  let lastInitializeError: any;
   Log.debug(
     `EnsureConnected function start, MAX_RETRY_COUNT=${MAX_RETRY_COUNT}, POLL_INTERVAL_TIME=${POLL_INTERVAL_TIME}  `
   );
@@ -1190,7 +1268,9 @@ const ensureConnected = async (
       Log.debug('EnsureConnected function try count: ', tryCount, ' poll interval time: ', time);
       try {
         await initDeviceList(method);
+        lastInitializeError = undefined;
       } catch (error) {
+        lastInitializeError = error;
         Log.debug('device list error: ', error);
         if (
           [
@@ -1205,6 +1285,7 @@ const ensureConnected = async (
         }
         if (error.errorCode === HardwareErrorCode.TransportNotConfigured) {
           await TransportManager.configure();
+          lastInitializeError = undefined;
         }
       }
 
@@ -1273,6 +1354,8 @@ const ensureConnected = async (
             HardwareErrorCode.BleDeviceBondedCanceled,
             HardwareErrorCode.BleCharacteristicNotifyError,
             HardwareErrorCode.BleTimeoutError,
+            // A transport setup reset must also stop this outer poll.
+            HardwareErrorCode.PollingTimeout,
             HardwareErrorCode.BleWriteCharacteristicError,
             HardwareErrorCode.BleAlreadyConnected,
             HardwareErrorCode.FirmwareUpdateLimitOneDevice,
@@ -1283,7 +1366,12 @@ const ensureConnected = async (
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
-          isProtocolV2PeerRemovedPairingError(method, error)
+          (env === 'react-native' &&
+            [HardwareErrorCode.BleDeviceDisconnected, HardwareErrorCode.PollingTimeout].includes(
+              error.errorCode
+            )) ||
+          isTerminalBleStaleBondError(error) ||
+          isDeviceIdentityMismatchError(error)
         ) {
           reject(error);
           return;
@@ -1295,14 +1383,22 @@ const ensureConnected = async (
           clearTimeout(timer);
         }
         Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
-        // Browser WebUSB needs permission prompt, desktop WebUSB doesn't
-        // skipWebDevicePrompt can override this behavior for special cases
-        if (DataManager.isBrowserWebUsb(env) && !method.payload?.skipWebDevicePrompt) {
+        const preserveWebUsbInitError =
+          DataManager.isBrowserWebUsb(env) || DataManager.isDesktopWebUsb(env);
+        const needsPermissionPrompt =
+          DataManager.isBrowserWebUsb(env) && !method.payload?.skipWebDevicePrompt;
+        const fallbackError = needsPermissionPrompt
+          ? ERRORS.TypedError(HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission)
+          : ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+        const errorToReject =
+          preserveWebUsbInitError && lastInitializeError ? lastInitializeError : fallbackError;
+        // Only ask the host for a WebUSB grant when the failure is actually
+        // "not found / needs permission". A preserved initialize error must
+        // not fire that prompt with a different public code.
+        if (needsPermissionPrompt && errorToReject === fallbackError) {
           postMessage(createUiMessage(UI_REQUEST.WEB_DEVICE_PROMPT_ACCESS_PERMISSION));
-          reject(ERRORS.TypedError(HardwareErrorCode.WebDeviceNotFoundOrNeedsPermission));
-        } else {
-          reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotFound));
         }
+        reject(errorToReject);
         return;
       }
 
@@ -1374,10 +1470,11 @@ export const cancel = (context: CoreContext, connectId?: string) => {
     }
   } else {
     const env = DataManager.getSettings('env');
+    // Abort every method before rejecting its queue task. Non-BLE methods also
+    // use the signal to stop recovery loops after the public promise is rejected.
+    requestQueue.abortAllRequests();
     if (DataManager.isBleConnect(env)) {
       Log.debug('Cancel Api all _deviceList: ');
-      // Keep method abort signals observable until every active task is rejected.
-      requestQueue.abortAllRequests();
       const canceledDevices: Device[] = [];
       const interruptDevice = (device?: Device) => {
         if (!device || canceledDevices.includes(device)) {
@@ -1759,7 +1856,17 @@ export default class Core extends EventEmitter {
           this.prePendingCallPromises.delete(connectId);
           return;
         }
-        this.prePendingCallPromises.set(connectId, promise);
+        const previous = this.prePendingCallPromises.get(connectId);
+        const cleanupPromise =
+          previous && previous !== promise
+            ? Promise.all([previous, promise]).then(() => undefined)
+            : promise;
+        this.prePendingCallPromises.set(connectId, cleanupPromise);
+        // cancel() is fire-and-forget. Observe failures immediately, while
+        // preserving the rejected barrier for the next caller's safety check.
+        cleanupPromise.catch(error => {
+          Log.warn('Device cancellation cleanup failed', { errorCode: error?.errorCode });
+        });
       },
       removePrePendingCallPromise: (connectId: string, promise: Promise<void>) => {
         if (this.prePendingCallPromises.get(connectId) === promise) {

package/src/data/messages/messages-protocol-v2.json

@@ -4463,10 +4463,6 @@
         "request_id": {
           "type": "bytes",
           "id": 5
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 6
         }
       }
     },
@@ -4722,10 +4718,6 @@
         "expected_address": {
           "type": "bytes",
           "id": 12
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 13
         }
       }
     },
@@ -4810,10 +4802,6 @@
         "expected_address": {
           "type": "bytes",
           "id": 12
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 13
         }
       }
     },
@@ -4961,7 +4949,14 @@
           "type": "EthereumAuthorizationSignature",
           "id": 10
         }
-      }
+      },
+      "reserved": [
+        [5, 5],
+        [6, 6],
+        [7, 7],
+        [8, 8],
+        [9, 9]
+      ]
     },
     "EthereumTxAckOneKey": {
       "fields": {
@@ -4990,10 +4985,6 @@
         "chain_id": {
           "type": "uint64",
           "id": 3
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 4
         }
       }
     },
@@ -8968,7 +8959,8 @@
     },
     "SolanaOffChainMessageVersion": {
       "values": {
-        "MESSAGE_VERSION_0": 0
+        "MESSAGE_VERSION_0": 0,
+        "MESSAGE_VERSION_1": 1
       }
     },
     "SolanaOffChainMessageFormat": {
@@ -9016,10 +9008,6 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 3
         }
       }
     },
@@ -9056,17 +9044,15 @@
         },
         "message_format": {
           "type": "SolanaOffChainMessageFormat",
-          "id": 4,
-          "options": {
-            "default": "V0_RESTRICTED_ASCII"
-          }
+          "id": 4
         },
         "application_domain": {
           "type": "bytes",
           "id": 5
         },
-        "source_fingerprint": {
-          "type": "uint32",
+        "required_signers": {
+          "rule": "repeated",
+          "type": "bytes",
           "id": 6
         }
       }
@@ -9085,10 +9071,6 @@
           "rule": "required",
           "type": "bytes",
           "id": 2
-        },
-        "source_fingerprint": {
-          "type": "uint32",
-          "id": 3
         }
       }
     },
@@ -11501,6 +11483,7 @@
         "MessageType_DeviceFindMyTokenState": 60450,
         "MessageType_DeviceFindMyTokenUpdate": 60451,
         "MessageType_DeviceFindMyTokenStateGet": 60452,
+        "MessageType_DeviceAnimationControl": 60461,
         "MessageType_DeviceInfoGet": 60600,
         "MessageType_DeviceInfo": 60601,
         "MessageType_DeviceStatusGet": 60602,
@@ -11824,6 +11807,26 @@
         }
       }
     },
+    "DeviceAnimationAction": {
+      "values": {
+        "AnimationAction_Unknown": 0,
+        "AnimationAction_Start": 1,
+        "AnimationAction_Stop": 2
+      }
+    },
+    "DeviceAnimationControl": {
+      "fields": {
+        "action": {
+          "rule": "required",
+          "type": "DeviceAnimationAction",
+          "id": 1
+        },
+        "timeout_ms": {
+          "type": "uint32",
+          "id": 2
+        }
+      }
+    },
     "DeviceFactoryAck": {
       "values": {
         "FACTORY_ACK_SUCCESS": 0,
@@ -11885,6 +11888,10 @@
         "manufacture_time": {
           "type": "DeviceFactoryInfoManufactureTime",
           "id": 5
+        },
+        "data": {
+          "type": "bytes",
+          "id": 100
         }
       }
     },
@@ -11894,11 +11901,20 @@
           "rule": "required",
           "type": "DeviceFactoryInfo",
           "id": 1
+        },
+        "full_data": {
+          "type": "bool",
+          "id": 2
         }
       }
     },
     "DeviceFactoryInfoGet": {
-      "fields": {}
+      "fields": {
+        "full_data": {
+          "type": "bool",
+          "id": 1
+        }
+      }
     },
     "DeviceFactoryPermanentLock": {
       "fields": {

package/src/data/messages/messages.json

@@ -10243,7 +10243,8 @@
     },
     "SolanaOffChainMessageVersion": {
       "values": {
-        "MESSAGE_VERSION_0": 0
+        "MESSAGE_VERSION_0": 0,
+        "MESSAGE_VERSION_1": 1
       }
     },
     "SolanaOffChainMessageFormat": {
@@ -10276,14 +10277,16 @@
         },
         "message_format": {
           "type": "SolanaOffChainMessageFormat",
-          "id": 4,
-          "options": {
-            "default": "V0_RESTRICTED_ASCII"
-          }
+          "id": 4
         },
         "application_domain": {
           "type": "bytes",
           "id": 5
+        },
+        "required_signers": {
+          "rule": "repeated",
+          "type": "bytes",
+          "id": 7
         }
       }
     },

package/src/data-manager/TransportManager.ts

@@ -33,6 +33,8 @@ export default class TransportManager {
 
   static reactNativeInit = false;
 
+  static webUsbInit = false;
+
   static protocolV1MessageSchema: ProtocolV1MessageSchema = 'v1CurrentSchema';
 
   static plugin: LowlevelTransportSharedPlugin | null = null;
@@ -42,6 +44,17 @@ export default class TransportManager {
     this.defaultMessages = DataManager.getProtobufMessages();
     this.currentMessages = this.defaultMessages;
     this.protocolV1MessageSchema = 'v1CurrentSchema';
+    this.webUsbInit = false;
+  }
+
+  static async ensureInitialized() {
+    const env = DataManager.getSettings('env');
+    if (env !== 'webusb' && env !== 'desktop-webusb') return;
+    if (this.webUsbInit) return;
+    // The emitter registers USB disconnect events; this must happen even when
+    // schema configuration is intentionally deferred during discovery.
+    await this.transport.init(WebUsbLogger, DevicePool.emitter);
+    this.webUsbInit = true;
   }
 
   static async configure() {
@@ -69,9 +82,7 @@ export default class TransportManager {
       } else if (env === 'desktop-web-ble') {
         await this.transport.init(WebBleLogger, DevicePool.emitter);
       } else if (env === 'webusb' || env === 'desktop-webusb') {
-        // The emitter is what turns a navigator.usb 'disconnect' into a
-        // DEVICE.DISCONNECT; without it WebUSB never reports device removal.
-        await this.transport.init(WebUsbLogger, DevicePool.emitter);
+        await this.ensureInitialized();
       } else {
         await this.transport.init(HttpLogger);
       }