@onetokenfe/hd-core 1.1.23

package/src/api/BaseMethod.ts

@@ -0,0 +1,275 @@
+import semver from 'semver';
+import {
+  createDeviceNotSupportMethodError,
+  createNeedUpgradeFirmwareHardwareError,
+} from '@onetokenfe/hd-shared';
+
+import { supportInputPinOnSoftware, supportModifyHomescreen } from '../utils/deviceFeaturesUtils';
+import { createDeviceMessage } from '../events/device';
+import { UI_REQUEST } from '../constants/ui-request';
+import { DEVICE, FIRMWARE, createFirmwareMessage, createUiMessage } from '../events';
+import { getBleFirmwareReleaseInfo, getFirmwareReleaseInfo } from './firmware/releaseHelper';
+import {
+  LoggerNames,
+  getDeviceFirmwareVersion,
+  getFirmwareType,
+  getLogger,
+  getMethodVersionRange,
+} from '../utils';
+import { generateInstanceId } from '../utils/tracing';
+
+import type { Device } from '../device/Device';
+import type DeviceConnector from '../device/DeviceConnector';
+import type { DeviceFirmwareRange, KnownDevice } from '../types';
+import type { CoreMessage } from '../events';
+import type { RequestContext } from '../utils/tracing';
+import type { CoreContext } from '../core';
+
+const Log = getLogger(LoggerNames.Method);
+
+export abstract class BaseMethod<Params = undefined> {
+  responseID: number;
+
+  // @ts-expect-error
+  device: Device;
+
+  // @ts-expect-error
+  params: Params;
+
+  /**
+   * USB: onetoken_serial or serial_no
+   * iOS: uuid
+   * Android: MAC address
+   */
+  connectId?: string;
+
+  /**
+   * device id
+   */
+  deviceId?: string;
+
+  deviceState?: string;
+
+  /**
+   * method name
+   */
+  name: string;
+
+  instanceId!: string;
+
+  sdkInstanceId?: string;
+
+  requestContext?: RequestContext;
+
+  /**
+   * 请求携带参数
+   */
+  payload: Record<string, any>;
+
+  connector?: DeviceConnector;
+
+  /**
+   * 是否需要使用设备
+   */
+  useDevice: boolean;
+
+  /**
+   * 允许的设备模式。当前设备模式在该数组中，则可以允许运行。
+   * eg. NOT_INITIALIZE, BOOTLOADER, SEEDLESS
+   */
+  allowDeviceMode: string[];
+
+  /**
+   * 依赖的设备模式
+   */
+  requireDeviceMode: string[];
+
+  /**
+   * 是否需要轮询确认设备已连接
+   */
+  shouldEnsureConnected = true;
+
+  /**
+   * 是否需要校验 features 的 deviceId 是否一致
+   */
+  checkDeviceId = false;
+
+  /**
+   * 该方法是否需要校验 passphrase state
+   */
+  useDevicePassphraseState = true;
+
+  /**
+   * skip force update check
+   * @default false
+   */
+  skipForceUpdateCheck = false;
+
+  /**
+   * 严格检查设备是否支持该方法，不支持则抛出错误
+   * @experiment 默认不严格检查，如果需要严格检查，则需要设置为 true
+   * @default false
+   */
+  strictCheckDeviceSupport = false;
+
+  // @ts-expect-error: strictPropertyInitialization
+  postMessage: (message: CoreMessage) => void;
+
+  context?: CoreContext;
+
+  constructor(message: { id?: number; payload: any }) {
+    const { payload } = message;
+    this.name = payload.method;
+    this.payload = payload;
+    this.responseID = message.id || 0;
+    this.connectId = payload.connectId || '';
+    this.deviceId = payload.deviceId || '';
+    this.useDevice = true;
+    this.allowDeviceMode = [UI_REQUEST.NOT_INITIALIZE];
+    this.requireDeviceMode = [];
+  }
+
+  abstract init(): void;
+
+  abstract run(): Promise<any>;
+
+  getVersionRange(): DeviceFirmwareRange {
+    return {};
+  }
+
+  setContext(context: CoreContext) {
+    this.sdkInstanceId = context.sdkInstanceId;
+    this.instanceId = generateInstanceId('Method', this.sdkInstanceId);
+    Log.debug(
+      `[BaseMethod] Created: ${this.instanceId}, method: ${this.name}, SDK: ${this.sdkInstanceId}`
+    );
+  }
+
+  setDevice(device: Device) {
+    this.device = device;
+
+    if (!device.sdkInstanceId && this.sdkInstanceId) {
+      device.sdkInstanceId = this.sdkInstanceId;
+      device.instanceId = generateInstanceId('Device', this.sdkInstanceId);
+    }
+
+    if (this.requestContext) {
+      this.requestContext.deviceInstanceId = device.instanceId;
+      this.requestContext.commandsInstanceId = device.commands?.instanceId;
+      this.requestContext.sdkInstanceId = this.sdkInstanceId;
+    }
+
+    if (device.commands && this.sdkInstanceId) {
+      device.commands.instanceId = generateInstanceId('DeviceCommands', this.sdkInstanceId);
+    }
+
+    if (device.commands) {
+      device.commands.currentResponseID = this.responseID;
+    }
+
+    Log.debug(
+      `[${this.instanceId}] setDevice: ${device.instanceId}, commands: ${device.commands?.instanceId}`
+    );
+  }
+
+  checkFirmwareRelease() {
+    if (!this.device || !this.device.features) return;
+    const firmwareType = getFirmwareType(this.device.features);
+    const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
+    this.postMessage(
+      createFirmwareMessage(FIRMWARE.RELEASE_INFO, {
+        ...releaseInfo,
+        device: this.device.toMessageObject(),
+      })
+    );
+    const bleReleaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+    this.postMessage(
+      createFirmwareMessage(FIRMWARE.BLE_RELEASE_INFO, {
+        ...bleReleaseInfo,
+        device: this.device.toMessageObject(),
+      })
+    );
+  }
+
+  checkDeviceSupportFeature() {
+    if (!this.device || !this.device.features) return;
+    const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    const modifyHomescreen = supportModifyHomescreen(this.device.features);
+
+    this.postMessage(
+      createDeviceMessage(DEVICE.SUPPORT_FEATURES, {
+        inputPinOnSoftware,
+        modifyHomescreen,
+        device: this.device.toMessageObject(),
+      })
+    );
+  }
+
+  protected checkFeatureVersionLimit(
+    checkCondition: () => boolean,
+    getVersionRange: () => DeviceFirmwareRange,
+    options?: {
+      strictCheckDeviceSupport?: boolean;
+    }
+  ) {
+    if (!checkCondition()) {
+      return;
+    }
+
+    const firmwareVersion = getDeviceFirmwareVersion(this.device.features)?.join('.');
+    const versionRange = getMethodVersionRange(
+      this.device.features,
+      type => getVersionRange()[type]
+    );
+
+    if (!versionRange) {
+      if (options?.strictCheckDeviceSupport) {
+        throw createDeviceNotSupportMethodError(this.name, getFirmwareType(this.device.features));
+      }
+      // Equipment that does not need to be repaired
+      return;
+    }
+
+    if (semver.valid(firmwareVersion) && semver.lt(firmwareVersion, versionRange.min)) {
+      throw createNeedUpgradeFirmwareHardwareError({
+        currentVersion: firmwareVersion,
+        requireVersion: versionRange.min,
+        methodName: this.name,
+        firmwareType: getFirmwareType(this.device.features),
+      });
+    }
+  }
+
+  /**
+   * Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
+   * @returns {void}
+   */
+  async checkSafetyLevelOnTestNet() {
+    let checkFlag = false;
+    // 3 - Ropsten, 4 - Rinkeby, 5 - Goerli, 420 - Optimism Goerli, 11155111 - zkSync Sepolia
+    if (
+      this.name === 'evmSignTransaction' &&
+      [3, 4, 5, 420, 11155111].includes(Number(this.payload?.transaction?.chainId))
+    ) {
+      checkFlag = true;
+    }
+    if (checkFlag && this.device.features?.safety_checks === 'Strict') {
+      Log.debug('will change safety_checks level');
+      await this.device.commands.typedCall('ApplySettings', 'Success', {
+        safety_checks: 'PromptTemporarily',
+      });
+    }
+  }
+
+  dispose() {}
+
+  // Reusable events
+  postPreviousAddressMessage = (data: { address?: string; path?: string }) => {
+    this.postMessage(
+      createUiMessage(UI_REQUEST.PREVIOUS_ADDRESS_RESULT, {
+        device: this.device.toMessageObject() as KnownDevice,
+        data,
+      })
+    );
+  };
+}

