@onekeyfe/hd-core 0.0.8 → 0.1.0

package/dist/utils/networkUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"networkUtils.d.ts","sourceRoot":"","sources":["../../src/utils/networkUtils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAAe,MAAM,gCAe5C,CAAC"}
+{"version":3,"file":"networkUtils.d.ts","sourceRoot":"","sources":["../../src/utils/networkUtils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW,QAAe,MAAM,gCAiB5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "0.0.8",
+  "version": "0.1.0",
   "description": "> TODO: description",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,7 +25,7 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-transport": "^0.0.8",
+    "@onekeyfe/hd-transport": "^0.1.0",
     "axios": "^0.27.2",
     "bignumber.js": "^9.0.2",
     "parse-uri": "^1.0.7",
@@ -35,5 +35,5 @@
     "@types/parse-uri": "^1.0.0",
     "@types/semver": "^7.3.9"
   },
-  "gitHead": "edfa30382fdf36182bc389c8ff1dd1a689096592"
+  "gitHead": "d50dc424865150391b7249d1010ee75dc2074a7e"
 }

package/src/api/BaseMethod.ts

@@ -1,6 +1,8 @@
 import { UI_REQUEST } from '../constants/ui-request';
 import { Device } from '../device/Device';
 import DeviceConnector from '../device/DeviceConnector';
