@onekeyfe/hd-web-sdk 0.1.37 → 0.1.40

package/build/onekey-js-sdk.js

@@ -4145,6 +4145,10 @@ const inject = ({
       connectId,
       method: 'deviceWipe'
     }),
+    getPassphraseState: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+      connectId,
+      method: 'getPassphraseState'
+    })),
     evmGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
       deviceId,
@@ -4819,6 +4823,262 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
+const HD_HARDENED = 0x80000000;
+
+const toHardened = n => (n | HD_HARDENED) >>> 0;
+
+const fromHardened = n => (n & ~HD_HARDENED) >>> 0;
+
+const PATH_NOT_VALID = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Not a valid path');
+const PATH_NEGATIVE_VALUES = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Path cannot contain negative values');
+
+const getHDPath = path => {
+  const parts = path.toLowerCase().split('/');
+  if (parts[0] !== 'm') throw PATH_NOT_VALID;
+  return parts.filter(p => p !== 'm' && p !== '').map(p => {
+    let hardened = false;
+
+    if (p.substr(p.length - 1) === "'") {
+      hardened = true;
+      p = p.substr(0, p.length - 1);
+    }
+
+    let n = parseInt(p);
+
+    if (Number.isNaN(n)) {
+      throw PATH_NOT_VALID;
+    } else if (n < 0) {
+      throw PATH_NEGATIVE_VALUES;
+    }
+
+    if (hardened) {
+      n = toHardened(n);
+    }
+
+    return n;
+  });
+};
+
+const isMultisigPath = path => Array.isArray(path) && path[0] === toHardened(48);
+
+const isSegwitPath = path => Array.isArray(path) && path[0] === toHardened(49);
+
+const getScriptType = path => {
+  if (!Array.isArray(path) || path.length < 1) return 'SPENDADDRESS';
+  const p1 = fromHardened(path[0]);
+
+  switch (p1) {
+    case 48:
+      return 'SPENDMULTISIG';
+
+    case 49:
+      return 'SPENDP2SHWITNESS';
+
+    case 84:
+      return 'SPENDWITNESS';
+
+    default:
+      return 'SPENDADDRESS';
+  }
+};
+
+const getOutputScriptType = path => {
+  if (!Array.isArray(path) || path.length < 1) return 'PAYTOADDRESS';
+
+  if (path[0] === 49) {
+    return 'PAYTOP2SHWITNESS';
+  }
+
+  const p = fromHardened(path[0]);
+
+  switch (p) {
+    case 48:
+      return 'PAYTOMULTISIG';
+
+    case 49:
+      return 'PAYTOP2SHWITNESS';
+
+    case 84:
+      return 'PAYTOWITNESS';
+
+    default:
+      return 'PAYTOADDRESS';
+  }
+};
+
+const serializedPath = path => {
+  const pathStr = path.map(p => {
+    if (p & HD_HARDENED) {
+      return `${p & ~HD_HARDENED}'`;
+    }
+
+    return p;
+  }).join('/');
+  return `m/${pathStr}`;
+};
+
+const validatePath = (path, length = 0, base = false) => {
+  let valid;
+
+  if (typeof path === 'string') {
+    valid = getHDPath(path);
+  } else if (Array.isArray(path)) {
+    valid = path.map(p => {
+      const n = parseInt(p);
+
+      if (Number.isNaN(n)) {
+        throw PATH_NOT_VALID;
+      } else if (n < 0) {
+        throw PATH_NEGATIVE_VALUES;
+      }
+
+      return n;
+    });
+  } else {
+    valid = undefined;
+  }
+
+  if (!valid) throw PATH_NOT_VALID;
+  if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
+  return base ? valid.splice(0, 3) : valid;
+};
+
+const getDeviceModel = features => {
+  if (!features || typeof features !== 'object') {
+    return 'model_mini';
+  }
+
+  if (features.model === '1') {
+    return 'model_mini';
+  }
+
+  return 'model_touch';
+};
+
+const getDeviceType = features => {
+  if (!features || typeof features !== 'object' || !features.serial_no) {
+    return 'classic';
+  }
+
+  const serialNo = features.serial_no;
+  const miniFlag = serialNo.slice(0, 2);
+  if (miniFlag.toLowerCase() === 'mi') return 'mini';
+  if (miniFlag.toLowerCase() === 'tc') return 'touch';
+  return 'classic';
+};
+
+const getDeviceTypeOnBootloader = features => getDeviceType(features);
+
+const getDeviceTypeByBleName = name => {
+  if (!name) return 'classic';
+  if (name.startsWith('MI')) return 'mini';
+  if (name.startsWith('T')) return 'touch';
+  return 'classic';
+};
+
+const getDeviceTypeByDeviceId = deviceId => {
+  if (!deviceId) {
+    return 'classic';
+  }
+
+  const miniFlag = deviceId.slice(0, 2);
+  if (miniFlag.toLowerCase() === 'mi') return 'mini';
+  return 'classic';
+};
+
+const getDeviceUUID = features => {
+  const deviceType = getDeviceType(features);
+
+  if (deviceType === 'classic') {
+    return features.onekey_serial;
+  }
+
+  return features.serial_no;
+};
+
+const getDeviceLabel = features => {
+  const deviceType = getDeviceType(features);
+
+  if (typeof features.label === 'string') {
+    return features.label;
+  }
+
+  return `My OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
+};
+
+const getDeviceFirmwareVersion = features => {
+  if (!features) return [0, 0, 0];
+
+  if (features.onekey_version) {
+    return features.onekey_version.split('.');
+  }
+
+  return [features.major_version, features.minor_version, features.patch_version];
+};
+
+const getDeviceBLEFirmwareVersion = features => {
+  if (!features.ble_ver) {
+    return null;
+  }
+
+  if (!semver__default["default"].valid(features.ble_ver)) {
+    return null;
+  }
+
+  return features.ble_ver.split('.');
+};
+
+const supportInputPinOnSoftware = features => {
+  if (!features) return {
+    support: false
+  };
+  const deviceType = getDeviceType(features);
+
+  if (deviceType === 'touch') {
+    return {
+      support: false
+    };
+  }
+
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+  return {
+    support: semver__default["default"].gte(currentVersion, '2.3.0'),
+    require: '2.3.0'
+  };
+};
+
+const supportNewPassphrase = features => {
+  if (!features) return {
+    support: false
+  };
+  const deviceType = getDeviceType(features);
+
+  if (deviceType === 'touch' || deviceType === 'pro') {
+    return {
+      support: true
+    };
+  }
+
+  const currentVersion = getDeviceFirmwareVersion(features).join('.');
+  return {
+    support: semver__default["default"].gte(currentVersion, '2.4.0'),
+    require: '2.4.0'
+  };
+};
+
+const getPassphraseState = (features, commands) => __awaiter(void 0, void 0, void 0, function* () {
+  if (!features) return false;
+  const {
+    message
+  } = yield commands.typedCall('GetAddress', 'Address', {
+    address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
+    coin_name: 'Testnet',
+    script_type: 'SPENDADDRESS',
+    show_display: false
+  });
+  return message.address;
+});
+
 var nested = {
   BinanceGetAddress: {
     fields: {
@@ -13599,223 +13859,6 @@ function patchFeatures(response) {
   return response;
 }
 
-const getDeviceModel = features => {
-  if (!features || typeof features !== 'object') {
-    return 'model_mini';
-  }
-
-  if (features.model === '1') {
-    return 'model_mini';
-  }
-
-  return 'model_touch';
-};
-
-const getDeviceType = features => {
-  if (!features || typeof features !== 'object' || !features.serial_no) {
-    return 'classic';
-  }
-
-  const serialNo = features.serial_no;
-  const miniFlag = serialNo.slice(0, 2);
-  if (miniFlag.toLowerCase() === 'mi') return 'mini';
-  if (miniFlag.toLowerCase() === 'tc') return 'touch';
-  return 'classic';
-};
-
-const getDeviceTypeOnBootloader = features => getDeviceType(features);
-
-const getDeviceTypeByBleName = name => {
-  if (!name) return 'classic';
-  if (name.startsWith('MI')) return 'mini';
-  if (name.startsWith('T')) return 'touch';
-  return 'classic';
-};
-
-const getDeviceTypeByDeviceId = deviceId => {
-  if (!deviceId) {
-    return 'classic';
-  }
-
-  const miniFlag = deviceId.slice(0, 2);
-  if (miniFlag.toLowerCase() === 'mi') return 'mini';
-  return 'classic';
-};
-
-const getDeviceUUID = features => {
-  const deviceType = getDeviceType(features);
-
-  if (deviceType === 'classic') {
-    return features.onekey_serial;
-  }
-
-  return features.serial_no;
-};
-
-const getDeviceLabel = features => {
-  const deviceType = getDeviceType(features);
-
-  if (typeof features.label === 'string') {
-    return features.label;
-  }
-
-  return `My OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
-};
-
-const getDeviceFirmwareVersion = features => {
-  if (!features) return [0, 0, 0];
-
-  if (features.onekey_version) {
-    return features.onekey_version.split('.');
-  }
-
-  return [features.major_version, features.minor_version, features.patch_version];
-};
-
-const getDeviceBLEFirmwareVersion = features => {
-  if (!features.ble_ver) {
-    return null;
-  }
-
-  if (!semver__default["default"].valid(features.ble_ver)) {
-    return null;
-  }
-
-  return features.ble_ver.split('.');
-};
-
-const supportInputPinOnSoftware = features => {
-  if (!features) return false;
-  const deviceType = getDeviceType(features);
-
-  if (deviceType === 'touch') {
-    return false;
-  }
-
-  const currentVersion = getDeviceFirmwareVersion(features).join('.');
-  return semver__default["default"].gte(currentVersion, '2.3.0');
-};
-
-const HD_HARDENED = 0x80000000;
-
-const toHardened = n => (n | HD_HARDENED) >>> 0;
-
-const fromHardened = n => (n & ~HD_HARDENED) >>> 0;
-
-const PATH_NOT_VALID = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Not a valid path');
-const PATH_NEGATIVE_VALUES = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Path cannot contain negative values');
-
-const getHDPath = path => {
-  const parts = path.toLowerCase().split('/');
-  if (parts[0] !== 'm') throw PATH_NOT_VALID;
-  return parts.filter(p => p !== 'm' && p !== '').map(p => {
-    let hardened = false;
-
-    if (p.substr(p.length - 1) === "'") {
-      hardened = true;
-      p = p.substr(0, p.length - 1);
-    }
-
-    let n = parseInt(p);
-
-    if (Number.isNaN(n)) {
-      throw PATH_NOT_VALID;
-    } else if (n < 0) {
-      throw PATH_NEGATIVE_VALUES;
-    }
-
-    if (hardened) {
-      n = toHardened(n);
-    }
-
-    return n;
-  });
-};
-
-const isMultisigPath = path => Array.isArray(path) && path[0] === toHardened(48);
-
-const isSegwitPath = path => Array.isArray(path) && path[0] === toHardened(49);
-
-const getScriptType = path => {
-  if (!Array.isArray(path) || path.length < 1) return 'SPENDADDRESS';
-  const p1 = fromHardened(path[0]);
-
-  switch (p1) {
-    case 48:
-      return 'SPENDMULTISIG';
-
-    case 49:
-      return 'SPENDP2SHWITNESS';
-
-    case 84:
-      return 'SPENDWITNESS';
-
-    default:
-      return 'SPENDADDRESS';
-  }
-};
-
-const getOutputScriptType = path => {
-  if (!Array.isArray(path) || path.length < 1) return 'PAYTOADDRESS';
-
-  if (path[0] === 49) {
-    return 'PAYTOP2SHWITNESS';
-  }
-
-  const p = fromHardened(path[0]);
-
-  switch (p) {
-    case 48:
-      return 'PAYTOMULTISIG';
-
-    case 49:
-      return 'PAYTOP2SHWITNESS';
-
-    case 84:
-      return 'PAYTOWITNESS';
-
-    default:
-      return 'PAYTOADDRESS';
-  }
-};
-
-const serializedPath = path => {
-  const pathStr = path.map(p => {
-    if (p & HD_HARDENED) {
-      return `${p & ~HD_HARDENED}'`;
-    }
-
-    return p;
-  }).join('/');
-  return `m/${pathStr}`;
-};
-
-const validatePath = (path, length = 0, base = false) => {
-  let valid;
-
-  if (typeof path === 'string') {
-    valid = getHDPath(path);
-  } else if (Array.isArray(path)) {
-    valid = path.map(p => {
-      const n = parseInt(p);
-
-      if (Number.isNaN(n)) {
-        throw PATH_NOT_VALID;
-      } else if (n < 0) {
-        throw PATH_NEGATIVE_VALUES;
-      }
-
-      return n;
-    });
-  } else {
-    valid = undefined;
-  }
-
-  if (!valid) throw PATH_NOT_VALID;
-  if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
-  return base ? valid.splice(0, 3) : valid;
-};
-
 const LOG_EVENT = 'LOG_EVENT';
 const LOG = {
   OUTPUT: 'log-output'
@@ -14225,6 +14268,7 @@ const UI_REQUEST$1 = {
   REQUEST_PIN: 'ui-request_pin',
   INVALID_PIN: 'ui-invalid_pin',
   REQUEST_BUTTON: 'ui-button',
+  REQUEST_PASSPHRASE_ON_DEVICE: 'ui-request_passphrase_on_device',
   CLOSE_UI_WINDOW: 'ui-close_window',
   BLUETOOTH_PERMISSION: 'ui-bluetooth_permission',
   LOCATION_PERMISSION: 'ui-location_permission',
@@ -14358,13 +14402,13 @@ class DevicePool extends events.exports {
     this.connector = connector;
   }
 
-  static getDevices(descriptorList, connectId) {
+  static getDevices(descriptorList, connectId, initOptions) {
     var descriptorList_1, descriptorList_1_1;
 
     var e_1, _a;
 
     return __awaiter(this, void 0, void 0, function* () {
-      Log$6.debug('get device list');
+      Log$6.debug('get device list: connectId: ', connectId);
       const devices = {};
       const deviceList = [];
 
@@ -14379,7 +14423,7 @@ class DevicePool extends events.exports {
             device.updateDescriptor(exist, true);
             devices[connectId] = device;
             deviceList.push(device);
-            yield this._checkDevicePool();
+            yield this._checkDevicePool(initOptions);
             return {
               devices,
               deviceList
@@ -14393,7 +14437,7 @@ class DevicePool extends events.exports {
       try {
         for (descriptorList_1 = __asyncValues(descriptorList); descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
           const descriptor = descriptorList_1_1.value;
-          const device = yield this._createDevice(descriptor);
+          const device = yield this._createDevice(descriptor, initOptions);
 
           if (device.features) {
             const uuid = getDeviceUUID(device.features);
@@ -14424,7 +14468,7 @@ class DevicePool extends events.exports {
       Log$6.debug('get devices result : ', devices, deviceList);
       console.log('device poll -> connected: ', this.connectedPool);
       console.log('device poll -> disconnected: ', this.disconnectPool);
-      yield this._checkDevicePool();
+      yield this._checkDevicePool(initOptions);
       return {
         devices,
         deviceList
@@ -14432,7 +14476,16 @@ class DevicePool extends events.exports {
     });
   }
 
-  static _createDevice(descriptor) {
+  static clearDeviceCache(connectId) {
+    Log$6.debug('clear device pool cache: connectId', connectId);
+    Log$6.debug('clear device pool cache: ', this.devicesCache);
+
+    if (connectId) {
+      delete this.devicesCache[connectId];
+    }
+  }
+
+  static _createDevice(descriptor, initOptions) {
     return __awaiter(this, void 0, void 0, function* () {
       let device = this.getDeviceByPath(descriptor.path);
 
@@ -14440,7 +14493,7 @@ class DevicePool extends events.exports {
         device = Device.fromDescriptor(descriptor);
         device.deviceConnector = this.connector;
         yield device.connect();
-        yield device.initialize();
+        yield device.initialize(initOptions);
         yield device.release();
       }
 
@@ -14448,19 +14501,19 @@ class DevicePool extends events.exports {
     });
   }
 
-  static _checkDevicePool() {
+  static _checkDevicePool(initOptions) {
     return __awaiter(this, void 0, void 0, function* () {
-      yield this._sendConnectMessage();
+      yield this._sendConnectMessage(initOptions);
 
       this._sendDisconnectMessage();
     });
   }
 
-  static _sendConnectMessage() {
+  static _sendConnectMessage(initOptions) {
     return __awaiter(this, void 0, void 0, function* () {
       for (let i = this.connectedPool.length - 1; i >= 0; i--) {
         const descriptor = this.connectedPool[i];
-        const device = yield this._createDevice(descriptor);
+        const device = yield this._createDevice(descriptor, initOptions);
         Log$6.debug('emit DEVICE.CONNECT: ', device);
         this.emitter.emit(DEVICE.CONNECT, device);
         this.connectedPool.splice(i, 1);
@@ -14749,8 +14802,6 @@ class DeviceCommands {
   }
 
   _filterCommonTypes(res) {
-    var _a;
-
     Log$4.debug('_filterCommonTypes: ', res);
 
     if (res.type === 'Failure') {
@@ -14778,6 +14829,10 @@ class DeviceCommands {
         error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinCancelled);
       }
 
+      if (code === 'Failure_DataError' && message === 'Please confirm the BlindSign enabled') {
+        error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlindSignDisabled);
+      }
+
       if (error) {
         return Promise.reject(error);
       }
@@ -14818,12 +14873,10 @@ class DeviceCommands {
       }, () => this._commonCall('Cancel', {}));
     }
 
-    if ((_a = this.device.features) === null || _a === void 0 ? void 0 : _a.passphrase_protection) {
-      return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportPassphrase));
-    }
-
     if (res.type === 'PassphraseRequest') {
-      return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportPassphrase));
+      return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportPassphrase, 'Device not support passphrase', {
+        require: '2.4.0'
+      }));
     }
 
     if (res.type === 'Deprecated_PassphraseStateRequest') ;
@@ -14865,7 +14918,7 @@ const UI_REQUEST = {
   FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device'
 };
-const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${"0.1.37"}/`;
+const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${"0.1.40"}/`;
 const DEFAULT_PRIORITY = 2;
 const initialSettings = {
   configSrc: './data/config.json',
@@ -14967,6 +15020,7 @@ const parseRunOptions = options => {
 };
 
 const Log$3 = getLogger(exports.d0.Device);
+const deviceSessionCache = {};
 
 class Device extends events.exports {
   constructor(descriptor) {
@@ -14980,6 +15034,7 @@ class Device extends events.exports {
     this.internalState = [];
     this.needReloadDevice = false;
     this.keepSession = false;
+    this.passphraseState = undefined;
     this.originalDescriptor = descriptor;
   }
 
@@ -15116,44 +15171,83 @@ class Device extends events.exports {
     return this.commands;
   }
 
-  getInternalState() {
-    return this.internalState[this.instance];
+  getInternalState(_deviceId) {
+    var _a, _b;
+
+    Log$3.debug('getInternalState session param: ', `device_id: ${_deviceId}`, `features.device_id: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id}`, `passphraseState: ${this.passphraseState}`);
+    Log$3.debug('getInternalState session cache: ', deviceSessionCache);
+    const deviceId = _deviceId || ((_b = this.features) === null || _b === void 0 ? void 0 : _b.device_id);
+    if (!deviceId) return undefined;
+    if (!this.passphraseState) return undefined;
+    const usePassKey = `${deviceId}@${this.passphraseState}`;
+
+    if (!deviceSessionCache[usePassKey]) {
+      const key = `${deviceId}`;
+
+      if (deviceSessionCache[key]) {
+        deviceSessionCache[usePassKey] = deviceSessionCache[key];
+      }
+    }
+
+    return deviceSessionCache[usePassKey];
+  }
+
+  setInternalState(state, initSession) {
+    var _a;
+
+    Log$3.debug('setInternalState session param: ', `state: ${state}`, `initSession: ${initSession}`, `device_id: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id}`, `passphraseState: ${this.passphraseState}`);
+    if (!this.features) return;
+    if (!this.passphraseState && !initSession) return;
+    let key = `${this.features.device_id}`;
+
+    if (this.passphraseState) {
+      key += `@${this.passphraseState}`;
+    }
+
+    if (state) {
+      deviceSessionCache[key] = state;
+    }
+
+    Log$3.debug('setInternalState done session cache: ', deviceSessionCache);
+  }
+
+  clearInternalState(_deviceId) {
+    var _a;
+
+    Log$3.debug('clearInternalState param: ', _deviceId);
+    const deviceId = _deviceId || ((_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id);
+    if (!deviceId) return;
+    const key = `${deviceId}`;
+    delete deviceSessionCache[key];
+
+    if (this.passphraseState) {
+      const usePassKey = `${deviceId}@${this.passphraseState}`;
+      delete deviceSessionCache[usePassKey];
+    }
   }
 
-  initialize() {
+  initialize(options) {
     return __awaiter(this, void 0, void 0, function* () {
-      let payload;
+      Log$3.debug('initialize param:', options);
+      this.passphraseState = options === null || options === void 0 ? void 0 : options.passphraseState;
 
-      if (this.features) {
-        const internalState = this.getInternalState();
-        payload = {};
+      if (options === null || options === void 0 ? void 0 : options.initSession) {
+        this.clearInternalState(options === null || options === void 0 ? void 0 : options.deviceId);
+      }
 
-        if (internalState) {
-          payload.session_id = internalState;
-        }
+      const internalState = this.getInternalState(options === null || options === void 0 ? void 0 : options.deviceId);
+      const payload = {};
+
+      if (internalState) {
+        payload.session_id = internalState;
       }
 
+      Log$3.debug('initialize payload:', payload);
       const {
         message
       } = yield this.commands.typedCall('Initialize', 'Features', payload);
 
-      this._updateFeatures(message);
-
-      if (message.passphrase_protection) {
-        if (this.listenerCount(DEVICE.PIN) > 0) {
-          Log$3.debug('try to close passpharse');
-
-          try {
-            yield this.commands.typedCall('ApplySettings', 'Success', {
-              use_passphrase: false
-            });
-          } catch (e) {
-            yield this.release();
-            this.runPromise = null;
-            throw e;
-          }
-        }
-      }
+      this._updateFeatures(message, options === null || options === void 0 ? void 0 : options.initSession);
     });
   }
 
@@ -15167,11 +15261,15 @@ class Device extends events.exports {
     });
   }
 
-  _updateFeatures(feat) {
+  _updateFeatures(feat, initSession) {
     if (this.features && this.features.session_id && !feat.session_id) {
       feat.session_id = this.features.session_id;
     }
 
+    if (this.features && this.features.device_id && feat.session_id) {
+      this.setInternalState(feat.session_id, initSession);
+    }
+
     feat.unlocked = feat.unlocked || true;
     this.features = feat;
     this.featuresNeedsReload = false;
@@ -15221,8 +15319,6 @@ class Device extends events.exports {
   }
 
   _runInner(fn, options) {
-    var _a;
-
     return __awaiter(this, void 0, void 0, function* () {
       if (!this.isUsedHere() || this.commands.disposed) {
         const env = DataManager.getSettings('env');
@@ -15232,7 +15328,7 @@ class Device extends events.exports {
 
           try {
             if (fn) {
-              yield this.initialize();
+              yield this.initialize(options);
             }
           } catch (error) {
             this.runPromise = null;
@@ -15243,21 +15339,6 @@ class Device extends events.exports {
 
             return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed, `Initialize failed: ${error.message}, code: ${error.code}`));
           }
-        } else if (env === 'react-native') {
-          if ((_a = this.features) === null || _a === void 0 ? void 0 : _a.passphrase_protection) {
-            if (this.listenerCount(DEVICE.PIN) > 0) {
-              Log$3.debug('try to close passpharse for mobile');
-
-              try {
-                yield this.commands.typedCall('ApplySettings', 'Success', {
-                  use_passphrase: false
-                });
-              } catch (e) {
-                this.runPromise = null;
-                return Promise.reject(e);
-              }
-            }
-          }
         }
       }
 
@@ -15391,6 +15472,14 @@ class Device extends events.exports {
     return null;
   }
 
+  hasUsePassphrase() {
+    var _a;
+
+    const isModeT = getDeviceType(this.features) === 'touch' || getDeviceType(this.features) === 'pro';
+    const preCheckTouch = isModeT && ((_a = this.features) === null || _a === void 0 ? void 0 : _a.unlocked) === true;
+    return this.features && (!!this.features.passphrase_protection || preCheckTouch);
+  }
+
   checkDeviceId(deviceId) {
     if (this.features) {
       return this.features.device_id === deviceId;
@@ -15399,6 +15488,26 @@ class Device extends events.exports {
     return false;
   }
 
+  checkPassphraseState() {
+    var _a;
+
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.features) return false;
+      const locked = ((_a = this.features) === null || _a === void 0 ? void 0 : _a.unlocked) === true;
+      const isModeT = getDeviceType(this.features) === 'touch' || getDeviceType(this.features) === 'pro';
+      const newState = yield getPassphraseState(this.features, this.commands);
+
+      if (isModeT && locked) {
+        yield this.getFeatures();
+      }
+
+      if (this.passphraseState && this.passphraseState !== newState) {
+        this.clearInternalState();
+        return newState;
+      }
+    });
+  }
+
 }
 
 class DeviceList extends events.exports {
@@ -15407,7 +15516,7 @@ class DeviceList extends events.exports {
     this.devices = {};
   }
 
-  getDeviceLists(connectId) {
+  getDeviceLists(connectId, initOptions) {
     var _a, _b;
 
     return __awaiter(this, void 0, void 0, function* () {
@@ -15417,7 +15526,7 @@ class DeviceList extends events.exports {
       const {
         deviceList,
         devices
-      } = yield DevicePool.getDevices(descriptorList, connectId);
+      } = yield DevicePool.getDevices(descriptorList, connectId, initOptions);
       this.devices = devices;
       return deviceList;
     });
@@ -15459,6 +15568,7 @@ class BaseMethod {
   constructor(message) {
     this.shouldEnsureConnected = true;
     this.checkDeviceId = false;
+    this.useDevicePassphraseState = true;
     const {
       payload
     } = message;
@@ -15509,6 +15619,7 @@ class BaseMethod {
 class SearchDevices extends BaseMethod {
   init() {
     this.useDevice = false;
+    this.useDevicePassphraseState = false;
   }
 
   run() {
@@ -15543,6 +15654,7 @@ class SearchDevices extends BaseMethod {
 class GetFeatures extends BaseMethod {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE, UI_REQUEST.BOOTLOADER];
+    this.useDevicePassphraseState = false;
   }
 
   run() {
@@ -16810,7 +16922,9 @@ class BTCVerifyMessage extends BaseMethod {
 }
 
 class CheckFirmwareRelease extends BaseMethod {
-  init() {}
+  init() {
+    this.useDevicePassphraseState = false;
+  }
 
   run() {
     if (this.device.features) {
@@ -16827,6 +16941,7 @@ class CheckBLEFirmwareRelease extends BaseMethod {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
     this.checkDeviceId = true;
+    this.useDevicePassphraseState = false;
   }
 
   run() {
@@ -16843,6 +16958,7 @@ class CheckBLEFirmwareRelease extends BaseMethod {
 class CheckTransportRelease extends BaseMethod {
   init() {
     this.useDevice = false;
+    this.useDevicePassphraseState = false;
   }
 
   run() {
@@ -16859,6 +16975,7 @@ class CheckTransportRelease extends BaseMethod {
 class CheckBridgeStatus$1 extends BaseMethod {
   init() {
     this.useDevice = false;
+    this.useDevicePassphraseState = false;
   }
 
   run() {
@@ -16883,7 +17000,9 @@ class CheckBridgeStatus$1 extends BaseMethod {
 }
 
 class DeviceBackup extends BaseMethod {
-  init() {}
+  init() {
+    this.useDevicePassphraseState = false;
+  }
 
   run() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -16896,6 +17015,7 @@ class DeviceBackup extends BaseMethod {
 
 class DeviceChangePin extends BaseMethod {
   init() {
+    this.useDevicePassphraseState = false;
     validateParams(this.payload, [{
       name: 'remove',
       type: 'boolean'
@@ -16916,6 +17036,7 @@ class DeviceChangePin extends BaseMethod {
 
 class DeviceFlags extends BaseMethod {
   init() {
+    this.useDevicePassphraseState = false;
     validateParams(this.payload, [{
       name: 'flags',
       type: 'number'
@@ -16935,7 +17056,9 @@ class DeviceFlags extends BaseMethod {
 }
 
 class DeviceRebootToBootloader extends BaseMethod {
-  init() {}
+  init() {
+    this.useDevicePassphraseState = false;
+  }
 
   getVersionRange() {
     return {
@@ -16959,6 +17082,7 @@ class DeviceRebootToBootloader extends BaseMethod {
 
 class DeviceRecovery extends BaseMethod {
   init() {
+    this.useDevicePassphraseState = false;
     validateParams(this.payload, [{
       name: 'wordCount',
       type: 'number'
@@ -17011,6 +17135,7 @@ class DeviceRecovery extends BaseMethod {
 
 class DeviceReset extends BaseMethod {
   init() {
+    this.useDevicePassphraseState = false;
     validateParams(this.payload, [{
       name: 'displayRandom',
       type: 'boolean'
@@ -17066,6 +17191,7 @@ class DeviceReset extends BaseMethod {
 
 class DeviceSettings extends BaseMethod {
   init() {
+    this.useDevicePassphraseState = false;
     validateParams(this.payload, [{
       name: 'language',
       type: 'string'
@@ -17097,7 +17223,6 @@ class DeviceSettings extends BaseMethod {
       name: 'experimentalFeatures',
       type: 'boolean'
     }]);
-    console.log('DeviceSettings payload', this.payload);
     this.params = {
       language: this.payload.language,
       label: this.payload.label,
@@ -17112,6 +17237,18 @@ class DeviceSettings extends BaseMethod {
     };
   }
 
+  getVersionRange() {
+    if (this.payload.usePassphrase) {
+      return {
+        model_mini: {
+          min: '2.4.0'
+        }
+      };
+    }
+
+    return {};
+  }
+
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       const res = yield this.device.commands.typedCall('ApplySettings', 'Success', Object.assign({}, this.params));
@@ -17122,7 +17259,9 @@ class DeviceSettings extends BaseMethod {
 }
 
 class DeviceUpdateReboot extends BaseMethod {
-  init() {}
+  init() {
+    this.useDevicePassphraseState = false;
+  }
 
   run() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -17134,7 +17273,9 @@ class DeviceUpdateReboot extends BaseMethod {
 }
 
 class DeviceSupportFeatures extends BaseMethod {
-  init() {}
+  init() {
+    this.useDevicePassphraseState = false;
+  }
 
   run() {
     if (!this.device.features) return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device not initialized'));
@@ -17149,6 +17290,7 @@ class DeviceSupportFeatures extends BaseMethod {
 
 class DeviceVerify extends BaseMethod {
   init() {
+    this.useDevicePassphraseState = false;
     validateParams(this.payload, [{
       name: 'dataHex',
       type: 'hexString'
@@ -17187,7 +17329,9 @@ class DeviceVerify extends BaseMethod {
 }
 
 class DeviceWipe extends BaseMethod {
-  init() {}
+  init() {
+    this.useDevicePassphraseState = false;
+  }
 
   run() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -19075,6 +19219,7 @@ class FirmwareUpdate extends BaseMethod {
   init() {
     this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
     this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+    this.useDevicePassphraseState = false;
     const {
       payload
     } = this;
@@ -19149,6 +19294,7 @@ const Log$2 = getLogger(exports.d0.Method);
 class RequestWebUsbDevice extends BaseMethod {
   init() {
     this.useDevice = false;
+    this.useDevicePassphraseState = false;
   }
 
   run() {
@@ -19185,9 +19331,45 @@ class RequestWebUsbDevice extends BaseMethod {
 
 }
 
+class GetPassphraseState extends BaseMethod {
+  init() {
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+    this.useDevicePassphraseState = false;
+  }
+
+  run() {
+    var _a, _b;
+
+    return __awaiter(this, void 0, void 0, function* () {
+      if (!this.device.features) return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed));
+      let {
+        features
+      } = this.device;
+      const locked = ((_b = (_a = this.device) === null || _a === void 0 ? void 0 : _a.features) === null || _b === void 0 ? void 0 : _b.unlocked) === true;
+      const passphraseState = yield getPassphraseState(this.device.features, this.device.commands);
+      const isModeT = getDeviceType(features) === 'touch' || getDeviceType(features) === 'pro';
+
+      if (isModeT && locked) {
+        const {
+          message
+        } = yield this.device.commands.typedCall('GetFeatures', 'Features', {});
+        features = message;
+      }
+
+      if (features && features.passphrase_protection === true) {
+        return Promise.resolve(passphraseState);
+      }
+
+      return Promise.resolve(undefined);
+    });
+  }
+
+}
+
 class CheckBridgeStatus extends BaseMethod {
   init() {
     this.useDevice = false;
+    this.useDevicePassphraseState = false;
   }
 
   run() {
@@ -19244,6 +19426,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   stellarSignTransaction: StellarSignTransaction,
   firmwareUpdate: FirmwareUpdate,
   requestWebUsbDevice: RequestWebUsbDevice,
+  getPassphraseState: GetPassphraseState,
   getLogs: CheckBridgeStatus
 });
 
@@ -19393,6 +19576,12 @@ class DeviceConnector {
 
 const Log = getLogger(exports.d0.Core);
 
+const parseInitOptions = method => ({
+  initSession: method === null || method === void 0 ? void 0 : method.payload.initSession,
+  passphraseState: method === null || method === void 0 ? void 0 : method.payload.passphraseState,
+  deviceId: method === null || method === void 0 ? void 0 : method.payload.deviceId
+});
+
 let _core;
 
 let _deviceList;
@@ -19407,6 +19596,9 @@ const callApiQueue = [];
 const deviceCacheMap = new Map();
 let pollingId = 1;
 const pollingState = {};
+let preConnectCache = {
+  passphraseState: undefined
+};
 
 const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
   var _a;
@@ -19446,6 +19638,16 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
     Log.debug('should cancel the previous method execution: ', callApiQueue.map(m => m.name));
   }
 
+  const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
+  preConnectCache = {
+    passphraseState: method.payload.passphraseState
+  };
+
+  if (connectStateChange || method.payload.initSession) {
+    Log.debug('passphrase state change, clear device cache');
+    DevicePool.clearDeviceCache(method.payload.connectId);
+  }
+
   if (pollingState[pollingId]) {
     pollingState[pollingId] = false;
   }
@@ -19465,6 +19667,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
   (_a = method.setDevice) === null || _a === void 0 ? void 0 : _a.call(method, device);
   device.on(DEVICE.PIN, onDevicePinHandler);
   device.on(DEVICE.BUTTON, onDeviceButtonHandler);
+  device.on(DEVICE.PASSPHRASE_ON_DEVICE, onDevicePassphraseHandler);
   device.on(DEVICE.FEATURES, onDeviceFeaturesHandler);
 
   try {
@@ -19518,6 +19721,26 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
         yield TransportManager.reconfigure(device.getFirmwareVersion());
       }
 
+      checkPassphraseSafety(method, device.features);
+
+      if (device.hasUsePassphrase() && method.useDevicePassphraseState) {
+        const support = supportNewPassphrase(device.features);
+
+        if (!support.support) {
+          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportPassphrase, `Device not support passphrase, please update to ${support.require}`, {
+            require: support.require
+          }));
+        }
+
+        const passphraseState = yield device.checkPassphraseState();
+        checkPassphraseSafety(method, device.features);
+
+        if (passphraseState) {
+          DevicePool.clearDeviceCache(method.payload.connectId);
+          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError));
+        }
+      }
+
       try {
         const response = yield method.run();
         Log.debug('Call API - Inner Method Run: ');
@@ -19533,8 +19756,11 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
     });
 
     Log.debug('Call API - Device Run: ', device.mainId);
+    const runOptions = Object.assign({
+      keepSession: method.payload.keepSession
+    }, parseInitOptions(method));
 
-    const deviceRun = () => device.run(inner);
+    const deviceRun = () => device.run(inner, runOptions);
 
     _callPromise = hdShared.createDeferred(deviceRun);
 
@@ -19589,7 +19815,7 @@ function initDeviceList(method) {
       _deviceList.connector = _connector;
     }
 
-    yield _deviceList.getDeviceLists(method.connectId);
+    yield _deviceList.getDeviceLists(method.connectId, parseInitOptions(method));
   });
 }
 
@@ -19701,7 +19927,7 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
 
           if (env === 'react-native') {
             yield device.acquire();
-            yield device.initialize();
+            yield device.initialize(parseInitOptions(method));
           }
 
           resolve(device);
@@ -19761,6 +19987,20 @@ const cancel = connectId => {
   closePopup();
 };
 
+const checkPassphraseSafety = (method, features) => {
+  if (!method.useDevicePassphraseState) return;
+
+  if ((features === null || features === void 0 ? void 0 : features.passphrase_protection) === true && !method.payload.passphraseState) {
+    DevicePool.clearDeviceCache(method.payload.connectId);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceOpenedPassphrase);
+  }
+
+  if ((features === null || features === void 0 ? void 0 : features.passphrase_protection) === false && method.payload.passphraseState) {
+    DevicePool.clearDeviceCache(method.payload.connectId);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotOpenedPassphrase);
+  }
+};
+
 const cleanup = () => {
   _uiPromises = [];
   Log.debug('Cleanup...');
@@ -19769,6 +20009,7 @@ const cleanup = () => {
 const removeDeviceListener = device => {
   device.removeListener(DEVICE.PIN, onDevicePinHandler);
   device.removeListener(DEVICE.BUTTON, onDeviceButtonHandler);
+  device.removeListener(DEVICE.PASSPHRASE_ON_DEVICE, onDevicePassphraseHandler);
   device.removeListener(DEVICE.FEATURES, onDeviceFeaturesHandler);
   DevicePool.emitter.removeListener(DEVICE.CONNECT, onDeviceConnectHandler);
 };
@@ -19825,6 +20066,13 @@ const onDeviceFeaturesHandler = (...[_, features]) => {
   postMessage(createDeviceMessage(DEVICE.FEATURES, Object.assign({}, features)));
 };
 
+const onDevicePassphraseHandler = (...[device]) => {
+  postMessage(createUiMessage(UI_REQUEST$1.REQUEST_PASSPHRASE_ON_DEVICE, {
+    device: device.toMessageObject(),
+    passphraseState: device.passphraseState
+  }));
+};
+
 const postMessage = message => {
   _core.emit(CORE_EVENT, message);
 };
@@ -21196,6 +21444,9 @@ const HardwareErrorCode = {
   DeviceInterruptedFromUser: 109,
   DeviceCheckDeviceIdError: 110,
   DeviceNotSupportPassphrase: 111,
+  DeviceCheckPassphraseStateError: 112,
+  DeviceNotOpenedPassphrase: 113,
+  DeviceOpenedPassphrase: 114,
   NotInitialized: 200,
   IFrameNotInitialized: 300,
   IFrameAleradyInitialized: 301,
@@ -21235,7 +21486,8 @@ const HardwareErrorCode = {
   BridgeTimeoutError: 807,
   BridgeNotInstalled: 808,
   PollingTimeout: 809,
-  PollingStop: 810
+  PollingStop: 810,
+  BlindSignDisabled: 811
 };
 const HardwareErrorCodeMessage = {
   [HardwareErrorCode.UnknownError]: 'Unknown error occurred. Check message property.',
@@ -21250,6 +21502,9 @@ const HardwareErrorCodeMessage = {
   [HardwareErrorCode.DeviceUnexpectedBootloaderMode]: 'Device should be in bootloader mode',
   [HardwareErrorCode.DeviceCheckDeviceIdError]: 'Device Id in the features is not same.',
   [HardwareErrorCode.DeviceNotSupportPassphrase]: 'Device not support passphrase',
+  [HardwareErrorCode.DeviceCheckPassphraseStateError]: 'Device passphrase state error',
+  [HardwareErrorCode.DeviceNotOpenedPassphrase]: 'Device not opened passphrase',
+  [HardwareErrorCode.DeviceOpenedPassphrase]: 'Device opened passphrase',
   [HardwareErrorCode.NotInitialized]: 'Not initialized',
   [HardwareErrorCode.IFrameNotInitialized]: 'IFrame not initialized',
   [HardwareErrorCode.IFrameAleradyInitialized]: 'IFrame alerady initialized',
@@ -21289,7 +21544,8 @@ const HardwareErrorCodeMessage = {
   [HardwareErrorCode.BridgeTimeoutError]: 'Bridge network timeout',
   [HardwareErrorCode.BridgeNotInstalled]: 'Bridge not installed',
   [HardwareErrorCode.PollingTimeout]: 'Polling timeout',
-  [HardwareErrorCode.PollingStop]: 'Polling stop'
+  [HardwareErrorCode.PollingStop]: 'Polling stop',
+  [HardwareErrorCode.BlindSignDisabled]: 'Please confirm the BlindSign enabled'
 };
 
 const TypedError = (hardwareError, message, params) => {
@@ -46540,7 +46796,7 @@ const src_init = async settings => {
 
   try {
     await init({ ..._settings,
-      version: "0.1.37"
+      version: "0.1.40"
     });
     return true;
   } catch (e) {