package/src/api/CheckAllFirmwareRelease.ts

@@ -0,0 +1,73 @@
+import { BaseMethod } from './BaseMethod';
+import { UI_REQUEST } from '../constants/ui-request';
+import {
+  getBleFirmwareReleaseInfo,
+  getBootloaderReleaseInfo,
+  getFirmwareReleaseInfo,
+} from './firmware/releaseHelper';
+import { getBridgeReleaseInfo } from '../utils/bridgeUpdate';
+import { getDeviceFirmwareVersion, getDeviceType, getFirmwareType } from '../utils';
+
+import type {
+  AllFirmwareRelease,
+  CheckAllFirmwareReleaseParams,
+} from '../types/api/checkAllFirmwareRelease';
+
+export default class CheckAllFirmwareRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    const { features } = this.device;
+    const { checkBridgeRelease, firmwareType: firmwareTypeParams } = this
+      .payload as CheckAllFirmwareReleaseParams;
+
+    if (!features) {
+      return Promise.resolve(null);
+    }
+
+    const deviceFirmwareType = getFirmwareType(features);
+    const firmwareType = firmwareTypeParams ?? deviceFirmwareType;
+    const firmwareRelease = getFirmwareReleaseInfo(features, firmwareType);
+
+    const currentFirmwareVersion = getDeviceFirmwareVersion(features).join('.');
+    const willUpdateFirmwareVersion = firmwareRelease.release?.version?.join('.');
+    const deviceType = getDeviceType(features);
+
+    let bridgeReleaseInfo = null;
+    if (
+      checkBridgeRelease &&
+      (firmwareRelease.status === 'required' || firmwareRelease.status === 'outdated')
+    ) {
+      bridgeReleaseInfo = await getBridgeReleaseInfo({
+        deviceType,
+        currentFirmwareVersion,
+        willUpdateFirmwareVersion,
+      });
+    }
+    const bootloaderRelease = getBootloaderReleaseInfo({
+      features,
+      willUpdateFirmwareVersion,
+      firmwareType,
+    });
+    const bleFirmwareReleaseInfo = getBleFirmwareReleaseInfo(features);
+
+    return {
+      firmware: firmwareRelease,
+      bootloader: bootloaderRelease,
+      ble: bleFirmwareReleaseInfo,
+      bridge: bridgeReleaseInfo
+        ? {
+            shouldUpdate: bridgeReleaseInfo.shouldUpdate,
+            status: bridgeReleaseInfo.shouldUpdate ? 'outdated' : 'valid',
+            changelog: bridgeReleaseInfo.changelog,
+            release: bridgeReleaseInfo.releaseVersion,
+          }
+        : undefined,
+      features,
+    } as AllFirmwareRelease;
+  }
+}

