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

package/src/api/btc/helpers/xpubUtils.ts

@@ -11,31 +11,54 @@ const VERSION_BYTES = {
   ZPUB: 0x04b24746,
 };
 
-function getVersionBytes(coinName: string, scriptType?: InputScriptType): number {
+export function getVersionBytes(
+  coinName: string,
+  scriptType?: InputScriptType
+): number | undefined {
   if (coinName.toLowerCase() === 'bitcoin') {
     switch (scriptType) {
       case 'SPENDADDRESS':
       case 'SPENDMULTISIG':
+        // 44、48
         return VERSION_BYTES.XPUB;
       case 'SPENDP2SHWITNESS':
+        // 49
         return VERSION_BYTES.YPUB;
       case 'SPENDWITNESS':
+        // 84
         return VERSION_BYTES.ZPUB;
       default:
+        // 86、10025
         return VERSION_BYTES.XPUB;
     }
-  } else if (coinName.toLowerCase() === 'testnet') {
-    return 0x043587cf;
-  } else if (coinName.toLowerCase() === 'regtest') {
-    return 0x043587cf;
   } else if (coinName.toLowerCase() === 'litecoin') {
-    return 0x019da462;
+    switch (scriptType) {
+      case 'SPENDADDRESS':
+      case 'SPENDMULTISIG':
+        // 44、48
+        return 0x019da462;
+      case 'SPENDP2SHWITNESS':
+        // 49
+        return 0x01b26ef6;
+      case 'SPENDWITNESS':
+        // 84
+        return 0x04b24746;
+      default:
+        // not support 86、10025 path
+        return undefined;
+    }
   } else if (coinName.toLowerCase() === 'dogecoin') {
-    return 0x02facafd;
-  } else if (coinName.toLowerCase() === 'dash') {
-    return 0x02fe52cc;
+    if (scriptType === 'SPENDADDRESS') {
+      // 44
+      return 0x02facafd;
+    }
+    if (scriptType === 'SPENDMULTISIG') {
+      // 48
+      return 0x0488b21e;
+    }
+    return undefined;
   }
-  return VERSION_BYTES.XPUB;
+  return undefined;
 }
 
 function base58Check(data: Buffer): string {
@@ -76,6 +99,10 @@ function generateExtendedPublicKey(
 ): string {
   const versionBytes = getVersionBytes(coinName, scriptType);
 
+  if (!versionBytes) {
+    throw new Error(`Invalid coinName, not support generate xpub for scriptType: ${scriptType}`);
+  }
+
   const buffer = Buffer.alloc(78);
   buffer.writeUInt32BE(versionBytes, 0);
   buffer.writeUInt8(depth, 4);

package/src/api/evm/EVMSignTypedData.ts

@@ -13,7 +13,7 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
-import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
+import { formatAnyHex, parseChainId, stripHexStartZeroes } from '../helpers/hexUtils';
 import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import {
   DeviceModelToTypes,
@@ -217,7 +217,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         gasToken: data.message.gasToken,
         refundReceiver: data.message.refundReceiver,
         nonce: formatAnyHex(new BigNumber(data.message.nonce).toString(16)),
-        chain_id: new BigNumber(data.domain.chainId ?? '0x', 16).toNumber(),
+        chain_id: parseChainId(data.domain.chainId),
         verifyingContract: data.domain.verifyingContract,
       };
       response = await typedCall(

package/src/api/helpers/hexUtils.ts

@@ -1,3 +1,5 @@
+import BigNumber from 'bignumber.js';
+
 export const hasHexPrefix = (str: string): boolean => str.slice(0, 2).toLowerCase() === '0x';
 
 // remove hex prefix
@@ -80,3 +82,30 @@ export function hexToBytes(hex: string): Uint8Array {
   }
   return array;
 }
+
+export function parseChainId(chainId: string | number | undefined): number {
+  if (!chainId) {
+    return 0;
+  }
+
+  if (typeof chainId === 'string') {
+    if (chainId.trim() === '') {
+      return 0;
+    }
+
+    if (chainId.match(/^[0-9]+$/)) {
+      return new BigNumber(chainId, 10).toNumber();
+    }
+    if (chainId.startsWith('0x') || chainId.match(/^[0-9a-fA-F]+$/)) {
+      return new BigNumber(chainId, 16).toNumber();
+    }
+
+    throw new Error(`Invalid chainId ${chainId}`);
+  }
+
+  if (typeof chainId === 'number') {
+    return new BigNumber(chainId).toNumber();
+  }
+
+  throw new Error(`Invalid chainId ${chainId}`);
+}

package/src/api/index.ts

@@ -27,7 +27,6 @@ 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/core/index.ts

@@ -342,8 +342,7 @@ const onCallDevice = async (
 
         // Check Device passphrase State
         const passphraseStateSafety = await device.checkPassphraseStateSafety(
-          method.payload?.passphraseState,
-          method.payload?.useEmptyPassphrase
+          method.payload?.passphraseState
         );
 
         // Double check, handles the special case of Touch/Pro
@@ -837,12 +836,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' || request.code === 'ButtonRequest_AttachPin') {
-    Log.log('request Confirm Input PIN or Attach PIN');
+  if (request.code === 'ButtonRequest_PinEntry') {
+    Log.log('request Confirm Input PIN');
     postMessage(
       createUiMessage(UI_REQUEST.REQUEST_PIN, {
         device: device.toMessageObject() as KnownDevice,
-        type: request.code,
+        type: 'ButtonRequest_PinEntry',
       })
     );
   } else {
@@ -855,31 +854,27 @@ const onDeviceFeaturesHandler = (...[_, features]: [...DeviceEvents['features']]
   postMessage(createDeviceMessage(DEVICE.FEATURES, { ...features }));
 };
 
-const onDevicePassphraseHandler = async (
-  ...[device, requestPayload, callback]: DeviceEvents['passphrase']
-) => {
+const onDevicePassphraseHandler = async (...[device, 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, attachPinOnDevice } = uiResp.payload;
+  const { value, passphraseOnDevice, save } = 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,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,43 +693,12 @@ export class Device extends EventEmitter {
     return false;
   }
 
-  async lockDevice() {
-    const res = await this.commands.typedCall('LockDevice', 'Success', {});
-    return res.message;
-  }
-
-  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
-    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));
-    }
+    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/inject.ts

@@ -138,8 +138,6 @@ 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/firmwareUpdate.ts

@@ -25,7 +25,7 @@ export declare function firmwareUpdate(
   params: Params<FirmwareUpdateBinaryParams> & { rebootOnSuccess?: boolean }
 ): Response<PROTO.Success>;
 
-type IPlatform = 'native' | 'desktop' | 'ext' | 'web' | 'webEmbed';
+type IPlatform = 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
 type Platform = { platform: IPlatform };
 
 export declare function firmwareUpdateV2(

package/src/types/api/index.ts

@@ -35,7 +35,6 @@ 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';
@@ -215,7 +214,6 @@ 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,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.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,
-    };
-  }
-
+  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 = (

package/dist/api/device/DeviceUnlock.d.ts

@@ -1,7 +0,0 @@
-import { LockDevice } from '@onekeyfe/hd-transport';
-import { BaseMethod } from '../BaseMethod';
-export default class DeviceUnlock extends BaseMethod<LockDevice> {
-    init(): void;
-    run(): Promise<import("@onekeyfe/hd-transport").Features>;
-}
-//# sourceMappingURL=DeviceUnlock.d.ts.map