@onekeyfe/hd-core 0.0.9 → 0.1.1

package/src/api/FirmwareUpdate.ts

@@ -0,0 +1,78 @@
+import { ERRORS } from '../constants';
+import { UI_REQUEST } from '../constants/ui-request';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { getBinary } from './firmware/getBinary';
+import { uploadFirmware } from './firmware/uploadFirmware';
+
+type Params = {
+  binary?: ArrayBuffer;
+  version?: number[];
+  updateType: 'firmware' | 'ble';
+};
+
+export default class FirmwareUpdate extends BaseMethod<Params> {
+  init() {
+    this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
+    this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+
+    const { payload } = this;
+
+    validateParams(payload, [
+      { name: 'version', type: 'array' },
+      { name: 'binary', type: 'buffer' },
+    ]);
+
+    if (!payload.updateType) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'updateType is required');
+    }
+
+    this.params = { updateType: payload.updateType };
+
+    if ('version' in payload) {
+      this.params = {
+        ...this.params,
+        version: payload.version,
+      };
+    }
+
+    if ('binary' in payload) {
+      this.params = {
+        ...this.params,
+        binary: payload.binary,
+      };
+    }
+  }
+
+  async run() {
+    const { device, params } = this;
+
+    let binary;
+
+    try {
+      if (params.binary) {
+        binary = this.params.binary;
+      } else {
+        if (!device.features) {
+          throw ERRORS.TypedError('Runtime', 'no features found for this device');
+        }
+        const firmware = await getBinary({
+          features: device.features,
+          version: params.version,
+          updateType: params.updateType,
+        });
+        binary = firmware.binary;
+      }
+    } catch (err) {
+      throw ERRORS.TypedError('Method_FirmwareUpdate_DownloadFailed', err);
+    }
+
+    return uploadFirmware(
+      params.updateType,
+      this.device.getCommands().typedCall.bind(this.device.getCommands()),
+      this.postMessage,
+      device,
+      { payload: binary }
+    );
+  }
+}

package/src/api/firmware/getBinary.ts

@@ -0,0 +1,46 @@
+import semver from 'semver';
+import { Features } from '../../types';
+import { getDeviceType, httpRequest } from '../../utils';
+import { DataManager } from '../../data-manager';
+import { ERRORS } from '../../constants';
+
+export interface GetInfoProps {
+  features: Features;
+  updateType: 'firmware' | 'ble';
+}
+
+interface GetBinaryProps extends GetInfoProps {
+  version?: number[];
+}
+
+export const getBinary = async ({ features, updateType, version }: GetBinaryProps) => {
+  const releaseInfo = getInfo({ features, updateType });
+
+  if (!releaseInfo) {
+    throw ERRORS.TypedError('Runtime', 'no firmware found for this device');
+  }
+
+  if (
+    version &&
+    !semver.eq(releaseInfo.version as unknown as semver.SemVer, version as unknown as semver.SemVer)
+  ) {
+    throw ERRORS.TypedError('Runtime', 'firmware version mismatch');
+  }
+
+  // @ts-expect-error
+  const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
+  const fw = await httpRequest(url, 'binary');
+
+  return {
+    ...releaseInfo,
+    binary: fw,
+  };
+};
+
+const getInfo = ({ features, updateType }: GetInfoProps) => {
+  const deviceType = getDeviceType(features);
+  const { deviceMap } = DataManager;
+  const releaseInfo = deviceMap?.[deviceType]?.[updateType]?.[0] ?? null;
+
+  return releaseInfo;
+};

package/src/api/firmware/uploadFirmware.ts