package/src/api/CheckBLEFirmwareRelease.ts

@@ -0,0 +1,23 @@
+import { BaseMethod } from './BaseMethod';
+import { UI_REQUEST } from '../constants/ui-request';
+import { getBleFirmwareReleaseInfo } from './firmware/releaseHelper';
+
+export default class CheckBLEFirmwareRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  run() {
+    if (this.device.features) {
+      const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+      return Promise.resolve(releaseInfo);
+    }
+    return Promise.resolve(null);
+  }
+}

package/src/api/CheckBootloaderRelease.ts

@@ -0,0 +1,32 @@
+import { BaseMethod } from './BaseMethod';
+import { UI_REQUEST } from '../constants/ui-request';
+import { getBootloaderReleaseInfo } from './firmware/releaseHelper';
+import { getFirmwareType } from '../utils';
+
+import type { CheckBootloaderReleaseParams } from '../types/api/checkBootloaderRelease';
+
+export default class CheckBootloaderRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    if (!this.device.features) {
+      return null;
+    }
+    const { features } = this.device;
+    const payload = this.payload as CheckBootloaderReleaseParams;
+
+    const deviceFirmwareType = getFirmwareType(features);
+    const firmwareType = payload.firmwareType ?? deviceFirmwareType;
+
+    const releaseInfo = getBootloaderReleaseInfo({
+      features,
+      willUpdateFirmwareVersion: payload.willUpdateFirmwareVersion,
+      firmwareType,
+    });
+    return Promise.resolve(releaseInfo);
+  }
+}

