@onekeyfe/hd-core 1.0.36-alpha.1 → 1.0.37-alpha.3

package/src/api/device/DeviceUnlock.ts

@@ -0,0 +1,26 @@
+import { LockDevice } from '@onekeyfe/hd-transport';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { BaseMethod } from '../BaseMethod';
+import { toHardened } from '../helpers/pathUtils';
+
+export default class DeviceUnlock extends BaseMethod<LockDevice> {
+  init() {
+    this.useDevicePassphraseState = false;
+  }
+
+  async run() {
+    const { type } = await this.device.commands.typedCall('GetAddress', 'Address', {
+      address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
+      coin_name: 'Testnet',
+      script_type: 'SPENDADDRESS',
+      show_display: false,
+    });
+
+    // @ts-expect-error
+    if (type === 'CallMethodError') {
+      throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Get the passphrase state error');
+    }
+    const res = await this.device.commands.typedCall('GetFeatures', 'Features');
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -306,9 +306,9 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
       let progress: number;
       if (totalSize !== undefined && processedSize !== undefined) {
         currentFileProcessed = processedSize + chunkEnd;
-        progress = Math.min(Math.floor((currentFileProcessed / totalSize) * 100), 100);
+        progress = Math.min(Math.ceil((currentFileProcessed / totalSize) * 100), 99);
       } else {
-        progress = Math.min(Math.round(((i + 1) / totalChunks) * 100), 100);
+        progress = Math.min(Math.ceil(((i + 1) / totalChunks) * 100), 99);
       }
 
       const writeRes = await this.emmcFileWriteWithRetry(

package/src/api/index.ts

@@ -27,6 +27,7 @@ export { default as deviceWipe } from './device/DeviceWipe';
 export { default as deviceFullyUploadResource } from './device/DeviceFullyUploadResource';
 export { default as deviceUpdateBootloader } from './device/DeviceUpdateBootloader';
 export { default as deviceLock } from './device/DeviceLock';
+export { default as deviceUnlock } from './device/DeviceUnlock';
 export { default as deviceCancel } from './device/DeviceCancel';
 
 export { default as setU2FCounter } from './u2f/SetU2FCounter';

package/src/api/stellar/StellarSignTransaction.ts

@@ -194,9 +194,6 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
         this.operations.push(transformed);
       }
     });
-
-    console.log('StellarSignTransactionParams', this.params);
-    console.log('StellarSignTransactionOperations', this.operations);
   }
 
   processTxRequest = async (operations: any, index: number): Promise<StellarSignedTx> => {

package/src/core/index.ts

@@ -342,7 +342,9 @@ const onCallDevice = async (
 
         // Check Device passphrase State
         const passphraseStateSafety = await device.checkPassphraseStateSafety(
-          method.payload?.passphraseState
+          method.payload?.passphraseState,
+          method.payload?.useEmptyPassphrase,
+          method.payload?.skipPassphraseCheck
         );
 
         // Double check, handles the special case of Touch/Pro
@@ -354,6 +356,9 @@ const onCallDevice = async (
             ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError)
           );
         }
+
+        // close pin popup window
+        postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_WINDOW));
       }
 
       // Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