@@ -0,0 +1,72 @@
+import { DEVICE, CoreMessage, createUiMessage, UI_REQUEST } from '../../events';
+import { ERRORS, PROTO } from '../../constants';
+import type { Device } from '../../device/Device';
+import type { TypedCall } from '../../device/DeviceCommands';
+import { KnownDevice } from '../../types';
+
+const postConfirmationMessage = (device: Device) => {
+  // only if firmware is already installed. fresh device does not require button confirmation
+  if (device.features?.firmware_present) {
+    device.emit(DEVICE.BUTTON, device, { code: 'ButtonRequest_FirmwareUpdate' });
+  }
+};
+
+const postProgressMessage = (
+  device: Device,
+  progress: number,
+  postMessage: (message: CoreMessage) => void
+) => {
+  postMessage(
+    createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
+      device: device.toMessageObject() as KnownDevice,
+      progress,
+    })
+  );
+};
+
+export const uploadFirmware = async (
+  updateType: 'firmware' | 'ble',
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  { payload }: PROTO.FirmwareUpload
+) => {
+  if (device.features?.major_version === 1) {
+    postConfirmationMessage(device);
+    const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+    await typedCall(eraseCommand as unknown as any, 'Success', {});
+    postProgressMessage(device, 0, postMessage);
+    const { message } = await typedCall('FirmwareUpload', 'Success', {
+      payload,
+    });
+
+    return message;
+  }
+
+  if (device.features?.major_version === 2) {
+    postConfirmationMessage(device);
+    const length = payload.byteLength;
+
+    let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
+    while (response.type !== 'Success') {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const start = response.message.offset!;
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const end = response.message.offset! + response.message.length!;
+      const chunk = payload.slice(start, end);
+
+      if (start > 0) {
+        postProgressMessage(device, Math.round((start / length) * 100), postMessage);
+      }
+
+      response = await typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
+        payload: chunk,
+      });
+    }
+
+    postProgressMessage(device, 100, postMessage);
+    return response.message;
+  }
+
+  throw ERRORS.TypedError('Runtime', 'uploadFirmware: unknown major_version');
+};

package/src/api/index.ts

@@ -39,3 +39,5 @@ export { default as solSignTransaction } from './solana/SolSignTransaction';
 
 export { default as stellarGetAddress } from './stellar/StellarGetAddress';
 export { default as stellarSignTransaction } from './stellar/StellarSignTransaction';
+
+export { default as firmwareUpdate } from './FirmwareUpdate';

package/src/constants/errors.ts

@@ -3,6 +3,7 @@ export const ERROR_CODES = {
   Method_InvalidParameter: '',
   Call_API: '',
   Call_NotResponse: 'No response data',
+  Method_FirmwareUpdate_DownloadFailed: '',
 
   // device error
   Transport_InvalidProtobuf: '',

package/src/core/index.ts

@@ -57,6 +57,7 @@ export const callAPI = async (message: CoreMessage) => {
   try {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
+    method.postMessage = postMessage;
     method.init();
   } catch (error) {
     return Promise.reject(error);

package/src/data-manager/DataManager.ts

@@ -18,6 +18,7 @@ import type {
   IDeviceBLEFirmwareStatus,
   ITransportStatus,
 } from '../types';
+import { getReleaseChangelog, getReleaseStatus } from '../utils/release';
 
 export default class DataManager {
   static deviceMap: DeviceTypeMap = {
@@ -59,21 +60,30 @@ export default class DataManager {
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
-    const latestFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-
-    if (!latestFirmware) return 'valid';
-
-    const latestVersion = latestFirmware.version.join('.');
     const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
 
-    /** latest is greater or equal current */
-    if (semver.gt(latestVersion, currentVersion)) {
-      if (latestFirmware.required) return 'required';
+  static getFirmwareChangelog = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
 
-      return 'outdated';
+    if (
+      features.firmware_present === false ||
+      (deviceType === 'classic' && features.bootloader_mode)
+    ) {
+      return [];
     }
 
-    return 'valid';
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getFirmwareLeatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
+    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
   };
 
   static getBLEFirmwareStatus = (features: Features): IDeviceBLEFirmwareStatus => {
@@ -86,21 +96,27 @@ export default class DataManager {
     }
 
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    const latestBLEFirmware = targetDeviceConfigList[targetDeviceConfigList.length - 1];
-
-    if (!latestBLEFirmware) return 'valid';
-
-    const latestVersion = latestBLEFirmware.version.join('.');
     const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
 
-    /** latest is greater or equal current */
-    if (semver.gt(latestVersion, currentVersion)) {
-      if (latestBLEFirmware.required) return 'required';
+  static getBleFirmwareChangelog = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
 
-      return 'outdated';
+    if (!deviceBLEFirmwareVersion) {
+      return [];
     }
 
-    return 'valid';
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getBleFirmwareLeatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
   };
 
   static getTransportStatus = (localVersion: string): ITransportStatus => {

package/src/device/Device.ts

@@ -225,6 +225,10 @@ export class Device extends EventEmitter {
     }
   }
 
+  getCommands() {
+    return this.commands;
+  }
+
   getInternalState() {
     return this.internalState[this.instance];
   }

package/src/device/DeviceCommands.ts

@@ -205,3 +205,5 @@ export class DeviceCommands {
     });
   }
 }
+
+export type TypedCall = DeviceCommands['typedCall'];

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';
 
@@ -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);
+};