@onekeyfe/hd-core 1.2.8-alpha.10 → 1.2.8-alpha.101

package/src/api/SearchDevices.ts

@@ -5,10 +5,20 @@ import TransportManager from '../data-manager/TransportManager';
 import { DataManager } from '../data-manager';
 import { LoggerNames, getDeviceTypeByBleName, getLogger } from '../utils';
 import { DevicePool } from '../device/DevicePool';
+import { buildProtocolV1FeaturesPayload } from '../deviceProfile/buildDeviceFeatures';
+import { mapProtocolV2DeviceInfoToState } from '../device/DeviceStateMapper';
+import { getSupportProtocolV1MessageSchema } from '../utils/deviceFeaturesUtils';
+import { PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST } from '../protocols/protocol-v2/features';
 
-import type { SearchDevice } from '../types/device';
+import type { SearchDevice, UsbDeviceIdentity } from '../types/device';
+import type { PROTO } from '../constants';
 import type DeviceConnector from '../device/DeviceConnector';
-import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import type {
+  AcquireInput,
+  OneKeyDeviceInfo as DeviceDescriptor,
+  ProtocolV2DeviceInfo,
+  Transport,
+} from '@onekeyfe/hd-transport';
 import type { Device } from '../device/Device';
 
 const Log = getLogger(LoggerNames.DevicePool);
@@ -18,7 +28,10 @@ type RequestQueueLookup = {
   getTask: (requestId: number) => { method: { device?: Device } } | undefined;
 };
 
-const getDescriptorKeys = (descriptor: DeviceDescriptor) =>
+export type UsbIdentityProbeDescriptor = Pick<DeviceDescriptor, 'path' | 'commType'> &
+  Partial<Pick<DeviceDescriptor, 'id' | 'session'>>;
+
+const getDescriptorKeys = (descriptor: UsbIdentityProbeDescriptor) =>
   [descriptor.path, descriptor.id].filter(
     (key): key is string => typeof key === 'string' && key.length > 0
   );
@@ -33,11 +46,11 @@ const isOwnedByActiveWebUsbRequest = (
   );
 };
 