@@ -774,7 +779,7 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
   if (
     features?.passphrase_protection === true &&
     (method.payload.passphraseState == null || method.payload.passphraseState === '') &&
-    !method.payload.useEmptyPassphrase
+    (!method.payload.useEmptyPassphrase || !method.payload.skipPassphraseCheck)
   ) {
     DevicePool.clearDeviceCache(method.payload.connectId);
     throw ERRORS.TypedError(HardwareErrorCode.DeviceOpenedPassphrase);
@@ -836,12 +841,12 @@ const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin
 const onDeviceButtonHandler = (...[device, request]: [...DeviceEvents['button']]) => {
   postMessage(createDeviceMessage(DEVICE.BUTTON, { ...request, device: device.toMessageObject() }));
 
-  if (request.code === 'ButtonRequest_PinEntry') {
-    Log.log('request Confirm Input PIN');
+  if (request.code === 'ButtonRequest_PinEntry' || request.code === 'ButtonRequest_AttachPin') {
+    Log.log('request Confirm Input PIN or Attach PIN');
     postMessage(
       createUiMessage(UI_REQUEST.REQUEST_PIN, {
         device: device.toMessageObject() as KnownDevice,
-        type: 'ButtonRequest_PinEntry',
+        type: request.code,
       })
     );
   } else {
@@ -854,27 +859,31 @@ const onDeviceFeaturesHandler = (...[_, features]: [...DeviceEvents['features']]
   postMessage(createDeviceMessage(DEVICE.FEATURES, { ...features }));
 };
 
-const onDevicePassphraseHandler = async (...[device, callback]: DeviceEvents['passphrase']) => {
+const onDevicePassphraseHandler = async (
+  ...[device, requestPayload, callback]: DeviceEvents['passphrase']
+) => {
   Log.debug('onDevicePassphraseHandler');
   const uiPromise = createUiPromise(UI_RESPONSE.RECEIVE_PASSPHRASE, device);
   postMessage(
     createUiMessage(UI_REQUEST.REQUEST_PASSPHRASE, {
       device: device.toMessageObject() as KnownDevice,
       passphraseState: device.passphraseState,
+      existsAttachPinUser: requestPayload.existsAttachPinUser,
     })
   );
   // wait for passphrase
   const uiResp = await uiPromise.promise;
-  const { value, passphraseOnDevice, save } = uiResp.payload;
+  const { value, passphraseOnDevice, save, attachPinOnDevice } = uiResp.payload;
   // send as PassphrasePromptResponse
   callback({
     passphrase: value.normalize('NFKD'),
     passphraseOnDevice,
+    attachPinOnDevice,
     cache: save,
   });
 };
 
-const onEmptyPassphraseHandler = (...[_, callback]: DeviceEvents['passphrase']) => {
+const onEmptyPassphraseHandler = (...[_, , callback]: DeviceEvents['passphrase']) => {
   Log.debug('onEmptyPassphraseHandler');
   // send as PassphrasePromptResponse
   callback({ passphrase: '' });

package/src/data/messages/messages.json

@@ -3021,7 +3021,8 @@
             "ButtonRequest_Success": 17,
             "ButtonRequest_Warning": 18,
             "ButtonRequest_PassphraseEntry": 19,
-            "ButtonRequest_PinEntry": 20
+            "ButtonRequest_PinEntry": 20,
+            "ButtonRequest_AttachPin": 8000
           }
         }
       }
@@ -3071,6 +3072,10 @@
           "options": {
             "deprecated": true
           }
+        },
+        "exists_attach_pin_user": {
+          "type": "bool",
+          "id": 8000
         }
       }
     },
@@ -3090,6 +3095,10 @@
         "on_device": {
           "type": "bool",
           "id": 3
+        },
+        "on_device_attach_pin": {
+          "type": "bool",
+          "id": 8000
         }
       }
     },
@@ -6051,6 +6060,10 @@
         "derive_cardano": {
           "type": "bool",
           "id": 3
+        },
+        "passphrase_state": {
+          "type": "string",
+          "id": 8000
         }
       }
     },
@@ -6429,6 +6442,14 @@
         "onekey_se04_state": {
           "type": "OneKeySEState",
           "id": 624
+        },
+        "attach_to_pin_user": {
+          "type": "bool",
+          "id": 625
+        },
+        "unlocked_attach_pin": {
+          "type": "bool",
+          "id": 626
         }
       },
       "nested": {
@@ -7533,6 +7554,30 @@
         }
       }
     },
