@onekeyfe/hd-core 0.1.56 → 0.1.57

package/src/api/firmware/uploadFirmware.ts

@@ -1,9 +1,16 @@
+import { blake2s } from '@noble/hashes/blake2s';
+import JSZip from 'jszip';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Success } from '@onekeyfe/hd-transport';
+import { wait, getLogger, LoggerNames } from '../../utils/index';
 import { DEVICE, CoreMessage, createUiMessage, UI_REQUEST } from '../../events';
 import { PROTO } from '../../constants';
 import type { Device } from '../../device/Device';
-import type { TypedCall } from '../../device/DeviceCommands';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
 import { KnownDevice } from '../../types';
+import { bytesToHex } from '../helpers/hexUtils';
+
+const Log = getLogger(LoggerNames.Device);
 
 const postConfirmationMessage = (device: Device) => {
   // only if firmware is already installed. fresh device does not require button confirmation
@@ -40,6 +47,13 @@ const postProgressTip = (
   );
 };
 
+export const waitBleInstall = async (updateType: string) => {
+  if (updateType === 'ble') {
+    // wait for device install
+    await wait(10 * 1000);
+  }
+};
+
 export const uploadFirmware = async (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
@@ -58,6 +72,8 @@ export const uploadFirmware = async (
       payload,
     });
     postProgressMessage(device, 100, postMessage);
+
+    await waitBleInstall(updateType);
     return message;
   }
 
@@ -85,8 +101,91 @@ export const uploadFirmware = async (
     }
 
     postProgressMessage(device, 100, postMessage);
+
+    await waitBleInstall(updateType);
     return response.message;
   }
 
   throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
 };
+
+const processResourceRequest = async (
+  typedCall: TypedCall,
+  res: TypedResponseMessage<'ResourceRequest'> | TypedResponseMessage<'Success'>,
+  data: ArrayBuffer
+): Promise<Success> => {
+  if (res.type === 'Success') {
+    return res.message;
+  }
+
+  const { offset, data_length } = res.message;
+
+  if (offset === undefined) {
+    throw new Error('offset is undefined');
+  }
+
+  const payload = new Uint8Array(
+    data.slice(offset, Math.min(offset + data_length, data.byteLength))
+  );
+  const digest = blake2s(payload);
+
+  const resourceAckParams = {
+    data_chunk: bytesToHex(payload),
+    hash: bytesToHex(digest),
+  };
+
+  const response = await typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
+    ...resourceAckParams,
+  });
+  return processResourceRequest(typedCall, response, data);
+};
+
+// Fixed size
+const INIT_DATA_CHUNK_SIZE = 16 * 1024;
+export const updateResource = async (typedCall: TypedCall, fileName: string, data: ArrayBuffer) => {
+  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
+  const digest = blake2s(chunk);
+
+  const res = await typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
+    file_name: fileName,
+    data_length: data.byteLength,
+    initial_data_chunk: bytesToHex(chunk),
+    hash: bytesToHex(digest),
+  });
+
+  return processResourceRequest(typedCall, res, data);
+};
+
+export const updateResources = async (
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  source: ArrayBuffer
+) => {
+  postProgressTip(device, 'UpdateSysResource', postMessage);
+
+  const zipData = await JSZip.loadAsync(source);
+  const files = Object.entries(zipData.files);
+
+  let progress = 0;
+  const stepProgress = 100 / files.length;
+
+  for (const [fileName, file] of files) {
+    const name = fileName.split('/').pop();
+    if (!file.dir && fileName.indexOf('__MACOSX') === -1 && name) {
+      const data = await file.async('arraybuffer');
+      try {
+        await updateResource(typedCall, name, data);
+      } catch (error) {
+        Log.error(error);
+      }
+    }
+
+    progress += stepProgress;
+    postProgressMessage(device, Math.floor(progress), postMessage);
+  }
+
+  postProgressMessage(device, 100, postMessage);
+  postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
+  return true;
+};

package/src/api/index.ts

@@ -14,6 +14,7 @@ export { default as deviceRecovery } from './device/DeviceRecovery';
 export { default as deviceReset } from './device/DeviceReset';
 export { default as deviceSettings } from './device/DeviceSettings';
 export { default as deviceUpdateReboot } from './device/DeviceUpdateReboot';
+export { default as deviceUploadResource } from './device/DeviceUploadResource';
 export { default as deviceSupportFeatures } from './device/DeviceSupportFeatures';
 export { default as deviceVerify } from './device/DeviceVerify';
 export { default as deviceWipe } from './device/DeviceWipe';

package/src/data-manager/DataManager.ts

@@ -18,7 +18,7 @@ import type {
   IDeviceBLEFirmwareStatus,
   ITransportStatus,
 } from '../types';
