@onekeyfe/hd-core 0.1.25 → 0.1.28

package/src/device/DeviceList.ts

@@ -1,13 +1,7 @@
 import EventEmitter from 'events';
 import DeviceConnector from './DeviceConnector';
 import { Device } from './Device';
-import { getDeviceUUID } from '../utils/deviceFeaturesUtils';
-import { getLogger, LoggerNames } from '../utils';
-
-// const cacheDeviceMap = new Map<string, Device>();
-const cacheDeviceMap: Record<string, Device> = {};
-
-const Log = getLogger(LoggerNames.DeviceList);
+import { DevicePool } from './DevicePool';
 
 export class DeviceList extends EventEmitter {
   devices: Record<string, Device> = {};
@@ -23,44 +17,9 @@ export class DeviceList extends EventEmitter {
     const descriptorList = deviceDiff?.descriptors ?? [];
 
     this.devices = {};
-    const deviceList = [];
-    Log.debug('get device list');
-
-    // find existed device
-    if (connectId) {
-      const device = cacheDeviceMap[connectId];
-      if (device) {
-        const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
-        if (exist) {
-          device.updateDescriptor(exist, true);
-          Log.debug('find existed Device: ', connectId);
-          this.devices[connectId] = device;
-          return [device];
-        }
-      }
-    }
-
-    for await (const descriptor of descriptorList) {
-      let device = Device.fromDescriptor(descriptor);
-      device.deviceConnector = this.connector;
-      await device.connect();
-      await device.initialize();
-      await device.release();
-
-      // clean session after release
-      deviceList.push(device);
-      if (device.features) {
-        const uuid = getDeviceUUID(device.features);
-        if (cacheDeviceMap[uuid]) {
-          const cache = cacheDeviceMap[uuid];
-          cache?.updateFromCache(device);
-          device = cache;
-        }
-        this.devices[uuid] = device;
-        cacheDeviceMap[uuid] = device;
-      }
-    }
 
+    const { deviceList, devices } = await DevicePool.getDevices(descriptorList, connectId);
+    this.devices = devices;
     return deviceList;
   }
 

package/src/device/DevicePool.ts

@@ -0,0 +1,243 @@
+import EventEmitter from 'events';
+import { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+// eslint-disable-next-line import/no-cycle
+import { Device } from './Device';
+import { DEVICE } from '../events';
+import type DeviceConnector from './DeviceConnector';
+import { getDeviceUUID, getLogger, LoggerNames } from '../utils';
+
+const Log = getLogger(LoggerNames.DevicePool);
+
+export type DeviceDescriptorDiff = {
+  didUpdate: boolean;
+  connected: DeviceDescriptor[];
+  disconnected: DeviceDescriptor[];
+  changedSessions: DeviceDescriptor[];
+  changedDebugSessions: DeviceDescriptor[];
+  acquired: DeviceDescriptor[];
+  debugAcquired: DeviceDescriptor[];
+  released: DeviceDescriptor[];
+  debugReleased: DeviceDescriptor[];
+  descriptors: DeviceDescriptor[];
+};
+
+const getDiff = (
+  current: DeviceDescriptor[],
+  descriptors: DeviceDescriptor[]
+): DeviceDescriptorDiff => {
+  const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
+  const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
+  const changedSessions = descriptors.filter(d => {
+    const currentDescriptor = current.find(x => x.path === d.path);
+    if (currentDescriptor) {
+      // return currentDescriptor.debug ? (currentDescriptor.debugSession !== d.debugSession) : (currentDescriptor.session !== d.session);
+      return currentDescriptor.session !== d.session;
+    }
+    return false;
+  });
+  const acquired = changedSessions.filter(d => typeof d.session === 'string');
+  const released = changedSessions.filter(
+    d =>
+      // const session = descriptor.debug ? descriptor.debugSession : descriptor.session;
+      typeof d.session !== 'string'
+  );
+
+  const changedDebugSessions = descriptors.filter(d => {
+    const currentDescriptor = current.find(x => x.path === d.path);
+    if (currentDescriptor) {
+      return currentDescriptor.debugSession !== d.debugSession;
+    }
+    return false;
+  });
+  const debugAcquired = changedSessions.filter(d => typeof d.debugSession === 'string');
+  const debugReleased = changedSessions.filter(d => typeof d.debugSession !== 'string');
+
+  const didUpdate =
+    connected.length + disconnected.length + changedSessions.length + changedDebugSessions.length >
+    0;
+
+  return {
+    connected,
+    disconnected,
+    changedSessions,
+    acquired,
+    released,
+    changedDebugSessions,
+    debugAcquired,
+    debugReleased,
+    didUpdate,
+    descriptors,
+  };
+};
+
+export class DevicePool extends EventEmitter {
+  static current: DeviceDescriptor[] | null = null;
+
+  static upcoming: DeviceDescriptor[] = [];
+
+  static connectedPool: DeviceDescriptor[] = [];
+
+  static disconnectPool: DeviceDescriptor[] = [];
+
+  static devicesCache: Record<string, Device> = {};
+
+  static emitter = new EventEmitter();
+
+  static connector: DeviceConnector;
+
+  static setConnector(connector: DeviceConnector) {
+    this.connector = connector;
+  }
+
+  static async getDevices(descriptorList: DeviceDescriptor[], connectId?: string) {
+    Log.debug('get device list');
+
+    const devices: Record<string, Device> = {};
+    const deviceList = [];
+
+    // If there is a connectId
+    // it means that you only want to get data from cache
+    if (connectId) {
+      const device = this.devicesCache[connectId];
+      if (device) {
+        const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
+        if (exist) {
+          Log.debug('find existed Device: ', connectId);
+          device.updateDescriptor(exist, true);
+          devices[connectId] = device;
+          deviceList.push(device);
+          await this._checkDevicePool();
+          return { devices, deviceList };
+        }
+        Log.debug('found device in cache, but path is different: ', connectId);
+      }
+    }
+
+    for await (const descriptor of descriptorList) {
+      const device = await this._createDevice(descriptor);
+
+      if (device.features) {
+        const uuid = getDeviceUUID(device.features);
+        if (this.devicesCache[uuid]) {
+          const cache = this.devicesCache[uuid];
+          cache.updateDescriptor(descriptor, true);
+        }
+        this.devicesCache[uuid] = device;
+        devices[uuid] = device;
+      }
+
+      deviceList.push(device);
+    }
+    Log.debug('get devices result : ', devices, deviceList);
+    console.log('device poll -> connected: ', this.connectedPool);
+    console.log('device poll -> disconnected: ', this.disconnectPool);
+    await this._checkDevicePool();
+    return { devices, deviceList };
+  }
+
+  static async _createDevice(descriptor: DeviceDescriptor) {
+    let device = this.getDeviceByPath(descriptor.path);
+    if (!device) {
+      device = Device.fromDescriptor(descriptor);
+      device.deviceConnector = this.connector;
+      await device.connect();
+      await device.initialize();
+      await device.release();
+    }
+    return device;
+  }
+
+  static async _checkDevicePool() {
+    await this._sendConnectMessage();
+    this._sendDisconnectMessage();
+  }
+
+  static async _sendConnectMessage() {
+    for (let i = this.connectedPool.length - 1; i >= 0; i--) {
+      const descriptor = this.connectedPool[i];
+      const device = await this._createDevice(descriptor);
+      Log.debug('emit DEVICE.CONNECT: ', device);
+      this.emitter.emit(DEVICE.CONNECT, device);
+      this.connectedPool.splice(i, 1);
+    }
+  }
+
+  static _sendDisconnectMessage() {
+    for (let i = this.disconnectPool.length - 1; i >= 0; i--) {
+      const descriptor = this.connectedPool[i];
+      const device = this.getDeviceByPath(descriptor.path);
+      if (device) {
+        this.emitter.emit(DEVICE.DISCONNECT, device);
+      }
+      this.disconnectPool.splice(i, 1);
+    }
+  }
+
+  static reportDeviceChange(upcoming: DeviceDescriptor[]) {
+    const diff = getDiff(this.current || [], upcoming);
+
+    this.upcoming = upcoming;
+    this.current = this.upcoming;
+
+    console.log('device pool -> current: ', this.current);
+    console.log('device pool -> upcomming: ', this.upcoming);
+    console.log('DeviceCache.reportDeviceChange diff: ', diff);
+
+    if (!diff.didUpdate) {
+      return;
+    }
+
+    diff.connected.forEach(d => {
+      const device = this.getDeviceByPath(d.path);
+      if (!device) {
+        this._addConnectedDeviceToPool(d);
+        return;
+      }
+      Log.debug('emit DEVICE.CONNECT: ', device);
+      this.emitter.emit(DEVICE.CONNECT, device);
+    });
+
+    diff.disconnected.forEach(d => {
+      this._removeDeviceFromConnectedPool(d.path);
+      const device = this.getDeviceByPath(d.path);
+      if (!device) {
+        this._addDisconnectedDeviceToPool(d);
+        return;
+      }
+
+      Log.debug('emit DEVICE.DISCONNECT: ', device);
+      this.emitter.emit(DEVICE.DISCONNECT, device);
+    });
+  }
+
+  static getDeviceByPath(path: string) {
+    return Object.values(this.devicesCache).find(d => d.originalDescriptor.path === path);
+  }
+
+  static _addConnectedDeviceToPool(descriptor: DeviceDescriptor) {
+    const existDescriptorIndex = this.connectedPool.findIndex(d => d.path === descriptor.path);
+    if (existDescriptorIndex > -1) {
+      this.connectedPool.splice(existDescriptorIndex, 1, descriptor);
+      return;
+    }
+
+    this.connectedPool.push(descriptor);
+  }
+
+  static _removeDeviceFromConnectedPool(path: string) {
+    const index = this.connectedPool.findIndex(d => d.path === path);
+    if (index > -1) {
+      this.connectedPool.splice(index, 1);
+    }
+  }
+
+  static _addDisconnectedDeviceToPool(descriptor: DeviceDescriptor) {
+    const existDescriptorIndex = this.disconnectPool.findIndex(d => d.path === descriptor.path);
+    if (existDescriptorIndex > -1) {
+      this.disconnectPool.splice(existDescriptorIndex, 1, descriptor);
+      return;
+    }
+
+    this.disconnectPool.push(descriptor);
+  }
+}

package/src/events/device.ts

@@ -1,5 +1,5 @@
 import type { PROTO } from '../constants';
-import type { Features, KnownDevice as Device } from '../types/device';
+import type { Features, KnownDevice as Device, SupportFeatures } from '../types/device';
 import { MessageFactoryFn } from './utils';
 
 export const DEVICE_EVENT = 'DEVICE_EVENT';
@@ -24,10 +24,21 @@ export const DEVICE = {
   PASSPHRASE: 'passphrase',
   PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
   WORD: 'word',
+  SUPPORT_FEATURES: 'support_features',
 
   FEATURES: 'features',
 } as const;
 
+export interface DeviceConnnectRequest {
+  type: typeof DEVICE.CONNECT;
+  payload: { device: Device };
+}
+
+export interface DeviceDisconnnectRequest {
+  type: typeof DEVICE.DISCONNECT;
+  payload: { device: Device };
+}
+
 export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'code'> {
   code?: PROTO.ButtonRequest['code'] | 'ButtonRequest_FirmwareUpdate';
 }
@@ -44,7 +55,18 @@ export interface DeviceSendFeatures {
   payload: DeviceFeaturesPayload;
 }
 
-export type DeviceEvent = DeviceButtonRequest | DeviceSendFeatures;
+export type DeviceSupportFeaturesPayload = SupportFeatures & { device: Device | null };
+export interface DeviceSendSupportFeatures {
+  type: typeof DEVICE.SUPPORT_FEATURES;
+  payload: DeviceSupportFeaturesPayload;
+}
+
+export type DeviceEvent =
+  | DeviceButtonRequest
+  | DeviceSendFeatures
+  | DeviceSendSupportFeatures
+  | DeviceDisconnnectRequest
+  | DeviceConnnectRequest;
 
 export type DeviceEventMessage = DeviceEvent & { event: typeof DEVICE_EVENT };
 

package/src/inject.ts

@@ -85,6 +85,7 @@ export const inject = ({
     deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
     deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),
     deviceUpdateReboot: connectId => call({ connectId, method: 'deviceUpdateReboot' }),
+    deviceSupportFeatures: connectId => call({ connectId, method: 'deviceSupportFeatures' }),
     deviceVerify: (connectId, params) => call({ ...params, connectId, method: 'deviceVerify' }),
     deviceWipe: connectId => call({ connectId, method: 'deviceWipe' }),
 
@@ -141,6 +142,7 @@ export const inject = ({
       call({ ...params, connectId, deviceId, method: 'stellarSignTransaction' }),
 
     firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
+    requestWebUsbDevice: () => call({ method: 'requestWebUsbDevice' }),
   };
   return api;
 };

package/src/types/api/deviceSupportFeatures.ts

@@ -0,0 +1,6 @@
+import type { Response } from '../params';
+import type { Device, SupportFeatures } from '../device';
+
+export type DeviceSupportFeatures = SupportFeatures & { device: Device | null };
+
+export declare function deviceSupportFeatures(connectId?: string): Response<DeviceSupportFeatures>;

package/src/types/api/export.ts

@@ -19,6 +19,7 @@ export type { DeviceRecoveryParams } from './deviceRecovery';
 export type { DeviceResetParams } from './deviceReset';
 export type { DeviceSettingsParams } from './deviceSettings';
 export type { DeviceVerifyParams, DeviceVerifySignature } from './deviceVerify';
+export type { DeviceSupportFeatures } from './deviceSupportFeatures';
 
 export type { EVMAddress, EVMGetAddressParams } from './evmGetAddress';
 export type { EVMPublicKey, EVMGetPublicKeyParams } from './evmGetPublicKey';

package/src/types/api/index.ts

@@ -43,6 +43,8 @@ import { stellarSignTransaction } from './stellarSignTransaction';
 import { cipherKeyValue } from './cipherKeyValue';
 import { firmwareUpdate } from './firmwareUpdate';
 import { getLogs } from './getLogs';
+import { deviceSupportFeatures } from './deviceSupportFeatures';
+import { requestWebUsbDevice } from './requestWebUsbDevice';
 
 export * from './export';
 
@@ -65,6 +67,8 @@ export type CoreApi = {
    */
   searchDevices: typeof searchDevices;
 
+  requestWebUsbDevice: typeof requestWebUsbDevice;
+
   getFeatures: typeof getFeatures;
 
   checkFirmwareRelease: typeof checkFirmwareRelease;
@@ -85,6 +89,7 @@ export type CoreApi = {
   deviceReset: typeof deviceReset;
   deviceSettings: typeof deviceSettings;
   deviceUpdateReboot: typeof deviceUpdateReboot;
+  deviceSupportFeatures: typeof deviceSupportFeatures;
   deviceVerify: typeof deviceVerify;
   deviceWipe: typeof deviceWipe;
 

package/src/types/api/requestWebUsbDevice.ts

@@ -0,0 +1,4 @@
+import { KnownDevice } from '../device';
+import { Response } from '../params';
+
+export declare function requestWebUsbDevice(): Response<{ device: KnownDevice }>;

package/src/types/device.ts

@@ -130,3 +130,7 @@ type FeaturesNarrowing =
     };
 
 export type StrictFeatures = Features & FeaturesNarrowing;
+
+export type SupportFeatures = {
+  inputPinOnSoftware: boolean;
+};

package/src/types/settings.ts

@@ -14,7 +14,7 @@ export type ConnectSettings = {
   priority: number;
   trustedHost: boolean;
   supportedBrowser?: boolean;
-  env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native';
+  env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native' | 'webusb';
   timestamp: number;
   isFrame?: boolean;
 };

package/src/utils/deviceFeaturesUtils.ts

@@ -1,3 +1,4 @@
+import semver from 'semver';
 import type { Features, IVersionArray, IDeviceType, IDeviceModel } from '../types';
 
 export const getDeviceModel = (features?: Features): IDeviceModel => {
@@ -80,5 +81,20 @@ export const getDeviceBLEFirmwareVersion = (features: Features): IVersionArray |
   if (!features.ble_ver) {
     return null;
   }
+  if (!semver.valid(features.ble_ver)) {
+    return null;
+  }
   return features.ble_ver.split('.') as unknown as IVersionArray;
 };
+
+export const supportInputPinOnSoftware = (features: Features): boolean => {
+  if (!features) return false;
+
+  const deviceType = getDeviceType(features);
+  if (deviceType === 'touch') {
+    return false;
+  }
+
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+  return semver.gte(currentVersion, '2.3.0');
+};

package/src/utils/logger.ts

@@ -151,6 +151,8 @@ export enum LoggerNames {
   DeviceCommands = 'DeviceCommands',
   DeviceConnector = 'DeviceConnector',
   DeviceList = 'DeviceList',
+  DevicePool = 'DevicePool',
+  HdCommonConnectSdk = '@onekey/common-connect-sdk',
   HdBleSdk = '@onekey/hd-ble-sdk',
   HdTransportHttp = '@onekey/hd-transport-http',
   HdBleTransport = '@onekey/hd-ble-transport',
@@ -167,6 +169,7 @@ export const LoggerMap = {
   [LoggerNames.DeviceCommands]: initLog(LoggerNames.DeviceCommands),
   [LoggerNames.DeviceConnector]: initLog(LoggerNames.DeviceConnector),
   [LoggerNames.DeviceList]: initLog(LoggerNames.DeviceList),
+  [LoggerNames.DevicePool]: initLog(LoggerNames.DevicePool),
   [LoggerNames.HdBleSdk]: initLog(LoggerNames.HdBleSdk),
   [LoggerNames.HdTransportHttp]: initLog(LoggerNames.HdTransportHttp),
   [LoggerNames.HdBleTransport]: initLog(LoggerNames.HdBleTransport),
@@ -174,6 +177,7 @@ export const LoggerMap = {
   [LoggerNames.Iframe]: initLog(LoggerNames.Iframe),
   [LoggerNames.SendMessage]: initLog(LoggerNames.SendMessage),
   [LoggerNames.Method]: initLog(LoggerNames.Method),
+  [LoggerNames.HdCommonConnectSdk]: initLog(LoggerNames.Method),
 };
 
 export const getLogger = (key: LoggerNames) => LoggerMap[key];