+    "GetPassphraseState": {
+      "fields": {
+        "passphrase_state": {
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "PassphraseState": {
+      "fields": {
+        "passphrase_state": {
+          "type": "string",
+          "id": 1
+        },
+        "session_id": {
+          "type": "bytes",
+          "id": 2
+        },
+        "unlocked_attach_pin": {
+          "type": "bool",
+          "id": 3
+        }
+      }
+    },
     "MoneroTransactionSourceEntry": {
       "fields": {
         "outputs": {
@@ -12144,7 +12189,9 @@
         "MessageType_ListResDir": 10023,
         "MessageType_FileInfoList": 10024,
         "MessageType_OnekeyGetFeatures": 10025,
-        "MessageType_OnekeyFeatures": 10026
+        "MessageType_OnekeyFeatures": 10026,
+        "MessageType_GetPassphraseState": 10028,
+        "MessageType_PassphraseState": 10029
       }
     },
     "google": {

package/src/data-manager/DataManager.ts

@@ -349,7 +349,7 @@ export default class DataManager {
   }
 
   static isBleConnect = (env: ConnectSettings['env']) =>
-    env === 'react-native' || env === 'lowlevel';
+    env === 'react-native' || env === 'lowlevel' || env === 'desktop-web-ble';
 
   static isWebUsbConnect = (env: ConnectSettings['env']) => env === 'webusb';
 }

package/src/data-manager/TransportManager.ts

@@ -11,6 +11,7 @@ const Log = getLogger(LoggerNames.Transport);
 const BleLogger = getLogger(LoggerNames.HdBleTransport);
 const HttpLogger = getLogger(LoggerNames.HdTransportHttp);
 const LowLevelLogger = getLogger(LoggerNames.HdTransportLowLevel);
+const WebBleLogger = getLogger(LoggerNames.HdWebBleTransport);
 
 /**
  * transport 在同一个环境中只会存在一个
@@ -56,6 +57,8 @@ export default class TransportManager {
           );
         }
         await this.transport.init(LowLevelLogger, DevicePool.emitter, this.plugin);
+      } else if (env === 'desktop-web-ble') {
+        await this.transport.init(WebBleLogger);
       } else {
         await this.transport.init(HttpLogger);
       }

package/src/device/Device.ts

@@ -33,7 +33,13 @@ import {
   type Features,
   type UnavailableCapabilities,
 } from '../types';
-import { DEVICE, DeviceButtonRequestPayload, DeviceFeaturesPayload, UI_REQUEST } from '../events';
+import {
+  DEVICE,
+  DeviceButtonRequestPayload,
+  DeviceFeaturesPayload,
+  PassphraseRequestPayload,
+  UI_REQUEST,
+} from '../events';
 import { PROTO } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
@@ -61,7 +67,11 @@ export interface DeviceEvents {
   [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
   [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
   [DEVICE.FEATURES]: [Device, DeviceFeaturesPayload];
-  [DEVICE.PASSPHRASE]: [Device, (response: PassphrasePromptResponse, error?: Error) => void];
+  [DEVICE.PASSPHRASE]: [
+    Device,
+    PassphraseRequestPayload,
+    (response: PassphrasePromptResponse, error?: Error) => void
+  ];
   [DEVICE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE]: [
     Device,
     (err: any, deviceId: string) => void
@@ -288,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;
@@ -304,23 +314,39 @@ export class Device extends EventEmitter {
     return deviceSessionCache[usePassKey];
   }
 
-  tryFixInternalState(state: string, deviceId: string, sessionId: string | null = null) {
+  // attach to pin to fix internal state
+  updateInternalState(
+    enablePassphrase: boolean,
+    passphraseState: string | undefined,
+    deviceId: string,
+    sessionId: string | null = null,
+    featuresSessionId: string | null = null
+  ) {
     Log.debug(
-      'tryFixInternalState session param: ',
+      'updateInternalState session param: ',
       `device_id: ${deviceId}`,
-      `passphraseState: ${state}`,
-      `sessionId: ${sessionId}`
+      `enablePassphrase: ${enablePassphrase}`,
+      `passphraseState: ${passphraseState}`,
+      `sessionId: ${sessionId}`,
+      `featuresSessionId: ${featuresSessionId}`
     );
 
-    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;
+    if (enablePassphrase) {
+      // update the sessionId
+      if (sessionId) {
+        deviceSessionCache[this.generateStateKey(deviceId, passphraseState)] = sessionId;
+      } else if (featuresSessionId) {
+        deviceSessionCache[this.generateStateKey(deviceId, passphraseState)] = featuresSessionId;
+      }
     }
-    Log.debug('tryFixInternalState session cache: ', deviceSessionCache);
+
+    // delete the old sessionId
+    const oldKey = `${deviceId}`;
+    if (deviceSessionCache[oldKey]) {
+      delete deviceSessionCache[oldKey];
+    }
+
+    Log.debug('updateInternalState session cache: ', deviceSessionCache);
   }
 
   private setInternalState(state: string, initSession?: boolean) {
@@ -361,7 +387,7 @@ export class Device extends EventEmitter {
   }
 
   async initialize(options?: InitOptions) {
-    Log.debug('initialize param:', options);
+    // Log.debug('initialize param:', options);
 
     this.passphraseState = options?.passphraseState;
 
@@ -378,8 +404,14 @@ export class Device extends EventEmitter {
     if (options?.deriveCardano) {
       payload.derive_cardano = true;
     }
+    payload.passphrase_state = options?.passphraseState;
 
-    Log.debug('initialize payload:', payload);
+    Log.debug('Initialize device begin:', {
+      deviceId: options?.deviceId,
+      passphraseState: options?.passphraseState,
+      initSession: options?.initSession,
+      InitializePayload: payload,
+    });
 
     try {
       // @ts-expect-error
@@ -393,6 +425,7 @@ export class Device extends EventEmitter {
         }),
       ]);
 
+      Log.debug('Initialize device end: ', message);
       this._updateFeatures(message, options?.initSession);
       await TransportManager.reconfigure(this.features);
     } catch (error) {
@@ -693,12 +726,51 @@ export class Device extends EventEmitter {
     return false;
   }
 
-  async checkPassphraseStateSafety(passphraseState?: string) {
+  async lockDevice() {
+    const res = await this.commands.typedCall('LockDevice', 'Success', {});
+    return res.message;
+  }
+
+  async checkPassphraseStateSafety(
+    passphraseState?: string,
+    useEmptyPassphraseState?: boolean,
+    skipPassphraseCheck?: boolean
+  ) {
     if (!this.features) return false;
-    const newState = await getPassphraseStateWithRefreshDeviceInfo(this);
+    const { passphraseState: newPassphraseState, unlockedAttachPin } =
+      await getPassphraseStateWithRefreshDeviceInfo(this, {
+        expectPassphraseState: passphraseState,
+        onlyMainPin: useEmptyPassphraseState,
+      });
+
+    if (skipPassphraseCheck) {
+      return true;
+    }
+
+    // Main wallet and unlock Attach Pin, throw safe error
+    const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphraseState;
+    const useErrorAttachPin =
+      unlockedAttachPin && passphraseState && passphraseState !== newPassphraseState;
+
+    Log.debug('Check passphrase state safety: ', {
+      passphraseState,
+      newPassphraseState,
+      unlockedAttachPin,
+      useEmptyPassphraseState,
+    });
+
+    if (mainWalletUseAttachPin || useErrorAttachPin) {
+      try {
+        await this.lockDevice();
+      } catch (error) {
+        // ignore error
+      }
+      this.clearInternalState();
+      return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError));
+    }
 
     // When exists passphraseState, check passphraseState
-    if (passphraseState && passphraseState !== newState) {
+    if (passphraseState && passphraseState !== newPassphraseState) {
       this.clearInternalState();
       return false;
     }

package/src/device/DeviceCommands.ts

@@ -4,12 +4,13 @@ import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
 import { patchFeatures, getLogger, LoggerNames, getDeviceType } from '../utils';
 import type { Device } from './Device';
-import { DEVICE } from '../events';
+import { DEVICE, type PassphraseRequestPayload } from '../events';
 import { DeviceModelToTypes } from '../types';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
   passphraseOnDevice?: boolean;
+  attachPinOnDevice?: boolean;
   cache?: boolean;
 };
 
@@ -217,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);
@@ -438,8 +438,17 @@ export class DeviceCommands {
     }
 
     if (res.type === 'PassphraseRequest') {
-      return this._promptPassphrase().then(response => {
-        const { passphrase, passphraseOnDevice } = response;
+      const existsAttachPinUser = res.message.exists_attach_pin_user;
+      return this._promptPassphrase({
+        existsAttachPinUser,
+      }).then(response => {
+        const { passphrase, passphraseOnDevice, attachPinOnDevice } = response;
+
+        // Attach PIN on device
+        if (attachPinOnDevice && existsAttachPinUser) {
+          return this._commonCall('PassphraseAck', { on_device_attach_pin: true });
+        }
+
         return !passphraseOnDevice
           ? this._commonCall('PassphraseAck', { passphrase })
           : this._commonCall('PassphraseAck', { on_device: true });
@@ -501,7 +510,7 @@ export class DeviceCommands {
     });
   }
 
-  _promptPassphrase() {
+  _promptPassphrase(options: PassphraseRequestPayload) {
     return new Promise<PassphrasePromptResponse>((resolve, reject) => {
       const cancelAndReject = (_error?: Error) =>
         cancelDeviceInPrompt(this.device, false)
@@ -527,6 +536,7 @@ export class DeviceCommands {
         this.device.emit(
           DEVICE.PASSPHRASE,
           this.device,
+          options,
           (response: PassphrasePromptResponse, error?: Error) => {
             this.device.clearCancelableAction();
             if (error) {

package/src/events/device.ts

@@ -44,6 +44,10 @@ export interface DeviceButtonRequestPayload extends Omit<PROTO.ButtonRequest, 'c
   code?: PROTO.ButtonRequest['code'] | 'ButtonRequest_FirmwareUpdate';
 }
 
+export type PassphraseRequestPayload = {
+  existsAttachPinUser?: boolean;
+};
+
 export interface DeviceButtonRequest {
   type: typeof DEVICE.BUTTON;
   payload: DeviceButtonRequestPayload & { device: Device | null };

package/src/events/ui-request.ts

@@ -66,7 +66,7 @@ export type UiRequestDeviceAction = {
   type: typeof UI_REQUEST.REQUEST_PIN;
   payload: {
     device: Device;
-    type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry';
+    type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry' | 'ButtonRequest_AttachPin';
   };
 };
 
@@ -80,6 +80,7 @@ export interface UiRequestPassphrase {
   payload: {
     device: Device;
     passphraseState?: string;
+    existsAttachPinUser?: boolean;
   };
 }
 

package/src/events/ui-response.ts

@@ -18,6 +18,7 @@ export interface UiResponsePassphrase {
   payload: {
     value: string;
     passphraseOnDevice?: boolean;
+    attachPinOnDevice?: boolean;
     save?: boolean;
   };
 }

package/src/inject.ts

@@ -138,6 +138,8 @@ export const createCoreApi = (
     call({ ...params, connectId, method: 'getPassphraseState' }),
   deviceCancel: (connectId, params) => call({ ...params, connectId, method: 'deviceCancel' }),
   deviceLock: (connectId, params) => call({ ...params, connectId, method: 'deviceLock' }),
+  deviceUnlock: (connectId, params) =>
+    call({ ...params, useEmptyPassphrase: true, connectId, method: 'deviceUnlock' }),
 
   getNextU2FCounter: (connectId, params) =>
     call({ ...params, connectId, method: 'getNextU2FCounter' }),

package/src/types/api/deviceUnlock.ts

@@ -0,0 +1,4 @@
+import { Features } from '@onekeyfe/hd-transport';
+import type { CommonParams, Response } from '../params';
+
+export declare function deviceUnlock(connectId: string, params?: CommonParams): Response<Features>;

package/src/types/api/index.ts

@@ -35,6 +35,7 @@ import { deviceSupportFeatures } from './deviceSupportFeatures';
 import { deviceFullyUploadResource } from './deviceFullyUploadResource';
 import { deviceUpdateBootloader } from './deviceUpdateBootloader';
 import { deviceLock } from './deviceLock';
+import { deviceUnlock } from './deviceUnlock';
 import { deviceCancel } from './deviceCancel';
 
 import { getNextU2FCounter } from './getNextU2FCounter';
@@ -214,6 +215,7 @@ export type CoreApi = {
   deviceFullyUploadResource: typeof deviceFullyUploadResource;
   deviceUpdateBootloader: typeof deviceUpdateBootloader;
   deviceLock: typeof deviceLock;
+  deviceUnlock: typeof deviceUnlock;
   deviceCancel: typeof deviceCancel;
   getNextU2FCounter: typeof getNextU2FCounter;
   setU2FCounter: typeof setU2FCounter;

package/src/types/params.ts

@@ -37,6 +37,11 @@ export interface CommonParams {
    * Skip web device prompt
    */
   skipWebDevicePrompt?: boolean;
+
+  /**
+   * Skip passphrase check
+   */
+  skipPassphraseCheck?: boolean;
 }
 
 export type Params<T> = CommonParams & T & { bundle?: undefined };

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;