-const getUsbHandle = (descriptor?: DeviceDescriptor) =>
+const getUsbHandle = (descriptor?: UsbIdentityProbeDescriptor) =>
   (descriptor as { device?: unknown } | undefined)?.device;
 
 const getOwningRequestDevice = (
-  descriptor: DeviceDescriptor,
+  descriptor: UsbIdentityProbeDescriptor,
   requestQueue?: RequestQueueLookup
 ) => {
   if (!requestQueue) return undefined;
@@ -60,6 +73,158 @@ const getOwningRequestDevice = (
   return undefined;
 };
 
+export const getOwnedUsbDeviceIdentity = (
+  descriptor: UsbIdentityProbeDescriptor,
+  requestQueue: RequestQueueLookup
+): UsbDeviceIdentity | undefined => {
+  const owner = getOwningRequestDevice(descriptor, requestQueue);
+  if (!owner || descriptor.commType !== 'webusb' || owner.originalDescriptor?.commType !== 'webusb')
+    return undefined;
+  return {
+    path: descriptor.path,
+    serialNo: owner.getCurrentSerialNo() || null,
+    deviceId: owner.getCurrentDeviceId() || null,
+    deviceType: owner.getCurrentDeviceType(),
+    connectProtocol: owner.getProtocol(),
+    commType: 'webusb',
+    mode: owner.features?.mode ?? undefined,
+  };
+};
+
+export type UsbIdentityProbeTransport = Pick<
+  Transport,
+  'release' | 'call' | 'getProtocolType' | 'configureProtocolV2'
+> & {
+  init: (logger: object) => unknown;
+  enumerate: () => Promise<UsbIdentityProbeDescriptor[]>;
+  acquire: (input: AcquireInput) => Promise<string | undefined>;
+  configure: (signedData: string) => void | Promise<void>;
+};
+
+// Identity discovery must not publish device events or log raw Features/session data.
+const identityProbeLogger = {
+  debug: () => undefined,
+  log: () => undefined,
+  info: () => undefined,
+  warn: () => undefined,
+  error: () => undefined,
+};
+
+/** Runs on a separate transport; never initializes or switches the current Core. */
+export const probeUsbDeviceIdentitiesWithTransport = async (
+  transport: UsbIdentityProbeTransport,
+  commType: UsbDeviceIdentity['commType'],
+  getOwnedIdentity?: (descriptor: UsbIdentityProbeDescriptor) => UsbDeviceIdentity | undefined
+): Promise<UsbDeviceIdentity[]> => {
+  if (commType !== 'webusb') return [];
+  await transport.init(identityProbeLogger);
+  const defaultMessages = JSON.stringify(DataManager.getProtobufMessages());
+  await transport.configure(defaultMessages);
+  await transport.configureProtocolV2?.(
+    JSON.stringify(DataManager.getProtobufMessages('v2Schema'))
+  );
+  const descriptors = await transport.enumerate();
+  const identities: UsbDeviceIdentity[] = [];
+  const readIdentity = async (
+    descriptor: UsbIdentityProbeDescriptor
+  ): Promise<UsbDeviceIdentity | undefined> => {
+    const { path } = descriptor;
+    if (!path || descriptor.commType !== commType) return undefined;
+    if (descriptors.filter(candidate => candidate.path === path).length !== 1) return undefined;
+    const owner = getOwnedIdentity?.(descriptor);
+    if (owner) {
+      return owner;
+    }
+    // Do not borrow a browser handle or replace a Bridge session owned by another call.
+    if (descriptor.session || (getUsbHandle(descriptor) as USBDevice | undefined)?.opened)
+      return undefined;
+
+    let session: string | undefined;
+    let identified: UsbDeviceIdentity | undefined;
+    try {
+      await transport.configure(defaultMessages);
+      session = await transport.acquire({ path, previous: null, forceProtocolDetection: true });
+      if (!session) return undefined;
+      const protocol = transport.getProtocolType(path);
+      if (protocol === 'V1') {
+        const response = await transport.call(session, 'GetFeatures', {}, { timeoutMs: 3000 });
+        if (response.type !== 'Features') return undefined;
+        let features = buildProtocolV1FeaturesPayload(response.message as PROTO.Features);
+        // Classic-family loaders expose their supported information in Features.
+        // Touch/Pro retain their existing vendor-feature query.
+        if (
+          !features.serialNo &&
+          (features.mode !== 'bootloader' ||
+            features.deviceType === EDeviceType.Touch ||
+            features.deviceType === EDeviceType.Pro)
+        ) {
+          const { messages, protocolV1MessageSchema } = getSupportProtocolV1MessageSchema(features);
+          // Legacy V1 has no OnekeyGetFeatures; keep the identity confirmed by GetFeatures.
+          if (protocolV1MessageSchema === 'v1CurrentSchema') {
+            if (messages) await transport.configure(JSON.stringify(messages));
+            const vendor = await transport.call(
+              session,
+              'OnekeyGetFeatures',
+              {},
+              { timeoutMs: 3000 }
+            );
+            if (vendor.type === 'OnekeyFeatures') {
+              features = buildProtocolV1FeaturesPayload({
+                ...response.message,
+                ...vendor.message,
+              } as PROTO.Features);
+            }
+          }
+        }
+        identified = {
+          path,
+          serialNo: features.serialNo || null,
+          deviceId: features.deviceId || null,
+          deviceType: features.deviceType,
+          connectProtocol: 'V1',
+          commType,
+          mode: features.mode ?? undefined,
+        };
+      } else if (protocol === 'V2') {
+        const response = await transport.call(
+          session,
+          'DeviceInfoGet',
+          PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
+          { timeoutMs: 3000 }
+        );
+        if (response.type !== 'DeviceInfo') return undefined;
+        const { identity } = mapProtocolV2DeviceInfoToState(
+          response.message as ProtocolV2DeviceInfo
+        );
+        identified = {
+          path,
+          serialNo: identity?.serialNo || null,
+          deviceId: identity?.deviceId || null,
+          deviceType: identity?.deviceType ?? EDeviceType.Unknown,
+          connectProtocol: 'V2',
+          commType,
+        };
+      }
+    } catch {
+      // Discovery is best effort; a busy/disconnected device cannot confirm identity.
+    } finally {
+      if (session) {
+        try {
+          await transport.release(session, false);
+        } catch {
+          identified = undefined;
+        }
+      }
+    }
+    return identified;
+  };
+  for (const descriptor of descriptors) {
+    const identity = await readIdentity(descriptor);
+    if (identity) identities.push(identity);
+  }
+  return identities;
+};
+
 // A USB path is a routing key (the USB serial, a synthesized usb-vid-pid-name, or the
 // bootloader placeholder), not a hardware identity, so it never fills uuid/serialNo.
 const toSearchDeviceFromDescriptor = (descriptor: DeviceDescriptor): SearchDevice => {
@@ -81,7 +246,7 @@ const toSearchDevice = (device: Device): SearchDevice | null => {
 };
 
 export default class SearchDevices extends BaseMethod {
-  connector?: DeviceConnector;
+  connector?: DeviceConnector = undefined;
 
   init() {
     this.useDevice = false;
@@ -130,7 +295,7 @@ export default class SearchDevices extends BaseMethod {
             // BLE discovery cannot provide a physical-device identity before initialization.
             uuid: '',
             deviceId: null,
-            name: bleName || device.name,
+            name: bleName || device.name || '',
             deviceType: getDeviceTypeByBleName(bleName),
           });
         }

package/src/api/index.ts

@@ -175,3 +175,5 @@ export { default as benfenSignTransaction } from './benfen/BenfenSignTransaction
 
 export { default as neoGetAddress } from './neo/NeoGetAddress';
 export { default as neoSignTransaction } from './neo/NeoSignTransaction';
+export { default as zcashGetAddress } from './zcash/ZcashGetAddress';
+export { default as zcashSignPczt } from './zcash/ZcashSignPczt';

package/src/api/protocol-v2/DeviceReboot.ts

@@ -1,5 +1,6 @@
 import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
+import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { normalizeRebootType } from './helpers';
 
@@ -11,6 +12,7 @@ export default class DeviceReboot extends BaseMethod<DeviceRebootParams> {
   }
 
   init() {
+    this.allowDeviceMode.push(UI_REQUEST.BOOTLOADER);
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.unlockPolicy = 'unlock-before-run';

package/src/api/zcash/ZcashGetAddress.ts

@@ -0,0 +1,121 @@
+import { ZcashAddressScope, ZcashAddressType } from '@onekeyfe/hd-transport';
+
+import { BaseMethod } from '../BaseMethod';
+import { serializedPath, toHardened, validatePath } from '../helpers/pathUtils';
+import { invalidParameter, validateParams, validateResult } from '../helpers/paramsValidator';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ZcashGetAddress as HardwareZcashGetAddress } from '@onekeyfe/hd-transport';
+import type { ZcashGetAddressParams, ZcashAddress } from '../../types/api/zcashGetAddress';
+import type { DeviceFirmwareRange } from '../../types';
+
+export default class ZcashGetAddress extends BaseMethod<HardwareZcashGetAddress[]> {
+  hasBundle = false;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = [];
+    payload.bundle.forEach((batch: ZcashGetAddressParams) => {
+      // ZIP-32 account path: m/32'/133'/account'
+      const addressN = validatePath(batch.path, 3);
+      if (
+        addressN.length !== 3 ||
+        addressN[0] !== toHardened(32) ||
+        addressN[1] !== toHardened(133) ||
+        addressN[2] < toHardened(0) ||
+        addressN[2] > 0xffffffff
+      ) {
+        throw invalidParameter("Zcash requires a ZIP-32 account path m/32'/133'/account'");
+      }
+      const addressType = batch.addressType ?? ZcashAddressType.UNIFIED_ORCHARD_P2PKH;
+      const scope = batch.scope ?? ZcashAddressScope.EXTERNAL;
+      const diversifierIndex = batch.diversifierIndex ?? 0;
+      if (
+        ![
+          ZcashAddressType.UNIFIED_ORCHARD_P2PKH,
+          ZcashAddressType.TRANSPARENT_P2PKH,
+          ZcashAddressType.UNIFIED_ORCHARD,
+        ].includes(addressType) ||
+        ![ZcashAddressScope.EXTERNAL, ZcashAddressScope.INTERNAL].includes(scope)
+      ) {
+        throw invalidParameter('Invalid Zcash address type or scope');
+      }
+      const maxIndex = addressType === ZcashAddressType.UNIFIED_ORCHARD ? 0xffffffff : 0x7fffffff;
+      if (
+        !Number.isSafeInteger(diversifierIndex) ||
+        diversifierIndex < 0 ||
+        diversifierIndex > maxIndex
+      ) {
+        throw invalidParameter('Invalid Zcash diversifier index');
+      }
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'showOnOneKey', type: 'boolean' },
+        { name: 'includeUfvk', type: 'boolean' },
+        { name: 'includeSeedFingerprint', type: 'boolean' },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        address_type: addressType,
+        scope,
+        diversifier_index: diversifierIndex,
+        show_display: batch.showOnOneKey ?? true,
+        include_ufvk: batch.includeUfvk ?? false,
+        include_seed_fingerprint: batch.includeSeedFingerprint ?? false,
+      });
+    });
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '0.0.0',
+      },
+    };
+  }
+
+  async run() {
+    const responses: ZcashAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('ZcashGetAddress', 'ZcashAddress', {
+        ...param,
+      });
+
+      const path = serializedPath(param.address_n);
+      responses.push({
+        path,
+        address: res.message.address,
+        ufvk: res.message.ufvk,
+        seedFingerprint: res.message.seed_fingerprint,
+      });
+
+      this.postPreviousAddressMessage({
+        address: res.message.address,
+        path,
+      });
+    }
+
+    validateResult(responses, ['address'], {
+      expectedLength: this.params.length,
+    });
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

