@onekeyfe/hd-core 1.2.8-alpha.2 → 1.2.8-alpha.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.8-alpha.2",
+  "version": "1.2.8-alpha.20",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.8-alpha.2",
-    "@onekeyfe/hd-transport": "1.2.8-alpha.2",
+    "@onekeyfe/hd-shared": "1.2.8-alpha.20",
+    "@onekeyfe/hd-transport": "1.2.8-alpha.20",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "74ac64464df3806ef44ad54d313378754c3eaed2"
+  "gitHead": "973f059fe93a58fdcf098ddb32ba63f621a2c78e"
 }

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,149 @@ 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',
+  };
+};
+
+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);
+        if (!features.serialNo) {
+          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,
+        };
+      } 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 +237,7 @@ const toSearchDevice = (device: Device): SearchDevice | null => {
 };
 
 export default class SearchDevices extends BaseMethod {
-  connector?: DeviceConnector;
+  connector?: DeviceConnector = undefined;
 
   init() {
     this.useDevice = false;
@@ -130,7 +286,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/btc/BTCDeriveContextHash.ts

@@ -0,0 +1,90 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Buffer } from 'buffer';
+
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { getScriptType, validatePath } from '../helpers/pathUtils';
+
+import type { BabylonDeriveContextHash, CanonicalBitcoinNetwork } from '@onekeyfe/hd-transport';
+import type { BTCDeriveContextHashParams } from '../../types';
+
+const NETWORKS: Record<BTCDeriveContextHashParams['network'], CanonicalBitcoinNetwork> = {
+  'bitcoin-mainnet': 'BITCOIN_MAINNET',
+  'bitcoin-testnet': 'BITCOIN_TESTNET',
+  'bitcoin-signet': 'BITCOIN_SIGNET',
+  'bitcoin-regtest': 'BITCOIN_REGTEST',
+};
+
+export default class BTCDeriveContextHash extends BaseMethod<BabylonDeriveContextHash> {
+  strictCheckDeviceSupport = true;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowUsePreInitialize = true;
+
+    validateParams(this.payload, [
+      { name: 'path', required: true },
+      { name: 'appName', type: 'string', required: true },
+      { name: 'context', type: 'string', required: true },
+      { name: 'network', type: 'string', required: true },
+    ]);
+
+    const { path, appName, context, network } = this.payload;
+    if (typeof appName !== 'string' || !/^[a-z0-9-]{1,64}$/.test(appName)) {
+      throw invalidParameter(
+        'appName must contain 1..64 ASCII lowercase letters, digits or hyphens'
+      );
+    }
+    if (typeof context !== 'string' || !/^(?:[0-9a-f]{2}){1,1024}$/.test(context)) {
+      throw invalidParameter('context must be 1..1024 bytes of lowercase hex without a prefix');
+    }
+    if (typeof network !== 'string' || !Object.prototype.hasOwnProperty.call(NETWORKS, network)) {
+      throw invalidParameter('Unsupported Bitcoin network');
+    }
+
+    // Reject malformed or overflowing indices before validatePath can truncate them.
+    if (
+      (typeof path === 'string' &&
+        (!/^m(?:\/\d+'?)+$/i.test(path) ||
+          path
+            .split('/')
+            .slice(1)
+            .some(index => Number(index.replace(/'/g, '')) >= 0x80000000))) ||
+      (Array.isArray(path) &&
+        path.findIndex(index => !Number.isInteger(index) || index < 0 || index > 0xffffffff) !== -1)
+    ) {
+      throw invalidParameter('Not a valid BIP-32 path');
+    }
+    const addressN = validatePath(path, 3);
+
+    this.params = {
+      address_n: addressN,
+      script_type: getScriptType(addressN),
+      app_name: Buffer.from(appName, 'ascii').toString('hex'),
+      context,
+      network: NETWORKS[network as BTCDeriveContextHashParams['network']],
+    };
+  }
+
+  getVersionRange() {
+    return {
+      classic1s: { min: '3.21.0' },
+      classicpure: { min: '3.21.0' },
+    };
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'BabylonDeriveContextHash',
+      'BabylonDerivedContextHash',
+      this.params
+    );
+    if (typeof message.secret !== 'string' || !/^[0-9a-f]{64}$/.test(message.secret)) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodError,
+        'Invalid Babylon context hash response'
+      );
+    }
+    return message;
+  }
+}

package/src/api/index.ts

@@ -60,6 +60,7 @@ export { default as allNetworkGetAddressByLoop } from './allnetwork/AllNetworkGe
 
 export { default as btcGetAddress } from './btc/BTCGetAddress';
 export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
+export { default as btcDeriveContextHash } from './btc/BTCDeriveContextHash';
 export { default as btcSignMessage } from './btc/BTCSignMessage';
 export { default as btcSignPsbt } from './btc/BTCSignPsbt';
 export { default as btcSignTransaction } from './btc/BTCSignTransaction';

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/core/index.ts

@@ -1,4 +1,5 @@
 import semver from 'semver';
+import { getOwnedUsbDeviceIdentity } from '../api/SearchDevices';
 import EventEmitter from 'events';
 import {
   DeviceSessionPinType,
@@ -1589,7 +1590,7 @@ const onDeviceConnectHandler = (device: Device) => {
 
 const onDeviceDisconnectHandler = (device: Device) => {
   device.clearPreInitialized();
-  const deviceObject = device.toMessageObject();
+  const deviceObject = device.toDisconnectMessageObject();
   if (!deviceObject) return;
   postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject }));
 };
@@ -1826,6 +1827,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
@@ -2038,6 +2043,8 @@ export const init = async (
   }
 };
 
+let pendingTransportSwitch: Promise<void> = Promise.resolve();
+
 export const switchTransport = ({
   env,
   Transport,
@@ -2047,10 +2054,19 @@ export const switchTransport = ({
   Transport: any;
   plugin?: LowlevelTransportSharedPlugin;
 }) => {
-  DataManager.updateEnv(env);
-  TransportManager.setTransport(Transport, plugin);
-  _deviceList = undefined;
-  DevicePool.resetState();
-  _connector = undefined;
-  initConnector();
+  // Preserve request order while native transport cleanup is pending.
+  const switching = pendingTransportSwitch
+    .catch(() => undefined)
+    .then(async () => {
+      _connector?.stop();
+      await TransportManager.getTransport()?.stop?.();
+      DataManager.updateEnv(env);
+      TransportManager.setTransport(Transport, plugin);
+      _deviceList = undefined;
+      DevicePool.resetState();
+      _connector = undefined;
+      initConnector();
+    });
+  pendingTransportSwitch = switching;
+  return switching;
 };

package/src/data/messages/messages.json

@@ -12485,6 +12485,8 @@
         "(has_bitcoin_only_values)": true
       },
       "values": {
+        "MessageType_BabylonDeriveContextHash": 10054,
+        "MessageType_BabylonDerivedContextHash": 10055,
         "MessageType_Initialize": 0,
         "MessageType_Ping": 1,
         "MessageType_Success": 2,
@@ -12949,6 +12951,55 @@
         "MessageType_UpgradeFileHeader": 10050
       }
     },
+    "CanonicalBitcoinNetwork": {
+      "values": {
+        "BITCOIN_MAINNET": 0,
+        "BITCOIN_TESTNET": 1,
+        "BITCOIN_SIGNET": 2,
+        "BITCOIN_REGTEST": 3
+      }
+    },
+    "BabylonDeriveContextHash": {
+      "fields": {
+        "address_n": {
+          "rule": "repeated",
+          "type": "uint32",
+          "id": 1,
+          "options": {
+            "packed": false
+          }
+        },
+        "script_type": {
+          "rule": "required",
+          "type": "InputScriptType",
+          "id": 2
+        },
+        "app_name": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 3
+        },
+        "context": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 4
+        },
+        "network": {
+          "rule": "required",
+          "type": "CanonicalBitcoinNetwork",
+          "id": 5
+        }
+      }
+    },
+    "BabylonDerivedContextHash": {
+      "fields": {
+        "secret": {
+          "rule": "required",
+          "type": "bytes",
+          "id": 1
+        }
+      }
+    },
     "google": {
       "nested": {
         "protobuf": {

package/src/device/Device.ts

@@ -248,6 +248,9 @@ export class Device extends EventEmitter {
   /** Canonical device-state cache; legacy Features is a compatibility projection. */
   private stateStore = new DeviceStateStore();
 
+  /** Retain the old public identity only for disconnect notifications after wipe. */
+  private deviceBeforeWipe: DeviceTyped | null = null;
+
   /** Force the next initialization to reload DeviceInfo after reconnect or reboot. */
   private protocolV2StateNeedsReload = false;
 
@@ -351,6 +354,8 @@ export class Device extends EventEmitter {
   toMessageObject(): DeviceTyped | null {
     if (this.isUnacquired() || !this.features) return null;
 
+    this.deviceBeforeWipe = null;
+
     const env = DataManager.getSettings('env');
     const deviceType = this.getCurrentDeviceType();
 
@@ -395,6 +400,10 @@ export class Device extends EventEmitter {
     };
   }
 
+  toDisconnectMessageObject(): DeviceTyped | null {
+    return this.toMessageObject() ?? this.deviceBeforeWipe;
+  }
+
   /**
    * Device connect
    * @returns {Promise<boolean>}
@@ -1364,6 +1373,7 @@ export class Device extends EventEmitter {
   }
 
   invalidateAfterWipe() {
+    this.deviceBeforeWipe = this.toMessageObject() ?? this.deviceBeforeWipe;
     const deviceId = this.getCurrentDeviceId();
     if (deviceId) {
       deviceWalletSessionStore.deleteDevice(deviceId);

package/src/device/DevicePool.ts

@@ -114,7 +114,11 @@ export class DevicePool extends EventEmitter {
         const exist = canPathIdentifyDevice(cachedPath)
           ? descriptorList.find(d => d.path === cachedPath)
           : undefined;
-        if (exist && !initOptions?.forceProtocolDetection) {
+        if (
+          exist &&
+          !initOptions?.forceProtocolDetection &&
+          !(device.needReloadDevice && device.isUnacquired())
+        ) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
           await this._refreshRuntimeState(device, initOptions);
@@ -170,7 +174,13 @@ export class DevicePool extends EventEmitter {
     const forceProtocolDetection = initOptions?.forceProtocolDetection === true;
     const isNewDevice = !cachedDevice;
     const device = cachedDevice ?? Device.fromDescriptor(descriptor);
-    if (isNewDevice || forceProtocolDetection) {
+    if (
+      isNewDevice ||
+      forceProtocolDetection ||
+      (device.needReloadDevice && device.isUnacquired())
+    ) {
+      // Wipe invalidates state while the same USB path can remain discoverable.
+      if (cachedDevice) device.updateDescriptor(descriptor, true);
       device.deviceConnector = this.connector;
       // Search/discovery acquires outside Device.run(). Start a new attempt so
       // a previous user cancel does not hide this device from later searches.

package/src/events/logBlockEvent.ts

@@ -11,6 +11,7 @@ export const LogBlockEvent: Set<string> = new Set([
 // These resource/file APIs did not exist in 1.1.32. Skip the payload so
 // the log layer does not copy huge Base64 or binary data.
 const LogPayloadBlockMethod: Set<string> = new Set([
+  'btcDeriveContextHash',
   'deviceUploadNft',
   'deviceUploadWallpaper',
   'uploadPortfolio',

package/src/index.ts

@@ -21,6 +21,7 @@ export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
 export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
 export { getMethodSupportedProtocols } from './api/utils';
+export { probeUsbDeviceIdentitiesWithTransport } from './api/SearchDevices';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,

package/src/inject.ts

@@ -309,6 +309,8 @@ export const createCoreApi = (
     call({ ...params, connectId, deviceId, method: 'btcGetAddress' }),
   btcGetPublicKey: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcGetPublicKey' }),
+  btcDeriveContextHash: (connectId, deviceId, params) =>
+    call({ ...params, connectId, deviceId, method: 'btcDeriveContextHash' }),
   btcSignMessage: (connectId, deviceId, params) =>
     call({ ...params, connectId, deviceId, method: 'btcSignMessage' }),
   btcSignPsbt: (connectId, deviceId, params) =>

package/src/types/api/btcDeriveContextHash.ts

@@ -0,0 +1,15 @@
+import type { BabylonDerivedContextHash } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type BTCDeriveContextHashParams = {
+  path: string | number[];
+  appName: string;
+  context: string;
+  network: 'bitcoin-mainnet' | 'bitcoin-testnet' | 'bitcoin-signet' | 'bitcoin-regtest';
+};
+
+export declare function btcDeriveContextHash(
+  connectId: string,
+  deviceId: string,
+  params: CommonParams & BTCDeriveContextHashParams
+): Response<BabylonDerivedContextHash>;

package/src/types/api/export.ts

@@ -1,5 +1,6 @@
 export type { BTCAddress, BTCGetAddressParams } from './btcGetAddress';
 export type { BTCPublicKey, BTCGetPublicKeyParams } from './btcGetPublicKey';
+export type { BTCDeriveContextHashParams } from './btcDeriveContextHash';
 export type { BTCSignMessageParams } from './btcSignMessage';
 export type { BTCVerifyMessageParams } from './btcVerifyMessage';
 export type {

package/src/types/api/index.ts

@@ -73,6 +73,7 @@ import type { evmSignTypedData } from './evmSignTypedData';
 import type { evmVerifyMessage } from './evmVerifyMessage';
 import type { btcGetAddress } from './btcGetAddress';
 import type { btcGetPublicKey } from './btcGetPublicKey';
+import type { btcDeriveContextHash } from './btcDeriveContextHash';
 import type { btcSignMessage } from './btcSignMessage';
 import type { btcSignPsbt } from './btcSignPsbt';
 import type { btcSignTransaction } from './btcSignTransaction';
@@ -286,6 +287,7 @@ export type CoreApi = {
    */
   btcGetAddress: typeof btcGetAddress;
   btcGetPublicKey: typeof btcGetPublicKey;
+  btcDeriveContextHash: typeof btcDeriveContextHash;
   btcSignMessage: typeof btcSignMessage;
   btcSignPsbt: typeof btcSignPsbt;
   btcSignTransaction: typeof btcSignTransaction;

package/src/types/device.ts

@@ -85,6 +85,16 @@ export type SearchDevice = {
   commType: OneKeyDeviceCommType;
 };
 
+/** Identity confirmed over USB. The descriptor path is only a transport address. */
+export type UsbDeviceIdentity = {
+  path: string;
+  serialNo: string | null;
+  deviceId: string | null;
+  deviceType: IDeviceType;
+  connectProtocol: HardwareConnectProtocol;
+  commType: 'webusb' | 'bridge';
+};
+
 // export type UnknownDevice = {
 //   type: 'unacquired';
 //   id?: null;