@onetokenfe/hd-core 1.1.23

package/src/types/device.ts

@@ -0,0 +1,194 @@
+import { EDeviceType } from '@onetokenfe/hd-shared';
+
+import type { IVersionArray } from './settings';
+import type { PROTO } from '../constants';
+import type { OneTokenDeviceCommType } from '@onetokenfe/hd-transport';
+
+export type DeviceStatus = 'available' | 'occupied' | 'used';
+
+export enum EOneTokenDeviceMode {
+  bootloader = 'bootloader',
+  normal = 'normal',
+  notInitialized = 'notInitialized',
+  backupMode = 'backupMode',
+}
+
+export type UnavailableCapability =
+  | 'no-capability'
+  | 'no-support'
+  | 'update-required'
+  | 'trezor-connect-outdated';
+
+export type UnavailableCapabilities = { [key: string]: UnavailableCapability };
+
+export type KnownDevice = {
+  connectId: string | null;
+  uuid: string;
+  deviceId: string | null;
+  deviceType: IDeviceType | null;
+  commType: OneTokenDeviceCommType | null;
+  path: string;
+  label: string;
+  bleName: string | null;
+  name: string;
+  error?: typeof undefined;
+  mode: EOneTokenDeviceMode;
+  features: PROTO.Features;
+  unavailableCapabilities: UnavailableCapabilities;
+  bleFirmwareVersion: IVersionArray | null;
+  firmwareVersion: IVersionArray | null;
+
+  // debug sdk
+  instanceId?: string;
+  sdkInstanceId?: string;
+  createdAt?: number;
+};
+
+export type SearchDevice = {
+  connectId: string | null;
+  uuid: string;
+  deviceId: string | null;
+  deviceType: IDeviceType;
+  name: string;
+  commType: OneTokenDeviceCommType;
+};
+
+// export type UnknownDevice = {
+//   type: 'unacquired';
+//   id?: null;
+//   path: string;
+//   label: string;
+//   error?: typeof undefined;
+//   features?: typeof undefined;
+//   firmware?: typeof undefined;
+//   firmwareRelease?: typeof undefined;
+//   status?: typeof undefined;
+//   mode?: typeof undefined;
+//   state?: typeof undefined;
+//   unavailableCapabilities?: typeof undefined;
+// };
+
+// export type UnreadableDevice = {
+//   type: 'unreadable';
+//   id?: null;
+//   path: string;
+//   label: string;
+//   error: string;
+//   features?: typeof undefined;
+//   firmware?: typeof undefined;
+//   firmwareRelease?: typeof undefined;
+//   status?: typeof undefined;
+//   mode?: typeof undefined;
+//   state?: typeof undefined;
+//   unavailableCapabilities?: typeof undefined;
+// };
+
+export type Device = KnownDevice;
+
+export type Features = PROTO.Features;
+
+export type onetokenfeatures = PROTO.onetokenfeatures;
+
+export type IDeviceType =
+  | EDeviceType.Unknown
+  | EDeviceType.Classic
+  | EDeviceType.Classic1s
+  | EDeviceType.ClassicPure
+  | EDeviceType.Mini
+  | EDeviceType.Touch
+  | EDeviceType.Pro;
+
+/**
+ * model_classic: 'classic' | 'classic1s' | 'classicpure'
+ * model_mini: 'classic' | 'classic1s' | 'classicpure' | 'mini'
+ * model_touch: 'touch' | 'pro'
+ */
+export type IDeviceModel = 'model_classic' | 'model_mini' | 'model_touch' | 'model_classic1s';
+
+export const DeviceModelToTypes: { [deviceModel in IDeviceModel]: IDeviceType[] } = {
+  model_mini: [
+    EDeviceType.Classic,
+    EDeviceType.Classic1s,
+    EDeviceType.ClassicPure,
+    EDeviceType.Mini,
+  ],
+  model_touch: [EDeviceType.Touch, EDeviceType.Pro],
+  model_classic: [EDeviceType.Classic, EDeviceType.Classic1s, EDeviceType.ClassicPure],
+  model_classic1s: [EDeviceType.Classic1s, EDeviceType.ClassicPure],
+};
+
+export const DeviceTypeToModels: { [deviceType in IDeviceType]: IDeviceModel[] } = {
+  [EDeviceType.Classic]: ['model_classic', 'model_mini'],
+  [EDeviceType.Classic1s]: ['model_classic', 'model_mini', 'model_classic1s'],
+  [EDeviceType.ClassicPure]: ['model_classic', 'model_mini', 'model_classic1s'],
+  [EDeviceType.Mini]: ['model_mini'],
+  [EDeviceType.Touch]: ['model_touch'],
+  [EDeviceType.Pro]: ['model_touch'],
+  [EDeviceType.Unknown]: [],
+};
+
+export type IDeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
+
+export type IDeviceBLEFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'none';
+
+export type ITransportStatus = 'valid' | 'outdated';
+
+export type IVersionRange = {
+  min: string;
+  max?: string;
+};
+
+export type DeviceFirmwareRange = {
+  [deviceType in IDeviceType | IDeviceModel]?: IVersionRange;
+};
+
+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;
+
+export type SupportFeatureType = { support: boolean; require?: string };
+
+export type SupportFeatures = {
+  inputPinOnSoftware: SupportFeatureType;
+  modifyHomescreen: SupportFeatureType;
+};

