@onekeyfe/hd-core 0.0.10 → 0.1.2

package/src/device/Device.ts

@@ -85,8 +85,6 @@ export class Device extends EventEmitter {
 
   internalState: string[] = [];
 
-  loaded = false;
-
   needReloadDevice = false;
 
   /**
@@ -225,6 +223,10 @@ export class Device extends EventEmitter {
     }
   }
 
+  getCommands() {
+    return this.commands;
+  }
+
   getInternalState() {
     return this.internalState[this.instance];
   }
@@ -277,10 +279,19 @@ export class Device extends EventEmitter {
     }
   }
 
+  updateFromCache(device: Device) {
+    this.mainId = device.mainId;
+    this.commands = device.commands;
+    this.updateDescriptor(device.originalDescriptor);
+    if (device.features) {
+      this._updateFeatures(device.features);
+    }
+  }
+
   async run(fn?: () => Promise<void>, options?: RunOptions) {
     if (this.runPromise) {
-      Log.error('[Device] run error:', 'Device is running');
-      throw ERRORS.TypedError('Device_CallInProgress');
+      this.interruption();
+      Log.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
     }
 
     options = parseRunOptions(options);
@@ -315,11 +326,6 @@ export class Device extends EventEmitter {
       await fn();
     }
 
-    // reload features
-    if (this.loaded && this.features) {
-      await this.getFeatures();
-    }
-
     if (
       (!this.keepSession && typeof options.keepSession !== 'boolean') ||
       options.keepSession === false
@@ -334,9 +340,14 @@ export class Device extends EventEmitter {
     }
 
     this.runPromise = null;
+  }
 
-    if (!this.loaded) {
-      this.loaded = true;
+  interruption() {
+    if (this.commands) {
+      this.commands.dispose();
+    }
+    if (this.runPromise) {
+      this.runPromise.reject(ERRORS.TypedError('Device_Interrupted'));
     }
   }
 

package/src/device/DeviceCommands.ts

@@ -56,7 +56,11 @@ export class DeviceCommands {
 
   dispose() {
     this.disposed = true;
+    if (this._cancelableRequest) {
+      this._cancelableRequest();
+    }
     this._cancelableRequest = undefined;
+    this.transport.cancel?.();
   }
 
   // Sends an async message to the opened device.
@@ -205,3 +209,5 @@ export class DeviceCommands {
     });
   }
 }
+
+export type TypedCall = DeviceCommands['typedCall'];

package/src/device/DeviceList.ts

@@ -2,6 +2,11 @@ import EventEmitter from 'events';
 import DeviceConnector from './DeviceConnector';
 import { Device } from './Device';
 import { getDeviceUUID } from '../utils/deviceFeaturesUtils';
+import { initLog } from '../utils';
+
+const cacheDeviceMap = new Map<string, Device>();
+
+const Log = initLog('DeviceList');
 
 export class DeviceList extends EventEmitter {
   devices: Record<string, Device> = {};
@@ -20,7 +25,7 @@ export class DeviceList extends EventEmitter {
     const deviceList = [];
     console.log('get device list');
     for await (const descriptor of descriptorList) {
-      const device = Device.fromDescriptor(descriptor);
+      let device = Device.fromDescriptor(descriptor);
       device.deviceConnector = this.connector;
       await device.connect();
       await device.initialize();
@@ -30,7 +35,14 @@ export class DeviceList extends EventEmitter {
       deviceList.push(device);
       if (device.features) {
         const uuid = getDeviceUUID(device.features);
+        if (cacheDeviceMap.has(uuid)) {
+          const cache = cacheDeviceMap.get(uuid);
+          cache?.updateFromCache(device);
+          device = cache as Device;
+          Log.debug('use cache device: ', uuid);
+        }
         this.devices[uuid] = device;
+        cacheDeviceMap.set(uuid, device);
       }
     }
 

package/src/events/call.ts

@@ -46,6 +46,12 @@ export interface IFrameCallMessage {
   payload: CallMethodPayload;
 }
 
+export interface IFrameCancelMessage {
+  event: typeof IFRAME.CANCEL;
+  type: typeof IFRAME.CANCEL;
+  payload: { connectId?: string };
+}
+
 export const RESPONSE_EVENT = 'RESPONSE_EVENT';
 
 export interface MethodResponseMessage {

package/src/events/core.ts

@@ -1,5 +1,5 @@
 import { Unsuccessful } from '../types/params';
-import { IFrameCallMessage } from './call';
+import { IFrameCallMessage, IFrameCancelMessage } from './call';
 import { DeviceEventMessage } from './device';
 import { IFrameEventMessage } from './iframe';
 import { UiEventMessage } from './ui-request';
@@ -13,6 +13,7 @@ export type CoreMessage = {
 } & (
   | IFrameEventMessage
   | IFrameCallMessage
+  | IFrameCancelMessage
   | UiResponseMessage
   | UiEventMessage
   | DeviceEventMessage

package/src/events/iframe.ts

@@ -6,6 +6,7 @@ export const IFRAME = {
   INIT: 'iframe-init',
   INIT_BRIDGE: 'iframe-init-bridge',
   CALL: 'iframe-call',
+  CANCEL: 'iframe-cancel',
 } as const;
 
 export interface IFrameInit {

package/src/events/ui-request.ts

@@ -14,6 +14,8 @@ export const UI_REQUEST = {
 
   BLUETOOTH_PERMISSION: 'ui-bluetooth_permission',
   LOCATION_PERMISSION: 'ui-location_permission',
+
+  FIRMWARE_PROGRESS: 'ui-firmware-progress',
 } as const;
 
 export interface UiRequestWithoutPayload {
@@ -37,7 +39,19 @@ export interface UiRequestButton {
   payload: DeviceButtonRequest['payload'];
 }
 
-export type UiEvent = UiRequestWithoutPayload | UiRequestDeviceAction | UiRequestButton;
+export interface FirmwareProgress {
+  type: typeof UI_REQUEST.FIRMWARE_PROGRESS;
+  payload: {
+    device: Device;
+    progress: number;
+  };
+}
+
+export type UiEvent =
+  | UiRequestWithoutPayload
+  | UiRequestDeviceAction
+  | UiRequestButton
+  | FirmwareProgress;
 
 export type UiEventMessage = UiEvent & { event: typeof UI_EVENT };
 

package/src/inject.ts

@@ -124,6 +124,8 @@ export const inject = ({
       call({ ...params, connectId, method: 'stellarGetAddress' }),
     stellarSignTransaction: (connectId, params) =>
       call({ ...params, connectId, method: 'stellarSignTransaction' }),
+
+    firmwareUpdate: (connectId, params) => call({ ...params, connectId, method: 'firmwareUpdate' }),
   };
   return api;
 };

package/src/types/api/checkBLEFirmwareRelease.ts

@@ -1,6 +1,14 @@
 import type { Response } from '../params';
-import type { IDeviceFirmwareStatus } from '../device';
+import type { IDeviceBLEFirmwareStatus } from '../device';
+import { IBLEFirmwareReleaseInfo } from '../settings';
 
-export declare function checkBLEFirmwareRelease(
-  connectId?: string
-): Response<IDeviceFirmwareStatus>;
+type BleFirmwareRelease = {
+  status: IDeviceBLEFirmwareStatus;
+  changelog: {
+    'zh-CN': string;
+    'en-US': string;
+  }[];
+  release: IBLEFirmwareReleaseInfo;
+};
+
+export declare function checkBLEFirmwareRelease(connectId?: string): Response<BleFirmwareRelease>;

package/src/types/api/checkFirmwareRelease.ts

@@ -1,4 +1,14 @@
 import type { Response } from '../params';
 import type { IDeviceFirmwareStatus } from '../device';
+import { IFirmwareReleaseInfo } from '../settings';
 
-export declare function checkFirmwareRelease(connectId?: string): Response<IDeviceFirmwareStatus>;
+type FirmwareRelease = {
+  status: IDeviceFirmwareStatus;
+  changelog: {
+    'en-US': string;
+    'zh-CN': string;
+  }[];
+  release: IFirmwareReleaseInfo;
+};
+
+export declare function checkFirmwareRelease(connectId?: string): Response<FirmwareRelease>;

package/src/types/api/firmwareUpdate.ts

@@ -0,0 +1,21 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+
+export interface FirmwareUpdateBinary {
+  binary: ArrayBuffer;
+}
+
+export interface FirmwareUpdate {
+  version: number[];
+  btcOnly?: boolean;
+  updateType: 'firmware' | 'ble';
+}
+
+export declare function firmwareUpdate(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdate>
+): Response<PROTO.Success>;
+export declare function firmwareUpdate(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdateBinary>
+): Response<PROTO.Success>;

package/src/types/api/index.ts

@@ -39,6 +39,7 @@ import { solSignTransaction } from './solSignTransaction';
 import { stellarGetAddress } from './stellarGetAddress';
 import { stellarSignTransaction } from './stellarSignTransaction';
 import { cipherKeyValue } from './cipherKeyValue';
+import { firmwareUpdate } from './firmwareUpdate';
 
 export * from './export';
 
@@ -53,7 +54,7 @@ export type CoreApi = {
   dispose: () => void;
   call: (params: any) => Promise<any>;
   uiResponse: typeof uiResponse;
-  cancel: (params?: string) => void;
+  cancel: (connectId?: string) => void;
 
   /**
    * Core function
@@ -108,4 +109,6 @@ export type CoreApi = {
 
   stellarGetAddress: typeof stellarGetAddress;
   stellarSignTransaction: typeof stellarSignTransaction;
+
+  firmwareUpdate: typeof firmwareUpdate;
 };

package/src/types/device.ts

@@ -86,3 +86,47 @@ export type ITransportStatus = 'valid' | 'outdated';
 export type DeviceFirmwareRange = {
   [deviceType in IDeviceType | IDeviceModel]?: { min: string; max?: string };
 };
+
+type FeaturesNarrowing =
+  | {
+      major_version: 2;
+      fw_major: null;
+      fw_minor: null;
+      fw_patch: null;
+      bootloader_mode: true;
+      firmware_present: false;
+    }
+  | {
+      major_version: 2;
+      fw_major: null;
+      fw_minor: null;
+      fw_patch: null;
+      bootloader_mode: null;
+      firmware_present: null;
+    }
+  | {
+      major_version: 2;
+      fw_major: 2;
+      fw_minor: number;
+      fw_patch: number;
+      bootloader_mode: true;
+      firmware_present: true;
+    }
+  | {
+      major_version: 1;
+      fw_major: null;
+      fw_minor: null;
+      fw_patch: null;
+      bootloader_mode: true;
+      firmware_present: false;
+    }
+  | {
+      major_version: 1;
+      fw_major: null;
+      fw_minor: null;
+      fw_patch: null;
+      bootloader_mode: true;
+      firmware_present: true;
+    };
+
+export type StrictFeatures = Features & FeaturesNarrowing;

package/src/types/firmware.ts

@@ -9,7 +9,8 @@ export interface FirmwareRange {
   };
 }
 
-export type VersionArray = [1 | 2, number, number];
+export type MajorVersion = 1 | 2;
+export type VersionArray = [MajorVersion, number, number];
 
 export type FirmwareRelease = {
   required: boolean;

package/src/types/params.ts

@@ -2,6 +2,8 @@ export interface CommonParams {
   keepSession?: boolean;
 }
 
+export type Params<T> = CommonParams & T & { bundle?: undefined };
+
 export interface Unsuccessful {
   success: false;
   payload: { error: string; code?: string };

package/src/utils/assets.ts

@@ -1,5 +1,5 @@
 import { httpRequest as browserHttpRequest } from './networkUtils';
 
-export const httpRequest = (url: string, _type: string): any => browserHttpRequest(url);
+export const httpRequest = (url: string, type: string): any => browserHttpRequest(url, type);
 
 export const getTimeStamp = () => new Date().getTime();

package/src/utils/networkUtils.ts

@@ -4,13 +4,15 @@ export const httpRequest = async (url: string, type = 'text') => {
   const response = await axios.request({
     url,
     withCredentials: false,
+    responseType: type === 'binary' ? 'arraybuffer' : 'json',
   });
+
   if (+response.status === 200) {
     if (type === 'json') {
       return response.data;
     }
     if (type === 'binary') {
-      return response.data.arrayBuffer();
+      return response.data;
     }
     return response.data;
   }

package/src/utils/release.ts

@@ -0,0 +1,24 @@
+import semver from 'semver';
+import { IBLEFirmwareReleaseInfo, IDeviceFirmwareStatus, IFirmwareReleaseInfo } from '../types';
+
+export const getReleaseStatus = (
+  releases: (IFirmwareReleaseInfo | IBLEFirmwareReleaseInfo)[],
+  currentVersion: string
+): IDeviceFirmwareStatus => {
+  const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+  if (newVersions.length === 0) {
+    return 'valid';
+  }
+  if (newVersions.some(r => r.required)) {
+    return 'required';
+  }
+  return 'outdated';
+};
+
+export const getReleaseChangelog = (
+  releases: (IFirmwareReleaseInfo | IBLEFirmwareReleaseInfo)[],
+  currentVersion: string
+): IFirmwareReleaseInfo['changelog'][] => {
+  const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+  return newVersions.map(r => r.changelog);
+};