-import { getReleaseChangelog, getReleaseStatus } from '../utils/release';
+import { getReleaseChangelog, getReleaseStatus, findLatestRelease } from '../utils/release';
 
 export default class DataManager {
   static deviceMap: DeviceTypeMap = {
@@ -64,6 +64,25 @@ export default class DataManager {
     return getReleaseStatus(targetDeviceConfigList, currentVersion);
   };
 
+  /**
+   * Touch、Pro System UI Resource Update
+   * ** Interval upgrade is not considered **
+   */
+  static getSysResourcesLatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+
+    if (deviceType !== 'pro' && deviceType !== 'touch') return undefined;
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    const targetDeviceConfig = targetDeviceConfigList.filter(
+      item => semver.gt(item.version.join('.'), currentVersion) && !!item.resource
+    );
+
+    return findLatestRelease(targetDeviceConfig)?.resource;
+  };
+
   static getFirmwareChangelog = (features: Features) => {
     const deviceType = getDeviceType(features);
     const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
@@ -80,10 +99,21 @@ export default class DataManager {
     return getReleaseChangelog(targetDeviceConfigList, currentVersion);
   };
 
-  static getFirmwareLeatestRelease = (features: Features) => {
+  static getFirmwareLatestRelease = (features: Features) => {
     const deviceType = getDeviceType(features);
     const targetDeviceConfigList = this.deviceMap[deviceType]?.firmware ?? [];
-    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
+
+    const target = findLatestRelease(targetDeviceConfigList);
+    if (!target) return target;
+
+    if (!target.resource) {
+      const resource = this.getSysResourcesLatestRelease(features);
+      return {
+        ...target,
+        resource,
+      };
+    }
+    return target;
   };
 
   static getBLEFirmwareStatus = (features: Features): IDeviceBLEFirmwareStatus => {
@@ -113,10 +143,10 @@ export default class DataManager {
     return getReleaseChangelog(targetDeviceConfigList, currentVersion);
   };
 
-  static getBleFirmwareLeatestRelease = (features: Features) => {
+  static getBleFirmwareLatestRelease = (features: Features) => {
     const deviceType = getDeviceType(features);
     const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
-    return targetDeviceConfigList[targetDeviceConfigList.length - 1];
+    return findLatestRelease(targetDeviceConfigList);
   };
 
   static getTransportStatus = (localVersion: string): ITransportStatus => {

package/src/inject.ts

@@ -85,6 +85,8 @@ 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' }),
+    deviceUploadResource: (connectId, params) =>
+      call({ ...params, connectId, method: 'deviceUploadResource' }),
     deviceSupportFeatures: connectId => call({ connectId, method: 'deviceSupportFeatures' }),
     deviceVerify: (connectId, params) => call({ ...params, connectId, method: 'deviceVerify' }),
     deviceWipe: connectId => call({ connectId, method: 'deviceWipe' }),

package/src/types/api/confluxSignTransaction.ts

@@ -28,5 +28,5 @@ export type ConfluxSignTransactionParams = {
 export declare function confluxSignTransaction(
   connectId: string,
   deviceId: string,
-  params: CommonParams & ConfluxTransaction
+  params: CommonParams & ConfluxSignTransactionParams
 ): Response<ConfluxSignedTx>;

package/src/types/api/deviceUploadResource.ts

@@ -0,0 +1,15 @@
+import { ResourceType, Success } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export type DeviceUploadResourceParams = {
+  suffix: string;
+  dataHex: string;
+  thumbnailDataHex: string;
+  resType: ResourceType;
+  nftMetaData: string;
+};
+
+export declare function deviceUploadResource(
+  connectId: string,
+  params: CommonParams & DeviceUploadResourceParams
+): Response<Success>;

package/src/types/api/export.ts

@@ -20,6 +20,8 @@ export type { DeviceResetParams } from './deviceReset';
 export type { DeviceSettingsParams } from './deviceSettings';
 export type { DeviceVerifyParams, DeviceVerifySignature } from './deviceVerify';
 export type { DeviceSupportFeatures } from './deviceSupportFeatures';
+export type { DeviceUploadResourceParams } from './deviceUploadResource';
+export type { FirmwareUpdateParams, FirmwareUpdateBinaryParams } from './firmwareUpdate';
 
 export type { EVMAddress, EVMGetAddressParams } from './evmGetAddress';
 export type { EVMPublicKey, EVMGetPublicKeyParams } from './evmGetPublicKey';

package/src/types/api/firmwareUpdate.ts

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

package/src/types/api/index.ts

@@ -24,6 +24,7 @@ import { deviceChangePin } from './deviceChangePin';
 import { deviceSettings } from './deviceSettings';
 import { deviceFlags } from './deviceFlags';
 import { deviceUpdateReboot } from './deviceUpdateReboot';
+import { deviceUploadResource } from './deviceUploadResource';
 import { deviceSupportFeatures } from './deviceSupportFeatures';
 
 import { cipherKeyValue } from './cipherKeyValue';
@@ -110,6 +111,7 @@ export type CoreApi = {
   deviceReset: typeof deviceReset;
   deviceSettings: typeof deviceSettings;
   deviceUpdateReboot: typeof deviceUpdateReboot;
+  deviceUploadResource: typeof deviceUploadResource;
   deviceSupportFeatures: typeof deviceSupportFeatures;
   deviceVerify: typeof deviceVerify;
   deviceWipe: typeof deviceWipe;

package/src/types/settings.ts

@@ -27,6 +27,8 @@ export type ILocale = 'zh-CN' | 'en-US';
 export type IFirmwareReleaseInfo = {
   required: boolean;
   url: string;
+  /** Firmware UI resource */
+  resource?: string;
   fingerprint: string;
   version: IVersionArray;
   changelog: {

package/src/utils/release.ts

@@ -1,5 +1,10 @@
 import semver from 'semver';
-import { IBLEFirmwareReleaseInfo, IDeviceFirmwareStatus, IFirmwareReleaseInfo } from '../types';
+import {
+  IBLEFirmwareReleaseInfo,
+  IDeviceFirmwareStatus,
+  IFirmwareReleaseInfo,
+  IVersionArray,
+} from '../types';
 
 export const getReleaseStatus = (
   releases: (IFirmwareReleaseInfo | IBLEFirmwareReleaseInfo)[],
@@ -22,3 +27,15 @@ export const getReleaseChangelog = (
   const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
   return newVersions.map(r => r.changelog);
 };
+
+export const findLatestRelease = <T extends { version: IVersionArray }>(
+  releases: T[]
+): T | undefined => {
+  let leastRelease = releases[0];
+  releases.forEach(release => {
+    if (semver.gt(release.version.join('.'), leastRelease.version.join('.'))) {
+      leastRelease = release;
+    }
+  });
+  return leastRelease;
+};