package/src/api/zcash/ZcashSignPczt.ts

@@ -0,0 +1,155 @@
+import { bytesToHex } from '@noble/hashes/utils';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { stripHexPrefix } from '../helpers/hexUtils';
+import { UI_REQUEST } from '../../constants/ui-request';
+
+import type { ZcashSignPczt as HardwareZcashSignPczt } from '@onekeyfe/hd-transport';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
+import type { ZcashSignedPczt } from '../../types/api/zcashSignPczt';
+import type { DeviceFirmwareRange } from '../../types';
+
+const CHUNK_BYTE_SIZE = 1024;
+// Host memory sanity bound on the device-announced length, not a device limit.
+const SIGNED_PCZT_SANITY_MAX_BYTES = 16 * 1024 * 1024;
+
+export default class ZcashSignPczt extends BaseMethod<HardwareZcashSignPczt> {
+  pczt: Buffer = Buffer.alloc(0);
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+    this.strictCheckDeviceSupport = true;
+
+    validateParams(this.payload, [{ name: 'pczt', type: 'hexString', required: true }]);
+
+    // Reject odd-length hex instead of left-padding it, which would shift every nibble.
+    const pcztHex = stripHexPrefix(this.payload.pczt);
+    if (pcztHex.length % 2 !== 0) {
+      throw invalidParameter('pczt hex must have an even length');
+    }
+    this.pczt = Buffer.from(pcztHex, 'hex');
+    if (this.pczt.length === 0) {
+      throw invalidParameter('pczt is empty');
+    }
+
+    this.params = {
+      pczt_length: this.pczt.length,
+      pczt_initial_chunk: bytesToHex(this.pczt.subarray(0, CHUNK_BYTE_SIZE)),
+    };
+  }
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      model_pro2: {
+        min: '0.0.0',
+      },
+    };
+  }
+
+  // Upload: the device decides every chunk length via ZcashPcztChunkRequest and
+  // the host must answer with exactly that many bytes.
+  uploadPczt = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ZcashSignedPczt'> | TypedResponseMessage<'ZcashPcztChunkRequest'>,
+    offset: number
+  ): Promise<TypedResponseMessage<'ZcashSignedPczt'>> => {
+    if (res.type === 'ZcashSignedPczt') {
+      if (offset !== this.pczt.length) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          'device completed signing before receiving the whole pczt'
+        );
+      }
+      return res;
+    }
+
+    const { chunk_length: chunkLength } = res.message;
+    if (
+      !Number.isSafeInteger(chunkLength) ||
+      chunkLength <= 0 ||
+      offset + chunkLength > this.pczt.length
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        `device requested ${chunkLength} bytes at offset ${offset} of ${this.pczt.length}`
+      );
+    }
+
+    const chunk = this.pczt.subarray(offset, offset + chunkLength);
+    const next = await typedCall(
+      'ZcashPcztChunkAck',
+      ['ZcashSignedPczt', 'ZcashPcztChunkRequest'],
+      {
+        data_chunk: bytesToHex(chunk),
+      }
+    );
+
+    return this.uploadPczt(typedCall, next, offset + chunkLength);
+  };
+
+  // Download: the host decides chunk lengths via ZcashSignedPcztChunkRequest
+  // until the announced pczt_length has been received.
+  downloadSignedPczt = async (
+    typedCall: TypedCall,
+    res: TypedResponseMessage<'ZcashSignedPczt'>
+  ): Promise<Buffer> => {
+    const { pczt_length: total, pczt_initial_chunk: initial } = res.message;
+    if (!Number.isSafeInteger(total) || total <= 0 || total > SIGNED_PCZT_SANITY_MAX_BYTES) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        `device announced invalid signed pczt length ${total}`
+      );
+    }
+
+    const parts: Buffer[] = [Buffer.from(initial ?? '', 'hex')];
+    let received = parts[0].length;
+    if (received > total) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.ResponseUnexpectTypeError,
+        'device returned more initial pczt bytes than announced'
+      );
+    }
+
+    while (received < total) {
+      const chunkLength = Math.min(CHUNK_BYTE_SIZE, total - received);
+      const ack = await typedCall('ZcashSignedPcztChunkRequest', 'ZcashPcztChunkAck', {
+        chunk_length: chunkLength,
+      });
+      const chunk = Buffer.from(ack.message.data_chunk ?? '', 'hex');
+      if (chunk.length !== chunkLength) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.ResponseUnexpectTypeError,
+          `device returned ${chunk.length} of ${chunkLength} requested bytes at offset ${received} of ${total}`
+        );
+      }
+      parts.push(chunk);
+      received += chunk.length;
+    }
+
+    return Buffer.concat(parts);
+  };
+
+  async run(): Promise<ZcashSignedPczt> {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const first = await typedCall('ZcashSignPczt', ['ZcashSignedPczt', 'ZcashPcztChunkRequest'], {
+      ...this.params,
+    });
+
+    const signed = await this.uploadPczt(
+      typedCall,
+      first,
+      Math.min(CHUNK_BYTE_SIZE, this.pczt.length)
+    );
+    const pczt = await this.downloadSignedPczt(typedCall, signed);
+
+    return { pczt: bytesToHex(pczt) };
+  }
+}