package/src/api/CheckBridgeRelease.ts

@@ -0,0 +1,28 @@
+import { BaseMethod } from './BaseMethod';
+import { UI_REQUEST } from '../constants/ui-request';
+import { getDeviceFirmwareVersion, getDeviceType } from '../utils';
+import { getBridgeReleaseInfo } from '../utils/bridgeUpdate';
+
+export default class CheckBridgeRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    if (!this.device.features) {
+      return null;
+    }
+
+    const { willUpdateFirmwareVersion } = this.payload;
+    const { features } = this.device;
+    const deviceType = getDeviceType(features);
+    const currentFirmwareVersion = getDeviceFirmwareVersion(features).join('.');
+    return getBridgeReleaseInfo({
+      deviceType,
+      currentFirmwareVersion,
+      willUpdateFirmwareVersion,
+    });
+  }
+}

package/src/api/CheckBridgeStatus.ts

@@ -0,0 +1,32 @@
+import axios from 'axios';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { BaseMethod } from './BaseMethod';
+
+export default class CheckBridgeStatus extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  async run() {
+    return new Promise<boolean>((resolve, reject) => {
+      axios
+        .request({
+          url: 'http://localhost:21320',
+          method: 'POST',
+          withCredentials: false,
+          timeout: 3000,
+        })
+        .then(() => resolve(true))
+        .catch(e => {
+          if (e.code === 'ECONNABORTED') {
+            reject(ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError));
+          } else {
+            resolve(false);
+          }
+        });
+    });
+  }
+}

package/src/api/CheckFirmwareRelease.ts

@@ -0,0 +1,31 @@
+import { BaseMethod } from './BaseMethod';
+import { UI_REQUEST } from '../constants/ui-request';
+import { getFirmwareReleaseInfo } from './firmware/releaseHelper';
+import { getFirmwareType } from '../utils';
+
+import type { CheckFirmwareReleaseParams } from '../types/api/checkFirmwareRelease';
+
+export default class CheckFirmwareRelease extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  run() {
+    const payload = this.payload as CheckFirmwareReleaseParams;
+
+    if (this.device.features) {
+      const deviceFirmwareType = getFirmwareType(this.device.features);
+      const firmwareType = payload.firmwareType ?? deviceFirmwareType;
+
+      const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
+      return Promise.resolve(releaseInfo);
+    }
+    return Promise.resolve(null);
+  }
+}

package/src/api/CheckFirmwareTypeAvailable.tsx

@@ -0,0 +1,30 @@
+import { EDeviceType } from '@onetokenfe/hd-shared';
+
+import { BaseMethod } from './BaseMethod';
+import { getLatestFirmwareField } from '../utils/deviceFeaturesUtils';
+import { DataManager } from '../data-manager';
+import { findLatestRelease } from '../utils/release';
+
+import type { CheckFirmwareTypeAvailableParams } from '../types/api/checkFirmwareTypeAvailable';
+
+export default class CheckFirmwareTypeAvailable extends BaseMethod {
+  init() {
+    this.useDevice = false;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+  }
+
+  run() {
+    const payload = this.payload as CheckFirmwareTypeAvailableParams;
+    const { deviceType, firmwareType } = payload;
+    if (deviceType === EDeviceType.Unknown) {
+      return Promise.resolve(undefined);
+    }
+
+    const latestFirmwareField = getLatestFirmwareField(firmwareType);
+
+    const releaseInfos = DataManager.deviceMap[deviceType]?.[latestFirmwareField] ?? [];
+    const releaseInfo = findLatestRelease(releaseInfos);
+    return Promise.resolve(releaseInfo);
+  }
+}

package/src/api/CipherKeyValue.ts

@@ -0,0 +1,68 @@
+import { UI_REQUEST } from '../constants/ui-request';
+import { serializedPath, validatePath } from './helpers/pathUtils';
+import { BaseMethod } from './BaseMethod';
+import { validateParams } from './helpers/paramsValidator';
+import { formatAnyHex } from './helpers/hexUtils';
+
+import type { CipheredKeyValue, CipheredKeyValueParams } from '../types';
+import type { CipherKeyValue as HardwareCipherKeyValue } from '@onetokenfe/hd-transport';
+
+export default class CipherKeyValue extends BaseMethod<HardwareCipherKeyValue[]> {
+  hasBundle = false;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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]);
+  }
+}