package/src/types/firmware.ts

@@ -0,0 +1,41 @@
+export interface FirmwareRange {
+  '1': {
+    min: string;
+    max: string;
+  };
+  '2': {
+    min: string;
+    max: string;
+  };
+}
+
+export type MajorVersion = 1 | 2;
+export type VersionArray = [MajorVersion, number, number];
+
+export type FirmwareRelease = {
+  required: boolean;
+  url: string;
+  fingerprint: string;
+  changelog: string;
+  min_bridge_version: [number, number, number];
+  version: VersionArray;
+  min_firmware_version: VersionArray;
+  min_bootloader_version: VersionArray;
+  bootloader_version?: VersionArray;
+  url_bitcoinonly?: string;
+  fingerprint_bitcoinonly?: string;
+  notes?: string;
+  rollout?: number;
+  channel?: string;
+};
+
+export type ReleaseInfo = {
+  changelog: FirmwareRelease[] | null;
+  release: FirmwareRelease;
+  isLatest: boolean;
+  latest: FirmwareRelease;
+  isRequired: boolean | null;
+  isNewer: boolean | null;
+};
+
+export type TransportReleaseStatus = 'valid' | 'outdated';

package/src/types/global.d.ts

@@ -0,0 +1,3 @@
+interface Window {
+  ONETOKEN_CONNECT_SRC?: string;
+}

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './device';
+export * from './firmware';
+export * from './settings';
+export * from './params';

package/src/types/params.ts

@@ -0,0 +1,64 @@
+export interface CommonParams {
+  keepSession?: boolean;
+  /**
+   * polling connect max retry count
+   */
+  retryCount?: number;
+  /**
+   * polling interval time
+   */
+  pollIntervalTime?: number;
+  /**
+   * Timeout time for single polling
+   */
+  timeout?: number;
+  /**
+   * passphrase state
+   */
+  passphraseState?: string;
+  /**
+   * Use empty passphrase
+   */
+  useEmptyPassphrase?: boolean;
+  /**
+   * Every init session
+   */
+  initSession?: boolean;
+
+  /**
+   * Use derive cardano
+   */
+  deriveCardano?: boolean;
+
+  // Detect hardware that is in bootloader mode and return an error
+  detectBootloaderDevice?: boolean;
+
+  /**
+   * Skip web device prompt
+   */
+  skipWebDevicePrompt?: boolean;
+
+  /**
+   * Skip passphrase check
+   */
+  skipPassphraseCheck?: boolean;
+
+  /**
+   * Only connect device, not initialize device, only ble connect
+   */
+  onlyConnectBleDevice?: boolean;
+}
+
+export type Params<T> = CommonParams & T & { bundle?: undefined };
+
+export interface Unsuccessful {
+  success: false;
+  payload: { error: string; code?: string | number };
+}
+
+export interface Success<T> {
+  success: true;
+  payload: T;
+}
+
+export type Response<T> = Promise<Success<T> | Unsuccessful>;

package/src/types/settings.ts

