@onekeyfe/hd-core 0.1.36 → 0.1.39

package/dist/index.js

@@ -51,6 +51,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
         deviceSupportFeatures: connectId => call({ connectId, method: 'deviceSupportFeatures' }),
         deviceVerify: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceVerify' })),
         deviceWipe: connectId => call({ 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, method: 'evmGetAddress' })),
         evmGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmGetPublicKey' })),
         evmSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmSignMessage' })),
@@ -613,6 +614,212 @@ 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: {
@@ -9461,191 +9668,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',
@@ -9972,6 +9994,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',
@@ -10093,11 +10116,11 @@ class DevicePool extends events.exports {
     static setConnector(connector) {
         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 = [];
             if (connectId) {
@@ -10109,7 +10132,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 };
                     }
                     Log$6.debug('found device in cache, but path is different: ', connectId);
@@ -10118,7 +10141,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);
                         if (this.devicesCache[uuid]) {
@@ -10141,34 +10164,41 @@ 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 };
         });
     }
-    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);
             if (!device) {
                 device = Device.fromDescriptor(descriptor);
                 device.deviceConnector = this.connector;
                 yield device.connect();
-                yield device.initialize();
+                yield device.initialize(initOptions);
                 yield device.release();
             }
             return device;
         });
     }
-    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);
@@ -10402,7 +10432,6 @@ class DeviceCommands {
         });
     }
     _filterCommonTypes(res) {
-        var _a;
         Log$4.debug('_filterCommonTypes: ', res);
         if (res.type === 'Failure') {
             const { code } = res.message;
@@ -10420,6 +10449,9 @@ class DeviceCommands {
             if (code === 'Failure_PinCancelled') {
                 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);
             }
@@ -10450,11 +10482,10 @@ class DeviceCommands {
                 return this._commonCall('PinMatrixAck', { pin });
             }, () => 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') ;
         if (res.type === 'WordRequest') ;
@@ -10587,6 +10618,7 @@ const parseRunOptions = (options) => {
     return options;
 };
 const Log$3 = getLogger(exports.LoggerNames.Device);
+const deviceSessionCache = {};
 class Device extends events.exports {
     constructor(descriptor) {
         super();
@@ -10599,6 +10631,7 @@ class Device extends events.exports {
         this.internalState = [];
         this.needReloadDevice = false;
         this.keepSession = false;
+        this.passphraseState = undefined;
         this.originalDescriptor = descriptor;
     }
     static fromDescriptor(originalDescriptor) {
@@ -10723,34 +10756,62 @@ class Device extends events.exports {
     getCommands() {
         return this.commands;
     }
-    getInternalState() {
-        return this.internalState[this.instance];
+    getInternalState(_deviceId) {
+        var _a, _b, _c;
+        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;
+        const key = `${deviceId}`;
+        const usePassKey = `${deviceId}@${this.passphraseState}`;
+        const session = (_c = deviceSessionCache[key]) !== null && _c !== void 0 ? _c : deviceSessionCache[usePassKey];
+        return this.passphraseState ? session : undefined;
+    }
+    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);
     }
-    initialize() {
+    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(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            let payload;
-            if (this.features) {
-                const internalState = this.getInternalState();
-                payload = {};
-                if (internalState) {
-                    payload.session_id = internalState;
-                }
+            Log$3.debug('initialize param:', options);
+            this.passphraseState = options === null || options === void 0 ? void 0 : options.passphraseState;
+            if (options === null || options === void 0 ? void 0 : options.initSession) {
+                this.clearInternalState(options === null || options === void 0 ? void 0 : options.deviceId);
             }
-            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;
-                    }
-                }
+            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, options === null || options === void 0 ? void 0 : options.initSession);
         });
     }
     getFeatures() {
@@ -10759,10 +10820,13 @@ class Device extends events.exports {
             this._updateFeatures(message);
         });
     }
-    _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;
@@ -10802,7 +10866,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');
@@ -10810,7 +10873,7 @@ class Device extends events.exports {
                     yield this.acquire();
                     try {
                         if (fn) {
-                            yield this.initialize();
+                            yield this.initialize(options);
                         }
                     }
                     catch (error) {
@@ -10821,20 +10884,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);
-                            }
-                        }
-                    }
-                }
             }
             if (options.keepSession) {
                 this.keepSession = true;
@@ -10945,12 +10994,35 @@ 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;
         }
         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 {
@@ -10958,13 +11030,13 @@ class DeviceList extends events.exports {
         super(...arguments);
         this.devices = {};
     }
-    getDeviceLists(connectId) {
+    getDeviceLists(connectId, initOptions) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
             const descriptorList = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
             this.devices = {};
-            const { deviceList, devices } = yield DevicePool.getDevices(descriptorList, connectId);
+            const { deviceList, devices } = yield DevicePool.getDevices(descriptorList, connectId, initOptions);
             this.devices = devices;
             return deviceList;
         });