+import { DeviceFirmwareRange } from '../types';
+import { CoreMessage } from '../events';
 
 export abstract class BaseMethod<Params = undefined> {
   responseID: number;
@@ -47,6 +49,9 @@ export abstract class BaseMethod<Params = undefined> {
    */
   requireDeviceMode: string[];
 
+  // @ts-expect-error: strictPropertyInitialization
+  postMessage: (message: CoreMessage) => void;
+
   constructor(message: { id?: number; payload: any }) {
     const { payload } = message;
     this.name = payload.method;
@@ -62,6 +67,10 @@ export abstract class BaseMethod<Params = undefined> {
 
   abstract run(): Promise<any>;
 
+  getVersionRange(): DeviceFirmwareRange {
+    return {};
+  }
+
   setDevice(device: Device) {
     this.device = device;
     this.connectId = device.originalDescriptor.path;

package/src/api/CipherKeyValue.ts

@@ -0,0 +1,66 @@
+import { CipherKeyValue as HardwareCipherKeyValue } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../constants/ui-request';
+import { serializedPath, validatePath } from './helpers/pathUtils';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { CipheredKeyValue, CipheredKeyValueParams } from '../types';
+import { formatAnyHex } from './helpers/hexUtils';
+
+export default class CipherKeyValue extends BaseMethod<HardwareCipherKeyValue[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: CipheredKeyValueParams) => {
+      const addressN = validatePath(batch.path);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'key', type: 'string' },
+        { name: 'value', type: 'hexString' },
+        { name: 'encrypt', type: 'boolean' },
+        { name: 'askOnEncrypt', type: 'boolean' },
+        { name: 'askOnDecrypt', type: 'boolean' },
+        { name: 'iv', type: 'hexString' },
+      ]);
+
+      this.params.push({
+        address_n: addressN,
+        key: batch.key,
+        value: formatAnyHex(batch.value),
+        encrypt: batch.encrypt,
+        ask_on_encrypt: batch.askOnEncrypt,
+        ask_on_decrypt: batch.askOnDecrypt,
+        iv: formatAnyHex(batch.iv),
+      });
+    });
+  }
+
+  async run() {
+    const responses: CipheredKeyValue[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('CipherKeyValue', 'CipheredKeyValue', {
+        ...param,
+      });
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        ...res.message,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}

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/device/DeviceRebootToBootloader.ts

@@ -5,6 +5,17 @@ import { BaseMethod } from '../BaseMethod';
 export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloader> {
   init() {}
 
+  getVersionRange() {
+    return {
+      classic: {
+        min: '2.1.11',
+      },
+      mini: {
+        min: '2.1.11',
+      },
+    };
+  }
+
   async run() {
     const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
 

package/src/api/evm/EVMSignMessageEIP712.ts

@@ -26,6 +26,14 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
     };
   }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.1.9',
+      },
+    };
+  }
+
   async run() {
     const res = await this.device.commands.typedCall(
       'EthereumSignMessageEIP712',

package/src/api/evm/EVMSignTransaction.ts

@@ -178,6 +178,21 @@ export default class EVMSignTransaction extends BaseMethod {
     return this.processTxRequest(response.message, rest, chainId);
   };
 
+  getVersionRange() {
+    if (this.isEIP1559) {
+      return {
+        model_mini: {
+          min: '2.1.11',
+        },
+      };
+    }
+    return {
+      model_mini: {
+        min: '1.0.0',
+      },
+    };
+  }
+
   async run() {
     const { addressN, isEIP1559, formattedTx } = this;
 

package/src/api/evm/EVMSignTypedData.ts

@@ -1,4 +1,6 @@
+import semver from 'semver';
 import {
+  EthereumMessageSignature,
   EthereumTypedDataSignature,
   EthereumTypedDataStructAck,
   MessageKey,
@@ -14,6 +16,8 @@ import {
   EthereumSignTypedDataMessage,
   EthereumSignTypedDataTypes,
 } from '../../types/api/evmSignTypedData';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../utils/deviceFeaturesUtils';
+import { TypedResponseMessage } from '../../device/DeviceCommands';
 
 export type EVMSignTypedDataParams = {
   addressN: number[];
@@ -23,14 +27,14 @@ export type EVMSignTypedDataParams = {
   messageHash?: string;
 };
 
-export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataParams> {
+export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams> {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
 
     validateParams(this.payload, [
       { name: 'path', required: true },
-      { name: 'metamaskV4Compat', type: 'boolean', required: true },
-      { name: 'data', type: 'object', required: true },
+      { name: 'metamaskV4Compat', type: 'boolean' },
+      { name: 'data', type: 'object' },
       { name: 'domainHash', type: 'hexString' },
       { name: 'messageHash', type: 'hexString' },
     ]);
@@ -49,7 +53,7 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataPar
       this.params.domainHash = formatAnyHex(domainHash);
       if (messageHash) {
         this.params.messageHash = formatAnyHex(messageHash);
-      } else if (!data.primaryType || data.primaryType !== 'EIP712Domain') {
+      } else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
         throw ERRORS.TypedError(
           'Method_InvalidParameter',
           'message_hash should only be empty when data.primaryType=EIP712Domain'
@@ -173,6 +177,28 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataPar
   //   };
   // }
 
+  getVersionRange() {
+    return {
+      model_mini: {
+        min: '2.1.9',
+      },
+    };
+  }
+
+  supportSignTyped() {
+    const deviceType = getDeviceType(this.device.features);
+    if (deviceType === 'classic' || deviceType === 'mini') {
+      const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+      const supportSignTypedVersion = '2.2.0';
+
+      if (semver.lt(currentVersion, supportSignTypedVersion)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   async run() {
     if (!this.device.features) {
       throw ERRORS.TypedError(
@@ -184,23 +210,37 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EVMSignTypedDataPar
     const { addressN } = this.params;
 
     // For Classic、Mini device we use EthereumSignTypedData
-    if (this.device.features.model === '1') {
+    const deviceType = getDeviceType(this.device.features);
+    if (deviceType === 'classic' || deviceType === 'mini') {
       validateParams(this.params, [
         { name: 'domainHash', type: 'hexString', required: true },
-        { name: 'messageHash', type: 'hexString' },
+        { name: 'messageHash', type: 'hexString', required: true },
       ]);
 
       const { domainHash, messageHash } = this.params;
 
-      const response = await this.device.commands.typedCall(
-        'EthereumSignTypedHash',
-        'EthereumTypedDataSignature',
-        {
-          address_n: addressN,
-          domain_separator_hash: domainHash ?? '',
-          message_hash: messageHash,
-        }
-      );
+      let response;
+      if (this.supportSignTyped()) {
+        response = await this.device.commands.typedCall(
+          'EthereumSignTypedHash',
+          'EthereumTypedDataSignature',
+          {
+            address_n: addressN,
+            domain_separator_hash: domainHash ?? '',
+            message_hash: messageHash,
+          }
+        );
+      } else {
+        response = await this.device.commands.typedCall(
+          'EthereumSignMessageEIP712',
+          'EthereumMessageSignature',
+          {
+            address_n: addressN,
+            domain_hash: domainHash ?? '',
+            message_hash: messageHash ?? '',
+          }
+        );
+      }
 
       return Promise.resolve(response.message);
     }

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/helpers/hexUtils.ts

@@ -44,7 +44,6 @@ export const formatAnyHex: (value: any) => any = value => {
   if (typeof value === 'object') {
     return modifyValues(value, value => formatAnyHex(value));
   }
-  console.log('unexpected value', value);
 
   return value;
 };

package/src/api/index.ts

@@ -1,5 +1,6 @@
 export { default as searchDevices } from './SearchDevices';
 export { default as getFeatures } from './GetFeatures';
+export { default as cipherKeyValue } from './CipherKeyValue';
 export { default as btcGetAddress } from './btc/BTCGetAddress';
 export { default as btcGetPublicKey } from './btc/BTCGetPublicKey';
 export { default as btcSignMessage } from './btc/BTCSignMessage';
@@ -29,3 +30,14 @@ export { default as starcoinGetPublicKey } from './starcoin/StarcoinGetPublicKey
 export { default as starcoinSignMessage } from './starcoin/StarcoinSignMessage';
 export { default as starcoinSignTransaction } from './starcoin/StarcoinSignTransaction';
 export { default as starcoinVerifyMessage } from './starcoin/StarcoinVerifyMessage';
+
+export { default as nemGetAddress } from './nem/NEMGetAddress';
+export { default as nemSignTransaction } from './nem/NEMSignTransaction';
+
+export { default as solGetAddress } from './solana/SolGetAddress';
+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/api/nem/NEMGetAddress.ts

@@ -0,0 +1,61 @@
+import { NEMGetAddress as HardwareNEMGetAddress } from '@onekeyfe/hd-transport/src/types/messages';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validatePath, serializedPath } from '../helpers/pathUtils';
+import { BaseMethod } from '../BaseMethod';
+import { validateParams } from '../helpers/paramsValidator';
+import { NEMAddress, NEMGetAddressParams } from '../../types';
+
+const MAINNET = 0x68; // 104
+
+export default class NEMGetAddress extends BaseMethod<HardwareNEMGetAddress[]> {
+  hasBundle = false;
+
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+    const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+
+    // check payload
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    // init params
+    this.params = [];
+    payload.bundle.forEach((batch: NEMGetAddressParams) => {
+      const addressN = validatePath(batch.path, 3);
+
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'network', type: 'number' },
+        { name: 'showOnOneKey', type: 'boolean' },
+      ]);
+
+      const showOnOneKey = batch.showOnOneKey ?? true;
+
+      this.params.push({
+        address_n: addressN,
+        network: batch.network || MAINNET,
+        show_display: showOnOneKey,
+      });
+    });
+  }
+
+  async run() {
+    const responses: NEMAddress[] = [];
+
+    for (let i = 0; i < this.params.length; i++) {
+      const param = this.params[i];
+
+      const res = await this.device.commands.typedCall('NEMGetAddress', 'NEMAddress', {
+        ...param,
+      });
+
+      responses.push({
+        path: serializedPath(param.address_n),
+        ...res.message,
+      });
+    }
+
+    return Promise.resolve(this.hasBundle ? responses : responses[0]);
+  }
+}