@@ -0,0 +1,144 @@
+import type { EFirmwareType } from '@onetokenfe/hd-shared';
+import type { IDeviceType } from './device';
+
+export type transportEnv =
+  | 'node'
+  | 'web'
+  | 'webextension'
+  | 'electron'
+  | 'react-native'
+  | 'webusb'
+  | 'desktop-webusb'
+  | 'desktop-web-ble'
+  | 'emulator'
+  | 'lowlevel';
+export type ConnectSettings = {
+  connectSrc?: string;
+  debug?: boolean;
+  transportReconnect?: boolean;
+  lazyLoad?: boolean;
+  // internal part, not to be accepted from .init()
+  origin?: string;
+  parentOrigin?: string; // parent window origin
+  configSrc: string;
+  iframeSrc: string;
+  version: string;
+  priority: number;
+  trustedHost: boolean;
+  supportedBrowser?: boolean;
+  env: transportEnv;
+  timestamp: number;
+  isFrame?: boolean;
+  preRelease?: boolean;
+  fetchConfig?: boolean;
+  extension?: string;
+  configFetcher?: (url: string) => Promise<RemoteConfigResponse | null>;
+};
+
+export type IVersionArray = [number, number, number];
+
+export type ILocale = 'zh-CN' | 'en-US';
+
+/** STM32 firmware config */
+export type IFirmwareReleaseInfo = {
+  required: boolean;
+  url: string;
+  /**
+   * Firmware type (bitcoinonly or universal)
+   * This field is not present in the remote config, but will be inferred from the firmware field name
+   */
+  firmwareType?: EFirmwareType;
+  /** Firmware UI resource */
+  resource?: string;
+  /** Firmware full UI resource */
+  fullResource?: string;
+  fullResourceRange?: string[];
+  bootloaderResource?: string;
+  bootloaderVersion?: IVersionArray;
+  displayBootloaderVersion?: IVersionArray;
+  bootloaderRelatedFirmwareVersion?: IVersionArray;
+  bootloaderChangelog?: {
+    [k in ILocale]: string;
+  };
+  fingerprint: string;
+  version: IVersionArray;
+  changelog: {
+    [k in ILocale]: string;
+  };
+};
+
+/** BLE firmware config */
+export type IBLEFirmwareReleaseInfo = {
+  required: boolean;
+  /** bluetooth dfu version */
+  url: string;
+  /** stm bluetooth update version */
+  webUpdate: string;
+  fingerprint: string;
+  fingerprintWeb: string;
+  version: IVersionArray;
+  changelog: {
+    [k in ILocale]: string;
+  };
+};
+
+type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+
+/**
+ * Device firmware configuration map
+ *
+ * IMPORTANT: This type is used for firmware update logic.
+ * - DO NOT remove existing firmware fields
+ * - Only ADD new optional firmware fields for new versions
+ * - 'firmware' field is required for backward compatibility
+ * - 'ble' field is required for BLE firmware updates
+ *
+ * @example
+ * // When adding firmware-v8:
+ * // {
+ * //   firmware: IFirmwareReleaseInfo[];
+ * //   'firmware-v2'?: IFirmwareReleaseInfo[];
+ * //   'firmware-v8'?: IFirmwareReleaseInfo[];
+ * //   'firmware-v8'?: IFirmwareReleaseInfo[];      // New
+ * //   'firmware-btc-v8'?: IFirmwareReleaseInfo[];
+ * //   'firmware-btc-v8'?: IFirmwareReleaseInfo[];  // New
+ * //   ble: IBLEFirmwareReleaseInfo[];
+ * // }
+ */
+export type DeviceTypeMap = {
+  [k in IKnownDevice]: {
+    /** Base firmware field (required for backward compatibility) */
+    firmware: IFirmwareReleaseInfo[];
+    /** Firmware v2 (Touch/Pro specific) */
+    'firmware-v2'?: IFirmwareReleaseInfo[];
+    /** Universal firmware v7 */
+    'firmware-v8'?: IFirmwareReleaseInfo[];
+    /** Bitcoin-only firmware v7 */
+    'firmware-btc-v8'?: IFirmwareReleaseInfo[];
+    // Future firmware versions should be added here as optional fields:
+    // 'firmware-v8'?: IFirmwareReleaseInfo[];
+    // 'firmware-btc-v8'?: IFirmwareReleaseInfo[];
+    /** BLE firmware (required) */
+    ble: IBLEFirmwareReleaseInfo[];
+  };
+};
+
+export type AssetsMap = {
+  bridge: {
+    version: IVersionArray;
+    linux32Rpm: string;
+    linux64Rpm: string;
+    linux32Deb: string;
+    linux64Deb: string;
+    win: string;
+    mac: string;
+    sha256sumAsc: string;
+    changelog: {
+      [k in ILocale]: string;
+    };
+  };
+};
+
+export type RemoteConfigResponse = {
+  bridge: AssetsMap['bridge'];
+} & DeviceTypeMap;

