@onekeyfe/hd-core 1.0.33 → 1.0.34-alpha.1

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,38 @@
         }
       }
     },
+    "GetPassphraseState": {
+      "fields": {
+        "passphrase_state": {
+          "type": "string",
+          "id": 1
+        },
+        "_only_main_pin": {
+          "type": "bool",
+          "id": 2
+        },
+        "allow_create_attach_pin": {
+          "type": "bool",
+          "id": 3
+        }
+      }
+    },
+    "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 +12197,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/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
@@ -323,6 +333,26 @@ export class Device extends EventEmitter {
     Log.debug('tryFixInternalState session cache: ', deviceSessionCache);
   }
 
+  // attach to pin to fix internal state
+  updateInternalState(state: string, deviceId: string, sessionId: string | null = null) {
+    Log.debug(
+      'updateInternalState session param: ',
+      `device_id: ${deviceId}`,
+      `passphraseState: ${state}`,
+      `sessionId: ${sessionId}`
+    );
+
+    if (sessionId) {
+      deviceSessionCache[this.generateStateKey(deviceId, state)] = sessionId;
+      // 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) {
     Log.debug(
       'setInternalState session param: ',
@@ -361,7 +391,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 +408,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 payload:', payload);
+    console.log('=====>>>>>> initialize device begin: ', payload, {
+      deviceId: options?.deviceId,
+      passphraseState: options?.passphraseState,
+      initSession: options?.initSession,
+    });
 
     try {
       // @ts-expect-error
@@ -393,6 +429,7 @@ export class Device extends EventEmitter {
         }),
       ]);
 
+      console.log('=====>>>>>> initialize device end: ', message);
       this._updateFeatures(message, options?.initSession);
       await TransportManager.reconfigure(this.features);
     } catch (error) {
@@ -693,12 +730,43 @@ 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) {
     if (!this.features) return false;
-    const newState = await getPassphraseStateWithRefreshDeviceInfo(this);
+    const { passphraseState: newPassphraseState, unlockedAttachPin } =
+      await getPassphraseStateWithRefreshDeviceInfo(this, {
+        expectPassphraseState: passphraseState,
+        onlyMainPin: useEmptyPassphraseState,
+      });
+
+    // Main wallet and unlock Attach Pin, throw safe error
+    const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphraseState;
+    const useErrorAttachPin =
+      unlockedAttachPin && passphraseState && passphraseState !== newPassphraseState;
+
+    console.log('=====>>>>>> checkPassphraseStateSafety passphraseState: ', {
+      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;
 };
 
@@ -438,8 +439,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 +511,7 @@ export class DeviceCommands {
     });
   }
 
-  _promptPassphrase() {
+  _promptPassphrase(options: PassphraseRequestPayload) {
     return new Promise<PassphrasePromptResponse>((resolve, reject) => {
       const cancelAndReject = (_error?: Error) =>
         cancelDeviceInPrompt(this.device, false)
@@ -527,6 +537,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/utils/deviceFeaturesUtils.ts

@@ -73,11 +73,30 @@ export const supportNewPassphrase = (features?: Features): SupportFeatureType =>
   return { support: semver.gte(currentVersion, '2.4.0'), require: '2.4.0' };
 };
 
-export const getPassphraseStateWithRefreshDeviceInfo = async (device: Device) => {
+export const getPassphraseStateWithRefreshDeviceInfo = async (
+  device: Device,
+  options?: {
+    expectPassphraseState?: string;
+    onlyMainPin?: boolean;
+  }
+) => {
   const { features, commands } = device;
   const locked = features?.unlocked === false;
 
-  const passphraseState = await getPassphraseState(features, commands);
+  const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(
+    features,
+    commands,
+    {
+      ...options,
+    }
+  );
+
+  // 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;
 
@@ -93,14 +112,55 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (device: Device) =>
     await device.getFeatures();
   }
 
-  return passphraseState;
+  return { passphraseState, newSession, unlockedAttachPin };
 };
 
 export const getPassphraseState = async (
   features: Features | undefined,
-  commands: DeviceCommands
-) => {
-  if (!features) return false;
+  commands: DeviceCommands,
+  options?: {
+    expectPassphraseState?: string;
+    onlyMainPin?: boolean;
+    // createAttachPinWallet?: boolean;
+  }
+): Promise<{
+  passphraseState: string | undefined;
+  newSession: string | undefined;
+  unlockedAttachPin: boolean | undefined;
+}> => {
+  if (!features)
+    return { passphraseState: undefined, newSession: undefined, unlockedAttachPin: undefined };
+
+  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
+    );
+
+    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');
+    }
+
+    return {
+      passphraseState: message.passphrase_state,
+      newSession: message.session_id,
+      unlockedAttachPin: message.unlocked_attach_pin,
+    };
+  }
+
   const { message, type } = await commands.typedCall('GetAddress', 'Address', {
     address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
     coin_name: 'Testnet',
@@ -113,7 +173,11 @@ export const getPassphraseState = async (
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Get the passphrase state error');
   }
 
-  return message.address;
+  return {
+    passphraseState: message.address,
+    newSession: undefined,
+    unlockedAttachPin: undefined,
+  };
 };
 
 export const supportBatchPublicKey = (