package/src/core/index.ts

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { getOwnedUsbDeviceIdentity } from '../api/SearchDevices';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
@@ -23,7 +24,6 @@ import {
   createNeedUpgradeFirmwareHardwareError,
   createNewFirmwareForceUpdateHardwareError,
   createNewFirmwareUnReleaseHardwareError,
-  isBleStaleBondHardwareError,
 } from '@onekeyfe/hd-shared';
 
 import { LoggerNames, enableLog, getLogger, setLoggerPostMessage, wait } from '../utils';
@@ -126,6 +126,8 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
 });
 
 let _core: Core | undefined;
+let transportSwitchGeneration = 0;
+let pendingTransportSwitch: Promise<void> = Promise.resolve();
 let _deviceList: DeviceList | undefined;
 let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
@@ -991,15 +993,11 @@ function canSkipInitialize(method: BaseMethod, device: Device): boolean {
 }
 
 export function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const typedError = error as { errorCode?: unknown; message?: unknown };
-  const message =
-    typeof typedError?.message === 'string' ? typedError.message : String(error ?? '');
+  const typedError = error as { errorCode?: unknown; params?: { expectedProtocol?: unknown } };
   return (
     method.payload.connectProtocol === 'V2' &&
-    typedError?.errorCode === HardwareErrorCode.RuntimeError &&
-    message.includes('Device protocol mismatch') &&
-    message.includes('expected V2') &&
-    message.includes('did not respond to expected protocol')
+    typedError?.errorCode === HardwareErrorCode.TransportProtocolProbeFailed &&
+    typedError.params?.expectedProtocol === 'V2'
   );
 }
 