package/src/utils/arrayUtils.ts

@@ -0,0 +1,7 @@
+export function splitArray<T>(array: T[], size: number): T[][] {
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}

package/src/utils/assets.ts

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

package/src/utils/bridgeUpdate.ts

@@ -0,0 +1,80 @@
+import axios from 'axios';
+import semver from 'semver';
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import { DeviceModelToTypes } from '../types';
+import { DataManager } from '../data-manager';
+
+import type { IDeviceType } from '../types';
+
+const REQUIRED_BRIDGE_VERSION = '2.2.0';
+const TOUCH_NEED_UPDATE_BRIDGE_VERSION = '4.3.0';
+const CLASSIC_MINI_NEED_UPDATE_BRIDGE_VERSION = '3.1.0';
+
+export async function getBridgeReleaseInfo({
+  deviceType,
+  currentFirmwareVersion,
+  willUpdateFirmwareVersion,
+}: {
+  deviceType: IDeviceType;
+  currentFirmwareVersion: string;
+  willUpdateFirmwareVersion?: string;
+}) {
+  try {
+    const { data } = await axios.request({
+      url: 'http://localhost:21320',
+      method: 'POST',
+      withCredentials: false,
+      timeout: 3000,
+    });
+    const { version = '0.0.0' } = data;
+    const isOldVersionBridge = semver.lt(version, REQUIRED_BRIDGE_VERSION);
+
+    let shouldUpdate = false;
+    if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+      if (
+        willUpdateFirmwareVersion &&
+        semver.gte(willUpdateFirmwareVersion, TOUCH_NEED_UPDATE_BRIDGE_VERSION) &&
+        isOldVersionBridge
+      ) {
+        shouldUpdate = true;
+      }
+      if (
+        semver.gte(currentFirmwareVersion, TOUCH_NEED_UPDATE_BRIDGE_VERSION) &&
+        isOldVersionBridge
+      ) {
+        shouldUpdate = true;
+      }
+    }
+
+    if (DeviceModelToTypes.model_mini.includes(deviceType)) {
+      if (
+        willUpdateFirmwareVersion &&
+        semver.gte(willUpdateFirmwareVersion, CLASSIC_MINI_NEED_UPDATE_BRIDGE_VERSION) &&
+        isOldVersionBridge
+      ) {
+        shouldUpdate = true;
+      }
+      if (
+        semver.gte(currentFirmwareVersion, CLASSIC_MINI_NEED_UPDATE_BRIDGE_VERSION) &&
+        isOldVersionBridge
+      ) {
+        shouldUpdate = true;
+      }
+    }
+
+    const changelog = DataManager.getBridgeChangelog();
+
+    return {
+      shouldUpdate,
+      status: shouldUpdate ? 'outdated' : 'valid',
+      releaseVersion: REQUIRED_BRIDGE_VERSION,
+      changelog,
+    };
+  } catch (e) {
+    if (e.code === 'ECONNABORTED') {
+      throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
+    }
+    throw ERRORS.TypedError(HardwareErrorCode.BridgeNotInstalled);
+  }
+}

package/src/utils/capabilitieUtils.ts

@@ -0,0 +1,12 @@
+import type { Enum_Capability } from '@onetokenfe/hd-transport';
+import type { Features } from '../types/device';
+
+export const existCapability = (features?: Features, capability?: Enum_Capability) =>
+  // @ts-expect-error
+  features?.capabilities?.includes(capability);
+
+export const requireCapability = (features: Features, capability: Enum_Capability) => {
+  if (!existCapability(features, capability)) {
+    throw new Error(`Capability ${capability} is required`);
+  }
+};