@@ -11002,6 +11074,7 @@ class BaseMethod {
     constructor(message) {
         this.shouldEnsureConnected = true;
         this.checkDeviceId = false;
+        this.useDevicePassphraseState = true;
         const { payload } = message;
         this.name = payload.method;
         this.payload = payload;
@@ -11042,6 +11115,7 @@ class BaseMethod {
 class SearchDevices extends BaseMethod {
     init() {
         this.useDevice = false;
+        this.useDevicePassphraseState = false;
     }
     run() {
         var _a, _b;
@@ -11065,6 +11139,7 @@ class SearchDevices extends BaseMethod {
 class GetFeatures extends BaseMethod {
     init() {
         this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE, UI_REQUEST.BOOTLOADER];
+        this.useDevicePassphraseState = false;
     }
     run() {
         return Promise.resolve(this.device.features);
@@ -11975,7 +12050,9 @@ class BTCVerifyMessage extends BaseMethod {
 }
 
 class CheckFirmwareRelease extends BaseMethod {
-    init() { }
+    init() {
+        this.useDevicePassphraseState = false;
+    }
     run() {
         if (this.device.features) {
             const releaseInfo = getFirmwareReleaseInfo(this.device.features);
@@ -11989,6 +12066,7 @@ class CheckBLEFirmwareRelease extends BaseMethod {
     init() {
         this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
         this.checkDeviceId = true;
+        this.useDevicePassphraseState = false;
     }
     run() {
         if (this.device.features) {
@@ -12002,6 +12080,7 @@ class CheckBLEFirmwareRelease extends BaseMethod {
 class CheckTransportRelease extends BaseMethod {
     init() {
         this.useDevice = false;
+        this.useDevicePassphraseState = false;
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -12016,6 +12095,7 @@ class CheckTransportRelease extends BaseMethod {
 class CheckBridgeStatus$1 extends BaseMethod {
     init() {
         this.useDevice = false;
+        this.useDevicePassphraseState = false;
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -12042,7 +12122,9 @@ class CheckBridgeStatus$1 extends BaseMethod {
 }
 
 class DeviceBackup extends BaseMethod {
-    init() { }
+    init() {
+        this.useDevicePassphraseState = false;
+    }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.device.commands.typedCall('BackupDevice', 'Success');
@@ -12053,6 +12135,7 @@ class DeviceBackup extends BaseMethod {
 
 class DeviceChangePin extends BaseMethod {
     init() {
+        this.useDevicePassphraseState = false;
         validateParams(this.payload, [{ name: 'remove', type: 'boolean' }]);
         this.params = {
             remove: this.payload.remove,
@@ -12068,6 +12151,7 @@ class DeviceChangePin extends BaseMethod {
 
 class DeviceFlags extends BaseMethod {
     init() {
+        this.useDevicePassphraseState = false;
         validateParams(this.payload, [{ name: 'flags', type: 'number' }]);
         this.params = {
             flags: this.payload.flags,
@@ -12082,7 +12166,9 @@ class DeviceFlags extends BaseMethod {
 }
 
 class DeviceRebootToBootloader extends BaseMethod {
-    init() { }
+    init() {
+        this.useDevicePassphraseState = false;
+    }
     getVersionRange() {
         return {
             classic: {
@@ -12103,6 +12189,7 @@ class DeviceRebootToBootloader extends BaseMethod {
 
 class DeviceRecovery extends BaseMethod {
     init() {
+        this.useDevicePassphraseState = false;
         validateParams(this.payload, [
             { name: 'wordCount', type: 'number' },
             { name: 'passphraseProtection', type: 'boolean' },
@@ -12136,6 +12223,7 @@ class DeviceRecovery extends BaseMethod {
 
 class DeviceReset extends BaseMethod {
     init() {
+        this.useDevicePassphraseState = false;
         validateParams(this.payload, [
             { name: 'displayRandom', type: 'boolean' },
             { name: 'strength', type: 'number' },
@@ -12171,6 +12259,7 @@ class DeviceReset extends BaseMethod {
 
 class DeviceSettings extends BaseMethod {
     init() {
+        this.useDevicePassphraseState = false;
         validateParams(this.payload, [
             { name: 'language', type: 'string' },
             { name: 'label', type: 'string' },
@@ -12183,7 +12272,6 @@ class DeviceSettings extends BaseMethod {
             { name: 'safetyChecks', type: 'object' },
             { name: 'experimentalFeatures', type: 'boolean' },
         ]);
-        console.log('DeviceSettings payload', this.payload);
         this.params = {
             language: this.payload.language,
             label: this.payload.label,
@@ -12197,6 +12285,16 @@ class DeviceSettings extends BaseMethod {
             experimental_features: this.payload.experimentalFeatures,
         };
     }
+    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));
@@ -12206,7 +12304,9 @@ class DeviceSettings extends BaseMethod {
 }
 
 class DeviceUpdateReboot extends BaseMethod {
-    init() { }
+    init() {
+        this.useDevicePassphraseState = false;
+    }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.device.commands.typedCall('BixinReboot', 'Success');
@@ -12216,7 +12316,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'));
@@ -12230,6 +12332,7 @@ class DeviceSupportFeatures extends BaseMethod {
 
 class DeviceVerify extends BaseMethod {
     init() {
+        this.useDevicePassphraseState = false;
         validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);
         this.params = {
             data: formatAnyHex(this.payload.dataHex),
@@ -12261,7 +12364,9 @@ class DeviceVerify extends BaseMethod {
 }
 
 class DeviceWipe extends BaseMethod {
-    init() { }
+    init() {
+        this.useDevicePassphraseState = false;
+    }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             const res = yield this.device.commands.typedCall('WipeDevice', 'Success');
@@ -13616,6 +13721,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;
         validateParams(payload, [
             { name: 'version', type: 'array' },
@@ -13665,6 +13771,7 @@ const Log$2 = getLogger(exports.LoggerNames.Method);
 class RequestWebUsbDevice extends BaseMethod {
     init() {
         this.useDevice = false;
+        this.useDevicePassphraseState = false;
     }
     run() {
         var _a, _b;
@@ -13691,9 +13798,36 @@ 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() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -13748,6 +13882,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     stellarSignTransaction: StellarSignTransaction,
     firmwareUpdate: FirmwareUpdate,
     requestWebUsbDevice: RequestWebUsbDevice,
+    getPassphraseState: GetPassphraseState,
     getLogs: CheckBridgeStatus
 });
 
@@ -13880,6 +14015,11 @@ class DeviceConnector {
 }
 
 const Log = getLogger(exports.LoggerNames.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;
 let _connector;
@@ -13889,6 +14029,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;
     if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
@@ -13919,6 +14062,14 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     if (callApiQueue.length > 1) {
         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;
     }
@@ -13934,6 +14085,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 {
         const inner = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -13971,6 +14123,21 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
             if (_deviceList) {
                 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: ');
@@ -13984,7 +14151,8 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
             }
         });
         Log.debug('Call API - Device Run: ', device.mainId);
-        const deviceRun = () => device.run(inner);
+        const runOptions = Object.assign({ keepSession: method.payload.keepSession }, parseInitOptions(method));
+        const deviceRun = () => device.run(inner, runOptions);
         _callPromise = hdShared.createDeferred(deviceRun);
         try {
             return yield _callPromise.promise;
@@ -14030,7 +14198,7 @@ function initDeviceList(method) {
             yield TransportManager.configure();
             _deviceList.connector = _connector;
         }
-        yield _deviceList.getDeviceLists(method.connectId);
+        yield _deviceList.getDeviceLists(method.connectId, parseInitOptions(method));
     });
 }
 function initDevice(method) {
@@ -14123,7 +14291,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);
                     return;
@@ -14137,6 +14305,7 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
                     hdShared.HardwareErrorCode.BleDeviceNotBonded,
                     hdShared.HardwareErrorCode.BleCharacteristicNotifyError,
                     hdShared.HardwareErrorCode.BleWriteCharacteristicError,
+                    hdShared.HardwareErrorCode.BleAlreadyConnected,
                 ].includes(error.errorCode)) {
                     reject(error);
                     return;
@@ -14176,6 +14345,18 @@ const cancel = (connectId) => {
     cleanup();
     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...');
@@ -14183,6 +14364,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);
 };
@@ -14224,6 +14406,12 @@ const onDeviceButtonHandler = (...[device, request]) => {
 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);
 };