@onekeyfe/hd-core 1.2.0-alpha.67 → 1.2.0-alpha.68

package/src/device/DeviceConnector.ts

@@ -14,7 +14,7 @@ import type { OneKeyDeviceInfo as DeviceDescriptor, Transport } from '@onekeyfe/
 const Log = getLogger(LoggerNames.DeviceConnector);
 
 export default class DeviceConnector {
-  transport: Transport;
+  transport?: Transport;
 
   listenTimestamp = 0;
 
@@ -30,9 +30,21 @@ export default class DeviceConnector {
     DevicePool.setConnector(this);
   }
 
+  private getActiveTransport(): Transport {
+    const transport = this.transport ?? TransportManager.getTransport();
+    if (!transport) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportNotConfigured,
+        'Device connector was created before transport initialization'
+      );
+    }
+    this.transport = transport;
+    return transport;
+  }
+
   async enumerate() {
     try {
-      const descriptors = await this.transport.enumerate();
+      const descriptors = await this.getActiveTransport().enumerate();
       this.upcoming = descriptors;
       this._reportDevicesChange();
       return { descriptors } as DeviceDescriptorDiff;
@@ -50,11 +62,10 @@ export default class DeviceConnector {
     let descriptors: DeviceDescriptor[];
 
     try {
+      const transport = this.getActiveTransport();
       Log.debug('Start listening', current);
       this.listenTimestamp = new Date().getTime();
-      descriptors = waitForEvent
-        ? await this.transport.listen(current)
-        : await this.transport.enumerate();
+      descriptors = waitForEvent ? await transport.listen(current) : await transport.enumerate();
       if (!this.listening) return; // do not continue if stop() was called
 
       this.upcoming = descriptors;
@@ -88,16 +99,17 @@ export default class DeviceConnector {
     Log.debug('acquire', path, session, expectedProtocol, protocolHint);
     const env = DataManager.getSettings('env');
     try {
+      const transport = this.getActiveTransport();
       let res;
       if (DataManager.isBleConnect(env)) {
-        res = await this.transport.acquire({
+        res = await transport.acquire({
           uuid: path,
           forceCleanRunPromise,
           expectedProtocol,
           protocolHint,
         });
       } else {
-        res = await this.transport.acquire({
+        res = await transport.acquire({
           path,
           previous: session ?? null,
           expectedProtocol,
@@ -105,7 +117,13 @@ export default class DeviceConnector {
         });
       }
       if (expectedProtocol) {
-        const detectedProtocol = this.transport.getProtocolType(path);
+        // The acquire response is the stable snapshot from this active probe. A delayed
+        // disconnect from an older generation may clear caches, so do not rely on cache alone.
+        const acquiredProtocol =
+          typeof res === 'object' && res !== null
+            ? (res as DeviceDescriptor).protocolType
+            : undefined;
+        const detectedProtocol = acquiredProtocol ?? transport.getProtocolType(path);
         if (detectedProtocol !== expectedProtocol) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
@@ -122,7 +140,7 @@ export default class DeviceConnector {
 
   async release(session: string, onclose: boolean) {
     try {
-      const res = await this.transport.release(session, onclose);
+      const res = await this.getActiveTransport().release(session, onclose);
       return res;
     } catch (error) {
       safeThrowError(error);
@@ -131,8 +149,9 @@ export default class DeviceConnector {
 
   async disconnect(session: string | undefined | null) {
     try {
-      if (this.transport.disconnect && !!session) {
-        await this.transport.disconnect(session);
+      const transport = this.getActiveTransport();
+      if (transport.disconnect && !!session) {
+        await transport.disconnect(session);
       }
     } catch (error) {
       safeThrowError(error);
@@ -140,10 +159,11 @@ export default class DeviceConnector {
   }
 
   promptDeviceAccess(): Promise<USBDevice | BluetoothDevice | null> {
-    if (!this.transport.promptDeviceAccess) {
+    const transport = this.getActiveTransport();
+    if (!transport.promptDeviceAccess) {
       return Promise.resolve(null);
     }
-    return this.transport.promptDeviceAccess();
+    return transport.promptDeviceAccess();
   }
 
   _reportDevicesChange() {

package/src/device/DevicePool.ts

@@ -103,7 +103,7 @@ export class DevicePool extends EventEmitter {
       const device = this.devicesCache[connectId];
       if (device) {
         const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
-        if (exist) {
+        if (exist && !initOptions?.forceProtocolDetection) {
           // Log.debug('find existed Device: ', connectId);
           device.updateDescriptor(exist, true);
           await this._refreshRuntimeState(device, initOptions);
@@ -151,12 +151,23 @@ export class DevicePool extends EventEmitter {
     }
   }
 
-  static async _createDevice(descriptor: DeviceDescriptor, initOptions?: InitOptions) {
-    let device = this.getDeviceByPath(descriptor.path);
-    if (!device) {
-      device = Device.fromDescriptor(descriptor);
+  static async _createDevice(
+    descriptor: DeviceDescriptor,
+    initOptions?: InitOptions
+  ): Promise<Device> {
+    const cachedDevice = this.getDeviceByPath(descriptor.path);
+    const forceProtocolDetection = initOptions?.forceProtocolDetection === true;
+    const isNewDevice = !cachedDevice;
+    const device = cachedDevice ?? Device.fromDescriptor(descriptor);
+    if (isNewDevice || forceProtocolDetection) {
       device.deviceConnector = this.connector;
-      await device.connect(initOptions?.connectProtocol);
+      if (forceProtocolDetection && !isNewDevice) {
+        await device.acquire(initOptions?.connectProtocol, { forceProtocolDetection: true });
+      } else {
+        await device.connect(initOptions?.connectProtocol, {
+          forceProtocolDetection: initOptions?.forceProtocolDetection,
+        });
+      }
       try {
         await device.initialize(initOptions);
         if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {
@@ -181,7 +192,10 @@ export class DevicePool extends EventEmitter {
           refreshError = error;
         }
       },
-      { connectProtocol: initOptions.connectProtocol }
+      {
+        connectProtocol: initOptions.connectProtocol,
+        forceProtocolDetection: initOptions.forceProtocolDetection,
+      }
     );
     if (refreshError instanceof Error) throw refreshError;
     if (refreshError) throw new Error(String(refreshError));

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,4 +1,4 @@
-import { EFirmwareType } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import {
   resolveDeviceBleFirmwareVersion,
@@ -386,7 +386,7 @@ export const buildProtocolV2FeaturesPayload = ({
     device_id: deviceId ?? undefined,
     session_id: cached?.sessionId ?? undefined,
     ble_name: bleName ?? undefined,
-    onekey_device_type: 'PRO2',
+    onekey_device_type: deviceType === EDeviceType.Unknown ? undefined : deviceType.toUpperCase(),
     passphrase_protection: passphraseProtection ?? undefined,
     bootloader_mode: bootloaderMode,
     passphraseState: cached?.passphraseState,

package/src/deviceProfile/protocolV2DeviceIdentity.ts

@@ -26,6 +26,9 @@ export const resolveProtocolV2DeviceIdentity = (
     case DeviceType.PRO2:
     case 'PRO2':
       return { deviceType: EDeviceType.Pro2, model: 'pro2' };
+    case DeviceType.NEO:
+    case 'NEO':
+      return { deviceType: EDeviceType.Neo, model: 'neo' };
     default:
       return { deviceType: EDeviceType.Unknown, model: null };
   }

package/src/events/device.ts

@@ -1,4 +1,5 @@
 import type { MessageFactoryFn } from './utils';
+import type { HardwareUiInteractionMeta } from './ui-request';
 import type { PROTO } from '../constants';
 import type {
   KnownDevice as Device,
@@ -26,6 +27,8 @@ export const DEVICE = {
   // onekey-transport events in protobuf format
   BUTTON: 'button',
   PIN: 'pin',
+  PIN_ON_DEVICE: 'pin_on_device',
+  PIN_ON_DEVICE_COMPLETE: 'pin_on_device_complete',
   PASSPHRASE: 'passphrase',
   PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
   ATTACH_PIN_ON_DEVICE: 'attach_pin_on_device',
@@ -58,6 +61,7 @@ export type PassphraseRequestPayload = {
   source?: 'wallet-session-coordinator';
   reason?: 'open-wallet' | 'session-recovery';
   expectedPassphraseState?: string;
+  interaction?: HardwareUiInteractionMeta;
 };
 
 export interface DeviceButtonRequest {

package/src/events/logBlockEvent.ts

@@ -10,6 +10,7 @@ export const LogBlockEvent: Set<string> = new Set([
 
 const LogLabelMethod: Set<string> = new Set([
   'openWalletSession',
+  'deviceUploadNft',
   'deviceUploadWallpaper',
   'uploadPortfolio',
   'fileWrite',

package/src/events/ui-promise.ts

@@ -1,7 +1,7 @@
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { DEVICE } from './device';
 import type { Device } from '../device/Device';
-import type { UiResponseEvent } from './ui-response';
+import type { UiResponseCorrelation, UiResponseEvent } from './ui-response';
 
 export type UiPromiseResponse =
   | UiResponseEvent
@@ -11,4 +11,6 @@ export type UiPromise<T extends UiPromiseResponse['type']> = Deferred<
   Extract<UiPromiseResponse, { type: T }>,
   T,
   Device
->;
+> & {
+  responseCorrelation?: UiResponseCorrelation;
+};

package/src/events/ui-request.ts

@@ -1,6 +1,7 @@
 import type { PROTO } from '../constants';
 import type { Device } from '../types';
 import type { DeviceButtonRequest } from './device';
+import type { UiResponseCorrelation } from './ui-response';
 import type { MessageFactoryFn } from './utils';
 
 export const UI_EVENT = 'UI_EVENT';
@@ -56,6 +57,17 @@ export type ProtocolV2UiEventSource =
 
 export type ProtocolV2UiCompletion = 'page-accepted' | 'operation-completed';
 
+export type HardwareUiInteractionMeta = {
+  interactionId: string;
+  phaseId: string;
+  sequence: number;
+  phase: 'pin' | 'passphrase' | 'passphrase-on-device' | 'button' | 'processing';
+  transition: 'start' | 'complete' | 'finish';
+  outcome?: 'submitted' | 'succeeded' | 'failed' | 'cancelled' | 'disconnected';
+  protocol: 'V2';
+  device?: Device;
+};
+
 export type ProtocolV2UiEventMetadata = {
   source?: ProtocolV2UiEventSource;
   reason?: string;
@@ -64,12 +76,29 @@ export type ProtocolV2UiEventMetadata = {
   method?: string;
   page?: string | number;
   operation?: string;
+  interaction?: HardwareUiInteractionMeta;
 };
 
+export type UiRequestWindowClose =
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
+      payload: HardwareUiInteractionMeta;
+    }
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW;
+      payload: HardwareUiInteractionMeta;
+    }
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_WINDOW;
+      payload?: undefined;
+    }
+  | {
+      type: typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW;
+      payload?: undefined;
+    };
+
 export interface UiRequestWithoutPayload {
   type:
-    | typeof UI_REQUEST.CLOSE_UI_WINDOW
-    | typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW
     | typeof UI_REQUEST.BLUETOOTH_PERMISSION
     | typeof UI_REQUEST.BLUETOOTH_UNSUPPORTED
     | typeof UI_REQUEST.BLUETOOTH_POWERED_OFF
@@ -93,6 +122,7 @@ export type UiRequestDeviceAction = {
   payload: ProtocolV2UiEventMetadata & {
     device: Device;
     type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry' | 'ButtonRequest_AttachPin';
+    responseCorrelation?: UiResponseCorrelation;
   };
 };
 
@@ -111,6 +141,8 @@ export interface UiRequestPassphrase {
     source?: 'wallet-session-coordinator';
     reason?: 'open-wallet' | 'session-recovery';
     expectedPassphraseState?: string;
+    interaction?: HardwareUiInteractionMeta;
+    responseCorrelation?: UiResponseCorrelation;
   };
 }
 
@@ -121,6 +153,7 @@ export interface UiRequestPassphraseOnDevice {
     passphraseState?: string;
     source?: 'wallet-session-coordinator';
     reason?: 'open-wallet' | 'session-recovery';
+    interaction?: HardwareUiInteractionMeta;
   };
 }
 
@@ -191,6 +224,7 @@ export interface PreviousAddressResult {
 
 export type UiEvent =
   | UiRequestWithoutPayload
+  | UiRequestWindowClose
   | UiRequestDeviceAction
   | UiRequestButton
   | UiRequestPassphraseOnDevice

package/src/events/ui-response.ts

@@ -11,12 +11,22 @@ export const UI_RESPONSE = {
     'ui-receive_select-device-for-switch-firmware-web-device',
 } as const;
 
-export interface UiResponsePin {
+export interface UiResponseCorrelation {
+  interactionId: string;
+  deviceId: string;
+}
+
+export interface UiResponseCorrelationFields {
+  interactionId?: string;
+  deviceId?: string;
+}
+
+export interface UiResponsePin extends UiResponseCorrelationFields {
   type: typeof UI_RESPONSE.RECEIVE_PIN;
   payload: string;
 }
 
-export interface UiResponsePassphrase {
+export interface UiResponsePassphrase extends UiResponseCorrelationFields {
   type: typeof UI_RESPONSE.RECEIVE_PASSPHRASE;
   payload: {
     value: string;

package/src/inject.ts

@@ -9,6 +9,7 @@ import {
   unregisterFirmwareUpdateHostBinding,
 } from './api/firmware/FirmwareHostBinding';
 
+import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type { EventEmitter } from 'events';
 import type { CallMethod } from './events';
 import type { Unsuccessful } from './types';
@@ -50,6 +51,50 @@ export interface InjectApi {
   switchTransport: CoreApi['switchTransport'];
 }
 
+const normalizeConnectId = (connectId: string) => connectId.trim().toLowerCase();
+
+/**
+ * Keeps verified protocols isolated per transport endpoint and injects them at
+ * the single public call boundary, including APIs that do not expose params.
+ */
+export const createProtocolAwareCall = (rawCall: CoreApi['call']) => {
+  const protocolByConnectId = new Map<string, HardwareConnectProtocol>();
+
+  const setDeviceConnectProtocol: CoreApi['setDeviceConnectProtocol'] = (
+    connectId,
+    connectProtocol
+  ) => {
+    const normalizedConnectId = normalizeConnectId(connectId);
+    if (!normalizedConnectId) return;
+    if (connectProtocol) {
+      protocolByConnectId.set(normalizedConnectId, connectProtocol);
+    } else {
+      protocolByConnectId.delete(normalizedConnectId);
+    }
+  };
+
+  const call: CoreApi['call'] = params => {
+    if (!params || typeof params !== 'object') {
+      return rawCall(params);
+    }
+
+    const connectId = typeof params.connectId === 'string' ? params.connectId : undefined;
+    const boundProtocol = connectId
+      ? protocolByConnectId.get(normalizeConnectId(connectId))
+      : undefined;
+    if (
+      boundProtocol &&
+      params.connectProtocol === undefined &&
+      params.forceProtocolDetection !== true
+    ) {
+      return rawCall({ ...params, connectProtocol: boundProtocol });
+    }
+    return rawCall(params);
+  };
+
+  return { call, setDeviceConnectProtocol };
+};
+
 export const inject = ({
   call,
   cancel,
@@ -60,6 +105,7 @@ export const inject = ({
   switchTransport,
   uiResponse,
 }: InjectApi): CoreApi => {
+  const protocolAwareCall = createProtocolAwareCall(call);
   const api: CoreApi = {
     on: <T extends string, P extends (...args: any[]) => any>(type: T, fn: P) => {
       eventEmitter.on(type, fn);
@@ -77,7 +123,9 @@ export const inject = ({
 
     init,
 
-    call,
+    call: protocolAwareCall.call,
+
+    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
     dispose: async () => {
       unregisterFirmwareUpdateHostBinding();
@@ -92,7 +140,7 @@ export const inject = ({
 
     switchTransport,
 
-    ...createCoreApi(call),
+    ...createCoreApi(protocolAwareCall.call),
   };
   return api;
 };
@@ -107,6 +155,7 @@ export const createCoreApi = (
   | 'removeAllListeners'
   | 'init'
   | 'call'
+  | 'setDeviceConnectProtocol'
   | 'dispose'
   | 'uiResponse'
   | 'cancel'
@@ -125,6 +174,12 @@ export const createCoreApi = (
    * 搜索设备
    */
   searchDevices: params => call({ ...params, method: 'searchDevices' }),
+  detectDeviceConnectProtocol: connectId =>
+    call({
+      connectId,
+      method: 'detectDeviceConnectProtocol',
+      forceProtocolDetection: true,
+    }),
 
   /**
    * 获取设备信息
@@ -182,6 +237,7 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
   deviceUploadWallpaper: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceUploadWallpaper' }),
+  deviceUploadNft: (connectId, params) => call({ ...params, connectId, method: 'deviceUploadNft' }),
   uploadPortfolio: (connectId, params) => call({ ...params, connectId, method: 'uploadPortfolio' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),

package/src/lowLevelInject.ts

@@ -1,4 +1,4 @@
-import { createCoreApi } from './inject';
+import { createCoreApi, createProtocolAwareCall } from './inject';
 import { unregisterFirmwareUpdateHostBinding } from './api/firmware/FirmwareHostBinding';
 
 import type { EventEmitter } from 'events';
@@ -34,6 +34,7 @@ export const lowLevelInject = ({
   switchTransport,
   addHardwareGlobalEventListener,
 }: LowLevelInjectApi): LowLevelCoreApi => {
+  const protocolAwareCall = createProtocolAwareCall(call);
   const api: LowLevelCoreApi = {
     addHardwareGlobalEventListener,
     removeAllListeners: type => {
@@ -42,7 +43,9 @@ export const lowLevelInject = ({
 
     init,
 
-    call,
+    call: protocolAwareCall.call,
+
+    setDeviceConnectProtocol: protocolAwareCall.setDeviceConnectProtocol,
 
     dispose: async () => {
       unregisterFirmwareUpdateHostBinding();
@@ -59,7 +62,7 @@ export const lowLevelInject = ({
 
     emit: () => {},
 
-    ...createCoreApi(call),
+    ...createCoreApi(protocolAwareCall.call),
   };
   return api;
 };

package/src/protocols/protocol-v2/features.ts

@@ -107,10 +107,6 @@ export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
     hw: true,
     fw: true,
     coprocessor: true,
-    se1: true,
-    se2: true,
-    se3: true,
-    se4: true,
   },
   types: {
     version: true,
@@ -157,7 +153,7 @@ export const PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST = {
 };
 
 export const PROTOCOL_V2_DEVICE_INFO_REQUEST = PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST;
-export const PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS = 10 * 1000;
+export const PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS = 30 * 1000;
 
 export async function requestProtocolV2ProtocolInfo({
   commands,
@@ -168,8 +164,15 @@ export async function requestProtocolV2ProtocolInfo({
 }): Promise<ProtocolInfo> {
   const response =
     timeoutMs === undefined
-      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {})
-      : await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {}, { timeoutMs });
+      ? await commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+          eventless_wallet_session: true,
+        })
+      : await commands.typedCall(
+          'ProtocolInfoRequest',
+          'ProtocolInfo',
+          { eventless_wallet_session: true },
+          { timeoutMs }
+        );
   return response.message;
 }
 

package/src/protocols/protocol-v2/firmware.ts

@@ -15,5 +15,7 @@ export const ProtocolV2FirmwareTargetType = {
   FW_MGMT_TARGET_SE04: 10,
 } as const;
 
+// 这里有意同时导出同名值与类型，以保持现有公共 API 不变。
+// eslint-disable-next-line @typescript-eslint/no-redeclare
 export type ProtocolV2FirmwareTargetType =
   (typeof ProtocolV2FirmwareTargetType)[keyof typeof ProtocolV2FirmwareTargetType];