@onetokenfe/hd-core 1.1.23

package/src/events/firmware.ts

@@ -0,0 +1,43 @@
+import type { MessageFactoryFn } from './utils';
+import type {
+  getBleFirmwareReleaseInfo,
+  getFirmwareReleaseInfo,
+} from '../api/firmware/releaseHelper';
+import type { KnownDevice as Device } from '../types/device';
+
+export const FIRMWARE_EVENT = 'FIRMWARE_EVENT';
+export const FIRMWARE = {
+  RELEASE_INFO: 'firmware-release-info',
+  BLE_RELEASE_INFO: 'ble-firmware-release-info',
+} as const;
+
+export type ReleaseInfoPayload = ReturnType<typeof getFirmwareReleaseInfo> & {
+  device?: Device | null;
+};
+export interface ReleaseInfoEvent {
+  type: typeof FIRMWARE.RELEASE_INFO;
+  payload: ReleaseInfoPayload;
+}
+
+export type BleReleaseInfoPayload = ReturnType<typeof getBleFirmwareReleaseInfo> & {
+  device?: Device | null;
+};
+
+export interface BleReleaseInfoEvent {
+  type: typeof FIRMWARE.BLE_RELEASE_INFO;
+  payload: BleReleaseInfoPayload;
+}
+
+export type FirmwareEvent = ReleaseInfoEvent | BleReleaseInfoEvent;
+
+export type FirmwareMessage = FirmwareEvent & { event: typeof FIRMWARE_EVENT };
+
+export const createFirmwareMessage: MessageFactoryFn<typeof FIRMWARE_EVENT, FirmwareEvent> = (
+  type,
+  payload
+) =>
+  ({
+    event: FIRMWARE_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/iframe.ts

@@ -0,0 +1,55 @@
+import { UI_EVENT } from './ui-request';
+
+import type { MessageFactoryFn } from './utils';
+import type { ConnectSettings } from '../types';
+
+export const IFRAME = {
+  INIT: 'iframe-init',
+  INIT_BRIDGE: 'iframe-init-bridge',
+  CALL: 'iframe-call',
+  CANCEL: 'iframe-cancel',
+  SWITCH_TRANSPORT: 'iframe-switch-transport',
+  CALLBACK: 'iframe-callback',
+} as const;
+
+export interface IFrameInit {
+  type: typeof IFRAME.INIT;
+  payload: {
+    settings: ConnectSettings;
+  };
+}
+
+export interface IFrameBridge {
+  type: typeof IFRAME.INIT_BRIDGE;
+  payload: unknown;
+}
+
+export interface IFrameSwitchTransport {
+  type: typeof IFRAME.SWITCH_TRANSPORT;
+  payload: {
+    env: ConnectSettings['env'];
+  };
+}
+
+export interface IFrameCallback {
+  type: typeof IFRAME.CALLBACK;
+  payload: {
+    callbackId: string;
+    data?: any;
+    error?: any;
+    finished?: boolean;
+  };
+}
+
+export type IFrameEvent = IFrameInit | IFrameBridge | IFrameSwitchTransport | IFrameCallback;
+export type IFrameEventMessage = IFrameEvent & { event: typeof UI_EVENT };
+
+export const createIFrameMessage: MessageFactoryFn<typeof UI_EVENT, IFrameEvent> = (
+  type,
+  payload
+) =>
+  ({
+    event: UI_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/index.ts

@@ -0,0 +1,10 @@
+export * from './core';
+export * from './iframe';
+export * from './call';
+export * from './ui-request';
+export * from './ui-promise';
+export * from './ui-response';
+export * from './device';
+export * from './log';
+export * from './firmware';
+export * from './logBlockEvent';

package/src/events/log.ts

@@ -0,0 +1,23 @@
+import type { MessageFactoryFn } from './utils';
+
+export const LOG_EVENT = 'LOG_EVENT';
+
+export const LOG = {
+  OUTPUT: 'log-output',
+} as const;
+
+export interface LogOutput {
+  type: typeof LOG.OUTPUT;
+  payload: any;
+}
+
+export type LogEvent = LogOutput;
+
+export type LogEventMessage = LogEvent & { event: typeof LOG_EVENT };
+
+export const createLogMessage: MessageFactoryFn<typeof LOG_EVENT, LogEvent> = (type, payload) =>
+  ({
+    event: LOG_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/logBlockEvent.ts

@@ -0,0 +1,6 @@
+import { UI_RESPONSE } from './ui-response';
+
+export const LogBlockEvent: Set<string> = new Set([
+  UI_RESPONSE.RECEIVE_PIN,
+  UI_RESPONSE.RECEIVE_PASSPHRASE,
+]);

package/src/events/ui-promise.ts

@@ -0,0 +1,14 @@
+import type { Deferred } from '@onetokenfe/hd-shared';
+import type { DEVICE } from './device';
+import type { Device } from '../device/Device';
+import type { UiResponseEvent } from './ui-response';
+
+export type UiPromiseResponse =
+  | UiResponseEvent
+  | { type: typeof DEVICE.DISCONNECT; payload?: undefined };
+
+export type UiPromise<T extends UiPromiseResponse['type']> = Deferred<
+  Extract<UiPromiseResponse, { type: T }>,
+  T,
+  Device
+>;

package/src/events/ui-request.ts

@@ -0,0 +1,216 @@
+import type { PROTO } from '../constants';
+import type { Device } from '../types';
+import type { DeviceButtonRequest } from './device';
+import type { MessageFactoryFn } from './utils';
+
+export const UI_EVENT = 'UI_EVENT';
+
+export const UI_REQUEST = {
+  REQUEST_PIN: 'ui-request_pin',
+  INVALID_PIN: 'ui-invalid_pin',
+  REQUEST_BUTTON: 'ui-button',
+  REQUEST_PASSPHRASE: 'ui-request_passphrase',
+  REQUEST_PASSPHRASE_ON_DEVICE: 'ui-request_passphrase_on_device',
+  REQUEST_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE:
+    'ui-request_select_device_in_bootloader_for_web_device',
+  REQUEST_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE:
+    'ui-request_select_device_for_switch_firmware_web_device',
+
+  CLOSE_UI_WINDOW: 'ui-close_window',
+  CLOSE_UI_PIN_WINDOW: 'ui-close_pin_window',
+  DEVICE_PROGRESS: 'ui-device_progress',
+
+  BLUETOOTH_PERMISSION: 'ui-bluetooth_permission',
+  BLUETOOTH_UNSUPPORTED: 'ui-bluetooth_unsupported',
+  BLUETOOTH_POWERED_OFF: 'ui-bluetooth_powered_off',
+
+  BLUETOOTH_CHARACTERISTIC_NOTIFY_CHANGE_FAILURE:
+    'ui-bluetooth_characteristic_notify_change_failure',
+  LOCATION_PERMISSION: 'ui-location_permission',
+  LOCATION_SERVICE_PERMISSION: 'ui-location_service_permission',
+
+  FIRMWARE_PROCESSING: 'ui-firmware-processing',
+  FIRMWARE_PROGRESS: 'ui-firmware-progress',
+  FIRMWARE_TIP: 'ui-firmware-tip',
+
+  PREVIOUS_ADDRESS_RESULT: 'ui-previous_address_result',
+
+  WEB_DEVICE_PROMPT_ACCESS_PERMISSION: 'ui-web_device_prompt_access_permission',
+
+  BOOTLOADER: 'ui-device_bootloader_mode',
+  NOT_IN_BOOTLOADER: 'ui-device_not_in_bootloader_mode',
+  REQUIRE_MODE: 'ui-device_require_mode',
+  NOT_INITIALIZE: 'ui-device_not_initialized',
+  SEEDLESS: 'ui-device_seedless',
+  FIRMWARE_OLD: 'ui-device_firmware_old',
+  FIRMWARE_NOT_SUPPORTED: 'ui-device_firmware_unsupported',
+  FIRMWARE_NOT_COMPATIBLE: 'ui-device_firmware_not_compatible',
+  FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
+  NOT_USE_ONETOKEN_DEVICE: 'ui-device_please_use_onetoken_device',
+} as const;
+
+export interface UiRequestWithoutPayload {
+  type:
+    | typeof UI_REQUEST.CLOSE_UI_WINDOW
+    | typeof UI_REQUEST.CLOSE_UI_PIN_WINDOW
+    | typeof UI_REQUEST.BLUETOOTH_PERMISSION
+    | typeof UI_REQUEST.BLUETOOTH_UNSUPPORTED
+    | typeof UI_REQUEST.BLUETOOTH_POWERED_OFF
+    | typeof UI_REQUEST.BLUETOOTH_CHARACTERISTIC_NOTIFY_CHANGE_FAILURE
+    | typeof UI_REQUEST.LOCATION_PERMISSION
+    | typeof UI_REQUEST.LOCATION_SERVICE_PERMISSION
+    | typeof UI_REQUEST.FIRMWARE_PROCESSING
+    | typeof UI_REQUEST.WEB_DEVICE_PROMPT_ACCESS_PERMISSION;
+  payload?: typeof undefined;
+}
+
+export interface UiRequestFirmwareProgressing {
+  type: typeof UI_REQUEST.FIRMWARE_PROCESSING;
+  payload: {
+    type: 'firmware' | 'ble' | 'bootloader' | 'resource';
+  };
+}
+
+export type UiRequestDeviceAction = {
+  type: typeof UI_REQUEST.REQUEST_PIN;
+  payload: {
+    device: Device;
+    type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry' | 'ButtonRequest_AttachPin';
+  };
+};
+
+export interface UiRequestButton {
+  type: typeof UI_REQUEST.REQUEST_BUTTON;
+  payload: DeviceButtonRequest['payload'];
+}
+
+export interface UiRequestPassphrase {
+  type: typeof UI_REQUEST.REQUEST_PASSPHRASE;
+  payload: {
+    device: Device;
+    passphraseState?: string;
+    existsAttachPinUser?: boolean;
+  };
+}
+
+export interface UiRequestPassphraseOnDevice {
+  type: typeof UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE;
+  payload: {
+    device: Device;
+    passphraseState?: string;
+  };
+}
+
+export interface UiRequestSelectDeviceInBootloaderForWebDevice {
+  type: typeof UI_REQUEST.REQUEST_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE;
+  payload: {
+    device: Device;
+  };
+}
+
+export interface UiRequestSelectDeviceForSwitchFirmwareWebDevice {
+  type: typeof UI_REQUEST.REQUEST_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE;
+  payload: {
+    device: Device;
+  };
+}
+
+export interface FirmwareProcessing {
+  type: typeof UI_REQUEST.FIRMWARE_PROCESSING;
+  payload: {
+    type: 'firmware' | 'ble' | 'bootloader' | 'resource';
+  };
+}
+
+export type IFirmwareUpdateProgressType = 'transferData' | 'installingFirmware';
+export interface FirmwareProgress {
+  type: typeof UI_REQUEST.FIRMWARE_PROGRESS;
+  payload: {
+    device: Device;
+    progress: number;
+    progressType: IFirmwareUpdateProgressType;
+  };
+}
+
+export interface FirmwareTip {
+  type: typeof UI_REQUEST.FIRMWARE_TIP;
+  payload: {
+    device: Device;
+    data: { message: string };
+  };
+}
+
+export interface DeviceProgress {
+  type: typeof UI_REQUEST.DEVICE_PROGRESS;
+  payload: {
+    progress?: number;
+  };
+}
+
+export interface PreviousAddressResult {
+  type: typeof UI_REQUEST.PREVIOUS_ADDRESS_RESULT;
+  payload: {
+    device: Device;
+    data: {
+      address?: string;
+      path?: string;
+    };
+  };
+}
+
+export type UiEvent =
+  | UiRequestWithoutPayload
+  | UiRequestDeviceAction
+  | UiRequestButton
+  | UiRequestPassphraseOnDevice
+  | UiRequestPassphrase
+  | UiRequestSelectDeviceInBootloaderForWebDevice
+  | UiRequestSelectDeviceForSwitchFirmwareWebDevice
+  | FirmwareProcessing
+  | UiRequestSelectDeviceInBootloaderForWebDevice
+  | FirmwareProgress
+  | FirmwareTip
+  | DeviceProgress
+  | PreviousAddressResult;
+
+export enum FirmwareUpdateTipMessage {
+  CheckLatestUiResource = 'CheckLatestUiResource',
+
+  StartDownloadFirmware = 'StartDownloadFirmware',
+  FinishDownloadFirmware = 'FinishDownloadFirmware',
+  DownloadLatestUiResource = 'DownloadLatestUiResource',
+  DownloadFirmware = 'DownloadFirmware',
+  DownloadBleFirmware = 'DownloadBleFirmware',
+  DownloadLatestBootloaderResource = 'DownloadLatestBootloaderResource',
+
+  DownloadLatestUiResourceSuccess = 'DownloadLatestUiResourceSuccess',
+  DownloadFirmwareSuccess = 'DownloadFirmwareSuccess',
+  DownloadBleFirmwareSuccess = 'DownloadBleFirmwareSuccess',
+  DownloadLatestBootloaderResourceSuccess = 'DownloadLatestBootloaderResourceSuccess',
+
+  AutoRebootToBootloader = 'AutoRebootToBootloader',
+  GoToBootloaderSuccess = 'GoToBootloaderSuccess',
+  SelectDeviceInBootloaderForWebDevice = 'SelectDeviceInBootloaderForWebDevice',
+  SwitchFirmwareReconnectDevice = 'SwitchFirmwareReconnectDevice',
+  ConfirmOnDevice = 'ConfirmOnDevice',
+  FirmwareEraseSuccess = 'FirmwareEraseSuccess',
+  StartTransferData = 'StartTransferData',
+  InstallingFirmware = 'InstallingFirmware',
+  UpdateBootloader = 'UpdateBootloader',
+  UpdateBootloaderSuccess = 'UpdateBootloaderSuccess',
+  UpdateSysResource = 'UpdateSysResource',
+  UpdateSysResourceSuccess = 'UpdateSysResourceSuccess',
+  FirmwareUpdating = 'FirmwareUpdating',
+  FirmwareUpdateCompleted = 'FirmwareUpdateCompleted',
+}
+
+export type IFirmwareUpdateTipMessage = `${FirmwareUpdateTipMessage}`;
+
+export type UiEventMessage = UiEvent & { event: typeof UI_EVENT };
+
+export const createUiMessage: MessageFactoryFn<typeof UI_EVENT, UiEvent> = (type, payload) =>
+  ({
+    event: UI_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/ui-response.ts

@@ -0,0 +1,59 @@
+import { UI_EVENT } from './ui-request';
+
+import type { MessageFactoryFn } from './utils';
+
+export const UI_RESPONSE = {
+  RECEIVE_PIN: 'ui-receive_pin',
+  RECEIVE_PASSPHRASE: 'ui-receive_passphrase',
+  SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE:
+    'ui-receive_select-device-in-bootloader-for-web-device',
+  SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE:
+    'ui-receive_select-device-for-switch-firmware-web-device',
+} as const;
+
+export interface UiResponsePin {
+  type: typeof UI_RESPONSE.RECEIVE_PIN;
+  payload: string;
+}
+
+export interface UiResponsePassphrase {
+  type: typeof UI_RESPONSE.RECEIVE_PASSPHRASE;
+  payload: {
+    value: string;
+    passphraseOnDevice?: boolean;
+    attachPinOnDevice?: boolean;
+    save?: boolean;
+  };
+}
+
+export interface UiResponseSelectDeviceInBootloaderForWebDevice {
+  type: typeof UI_RESPONSE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE;
+  payload: {
+    deviceId: string;
+  };
+}
+
+export interface UiResponseSelectDeviceForSwitchFirmwareWebDevice {
+  type: typeof UI_RESPONSE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE;
+  payload: {
+    deviceId: string;
+  };
+}
+
+export type UiResponseEvent =
+  | UiResponsePin
+  | UiResponsePassphrase
+  | UiResponseSelectDeviceInBootloaderForWebDevice
+  | UiResponseSelectDeviceForSwitchFirmwareWebDevice;
+
+export type UiResponseMessage = UiResponseEvent & { event: typeof UI_EVENT };
+
+export const createUiResponse: MessageFactoryFn<typeof UI_EVENT, UiResponseEvent> = (
+  type,
+  payload
+) =>
+  ({
+    event: UI_EVENT,
+    type,
+    payload,
+  } as any);

package/src/events/utils.ts

@@ -0,0 +1,19 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I
+) => void
+  ? I
+  : never;
+
+export type MessageFactoryFn<Group, Event> = UnionToIntersection<
+  Event extends { type: string }
+    ? Event extends { payload: any }
+      ? (
+          type: Event['type'],
+          payload: Event['payload']
+        ) => { event: Group; type: Event['type']; payload: Event['payload'] }
+      : (
+          type: Event['type'],
+          payload?: undefined
+        ) => { event: Group; type: Event['type']; payload: undefined }
+    : never
+>;

package/src/index.ts

@@ -0,0 +1,70 @@
+import { cleanupCallback, executeCallback, inject } from './inject';
+import { lowLevelInject } from './lowLevelInject';
+import { topLevelInject } from './topLevelInject';
+
+import type { LowLevelCoreApi, LowLevelInjectApi } from './lowLevelInject';
+import type { InjectApi } from './inject';
+import type { CoreApi } from './types/api';
+
+export type { LowLevelCoreApi, LowLevelInjectApi } from './lowLevelInject';
+export type { TopLevelInjectApi } from './topLevelInject';
+
+export { default as Core, init as initCore, switchTransport } from './core';
+
+export * from './constants';
+export * from './utils';
+export * from './data-manager';
+export * from './events';
+export * from './types';
+export { whitelist, whitelistExtension } from './data/config';
+export { executeCallback, cleanupCallback };
+
+const HardwareSdk = ({
+  init,
+  call,
+  dispose,
+  eventEmitter,
+  uiResponse,
+  cancel,
+  updateSettings,
+  switchTransport,
+}: InjectApi): CoreApi =>
+  inject({
+    init,
+    call,
+    dispose,
+    eventEmitter,
+    uiResponse,
+    cancel,
+    updateSettings,
+    switchTransport,
+  });
+
+const HardwareSDKLowLevel = ({
+  init,
+  call,
+  dispose,
+  eventEmitter,
+  addHardwareGlobalEventListener,
+  uiResponse,
+  cancel,
+  updateSettings,
+  switchTransport,
+}: LowLevelInjectApi): LowLevelCoreApi =>
+  lowLevelInject({
+    init,
+    call,
+    dispose,
+    eventEmitter,
+    addHardwareGlobalEventListener,
+    uiResponse,
+    cancel,
+    updateSettings,
+    switchTransport,
+  });
+
+const HardwareTopLevelSdk = (): CoreApi => topLevelInject();
+
+export { HardwareTopLevelSdk, HardwareSDKLowLevel };
+
+export default HardwareSdk;