@onekeyfe/hd-core 1.0.33-alpha.8 → 1.0.33

package/src/data/messages/messages.json

@@ -3021,8 +3021,7 @@
             "ButtonRequest_Success": 17,
             "ButtonRequest_Warning": 18,
             "ButtonRequest_PassphraseEntry": 19,
-            "ButtonRequest_PinEntry": 20,
-            "ButtonRequest_AttachPin": 8000
+            "ButtonRequest_PinEntry": 20
           }
         }
       }
@@ -3072,10 +3071,6 @@
           "options": {
             "deprecated": true
           }
-        },
-        "exists_attach_pin_user": {
-          "type": "bool",
-          "id": 8000
         }
       }
     },
@@ -3095,10 +3090,6 @@
         "on_device": {
           "type": "bool",
           "id": 3
-        },
-        "on_device_attach_pin": {
-          "type": "bool",
-          "id": 8000
         }
       }
     },
@@ -6060,10 +6051,6 @@
         "derive_cardano": {
           "type": "bool",
           "id": 3
-        },
-        "passphrase_state": {
-          "type": "string",
-          "id": 8000
         }
       }
     },
@@ -6442,14 +6429,6 @@
         "onekey_se04_state": {
           "type": "OneKeySEState",
           "id": 624
-        },
-        "attach_to_pin_user": {
-          "type": "bool",
-          "id": 625
-        },
-        "unlocked_attach_pin": {
-          "type": "bool",
-          "id": 626
         }
       },
       "nested": {
@@ -7554,38 +7533,6 @@
         }
       }
     },
-    "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": {
@@ -12197,9 +12144,7 @@
         "MessageType_ListResDir": 10023,
         "MessageType_FileInfoList": 10024,
         "MessageType_OnekeyGetFeatures": 10025,
-        "MessageType_OnekeyFeatures": 10026,
-        "MessageType_GetPassphraseState": 10028,
-        "MessageType_PassphraseState": 10029
+        "MessageType_OnekeyFeatures": 10026
       }
     },
     "google": {

package/src/device/Device.ts

@@ -33,13 +33,7 @@ import {
   type Features,
   type UnavailableCapabilities,
 } from '../types';
-import {
-  DEVICE,
-  DeviceButtonRequestPayload,
-  DeviceFeaturesPayload,
-  PassphraseRequestPayload,
-  UI_REQUEST,
-} from '../events';
+import { DEVICE, DeviceButtonRequestPayload, DeviceFeaturesPayload, UI_REQUEST } from '../events';
 import { PROTO } from '../constants';
 import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
@@ -67,11 +61,7 @@ export interface DeviceEvents {
   [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
   [DEVICE.BUTTON]: [Device, DeviceButtonRequestPayload];
   [DEVICE.FEATURES]: [Device, DeviceFeaturesPayload];
-  [DEVICE.PASSPHRASE]: [
-    Device,
-    PassphraseRequestPayload,
-    (response: PassphrasePromptResponse, error?: Error) => void
-  ];
+  [DEVICE.PASSPHRASE]: [Device, (response: PassphrasePromptResponse, error?: Error) => void];
   [DEVICE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE]: [
     Device,
     (err: any, deviceId: string) => void
@@ -333,26 +323,6 @@ 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: ',
@@ -391,7 +361,7 @@ export class Device extends EventEmitter {
   }
 
   async initialize(options?: InitOptions) {
-    // Log.debug('initialize param:', options);
+    Log.debug('initialize param:', options);
 
     this.passphraseState = options?.passphraseState;
 
@@ -408,14 +378,8 @@ export class Device extends EventEmitter {
     if (options?.deriveCardano) {
       payload.derive_cardano = true;
     }
-    payload.passphrase_state = options?.passphraseState;
 
-    // Log.debug('initialize payload:', payload);
-    console.log('=====>>>>>> initialize device begin: ', payload, {
-      deviceId: options?.deviceId,
-      passphraseState: options?.passphraseState,
-      initSession: options?.initSession,
-    });
+    Log.debug('initialize payload:', payload);
 
     try {
       // @ts-expect-error
@@ -429,7 +393,6 @@ export class Device extends EventEmitter {
         }),
       ]);
 
-      console.log('=====>>>>>> initialize device end: ', message);
       this._updateFeatures(message, options?.initSession);
       await TransportManager.reconfigure(this.features);
     } catch (error) {
@@ -730,22 +693,12 @@ export class Device extends EventEmitter {
     return false;
   }
 
-  async checkPassphraseStateSafety(passphraseState?: string, useEmptyPassphraseState?: boolean) {
+  async checkPassphraseStateSafety(passphraseState?: string) {
     if (!this.features) return false;
-    const { passphraseState: newPassphraseState, unlockedAttachPin } =
-      await getPassphraseStateWithRefreshDeviceInfo(this, {
-        expectPassphraseState: passphraseState,
-        onlyMainPin: useEmptyPassphraseState,
-      });
-
-    // Main wallet and unlock Attach Pin, throw safe error
-    if (unlockedAttachPin && useEmptyPassphraseState) {
-      this.clearInternalState();
-      return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckUnlockTypeError));
-    }
+    const newState = await getPassphraseStateWithRefreshDeviceInfo(this);
 
     // When exists passphraseState, check passphraseState
-    if (passphraseState && passphraseState !== newPassphraseState) {
+    if (passphraseState && passphraseState !== newState) {
       this.clearInternalState();
       return false;
     }

package/src/device/DeviceCommands.ts

@@ -4,13 +4,12 @@ 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, type PassphraseRequestPayload } from '../events';
+import { DEVICE } from '../events';
 import { DeviceModelToTypes } from '../types';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
   passphraseOnDevice?: boolean;
-  attachPinOnDevice?: boolean;
   cache?: boolean;
 };
 
@@ -439,17 +438,8 @@ export class DeviceCommands {
     }
 
     if (res.type === 'PassphraseRequest') {
-      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 this._promptPassphrase().then(response => {
+        const { passphrase, passphraseOnDevice } = response;
         return !passphraseOnDevice
           ? this._commonCall('PassphraseAck', { passphrase })
           : this._commonCall('PassphraseAck', { on_device: true });
@@ -511,7 +501,7 @@ export class DeviceCommands {
     });
   }
 
-  _promptPassphrase(options: PassphraseRequestPayload) {
+  _promptPassphrase() {
     return new Promise<PassphrasePromptResponse>((resolve, reject) => {
       const cancelAndReject = (_error?: Error) =>
         cancelDeviceInPrompt(this.device, false)
@@ -537,7 +527,6 @@ 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,10 +44,6 @@ 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' | 'ButtonRequest_AttachPin';
+    type?: PROTO.PinMatrixRequestType | 'ButtonRequest_PinEntry';
   };
 };
 
@@ -80,7 +80,6 @@ export interface UiRequestPassphrase {
   payload: {
     device: Device;
     passphraseState?: string;
-    existsAttachPinUser?: boolean;
   };
 }
 

package/src/events/ui-response.ts

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

package/src/utils/deviceFeaturesUtils.ts

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