@@ -1009,7 +1007,7 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   }
   const typedError = error as {
     errorCode?: unknown;
-    params?: { acquireDeadlineExceeded?: unknown };
+    params?: { acquireDeadlineExceeded?: unknown; expectedProtocol?: unknown };
   };
   if (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError &&
@@ -1020,6 +1018,8 @@ export function isRetryableBleConnectionError(method: BaseMethod, error: unknown
   return (
     typedError?.errorCode === HardwareErrorCode.BleTimeoutError ||
     typedError?.errorCode === HardwareErrorCode.BleConnectedError ||
+    (typedError?.errorCode === HardwareErrorCode.TransportProtocolProbeFailed &&
+      !typedError.params?.expectedProtocol) ||
     isRetryableBleProtocolV2ProbeError(method, error) ||
     isMissingDetectedProtocolV2Error(method, error)
   );
@@ -1035,10 +1035,6 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
   );
 }
 
-export function isTerminalBleStaleBondError(error: unknown) {
-  return isBleStaleBondHardwareError(error);
-}
-
 export function isDeviceIdentityMismatchError(error: unknown) {
   return (
     (error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.DeviceCheckDeviceIdError
@@ -1277,6 +1273,9 @@ const ensureConnected = async (
             HardwareErrorCode.BridgeNotInstalled,
             HardwareErrorCode.BridgeTimeoutError,
             HardwareErrorCode.BridgeNeedsPermission,
+            HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
           ].includes(error.errorCode)
         ) {
           _deviceList = undefined;
@@ -1363,6 +1362,9 @@ const ensureConnected = async (
             HardwareErrorCode.DeviceDetectInBootloaderMode,
             HardwareErrorCode.BleCharacteristicNotifyChangeFailure,
             HardwareErrorCode.BridgeNeedsPermission,
+            HardwareErrorCode.WebUsbDeviceAccessError,
+            HardwareErrorCode.TransportProtocolProbeFailed,
+            HardwareErrorCode.TransportProtocolMismatch,
             HardwareErrorCode.DeviceInterruptedFromUser,
             HardwareErrorCode.CallQueueActionCancelled,
           ].includes(error.errorCode) ||
@@ -1370,7 +1372,6 @@ const ensureConnected = async (
             [HardwareErrorCode.BleDeviceDisconnected, HardwareErrorCode.PollingTimeout].includes(
               error.errorCode
             )) ||
-          isTerminalBleStaleBondError(error) ||
           isDeviceIdentityMismatchError(error)
         ) {
           reject(error);
@@ -1830,6 +1831,10 @@ export default class Core extends EventEmitter {
 
   private requestQueue = new RequestQueue();
 
+  getOwnedUsbDeviceIdentity(descriptor: Parameters<typeof getOwnedUsbDeviceIdentity>[0]) {
+    return getOwnedUsbDeviceIdentity(descriptor, this.requestQueue);
+  }
+
   private disposePromise?: Promise<void>;
 
   // background task
@@ -1963,6 +1968,8 @@ export default class Core extends EventEmitter {
 
   private async disposeResources(): Promise<void> {
     Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
+    transportSwitchGeneration += 1;
+    pendingTransportSwitch = Promise.resolve();
     pollingManager.stopAll();
     this.requestQueue.abortAllRequests();
     cleanup();
@@ -1997,6 +2004,8 @@ export default class Core extends EventEmitter {
 }
 
 export const initCore = () => {
+  transportSwitchGeneration += 1;
+  pendingTransportSwitch = Promise.resolve();
   const core = new Core();
   _core = core;
   return core;
@@ -2026,6 +2035,8 @@ export const init = async (
   plugin?: LowlevelTransportSharedPlugin
 ) => {
   try {
+    transportSwitchGeneration += 1;
+    pendingTransportSwitch = Promise.resolve();
     await DataManager.load(settings);
     initTransport(Transport, plugin);
     enableLog(DataManager.getSettings('debug'));
@@ -2051,10 +2062,26 @@ export const switchTransport = ({
   Transport: any;
   plugin?: LowlevelTransportSharedPlugin;
 }) => {
-  DataManager.updateEnv(env);
-  TransportManager.setTransport(Transport, plugin);
-  _deviceList = undefined;
-  DevicePool.resetState();
-  _connector = undefined;
-  initConnector();
+  const generation = transportSwitchGeneration;
+  // Preserve request order while native transport cleanup is pending.
+  const switching = pendingTransportSwitch
+    .catch(() => undefined)
+    .then(async () => {
+      if (generation !== transportSwitchGeneration) {
+        throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
+      }
+      _connector?.stop();
+      await TransportManager.getTransport()?.stop?.();
+      if (generation !== transportSwitchGeneration) {
+        throw ERRORS.TypedError(HardwareErrorCode.NotInitialized);
+      }
+      DataManager.updateEnv(env);
+      TransportManager.setTransport(Transport, plugin);
+      _deviceList = undefined;
+      DevicePool.resetState();
+      _connector = undefined;
+      initConnector();
+    });
+  pendingTransportSwitch = switching;
+  return switching;
 };