@onekeyfe/hd-core 1.0.39-alpha.0 → 1.0.39-alpha.10

package/src/device/Device.ts

@@ -298,13 +298,13 @@ export class Device extends EventEmitter {
   }
 
   getInternalState(_deviceId?: string) {
+    Log.debug('getInternalState session cache: ', deviceSessionCache);
     Log.debug(
       'getInternalState session param: ',
       `device_id: ${_deviceId}`,
       `features.device_id: ${this.features?.device_id}`,
       `passphraseState: ${this.passphraseState}`
     );
-    Log.debug('getInternalState session cache: ', deviceSessionCache);
 
     const deviceId = _deviceId || this.features?.device_id;
     if (!deviceId) return undefined;
@@ -314,42 +314,38 @@ export class Device extends EventEmitter {
     return deviceSessionCache[usePassKey];
   }
 
-  tryFixInternalState(state: string, deviceId: string, sessionId: string | null = null) {
-    Log.debug(
-      'tryFixInternalState session param: ',
-      `device_id: ${deviceId}`,
-      `passphraseState: ${state}`,
-      `sessionId: ${sessionId}`
-    );
-
-    const key = `${deviceId}`;
-    const session = deviceSessionCache[key];
-    if (session) {
-      deviceSessionCache[this.generateStateKey(deviceId, state)] = session;
-      delete deviceSessionCache[key];
-    } else if (sessionId) {
-      deviceSessionCache[this.generateStateKey(deviceId, state)] = sessionId;
-    }
-    Log.debug('tryFixInternalState session cache: ', deviceSessionCache);
-  }
-
   // attach to pin to fix internal state
-  updateInternalState(state: string, deviceId: string, sessionId: string | null = null) {
+  updateInternalState(
+    enablePassphrase: boolean,
+    passphraseState: string | undefined,
+    deviceId: string,
+    sessionId: string | null = null,
+    featuresSessionId: string | null = null
+  ) {
     Log.debug(
       'updateInternalState session param: ',
       `device_id: ${deviceId}`,
-      `passphraseState: ${state}`,
-      `sessionId: ${sessionId}`
+      `enablePassphrase: ${enablePassphrase}`,
+      `passphraseState: ${passphraseState}`,
+      `sessionId: ${sessionId}`,
+      `featuresSessionId: ${featuresSessionId}`
     );
 
-    if (sessionId) {
-      deviceSessionCache[this.generateStateKey(deviceId, state)] = sessionId;
-      // delete the old sessionId
-      const oldKey = `${deviceId}`;
-      if (deviceSessionCache[oldKey]) {
-        delete deviceSessionCache[oldKey];
+    if (enablePassphrase) {
+      // update the sessionId
+      if (sessionId) {
+        deviceSessionCache[this.generateStateKey(deviceId, passphraseState)] = sessionId;
+      } else if (featuresSessionId) {
+        deviceSessionCache[this.generateStateKey(deviceId, passphraseState)] = featuresSessionId;
       }
     }
+
+    // delete the old sessionId
+    const oldKey = `${deviceId}`;
+    if (deviceSessionCache[oldKey]) {
+      delete deviceSessionCache[oldKey];
+    }
+
     Log.debug('updateInternalState session cache: ', deviceSessionCache);
   }
 
@@ -409,12 +405,13 @@ export class Device extends EventEmitter {
       payload.derive_cardano = true;
     }
     payload.passphrase_state = options?.passphraseState;
+    payload.is_contains_attach = true;
 
-    // Log.debug('initialize payload:', payload);
-    console.log('=====>>>>>> initialize device begin: ', payload, {
+    Log.debug('Initialize device begin:', {
       deviceId: options?.deviceId,
       passphraseState: options?.passphraseState,
       initSession: options?.initSession,
+      InitializePayload: payload,
     });
 
     try {
@@ -429,7 +426,7 @@ export class Device extends EventEmitter {
         }),
       ]);
 
-      console.log('=====>>>>>> initialize device end: ', message);
+      Log.debug('Initialize device end: ', message);
       this._updateFeatures(message, options?.initSession);
       await TransportManager.reconfigure(this.features);
     } catch (error) {
@@ -737,14 +734,14 @@ export class Device extends EventEmitter {
 
   async checkPassphraseStateSafety(
     passphraseState?: string,
-    useEmptyPassphraseState?: boolean,
+    useEmptyPassphrase?: boolean,
     skipPassphraseCheck?: boolean
   ) {
     if (!this.features) return false;
     const { passphraseState: newPassphraseState, unlockedAttachPin } =
       await getPassphraseStateWithRefreshDeviceInfo(this, {
         expectPassphraseState: passphraseState,
-        onlyMainPin: useEmptyPassphraseState,
+        onlyMainPin: useEmptyPassphrase,
       });
 
     if (skipPassphraseCheck) {
@@ -752,15 +749,15 @@ export class Device extends EventEmitter {
     }
 
     // Main wallet and unlock Attach Pin, throw safe error
-    const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphraseState;
+    const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphrase;
     const useErrorAttachPin =
       unlockedAttachPin && passphraseState && passphraseState !== newPassphraseState;
 
-    console.log('=====>>>>>> checkPassphraseStateSafety passphraseState: ', {
+    Log.debug('Check passphrase state safety: ', {
       passphraseState,
       newPassphraseState,
       unlockedAttachPin,
-      useEmptyPassphraseState,
+      useEmptyPassphrase,
     });
 
     if (mainWalletUseAttachPin || useErrorAttachPin) {

package/src/device/DeviceCommands.ts

@@ -218,7 +218,6 @@ export class DeviceCommands {
       this.callPromise = promise;
       const res = await promise;
       Log.debug('[DeviceCommands] [call] Received', res.type);
-      console.log('[DeviceCommands] [call] Received', res.type);
       return res;
     } catch (error) {
       Log.debug('[DeviceCommands] [call] Received error', error);

package/src/events/ui-request.ts

@@ -18,6 +18,9 @@ export const UI_REQUEST = {
   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',
@@ -47,6 +50,8 @@ export interface UiRequestWithoutPayload {
   type:
     | typeof UI_REQUEST.CLOSE_UI_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

package/src/types/settings.ts

@@ -14,7 +14,16 @@ export type ConnectSettings = {
   priority: number;
   trustedHost: boolean;
   supportedBrowser?: boolean;
-  env: 'node' | 'web' | 'webextension' | 'electron' | 'react-native' | 'webusb' | 'lowlevel';
+  env:
+    | 'node'
+    | 'web'
+    | 'webextension'
+    | 'electron'
+    | 'react-native'
+    | 'webusb'
+    | 'emulator'
+    | 'desktop-web-ble'
+    | 'lowlevel';
   timestamp: number;
   isFrame?: boolean;
   preRelease?: boolean;

package/src/utils/capabilitieUtils.ts

@@ -0,0 +1,12 @@
+import { Enum_Capability } from '@onekeyfe/hd-transport';
+import { 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`);
+  }
+};

package/src/utils/deviceFeaturesUtils.ts

@@ -91,12 +91,6 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     }
   );
 
-  // Attach to pin try to fix internal state
-  if (newSession && passphraseState && features?.device_id) {
-    console.log('=====>>>>>> run updateInternalState newSession:', newSession);
-    device.updateInternalState(passphraseState, features.device_id, newSession);
-  }
-
   const isModeT =
     getDeviceType(features) === EDeviceType.Touch || getDeviceType(features) === EDeviceType.Pro;
 
@@ -112,6 +106,17 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     await device.getFeatures();
   }
 
+  // Attach to pin try to fix internal state
+  if (features?.device_id) {
+    device.updateInternalState(
+      device.features?.passphrase_protection ?? false,
+      passphraseState,
+      device.features?.device_id ?? '',
+      newSession,
+      device.features?.session_id
+    );
+  }
+
   return { passphraseState, newSession, unlockedAttachPin };
 };
 
@@ -121,7 +126,6 @@ export const getPassphraseState = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
-    // createAttachPinWallet?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
@@ -134,21 +138,11 @@ export const getPassphraseState = async (
   const firmwareVersion = getDeviceFirmwareVersion(features);
   const deviceType = getDeviceType(features);
 
-  if (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.14.0')) {
-    console.log(
-      '=====>>>>>> getPassphraseState begin: ',
-      options?.onlyMainPin,
-      options?.expectPassphraseState
-    );
-
+  if (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.15.0')) {
     const { message, type } = await commands.typedCall('GetPassphraseState', 'PassphraseState', {
       passphrase_state: options?.onlyMainPin ? undefined : options?.expectPassphraseState,
-      // allow_create_attach_pin: options?.createAttachPinWallet,
-      // _only_main_pin: options?.onlyMainPin,
     });
 
-    console.log('=====>>>>>> getPassphraseState end: result ', message);
-
     // @ts-expect-error
     if (type === 'CallMethodError') {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Get the passphrase state error');

package/src/utils/deviceInfoUtils.ts

@@ -1,8 +1,10 @@
 import { isEmpty } from 'lodash';
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { Enum_Capability } from '@onekeyfe/hd-transport';
 import { DeviceModelToTypes } from '../types';
 
 import type { Features, IDeviceModel, IDeviceType, IVersionRange } from '../types';
+import { existCapability } from './capabilitieUtils';
 
 /**
  * get device type by features
@@ -148,3 +150,17 @@ export const getMethodVersionRange = (
 
   return versionRange;
 };
+
+export const getFirmwareType = (features: Features | undefined) => {
+  if (!features) {
+    return EFirmwareType.Universal;
+  }
+  if (features.fw_vendor === 'OneKey Bitcoin-only') {
+    return EFirmwareType.BitcoinOnly;
+  }
+  // old firmware
+  return features?.capabilities?.length > 0 &&
+    !existCapability(features, Enum_Capability.Capability_Bitcoin_like)
+    ? EFirmwareType.BitcoinOnly
+    : EFirmwareType.Universal;
+};

package/src/utils/index.ts

@@ -10,6 +10,7 @@ export {
   getDeviceUUID,
   getDeviceLabel,
   getMethodVersionRange,
+  getFirmwareType,
 } from './deviceInfoUtils';
 export {
   getDeviceBoardloaderVersion,

package/src/utils/logger.ts

@@ -157,6 +157,7 @@ export enum LoggerNames {
   HdTransportHttp = '@onekey/hd-transport-http',
   HdTransportLowLevel = '@onekey/hd-transport-lowlevel',
   HdBleTransport = '@onekey/hd-ble-transport',
+  HdWebBleTransport = '@onekey/hd-web-ble-transport',
   Connect = '@onekey/connect',
   Iframe = 'IFrame',
   SendMessage = '[SendMessage]',
@@ -174,6 +175,7 @@ export const LoggerMap = {
   [LoggerNames.HdBleSdk]: initLog(LoggerNames.HdBleSdk),
   [LoggerNames.HdTransportHttp]: initLog(LoggerNames.HdTransportHttp),
   [LoggerNames.HdBleTransport]: initLog(LoggerNames.HdBleTransport),
+  [LoggerNames.HdWebBleTransport]: initLog(LoggerNames.HdWebBleTransport),
   [LoggerNames.HdTransportLowLevel]: initLog(LoggerNames.HdTransportLowLevel),
   [LoggerNames.Connect]: initLog(LoggerNames.Connect),
   [LoggerNames.Iframe]: initLog(LoggerNames.Iframe),