@onekeyfe/hd-core 0.0.1

package/src/device/DeviceConnector.ts

@@ -0,0 +1,173 @@
+import { Transport, OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import { DataManager } from '../data-manager';
+import TransportManager from '../data-manager/TransportManager';
+import { initLog } from '../utils';
+import { resolveAfter } from '../utils/promiseUtils';
+
+export type DeviceDescriptorDiff = {
+  didUpdate: boolean;
+  connected: DeviceDescriptor[];
+  disconnected: DeviceDescriptor[];
+  changedSessions: DeviceDescriptor[];
+  changedDebugSessions: DeviceDescriptor[];
+  acquired: DeviceDescriptor[];
+  debugAcquired: DeviceDescriptor[];
+  released: DeviceDescriptor[];
+  debugReleased: DeviceDescriptor[];
+  descriptors: DeviceDescriptor[];
+};
+
+const Log = initLog('DeviceConnector');
+
+const getDiff = (
+  current: DeviceDescriptor[],
+  descriptors: DeviceDescriptor[]
+): DeviceDescriptorDiff => {
+  const env = DataManager.getSettings('env');
+  if (env === 'react-native') {
+    return {
+      descriptors,
+    } as 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 default class DeviceConnector {
+  transport: Transport;
+
+  listenTimestamp = 0;
+
+  current: DeviceDescriptor[] | null = null;
+
+  upcoming: DeviceDescriptor[] = [];
+
+  listening = false;
+
+  constructor() {
+    TransportManager.load();
+    this.transport = TransportManager.getTransport();
+  }
+
+  async enumerate() {
+    try {
+      this.upcoming = await this.transport.enumerate();
+      const diff = this._reportDevicesChange();
+      Log.debug('diff result: ', diff);
+      return diff;
+    } catch (error) {
+      throw new Error(error);
+      // empty
+    }
+  }
+
+  async listen() {
+    const waitForEvent = this.current !== null;
+    const current: DeviceDescriptor[] = this.current || [];
+
+    this.listening = true;
+
+    let descriptors: DeviceDescriptor[];
+
+    try {
+      Log.debug('Start listening', current);
+      this.listenTimestamp = new Date().getTime();
+      descriptors = waitForEvent
+        ? await this.transport.listen(current)
+        : await this.transport.enumerate();
+      if (!this.listening) return; // do not continue if stop() was called
+
+      this.upcoming = descriptors;
+      Log.debug('Listen result', descriptors);
+      this._reportDevicesChange();
+      if (this.listening) this.listen(); // handlers might have called stop()
+    } catch (error) {
+      const time = new Date().getTime() - this.listenTimestamp;
+      Log.debug('Listen error', 'timestamp', time, typeof error);
+
+      if (time > 1100) {
+        await resolveAfter(1000, null);
+        if (this.listening) this.listen();
+      } else {
+        Log.warn('Transport error');
+      }
+    }
+  }
+
+  stop() {
+    this.listening = false;
+  }
+
+  async acquire(path: string, session?: string | null) {
+    console.log('acquire', path, session);
+    const env = DataManager.getSettings('env');
+    try {
+      let res;
+      if (env === 'react-native') {
+        res = await this.transport.acquire({ uuid: path });
+      } else {
+        res = await this.transport.acquire({ path, previous: session ?? null });
+      }
+      return res;
+    } catch (error) {
+      throw new Error(error);
+    }
+  }
+
+  async release(session: string, onclose: boolean) {
+    try {
+      const res = await this.transport.release(session, onclose);
+      return res;
+    } catch (error) {
+      throw new Error(error);
+    }
+  }
+
+  _reportDevicesChange() {
+    const diff = getDiff(this.current || [], this.upcoming);
+    this.current = this.upcoming;
+    return diff;
+  }
+}

package/src/device/DeviceList.ts

@@ -0,0 +1,47 @@
+import EventEmitter from 'events';
+import DeviceConnector from './DeviceConnector';
+import { Device } from './Device';
+import { getDeviceUUID } from '../utils/deviceFeaturesUtils';
+
+export class DeviceList extends EventEmitter {
+  devices: Record<string, Device> = {};
+
+  connector?: DeviceConnector;
+
+  /**
+   * 获取已连接的设备列表
+   * @returns {OneKeyDeviceInfo[]}
+   */
+  async getDeviceLists() {
+    const deviceDiff = await this.connector?.enumerate();
+    const descriptorList = deviceDiff?.descriptors ?? [];
+
+    this.devices = {};
+    const deviceList = [];
+    console.log('get device list');
+    for await (const descriptor of descriptorList) {
+      const 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);
+        this.devices[uuid] = device;
+      }
+    }
+
+    return deviceList;
+  }
+
+  allDevices(): Device[] {
+    return Object.keys(this.devices).map(key => this.devices[key]);
+  }
+
+  getDevice(connectId: string) {
+    return this.devices[connectId];
+  }
+}

package/src/events/call.ts

@@ -0,0 +1,72 @@
+import { serializeError } from '../constants/errors';
+import { IFRAME } from './iframe';
+import { CommonParams, CoreApi } from '../types';
+
+type UnwrappedResponse<T> = T extends Promise<infer R>
+  ? R extends { success: true; payload: infer P }
+    ? P
+    : never
+  : void;
+
+type OverloadedMethod<T, E extends Record<string, string>> = T extends {
+  (params: infer P1): infer R1;
+  (params: infer P2): infer R2;
+}
+  ? ((params: P1 & E) => R1) | ((params: P2 & E) => R2) // - method IS overloaded, result depends on params (example: getAddress)
+  : T extends (...args: infer P) => infer R
+  ? (params: E & P[0]) => R // - method in NOT overloaded, one set of params and one set of result (example: signTransaction)
+  : never;
+
+type UnwrappedMethod<T, M extends Record<string, string>> = T extends () => infer R
+  ? (params: M & CommonParams) => R // - method doesn't have params (example: dispose, disableWebUSB)
+  : OverloadedMethod<T, M>;
+
+type IsMethodCallable<T> = T extends (...args: any[]) => infer R
+  ? R extends Promise<{ success: boolean }>
+    ? R
+    : never
+  : never;
+
+type CallApi = {
+  [K in keyof CoreApi]: IsMethodCallable<CoreApi[K]> extends never
+    ? never
+    : UnwrappedMethod<CoreApi[K], { method: K }>;
+};
+
+export type CallMethodUnion = CallApi[keyof CallApi];
+export type CallMethodPayload = Parameters<CallMethodUnion>[0];
+export type CallMethodResponse<M extends keyof CallApi> = UnwrappedResponse<ReturnType<CallApi[M]>>;
+export type CallMethodAnyResponse = ReturnType<CallMethodUnion>;
+
+export type CallMethod = (params: CallMethodPayload) => Promise<any>;
+
+export interface IFrameCallMessage {
+  event: typeof IFRAME.CALL;
+  type: typeof IFRAME.CALL;
+  payload: CallMethodPayload;
+}
+
+export const RESPONSE_EVENT = 'RESPONSE_EVENT';
+
+export interface MethodResponseMessage {
+  event: typeof RESPONSE_EVENT;
+  type: typeof RESPONSE_EVENT;
+  id: number;
+  success: boolean;
+  payload: any;
+}
+
+export const createResponseMessage = (
+  id: number,
+  success: boolean,
+  payload: any
+): MethodResponseMessage => ({
+  event: RESPONSE_EVENT,
+  type: RESPONSE_EVENT,
+  id,
+  success,
+
+  payload: success ? payload : serializeError(payload),
+});
+
+export type CallMethodKeys = keyof CoreApi;

package/src/events/core.ts

@@ -0,0 +1,41 @@
+import { Unsuccessful } from '../types/params';
+import { IFrameCallMessage } from './call';
+import { IFrameEventMessage } from './iframe';
+import { UiEventMessage } from './ui-request';
+import { UiResponseMessage } from './ui-response';
+
+export const CORE_EVENT = 'CORE_EVENT';
+
+export type CoreMessage = {
+  id?: string;
+  success?: true | false;
+} & (IFrameEventMessage | IFrameCallMessage | UiResponseMessage | UiEventMessage);
+
+export type PostMessageEvent = MessageEvent<any>;
+
+export const parseMessage = (messageData: any): CoreMessage => {
+  const { data } = messageData;
+  const message: CoreMessage = {
+    event: data.event,
+    type: data.type,
+    payload: data.payload,
+  };
+
+  if (typeof messageData.id === 'number') {
+    message.id = messageData.id;
+  }
+
+  if (typeof message.success === 'boolean') {
+    message.success = data.success;
+  }
+
+  return message;
+};
+
+export const createErrorMessage = (error: Error & { code?: string }): Unsuccessful => ({
+  success: false,
+  payload: {
+    error: error.message,
+    code: error.code,
+  },
+});

package/src/events/device.ts

@@ -0,0 +1,28 @@
+import type { PROTO } from '../constants';
+
+export const DEVICE = {
+  // device list events
+  CONNECT: 'device-connect',
+  CONNECT_UNACQUIRED: 'device-connect_unacquired',
+  DISCONNECT: 'device-disconnect',
+  CHANGED: 'device-changed',
+  ACQUIRE: 'device-acquire',
+  RELEASE: 'device-release',
+  ACQUIRED: 'device-acquired',
+  RELEASED: 'device-released',
+  USED_ELSEWHERE: 'device-used_elsewhere',
+  UNREADABLE: 'unreadable-device',
+
+  LOADING: 'device-loading',
+
+  // onekey-transport events in protobuf format
+  BUTTON: 'button',
+  PIN: 'pin',
+  PASSPHRASE: 'passphrase',
+  PASSPHRASE_ON_DEVICE: 'passphrase_on_device',
+  WORD: 'word',
+} as const;
+
+export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'code'> {
+  code?: PROTO.ButtonRequest['code'] | 'ButtonRequest_FirmwareUpdate';
+}

package/src/events/iframe.ts

@@ -0,0 +1,34 @@
+import type { ConnectSettings } from '../types';
+import { UI_EVENT } from './ui-request';
+import { MessageFactoryFn } from './utils';
+
+export const IFRAME = {
+  INIT: 'iframe-init',
+  INIT_BRIDGE: 'iframe-init-bridge',
+  CALL: 'iframe-call',
+} as const;
+
+export interface IFrameInit {
+  type: typeof IFRAME.INIT;
+  payload: {
+    settings: ConnectSettings;
+  };
+}
+
+export interface IFrameBridge {
+  type: typeof IFRAME.INIT_BRIDGE;
+  payload: unknown;
+}
+
+export type IFrameEvent = IFrameInit | IFrameBridge;
+export type IFrameEventMessage = IFrameEvent & { event: typeof UI_EVENT };
+
+export const createIFrameMessage: MessageFactoryFn<typeof UI_EVENT, IFrameEvent> = (
+  type,
+  payload
+) =>
+  ({
+    event: UI_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/index.ts

@@ -0,0 +1,7 @@
+export * from './core';
+export * from './iframe';
+export * from './call';
+export * from './ui-request';
+export * from './ui-promise';
+export * from './ui-response';
+export * from './device';

package/src/events/ui-promise.ts

@@ -0,0 +1,14 @@
+import type { DEVICE } from './device';
+import type { Device } from '../device/Device';
+import type { UiResponseEvent } from './ui-response';
+import type { Deferred } from '../utils/deferred';
+
+export type UiPromiseResponse =
+  | UiResponseEvent
+  | { type: typeof DEVICE.DISCONNECT; payload?: undefined };
+
+export type UiPromise<T extends UiPromiseResponse['type']> = Deferred<
+  Extract<UiPromiseResponse, { type: T }>,
+  T,
+  Device
+>;

package/src/events/ui-request.ts

@@ -0,0 +1,28 @@
+import type { PROTO } from '../constants';
+import type { Device } from '../types';
+import type { MessageFactoryFn } from './utils';
+
+export const UI_EVENT = 'UI_EVENT';
+
+export const UI_REQUEST = {
+  REQUEST_PIN: 'ui-request_pin',
+} as const;
+
+export type UiRequestDeviceAction = {
+  type: typeof UI_REQUEST.REQUEST_PIN;
+  payload: {
+    device: Device;
+    type?: PROTO.PinMatrixRequestType;
+  };
+};
+
+export type UiEvent = UiRequestDeviceAction;
+
+export type UiEventMessage = UiEvent & { event: typeof UI_EVENT };
+
+export const createUiMessage: MessageFactoryFn<typeof UI_EVENT, UiEvent> = (type, payload) =>
+  ({
+    event: UI_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/ui-response.ts

@@ -0,0 +1,25 @@
+import { UI_EVENT } from './ui-request';
+import type { MessageFactoryFn } from './utils';
+
+export const UI_RESPONSE = {
+  RECEIVE_PIN: 'ui-receive_pin',
+} as const;
+
+export interface UiResponsePin {
+  type: typeof UI_RESPONSE.RECEIVE_PIN;
+  payload: string;
+}
+
+export type UiResponseEvent = UiResponsePin;
+
+export type UiResponseMessage = UiResponseEvent & { event: typeof UI_EVENT };
+
+export const createUiResponse: MessageFactoryFn<typeof UI_EVENT, UiResponseEvent> = (
+  type,
+  payload
+) =>
+  ({
+    event: UI_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/utils.ts

@@ -0,0 +1,19 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I
+) => void
+  ? I
+  : never;
+
+export type MessageFactoryFn<Group, Event> = UnionToIntersection<
+  Event extends { type: string }
+    ? Event extends { payload: any }
+      ? (
+          type: Event['type'],
+          payload: Event['payload']
+        ) => { event: Group; type: Event['type']; payload: Event['payload'] }
+      : (
+          type: Event['type'],
+          payload?: undefined
+        ) => { event: Group; type: Event['type']; payload: undefined }
+    : never
+>;

package/src/index.ts

@@ -0,0 +1,29 @@
+import { inject, InjectApi } from './inject';
+import { CoreApi } from './types/api';
+
+export { default as Core, init as initCore } from './core';
+
+export * from './constants';
+export * from './utils';
+export * from './data-manager';
+export * from './events';
+export * from './types';
+
+const HardwareSdk = ({
+  init,
+  call,
+  dispose,
+  eventEmitter,
+  uiResponse,
+  cancel,
+}: InjectApi): CoreApi =>
+  inject({
+    init,
+    call,
+    dispose,
+    eventEmitter,
+    uiResponse,
+    cancel,
+  });
+
+export default HardwareSdk;

package/src/inject.ts

@@ -0,0 +1,103 @@
+import { EventEmitter } from 'events';
+import { CallMethod } from './events';
+import { CoreApi } from './types/api';
+
+export interface InjectApi {
+  call: CallMethod;
+  eventEmitter: EventEmitter;
+  init: CoreApi['init'];
+  dispose: CoreApi['dispose'];
+  uiResponse: CoreApi['uiResponse'];
+  cancel: CoreApi['cancel'];
+}
+
+export const inject = ({
+  call,
+  cancel,
+  dispose,
+  eventEmitter,
+  init,
+  uiResponse,
+}: InjectApi): CoreApi => {
+  const api: CoreApi = {
+    on: <T extends string, P extends (...args: any[]) => any>(type: T, fn: P) => {
+      eventEmitter.on(type, fn);
+    },
+
+    off: (type, fn) => {
+      eventEmitter.removeListener(type, fn);
+    },
+
+    removeAllListeners: type => {
+      eventEmitter.removeAllListeners(type);
+    },
+
+    init,
+
+    call,
+
+    dispose,
+
+    uiResponse,
+
+    cancel,
+    /**
+     * 搜索设备
+     */
+    searchDevices: () => call({ method: 'searchDevices' }),
+
+    /**
+     * 获取设备信息
+     */
+    getFeatures: connectId => call({ connectId, method: 'getFeatures' }),
+
+    /**
+     * 检查固件版本
+     */
+    checkFirmwareRelease: connectId => call({ connectId, method: 'checkFirmwareRelease' }),
+
+    /**
+     * 检查蓝牙固件版本
+     */
+    checkBLEFirmwareRelease: connectId => call({ connectId, method: 'checkBLEFirmwareRelease' }),
+
+    /**
+     * 检查 bridge 版本
+     */
+    checkTransportRelease: () => call({ method: 'checkTransportRelease' }),
+
+    deviceBackup: connectId => call({ connectId, method: 'deviceBackup' }),
+    deviceChangePin: (connectId, params) =>
+      call({ ...params, connectId, method: 'deviceChangePin' }),
+    deviceFlags: (connectId, params) => call({ ...params, connectId, method: 'deviceFlags' }),
+    deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
+    deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
+    deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
+    deviceSettings: connectId => call({ connectId, method: 'deviceSettings' }),
+    deviceUpdateReboot: connectId => call({ connectId, method: 'deviceUpdateReboot' }),
+    deviceWipe: connectId => call({ connectId, method: 'deviceWipe' }),
+
+    evmGetAddress: (connectId, params) => call({ ...params, connectId, method: 'evmGetAddress' }),
+    evmGetPublicKey: (connectId, params) =>
+      call({ ...params, connectId, method: 'evmGetPublicKey' }),
+    evmSignMessage: (connectId, params) => call({ ...params, connectId, method: 'evmSignMessage' }),
+    evmSignMessageEIP712: (connectId, params) =>
+      call({ ...params, connectId, method: 'evmSignMessageEIP712' }),
+    evmSignTransaction: (connectId, params) =>
+      call({ ...params, connectId, method: 'evmSignTransaction' }),
+    evmSignTypedData: (connectId, params) =>
+      call({ ...params, connectId, method: 'evmSignTypedData' }),
+    evmVerifyMessage: (connectId, params) =>
+      call({ ...params, connectId, method: 'evmVerifyMessage' }),
+
+    btcGetAddress: (connectId, params) => call({ ...params, connectId, method: 'btcGetAddress' }),
+    btcGetPublicKey: (connectId, params) =>
+      call({ ...params, connectId, method: 'btcGetPublicKey' }),
+    btcSignMessage: (connectId, params) => call({ ...params, connectId, method: 'btcSignMessage' }),
+    btcSignTransaction: (connectId, params) =>
+      call({ ...params, connectId, method: 'btcSignTransaction' }),
+    btcVerifyMessage: (connectId, params) =>
+      call({ ...params, connectId, method: 'btcVerifyMessage' }),
+  };
+  return api;
+};

package/src/types/api/btcGetAddress.ts

@@ -0,0 +1,24 @@
+import {
+  Address,
+  InputScriptType,
+  MultisigRedeemScriptType,
+} from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type BTCGetAddressParams = {
+  path: string | number[];
+  coin?: string;
+  showOnOneKey?: boolean;
+  multisig?: MultisigRedeemScriptType;
+  scriptType?: InputScriptType;
+};
+
+export declare function btcGetAddress(
+  connectId: string,
+  params: CommonParams & BTCGetAddressParams
+): Response<Address>;
+
+export declare function btcGetAddress(
+  connectId: string,
+  params: CommonParams & { bundle?: BTCGetAddressParams[] }
+): Response<Array<Address>>;

package/src/types/api/btcGetPublicKey.ts

@@ -0,0 +1,19 @@
+import { InputScriptType, PublicKey } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type BTCGetPublicKeyParams = {
+  path: string | number[];
+  coin?: string;
+  showOnOneKey?: boolean;
+  scriptType?: InputScriptType;
+};
+
+export declare function btcGetPublicKey(
+  connectId: string,
+  params: CommonParams & BTCGetPublicKeyParams
+): Response<PublicKey>;
+
+export declare function btcGetPublicKey(
+  connectId: string,
+  params: CommonParams & { bundle?: BTCGetPublicKeyParams[] }
+): Response<Array<PublicKey>>;

package/src/types/api/btcSignMessage.ts

@@ -0,0 +1,13 @@
+import { MessageSignature } from '@onekeyfe/hd-transport/src/types/messages';
+import type { CommonParams, Response } from '../params';
+
+export type BTCSignMessageParams = {
+  path: string | number[];
+  messageHex: string;
+  coin?: string;
+};
+
+export declare function btcSignMessage(
+  connectId: string,
+  params: CommonParams & BTCSignMessageParams
+): Response<MessageSignature>;