@onekeyfe/hd-core 0.1.39 → 0.1.42

package/dist/index.js

@@ -1,20 +1,10 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var semver = require('semver');
-var hdShared = require('@onekeyfe/hd-shared');
-var axios = require('axios');
-var BigNumber = require('bignumber.js');
-var sha256 = require('js-sha256');
-var hdTransport = require('@onekeyfe/hd-transport');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var semver__default = /*#__PURE__*/_interopDefaultLegacy(semver);
-var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
-var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
-var sha256__default = /*#__PURE__*/_interopDefaultLegacy(sha256);
+import semver from 'semver';
+import { ERRORS, HardwareErrorCode, HardwareError, serializeError, createDeferred } from '@onekeyfe/hd-shared';
+import axios from 'axios';
+import BigNumber from 'bignumber.js';
+import sha256 from 'js-sha256';
+import { EthereumDataType } from '@onekeyfe/hd-transport';
+export { Messages as PROTO } from '@onekeyfe/hd-transport';
 
 const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
     const api = {
@@ -617,8 +607,8 @@ 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 PATH_NOT_VALID = ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Not a valid path');
+const PATH_NEGATIVE_VALUES = ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Path cannot contain negative values');
 const getHDPath = (path) => {
     const parts = path.toLowerCase().split('/');
     if (parts[0] !== 'm')
@@ -783,7 +773,7 @@ const getDeviceBLEFirmwareVersion = (features) => {
     if (!features.ble_ver) {
         return null;
     }
-    if (!semver__default["default"].valid(features.ble_ver)) {
+    if (!semver.valid(features.ble_ver)) {
         return null;
     }
     return features.ble_ver.split('.');
@@ -796,7 +786,7 @@ const supportInputPinOnSoftware = (features) => {
         return { support: false };
     }
     const currentVersion = getDeviceFirmwareVersion(features).join('.');
-    return { support: semver__default["default"].gte(currentVersion, '2.3.0'), require: '2.3.0' };
+    return { support: semver.gte(currentVersion, '2.3.0'), require: '2.3.0' };
 };
 const supportNewPassphrase = (features) => {
     if (!features)
@@ -806,7 +796,7 @@ const supportNewPassphrase = (features) => {
         return { support: true };
     }
     const currentVersion = getDeviceFirmwareVersion(features).join('.');
-    return { support: semver__default["default"].gte(currentVersion, '2.4.0'), require: '2.4.0' };
+    return { support: semver.gte(currentVersion, '2.4.0'), require: '2.4.0' };
 };
 const getPassphraseState = (features, commands) => __awaiter(void 0, void 0, void 0, function* () {
     if (!features)
@@ -9574,7 +9564,7 @@ var MessagesJSON = {
 };
 
 const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield axios__default["default"].request({
+    const response = yield axios.request({
         url,
         withCredentials: false,
         responseType: type === 'binary' ? 'arraybuffer' : 'json',
@@ -9680,7 +9670,7 @@ const createLogMessage = (type, payload) => ({
 
 const MAX_ENTRIES = 500;
 let postMessage$1;
-class Log$7 {
+class Log$8 {
     constructor(prefix, enabled) {
         this.prefix = prefix;
         this.enabled = enabled;
@@ -9732,7 +9722,7 @@ class Log$7 {
 }
 const _logs = {};
 const initLog = (prefix, enabled) => {
-    const instance = new Log$7(prefix, !!enabled);
+    const instance = new Log$8(prefix, !!enabled);
     _logs[prefix] = instance;
     return instance;
 };
@@ -9785,7 +9775,7 @@ const getCircularReplacer = () => {
 const sendLogMessage = (prefix, ...args) => {
     postMessage$1 === null || postMessage$1 === void 0 ? void 0 : postMessage$1(createLogMessage(LOG.OUTPUT, serializeLog(prefix, ...args)));
 };
-exports.LoggerNames = void 0;
+var LoggerNames;
 (function (LoggerNames) {
     LoggerNames["Core"] = "Core";
     LoggerNames["Transport"] = "Transport";
@@ -9802,28 +9792,28 @@ exports.LoggerNames = void 0;
     LoggerNames["Iframe"] = "IFrame";
     LoggerNames["SendMessage"] = "[SendMessage]";
     LoggerNames["Method"] = "[Method]";
-})(exports.LoggerNames || (exports.LoggerNames = {}));
+})(LoggerNames || (LoggerNames = {}));
 const LoggerMap = {
-    [exports.LoggerNames.Core]: initLog(exports.LoggerNames.Core),
-    [exports.LoggerNames.Transport]: initLog(exports.LoggerNames.Transport),
-    [exports.LoggerNames.Device]: initLog(exports.LoggerNames.Device),
-    [exports.LoggerNames.DeviceCommands]: initLog(exports.LoggerNames.DeviceCommands),
-    [exports.LoggerNames.DeviceConnector]: initLog(exports.LoggerNames.DeviceConnector),
-    [exports.LoggerNames.DeviceList]: initLog(exports.LoggerNames.DeviceList),
-    [exports.LoggerNames.DevicePool]: initLog(exports.LoggerNames.DevicePool),
-    [exports.LoggerNames.HdBleSdk]: initLog(exports.LoggerNames.HdBleSdk),
-    [exports.LoggerNames.HdTransportHttp]: initLog(exports.LoggerNames.HdTransportHttp),
-    [exports.LoggerNames.HdBleTransport]: initLog(exports.LoggerNames.HdBleTransport),
-    [exports.LoggerNames.Connect]: initLog(exports.LoggerNames.Connect),
-    [exports.LoggerNames.Iframe]: initLog(exports.LoggerNames.Iframe),
-    [exports.LoggerNames.SendMessage]: initLog(exports.LoggerNames.SendMessage),
-    [exports.LoggerNames.Method]: initLog(exports.LoggerNames.Method),
-    [exports.LoggerNames.HdCommonConnectSdk]: initLog(exports.LoggerNames.Method),
+    [LoggerNames.Core]: initLog(LoggerNames.Core),
+    [LoggerNames.Transport]: initLog(LoggerNames.Transport),
+    [LoggerNames.Device]: initLog(LoggerNames.Device),
+    [LoggerNames.DeviceCommands]: initLog(LoggerNames.DeviceCommands),
+    [LoggerNames.DeviceConnector]: initLog(LoggerNames.DeviceConnector),
+    [LoggerNames.DeviceList]: initLog(LoggerNames.DeviceList),
+    [LoggerNames.DevicePool]: initLog(LoggerNames.DevicePool),
+    [LoggerNames.HdBleSdk]: initLog(LoggerNames.HdBleSdk),
+    [LoggerNames.HdTransportHttp]: initLog(LoggerNames.HdTransportHttp),
+    [LoggerNames.HdBleTransport]: initLog(LoggerNames.HdBleTransport),
+    [LoggerNames.Connect]: initLog(LoggerNames.Connect),
+    [LoggerNames.Iframe]: initLog(LoggerNames.Iframe),
+    [LoggerNames.SendMessage]: initLog(LoggerNames.SendMessage),
+    [LoggerNames.Method]: initLog(LoggerNames.Method),
+    [LoggerNames.HdCommonConnectSdk]: initLog(LoggerNames.Method),
 };
 const getLogger = (key) => LoggerMap[key];
 
 const getReleaseStatus = (releases, currentVersion) => {
-    const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
+    const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
     if (newVersions.length === 0) {
         return 'valid';
     }
@@ -9833,7 +9823,7 @@ const getReleaseStatus = (releases, currentVersion) => {
     return 'outdated';
 };
 const getReleaseChangelog = (releases, currentVersion) => {
-    const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
+    const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
     return newVersions.map(r => r.changelog);
 };
 
@@ -9843,7 +9833,7 @@ class DataManager {
         return __awaiter(this, void 0, void 0, function* () {
             this.settings = settings;
             try {
-                const { data } = yield axios__default["default"].get(`https://data.onekey.so/config.json?noCache=${getTimeStamp()}`);
+                const { data } = yield axios.get(`https://data.onekey.so/config.json?noCache=${getTimeStamp()}`);
                 this.deviceMap = {
                     classic: data.classic,
                     mini: data.mini,
@@ -9958,7 +9948,7 @@ DataManager.getTransportStatus = (localVersion) => {
     const latestTransportVersion = (_c = (_b = _a.assets) === null || _b === void 0 ? void 0 : _b.bridge) === null || _c === void 0 ? void 0 : _c.version;
     if (!latestTransportVersion)
         return 'valid';
-    const isLatest = semver__default["default"].gte(localVersion, latestTransportVersion.join('.'));
+    const isLatest = semver.gte(localVersion, latestTransportVersion.join('.'));
     return isLatest ? 'valid' : 'outdated';
 };
 
@@ -9980,7 +9970,7 @@ const parseMessage = (messageData) => {
 };
 const createErrorMessage = (error) => {
     let payload = { error: error.message, code: error.code };
-    if (error instanceof hdShared.HardwareError) {
+    if (error instanceof HardwareError) {
         payload = { error: error.message, code: error.errorCode };
     }
     return {
@@ -10025,7 +10015,7 @@ const createResponseMessage = (id, success, payload) => ({
     type: RESPONSE_EVENT,
     id,
     success,
-    payload: success ? payload : hdShared.serializeError(payload),
+    payload: success ? payload : serializeError(payload),
 });
 
 const UI_RESPONSE = {
@@ -10075,7 +10065,7 @@ const createFirmwareMessage = (type, payload) => ({
     payload,
 });
 
-const Log$6 = getLogger(exports.LoggerNames.DevicePool);
+const Log$7 = getLogger(LoggerNames.DevicePool);
 const getDiff = (current, descriptors) => {
     const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
     const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
@@ -10120,7 +10110,7 @@ class DevicePool extends events.exports {
         var descriptorList_1, descriptorList_1_1;
         var e_1, _a;
         return __awaiter(this, void 0, void 0, function* () {
-            Log$6.debug('get device list: connectId: ', connectId);
+            Log$7.debug('get device list: connectId: ', connectId);
             const devices = {};
             const deviceList = [];
             if (connectId) {
@@ -10128,14 +10118,14 @@ class DevicePool extends events.exports {
                 if (device) {
                     const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
                     if (exist) {
-                        Log$6.debug('find existed Device: ', connectId);
+                        Log$7.debug('find existed Device: ', connectId);
                         device.updateDescriptor(exist, true);
                         devices[connectId] = device;
                         deviceList.push(device);
                         yield this._checkDevicePool(initOptions);
                         return { devices, deviceList };
                     }
-                    Log$6.debug('found device in cache, but path is different: ', connectId);
+                    Log$7.debug('found device in cache, but path is different: ', connectId);
                 }
             }
             try {
@@ -10161,7 +10151,7 @@ class DevicePool extends events.exports {
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            Log$6.debug('get devices result : ', devices, deviceList);
+            Log$7.debug('get devices result : ', devices, deviceList);
             console.log('device poll -> connected: ', this.connectedPool);
             console.log('device poll -> disconnected: ', this.disconnectPool);
             yield this._checkDevicePool(initOptions);
@@ -10169,8 +10159,8 @@ class DevicePool extends events.exports {
         });
     }
     static clearDeviceCache(connectId) {
-        Log$6.debug('clear device pool cache: connectId', connectId);
-        Log$6.debug('clear device pool cache: ', this.devicesCache);
+        Log$7.debug('clear device pool cache: connectId', connectId);
+        Log$7.debug('clear device pool cache: ', this.devicesCache);
         if (connectId) {
             delete this.devicesCache[connectId];
         }
@@ -10199,7 +10189,7 @@ class DevicePool extends events.exports {
             for (let i = this.connectedPool.length - 1; i >= 0; i--) {
                 const descriptor = this.connectedPool[i];
                 const device = yield this._createDevice(descriptor, initOptions);
-                Log$6.debug('emit DEVICE.CONNECT: ', device);
+                Log$7.debug('emit DEVICE.CONNECT: ', device);
                 this.emitter.emit(DEVICE.CONNECT, device);
                 this.connectedPool.splice(i, 1);
             }
@@ -10231,7 +10221,7 @@ class DevicePool extends events.exports {
                 this._addConnectedDeviceToPool(d);
                 return;
             }
-            Log$6.debug('emit DEVICE.CONNECT: ', device);
+            Log$7.debug('emit DEVICE.CONNECT: ', device);
             this.emitter.emit(DEVICE.CONNECT, device);
         });
         diff.disconnected.forEach(d => {
@@ -10241,7 +10231,7 @@ class DevicePool extends events.exports {
                 this._addDisconnectedDeviceToPool(d);
                 return;
             }
-            Log$6.debug('emit DEVICE.DISCONNECT: ', device);
+            Log$7.debug('emit DEVICE.DISCONNECT: ', device);
             this.emitter.emit(DEVICE.DISCONNECT, device);
         });
     }
@@ -10278,12 +10268,12 @@ DevicePool.disconnectPool = [];
 DevicePool.devicesCache = {};
 DevicePool.emitter = new events.exports();
 
-const Log$5 = getLogger(exports.LoggerNames.Transport);
-const BleLogger = getLogger(exports.LoggerNames.HdBleTransport);
-const HttpLogger = getLogger(exports.LoggerNames.HdTransportHttp);
+const Log$6 = getLogger(LoggerNames.Transport);
+const BleLogger = getLogger(LoggerNames.HdBleTransport);
+const HttpLogger = getLogger(LoggerNames.HdTransportHttp);
 class TransportManager {
     static load() {
-        Log$5.debug('transport manager load');
+        Log$6.debug('transport manager load');
         this.defaultMessages = DataManager.getProtobufMessages();
         this.currentMessages = this.defaultMessages;
     }
@@ -10291,27 +10281,27 @@ class TransportManager {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const env = DataManager.getSettings('env');
-                Log$5.debug('Initializing transports');
+                Log$6.debug('Initializing transports');
                 if (env === 'react-native') {
                     if (!this.reactNativeInit) {
                         yield this.transport.init(BleLogger, DevicePool.emitter);
                         this.reactNativeInit = true;
                     }
                     else {
-                        Log$5.debug('React Native Do Not Initializing transports');
+                        Log$6.debug('React Native Do Not Initializing transports');
                     }
                 }
                 else {
                     yield this.transport.init(HttpLogger);
                 }
-                Log$5.debug('Configuring transports');
+                Log$6.debug('Configuring transports');
                 yield this.transport.configure(JSON.stringify(this.defaultMessages));
-                Log$5.debug('Configuring transports done');
+                Log$6.debug('Configuring transports done');
             }
             catch (error) {
-                Log$5.debug('Initializing transports error: ', error);
+                Log$6.debug('Initializing transports error: ', error);
                 if (error.code === 'ECONNABORTED') {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
+                    throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
                 }
             }
         });
@@ -10329,7 +10319,7 @@ class TransportManager {
                 this.currentMessages = messages;
             }
             catch (error) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
+                throw ERRORS.TypedError(HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
             }
         });
     }
@@ -10341,7 +10331,7 @@ class TransportManager {
         else {
             this.transport = new TransportConstructor();
         }
-        Log$5.debug('set transport: ', this.transport);
+        Log$6.debug('set transport: ', this.transport);
     }
     static getTransport() {
         return this.transport;
@@ -10358,10 +10348,10 @@ TransportManager.reactNativeInit = false;
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
     if (!splitResTypes.includes(res.type)) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
+        throw ERRORS.TypedError(HardwareErrorCode.ResponseUnexpectTypeError, `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
     }
 };
-const Log$4 = getLogger(exports.LoggerNames.DeviceCommands);
+const Log$5 = getLogger(LoggerNames.DeviceCommands);
 class DeviceCommands {
     constructor(device, mainId) {
         this.device = device;
@@ -10383,16 +10373,16 @@ class DeviceCommands {
     call(type, msg = {}) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            Log$4.debug('[DeviceCommands] [call] Sending', type);
+            Log$5.debug('[DeviceCommands] [call] Sending', type);
             try {
                 const promise = this.transport.call(this.mainId, type, msg);
                 this.callPromise = promise;
                 const res = yield promise;
-                Log$4.debug('[DeviceCommands] [call] Received', res.type);
+                Log$5.debug('[DeviceCommands] [call] Received', res.type);
                 return res;
             }
             catch (error) {
-                Log$4.debug('[DeviceCommands] [call] Received error', error);
+                Log$5.debug('[DeviceCommands] [call] Received error', error);
                 if (((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === 'device disconnected during action') {
                     return { type: 'BridgeNetworkError', message: {} };
                 }
@@ -10403,18 +10393,18 @@ class DeviceCommands {
     typedCall(type, resType, msg) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.disposed) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'typedCall: DeviceCommands already disposed');
+                throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'typedCall: DeviceCommands already disposed');
             }
             const response = yield this._commonCall(type, msg);
             try {
                 assertType(response, resType);
             }
             catch (error) {
-                Log$4.debug('DeviceCommands typedcall error: ', error);
-                if (error instanceof hdShared.HardwareError) {
-                    if (error.errorCode === hdShared.HardwareErrorCode.ResponseUnexpectTypeError) {
+                Log$5.debug('DeviceCommands typedcall error: ', error);
+                if (error instanceof HardwareError) {
+                    if (error.errorCode === HardwareErrorCode.ResponseUnexpectTypeError) {
                         if (error.message.indexOf('BridgeNetworkError') > -1) {
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNetworkError);
+                            throw ERRORS.TypedError(HardwareErrorCode.BridgeNetworkError);
                         }
                     }
                 }
@@ -10432,30 +10422,30 @@ class DeviceCommands {
         });
     }
     _filterCommonTypes(res) {
-        Log$4.debug('_filterCommonTypes: ', res);
+        Log$5.debug('_filterCommonTypes: ', res);
         if (res.type === 'Failure') {
             const { code } = res.message;
             const { message } = res.message;
             let error = null;
             if (code === 'Failure_FirmwareError' && !message) {
-                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError);
+                error = ERRORS.TypedError(HardwareErrorCode.FirmwareError);
             }
             if (code === 'Failure_ActionCancelled') {
-                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ActionCancelled);
+                error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled);
             }
             if (code === 'Failure_PinInvalid') {
-                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinInvalid, message);
+                error = ERRORS.TypedError(HardwareErrorCode.PinInvalid, message);
             }
             if (code === 'Failure_PinCancelled') {
-                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinCancelled);
+                error = ERRORS.TypedError(HardwareErrorCode.PinCancelled);
             }
             if (code === 'Failure_DataError' && message === 'Please confirm the BlindSign enabled') {
-                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlindSignDisabled);
+                error = ERRORS.TypedError(HardwareErrorCode.BlindSignDisabled);
             }
             if (error) {
                 return Promise.reject(error);
             }
-            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${code || 'Failure_UnknownCode'},${message || 'Failure_UnknownMessage'}`));
+            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, `${code || 'Failure_UnknownCode'},${message || 'Failure_UnknownMessage'}`));
         }
         if (res.type === 'Features') {
             return Promise.resolve(patchFeatures(res));
@@ -10473,7 +10463,7 @@ class DeviceCommands {
         const isWebusbEnv = DataManager.getSettings('env') === 'webusb';
         if (res.type === 'PinMatrixRequest') {
             if (isWebusbEnv) {
-                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please unlock your device'));
+                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please unlock your device'));
             }
             return this._promptPin(res.message.type).then(pin => {
                 if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
@@ -10483,7 +10473,7 @@ class DeviceCommands {
             }, () => this._commonCall('Cancel', {}));
         }
         if (res.type === 'PassphraseRequest') {
-            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportPassphrase, 'Device not support passphrase', {
+            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportPassphrase, 'Device not support passphrase', {
                 require: '2.4.0',
             }));
         }
@@ -10507,7 +10497,7 @@ class DeviceCommands {
             }
             else {
                 console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
-                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, '_promptPin: PIN callback not configured'));
+                reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, '_promptPin: PIN callback not configured'));
             }
         });
     }
@@ -10537,7 +10527,7 @@ const initialSettings = {
     trustedHost: false,
     connectSrc: DEFAULT_DOMAIN,
     iframeSrc: `${DEFAULT_DOMAIN}iframe.html`,
-    parentOrigin: window.location ? window.location.origin : '',
+    parentOrigin: window && window.location ? window.location.origin : '',
     supportedBrowser: typeof navigator !== 'undefined' ? !/Trident|MSIE|Edge/.test(navigator.userAgent) : true,
     env: 'web',
     lazyLoad: false,
@@ -10617,7 +10607,7 @@ const parseRunOptions = (options) => {
         options = {};
     return options;
 };
-const Log$3 = getLogger(exports.LoggerNames.Device);
+const Log$4 = getLogger(LoggerNames.Device);
 const deviceSessionCache = {};
 class Device extends events.exports {
     constructor(descriptor) {
@@ -10700,11 +10690,11 @@ class Device extends events.exports {
                 if (env === 'react-native') {
                     const res = yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.originalDescriptor.id));
                     this.mainId = (_b = res.uuid) !== null && _b !== void 0 ? _b : '';
-                    Log$3.debug('Expected uuid:', this.mainId);
+                    Log$4.debug('Expected uuid:', this.mainId);
                 }
                 else {
                     this.mainId = yield ((_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.acquire(this.originalDescriptor.path, this.originalDescriptor.session));
-                    Log$3.debug('Expected session id:', this.mainId);
+                    Log$4.debug('Expected session id:', this.mainId);
                 }
                 this.updateDescriptor({ [mainIdKey]: this.mainId });
                 if (this.commands) {
@@ -10745,7 +10735,7 @@ class Device extends events.exports {
                     this.updateDescriptor({ session: null });
                 }
                 catch (err) {
-                    Log$3.error('[Device] release error: ', err);
+                    Log$4.error('[Device] release error: ', err);
                 }
                 finally {
                     this.needReloadDevice = true;
@@ -10757,20 +10747,26 @@ class Device extends events.exports {
         return this.commands;
     }
     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);
+        var _a, _b;
+        Log$4.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$4.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}`;
+        if (!this.passphraseState)
+            return undefined;
         const usePassKey = `${deviceId}@${this.passphraseState}`;
-        const session = (_c = deviceSessionCache[key]) !== null && _c !== void 0 ? _c : deviceSessionCache[usePassKey];
-        return this.passphraseState ? session : undefined;
+        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}`);
+        Log$4.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)
@@ -10782,11 +10778,11 @@ class Device extends events.exports {
         if (state) {
             deviceSessionCache[key] = state;
         }
-        Log$3.debug('setInternalState done session cache: ', deviceSessionCache);
+        Log$4.debug('setInternalState done session cache: ', deviceSessionCache);
     }
     clearInternalState(_deviceId) {
         var _a;
-        Log$3.debug('clearInternalState param: ', _deviceId);
+        Log$4.debug('clearInternalState param: ', _deviceId);
         const deviceId = _deviceId || ((_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id);
         if (!deviceId)
             return;
@@ -10799,7 +10795,7 @@ class Device extends events.exports {
     }
     initialize(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            Log$3.debug('initialize param:', options);
+            Log$4.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);
@@ -10809,7 +10805,7 @@ class Device extends events.exports {
             if (internalState) {
                 payload.session_id = internalState;
             }
-            Log$3.debug('initialize payload:', payload);
+            Log$4.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);
         });
@@ -10858,10 +10854,10 @@ class Device extends events.exports {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.runPromise) {
                 yield this.interruptionFromOutside();
-                Log$3.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
+                Log$4.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
             }
             options = parseRunOptions(options);
-            this.runPromise = hdShared.createDeferred(this._runInner.bind(this, fn, options));
+            this.runPromise = createDeferred(this._runInner.bind(this, fn, options));
             return this.runPromise.promise;
         });
     }
@@ -10878,10 +10874,10 @@ class Device extends events.exports {
                     }
                     catch (error) {
                         this.runPromise = null;
-                        if (error instanceof hdShared.HardwareError) {
+                        if (error instanceof HardwareError) {
                             return Promise.reject(error);
                         }
-                        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed, `Initialize failed: ${error.message}, code: ${error.code}`));
+                        return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed, `Initialize failed: ${error.message}, code: ${error.code}`));
                     }
                 }
             }
@@ -10904,7 +10900,7 @@ class Device extends events.exports {
                 options.keepSession === false) {
                 this.keepSession = false;
                 yield this.release();
-                Log$3.debug('release device, mainId: ', this.mainId);
+                Log$4.debug('release device, mainId: ', this.mainId);
             }
             if (this.runPromise) {
                 this.runPromise.resolve();
@@ -10918,7 +10914,7 @@ class Device extends events.exports {
                 yield this.commands.dispose(false);
             }
             if (this.runPromise) {
-                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside));
+                this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside));
             }
         });
     }
@@ -10928,7 +10924,7 @@ class Device extends events.exports {
                 yield this.commands.dispose(true);
             }
             if (this.runPromise) {
-                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser));
+                this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser));
             }
         });
     }
@@ -11070,6 +11066,7 @@ const getBleFirmwareReleaseInfo = (features) => {
     };
 };
 
+const Log$3 = getLogger(LoggerNames.Method);
 class BaseMethod {
     constructor(message) {
         this.shouldEnsureConnected = true;
@@ -11109,6 +11106,24 @@ class BaseMethod {
             device: this.device.toMessageObject(),
         }));
     }
+    checkSafetyLevelOnTestNet() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceType = getDeviceType(this.device.features);
+            if (deviceType !== 'touch')
+                return;
+            let checkFlag = false;
+            if (this.name === 'evmSignTransaction' && Number((_b = (_a = this.payload) === null || _a === void 0 ? void 0 : _a.transaction) === null || _b === void 0 ? void 0 : _b.chainId) !== 1) {
+                checkFlag = true;
+            }
+            if (checkFlag && ((_c = this.device.features) === null || _c === void 0 ? void 0 : _c.safety_checks) === 'Strict') {
+                Log$3.debug('will change safety_checks level');
+                yield this.device.commands.typedCall('ApplySettings', 'Success', {
+                    safety_checks: 'PromptTemporarily',
+                });
+            }
+        });
+    }
     dispose() { }
 }
 
@@ -11182,7 +11197,7 @@ const formatAnyHex = value => {
     return value;
 };
 
-const invalidParameter = (message) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, message);
+const invalidParameter = (message) => ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
 const validateParams = (values, fields) => {
     fields.forEach(field => {
         const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
@@ -11205,7 +11220,7 @@ const validateParams = (values, fields) => {
                         throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
                     }
                     try {
-                        const bn = new BigNumber__default["default"](value);
+                        const bn = new BigNumber(value);
                         if (bn.toFixed(0) !== value) {
                             throw new Error('');
                         }
@@ -11498,13 +11513,13 @@ const getCoinInfo = (path, coin) => {
     }
     if (!coinInfo) {
         if (coin) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Invalid coin name: ${coin}`);
+            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Invalid coin name: ${coin}`);
         }
         else if (path) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Invalid path: ${path[0]}`);
+            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Invalid path: ${path[0]}`);
         }
         else {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter);
+            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
         }
     }
     return coinInfo;
@@ -11661,49 +11676,49 @@ class BTCSignMessage extends BaseMethod {
 const requestPrevTxInfo$1 = ({ typedCall, txRequest: { request_type, details }, refTxs }) => {
     const { tx_hash } = details;
     if (!tx_hash) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
     }
     const tx = refTxs[tx_hash.toLowerCase()];
     if (!tx) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
     }
     if (request_type === 'TXINPUT') {
         if (!tx.bin_outputs)
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
         return typedCall('TxAckPrevInput', 'TxRequest', {
             tx: { input: tx.inputs[details.request_index] },
         });
     }
     if (request_type === 'TXOUTPUT') {
         if (!tx.bin_outputs)
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
         return typedCall('TxAckPrevOutput', 'TxRequest', {
             tx: { output: tx.bin_outputs[details.request_index] },
         });
     }
     if (request_type === 'TXORIGINPUT') {
         if (!tx.outputs)
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
         return typedCall('TxAckInput', 'TxRequest', {
             tx: { input: tx.inputs[details.request_index] },
         });
     }
     if (request_type === 'TXORIGOUTPUT') {
         if (!tx.outputs)
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
         return typedCall('TxAckOutput', 'TxRequest', {
             tx: { output: tx.outputs[details.request_index] },
         });
     }
     if (request_type === 'TXEXTRADATA') {
         if (typeof details.extra_data_len !== 'number') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
         }
         if (typeof details.extra_data_offset !== 'number') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
         }
         if (typeof tx.extra_data !== 'string') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
         }
         const data = tx.extra_data;
         const dataLen = details.extra_data_len;
@@ -11726,7 +11741,7 @@ const requestPrevTxInfo$1 = ({ typedCall, txRequest: { request_type, details },
         };
         return typedCall('TxAckPrevMeta', 'TxRequest', { tx: meta });
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 const requestSignedTxInfo$1 = ({ typedCall, txRequest: { request_type, details }, inputs, outputs, }) => {
     if (request_type === 'TXINPUT') {
@@ -11738,12 +11753,12 @@ const requestSignedTxInfo$1 = ({ typedCall, txRequest: { request_type, details }
         });
     }
     if (request_type === 'TXMETA') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
     }
     if (request_type === 'TXEXTRADATA') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 const requestTxAck$1 = (props) => {
     const { tx_hash } = props.txRequest.details;
@@ -11761,7 +11776,7 @@ const saveTxSignatures$1 = (serializedTx, signatures, txRequest) => {
     }
     if (typeof signature_index === 'number') {
         if (!signature) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
         }
         signatures[signature_index] = signature;
     }
@@ -11806,14 +11821,14 @@ var signtx = (typedCall, inputs, outputs, refTxsArray, options, coinName) => __a
 const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) => {
     const { tx_hash } = details;
     if (!tx_hash) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
     }
     const tx = refTxs[tx_hash.toLowerCase()];
     if (!tx) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
     }
     if (!tx.bin_outputs) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
     }
     if (request_type === 'TXINPUT') {
         return { inputs: [tx.inputs[details.request_index]] };
@@ -11823,13 +11838,13 @@ const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) =>
     }
     if (request_type === 'TXEXTRADATA') {
         if (typeof details.extra_data_len !== 'number') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
         }
         if (typeof details.extra_data_offset !== 'number') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
         }
         if (typeof tx.extra_data !== 'string') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
         }
         const data = tx.extra_data;
         const dataLen = details.extra_data_len;
@@ -11854,7 +11869,7 @@ const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) =>
         }
         return meta;
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 const requestSignedTxInfo = ({ txRequest: { request_type, details }, inputs, outputs, }) => {
     if (request_type === 'TXINPUT') {
@@ -11864,12 +11879,12 @@ const requestSignedTxInfo = ({ txRequest: { request_type, details }, inputs, out
         return { outputs: [outputs[details.request_index]] };
     }
     if (request_type === 'TXMETA') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
     }
     if (request_type === 'TXEXTRADATA') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 const requestTxAck = (props) => {
     const { tx_hash } = props.txRequest.details;
@@ -11887,7 +11902,7 @@ const saveTxSignatures = (serializedTx, signatures, txRequest) => {
     }
     if (typeof signature_index === 'number') {
         if (!signature) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
         }
         signatures[signature_index] = signature;
     }
@@ -11982,12 +11997,12 @@ class BTCSignTransaction extends BaseMethod {
             ]);
             if (Object.prototype.hasOwnProperty.call(output, 'address_n') &&
                 Object.prototype.hasOwnProperty.call(output, 'address')) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Cannot use address and address_n in one output');
+                throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Cannot use address and address_n in one output');
             }
             if (output.address_n) {
                 const scriptType = getOutputScriptType(output.address_n);
                 if (output.script_type !== scriptType)
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
+                    throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
             }
         });
         const { inputs, outputs, refTxs, account, coin } = this.payload;
@@ -12100,7 +12115,7 @@ class CheckBridgeStatus$1 extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                axios__default["default"]
+                axios
                     .request({
                     url: 'http://localhost:21320',
                     method: 'POST',
@@ -12110,7 +12125,7 @@ class CheckBridgeStatus$1 extends BaseMethod {
                     .then(() => resolve(true))
                     .catch(e => {
                     if (e.code === 'ECONNABORTED') {
-                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError));
+                        reject(ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError));
                     }
                     else {
                         resolve(false);
@@ -12269,7 +12284,7 @@ class DeviceSettings extends BaseMethod {
             { name: 'autoLockDelayMs', type: 'number' },
             { name: 'displayRotation', type: 'number' },
             { name: 'passphraseAlwaysOnDevice', type: 'boolean' },
-            { name: 'safetyChecks', type: 'object' },
+            { name: 'safetyChecks', type: 'number' },
             { name: 'experimentalFeatures', type: 'boolean' },
         ]);
         this.params = {
@@ -12321,7 +12336,7 @@ class DeviceSupportFeatures extends BaseMethod {
     }
     run() {
         if (!this.device.features)
-            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device not initialized'));
+            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not initialized'));
         const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
         return Promise.resolve({
             inputPinOnSoftware,
@@ -12343,7 +12358,7 @@ class DeviceVerify extends BaseMethod {
             const deviceType = getDeviceType(this.device.features);
             let response;
             if (deviceType === 'classic') {
-                const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign(Object.assign({}, this.params), { data: sha256__default["default"].sha256(this.params.data) }));
+                const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign(Object.assign({}, this.params), { data: sha256.sha256(this.params.data) }));
                 response = res.message;
             }
             else {
@@ -12358,7 +12373,7 @@ class DeviceVerify extends BaseMethod {
             }
             if (response)
                 return Promise.resolve(response);
-            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device not support verify'));
+            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not support verify'));
         });
     }
 }
@@ -12534,7 +12549,7 @@ class EVMSignTransaction extends BaseMethod {
                 const r = request.signature_r;
                 const s = request.signature_s;
                 if (v == null || r == null || s == null) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'processTxRequest: Unexpected request');
+                    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'processTxRequest: Unexpected request');
                 }
                 if (chain_id && v <= 1) {
                     v += 2 * chain_id + 35;
@@ -12654,13 +12669,13 @@ class EVMSignTransaction extends BaseMethod {
 
 const twosComplement = (number, bytes) => {
     if (bytes < 1 || bytes > 32) {
-        throw hdShared.ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+        throw ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
     }
-    const minValue = new BigNumber__default["default"](2).exponentiatedBy(bytes * 8 - 1).negated();
+    const minValue = new BigNumber(2).exponentiatedBy(bytes * 8 - 1).negated();
     const maxValue = minValue.negated().minus(1);
-    const bigNumber = new BigNumber__default["default"](number);
+    const bigNumber = new BigNumber(number);
     if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
     }
     if (bigNumber.isPositive()) {
         return bigNumber;
@@ -12668,17 +12683,17 @@ const twosComplement = (number, bytes) => {
     return bigNumber.minus(minValue).minus(minValue);
 };
 const intToHex = (number, bytes, signed) => {
-    let bigNumber = new BigNumber__default["default"](number);
+    let bigNumber = new BigNumber(number);
     if (signed) {
         bigNumber = twosComplement(bigNumber, bytes);
     }
     if (bigNumber.isNegative()) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Cannot convert negative number to unsigned interger: ${number.toString()}`);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Cannot convert negative number to unsigned interger: ${number.toString()}`);
     }
     const hex = bigNumber.toString(16);
     const hexChars = bytes * 2;
     if (hex.length > hexChars) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
     }
     return hex.padStart(bytes * 2, '0');
 };
@@ -12689,7 +12704,7 @@ const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
 const parseArrayType = (arrayTypeName) => {
     const arrayMatch = paramTypeArray.exec(arrayTypeName);
     if (arrayMatch === null) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
     }
     const [_, entryTypeName, arraySize] = arrayMatch;
     return {
@@ -12713,12 +12728,12 @@ const encodeData = (typeName, data) => {
     if (typeName === 'bool') {
         return data ? '01' : '00';
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Unsupported data type for direct field encoding: ${typeName}`);
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Unsupported data type for direct field encoding: ${typeName}`);
 };
 const paramTypesMap = {
-    string: hdTransport.EthereumDataType.STRING,
-    bool: hdTransport.EthereumDataType.BOOL,
-    address: hdTransport.EthereumDataType.ADDRESS,
+    string: EthereumDataType.STRING,
+    bool: EthereumDataType.BOOL,
+    address: EthereumDataType.ADDRESS,
 };
 const getFieldType = (typeName, types) => {
     const arrayMatch = paramTypeArray.exec(typeName);
@@ -12726,7 +12741,7 @@ const getFieldType = (typeName, types) => {
         const [_, arrayItemTypeName, arraySize] = arrayMatch;
         const entryType = getFieldType(arrayItemTypeName, types);
         return {
-            data_type: hdTransport.EthereumDataType.ARRAY,
+            data_type: EthereumDataType.ARRAY,
             size: parseInt(arraySize, 10) || undefined,
             entry_type: entryType,
         };
@@ -12735,7 +12750,7 @@ const getFieldType = (typeName, types) => {
     if (numberMatch) {
         const [_, type, bits] = numberMatch;
         return {
-            data_type: type === 'uint' ? hdTransport.EthereumDataType.UINT : hdTransport.EthereumDataType.INT,
+            data_type: type === 'uint' ? EthereumDataType.UINT : EthereumDataType.INT,
             size: Math.floor(parseInt(bits, 10) / 8),
         };
     }
@@ -12743,7 +12758,7 @@ const getFieldType = (typeName, types) => {
     if (bytesMatch) {
         const [_, size] = bytesMatch;
         return {
-            data_type: hdTransport.EthereumDataType.BYTES,
+            data_type: EthereumDataType.BYTES,
             size: parseInt(size, 10) || undefined,
         };
     }
@@ -12755,12 +12770,12 @@ const getFieldType = (typeName, types) => {
     }
     if (typeName in types) {
         return {
-            data_type: hdTransport.EthereumDataType.STRUCT,
+            data_type: EthereumDataType.STRUCT,
             size: types[typeName].length,
             struct_name: typeName,
         };
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `No type definition specified: ${typeName}`);
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `No type definition specified: ${typeName}`);
 };
 
 class EVMSignTypedData extends BaseMethod {
@@ -12787,7 +12802,7 @@ class EVMSignTypedData extends BaseMethod {
                 this.params.messageHash = formatAnyHex(messageHash);
             }
             else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'message_hash should only be empty when data.primaryType=EIP712Domain');
+                throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'message_hash should only be empty when data.primaryType=EIP712Domain');
             }
         }
     }
@@ -12809,7 +12824,7 @@ class EVMSignTypedData extends BaseMethod {
                 const { name: typeDefinitionName } = response.message;
                 const typeDefinition = types[typeDefinitionName];
                 if (typeDefinition === undefined) {
-                    throw hdShared.ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
+                    throw ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
                 }
                 const dataStruckAck = {
                     members: typeDefinition.map(({ name, type: typeName }) => ({
@@ -12838,7 +12853,7 @@ class EVMSignTypedData extends BaseMethod {
                         memberTypeName = primaryType;
                         break;
                     default:
-                        throw hdShared.ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
+                        throw ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
                 }
                 for (const index of nestedMemberPath) {
                     if (Array.isArray(memberData)) {
@@ -12864,7 +12879,7 @@ class EVMSignTypedData extends BaseMethod {
                 });
             }
             if (response.type !== 'EthereumTypedDataSignature') {
-                throw hdShared.ERRORS.TypedError('Runtime', 'Unexpected response type');
+                throw ERRORS.TypedError('Runtime', 'Unexpected response type');
             }
             const { address, signature } = response.message;
             return {
@@ -12885,7 +12900,7 @@ class EVMSignTypedData extends BaseMethod {
         if (deviceType === 'classic' || deviceType === 'mini') {
             const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
             const supportSignTypedVersion = '2.2.0';
-            if (semver__default["default"].lt(currentVersion, supportSignTypedVersion)) {
+            if (semver.lt(currentVersion, supportSignTypedVersion)) {
                 return false;
             }
         }
@@ -12894,7 +12909,7 @@ class EVMSignTypedData extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device.features) {
-                throw hdShared.ERRORS.TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
+                throw ERRORS.TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
             }
             const { addressN } = this.params;
             const deviceType = getDeviceType(this.device.features);
@@ -13309,7 +13324,7 @@ class NEMSignTransaction extends BaseMethod {
                     message.supply_change = this.supplyChangeMessage(transaction);
                     break;
                 default:
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unknown transaction type');
+                    throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Unknown transaction type');
             }
             return message;
         };
@@ -13647,11 +13662,11 @@ class StellarSignTransaction extends BaseMethod {
 const getBinary = ({ features, updateType, version }) => __awaiter(void 0, void 0, void 0, function* () {
     const releaseInfo = getInfo({ features, updateType });
     if (!releaseInfo) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no firmware found for this device');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no firmware found for this device');
     }
     if (version &&
-        !semver__default["default"].eq(releaseInfo.version, version)) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'firmware version mismatch');
+        !semver.eq(releaseInfo.version, version)) {
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware version mismatch');
     }
     const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
     let fw;
@@ -13659,7 +13674,7 @@ const getBinary = ({ features, updateType, version }) => __awaiter(void 0, void
         fw = yield httpRequest(url, 'binary');
     }
     catch (_a) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
     }
     return Object.assign(Object.assign({}, releaseInfo), { binary: fw });
 });
@@ -13714,7 +13729,7 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload })
         postProgressMessage(device, 100, postMessage);
         return response.message;
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
 });
 
 class FirmwareUpdate extends BaseMethod {
@@ -13728,7 +13743,7 @@ class FirmwareUpdate extends BaseMethod {
             { name: 'binary', type: 'buffer' },
         ]);
         if (!payload.updateType) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
+            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
         }
         this.params = { updateType: payload.updateType };
         if ('version' in payload) {
@@ -13749,7 +13764,7 @@ class FirmwareUpdate extends BaseMethod {
                 }
                 else {
                     if (!device.features) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no features found for this device');
+                        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no features found for this device');
                     }
                     const firmware = yield getBinary({
                         features: device.features,
@@ -13760,14 +13775,14 @@ class FirmwareUpdate extends BaseMethod {
                 }
             }
             catch (err) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_a = err.message) !== null && _a !== void 0 ? _a : err);
+                throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, (_a = err.message) !== null && _a !== void 0 ? _a : err);
             }
             return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: binary });
         });
     }
 }
 
-const Log$2 = getLogger(exports.LoggerNames.Method);
+const Log$2 = getLogger(LoggerNames.Method);
 class RequestWebUsbDevice extends BaseMethod {
     init() {
         this.useDevice = false;
@@ -13779,7 +13794,7 @@ class RequestWebUsbDevice extends BaseMethod {
             yield TransportManager.configure();
             const env = DataManager.getSettings('env');
             if (env !== 'webusb') {
-                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Not webusb environment'));
+                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Not webusb environment'));
             }
             try {
                 const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
@@ -13788,11 +13803,11 @@ class RequestWebUsbDevice extends BaseMethod {
                 if (deviceList.length > 0) {
                     return { device: deviceList[0].toMessageObject() };
                 }
-                return yield Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+                return yield Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
             }
             catch (error) {
                 Log$2.debug(error);
-                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
             }
         });
     }
@@ -13807,7 +13822,7 @@ class GetPassphraseState extends BaseMethod {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device.features)
-                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed));
+                return Promise.reject(ERRORS.TypedError(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);
@@ -13889,27 +13904,27 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
 function findMethod(message) {
     const { method } = message.payload;
     if (typeof method !== 'string') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
+        throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
     }
     const MethodConstructor = ApiMethods[method];
     if (MethodConstructor) {
         return new MethodConstructor(message);
     }
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
+    throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
 }
 
 const safeThrowError = (error) => {
-    if (error instanceof hdShared.HardwareError) {
+    if (error instanceof HardwareError) {
         throw error;
     }
     else if (error.code === 'ERR_NETWORK') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNotInstalled);
+        throw ERRORS.TypedError(HardwareErrorCode.BridgeNotInstalled);
     }
     else if (error.code === 'ECONNABORTED') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
+        throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
     }
     else {
-        throw hdShared.ERRORS.TypedError(error);
+        throw ERRORS.TypedError(error);
     }
 };
 
@@ -13917,7 +13932,7 @@ const resolveAfter = (msec, value) => new Promise(resolve => {
     setTimeout(resolve, msec, value);
 });
 
-const Log$1 = getLogger(exports.LoggerNames.DeviceConnector);
+const Log$1 = getLogger(LoggerNames.DeviceConnector);
 class DeviceConnector {
     constructor() {
         this.listenTimestamp = 0;
@@ -14014,7 +14029,7 @@ class DeviceConnector {
     }
 }
 
-const Log = getLogger(exports.LoggerNames.Core);
+const Log = getLogger(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,
@@ -14035,7 +14050,7 @@ let preConnectCache = {
 const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
-        return Promise.reject(hdShared.ERRORS.TypedError('on call: message.id or message.payload is missing'));
+        return Promise.reject(ERRORS.TypedError('on call: message.id or message.payload is missing'));
     }
     let method;
     let messageResponse;
@@ -14096,26 +14111,26 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
             const versionRange = versionRangeType !== null && versionRangeType !== void 0 ? versionRangeType : versionRangeModel;
             if (versionRange && device.features) {
                 const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
-                if (semver__default["default"].valid(versionRange.min) && semver__default["default"].lt(currentVersion, versionRange.min)) {
-                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNeedUpgradeFirmware, `Device firmware version is too low, please update to ${versionRange.min}`, { current: currentVersion, require: versionRange.min }));
+                if (semver.valid(versionRange.min) && semver.lt(currentVersion, versionRange.min)) {
+                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.CallMethodNeedUpgradeFirmware, `Device firmware version is too low, please update to ${versionRange.min}`, { current: currentVersion, require: versionRange.min }));
                 }
                 if (versionRange.max &&
-                    semver__default["default"].valid(versionRange.max) &&
-                    semver__default["default"].gte(currentVersion, versionRange.max)) {
-                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodDeprecated, `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`, { current: currentVersion, deprecated: versionRange.max }));
+                    semver.valid(versionRange.max) &&
+                    semver.gte(currentVersion, versionRange.max)) {
+                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.CallMethodDeprecated, `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`, { current: currentVersion, deprecated: versionRange.max }));
                 }
             }
             const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
             if (unexpectedMode) {
                 if (unexpectedMode === UI_REQUEST$1.NOT_IN_BOOTLOADER) {
-                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceUnexpectedBootloaderMode));
+                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceUnexpectedBootloaderMode));
                 }
-                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceUnexpectedMode, unexpectedMode));
+                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceUnexpectedMode, unexpectedMode));
             }
             if (method.deviceId && method.checkDeviceId) {
                 const isSameDeviceID = device.checkDeviceId(method.deviceId);
                 if (!isSameDeviceID) {
-                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError));
+                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError));
                 }
             }
             method.checkFirmwareRelease();
@@ -14127,7 +14142,7 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
             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}`, {
+                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportPassphrase, `Device not support passphrase, please update to ${support.require}`, {
                         require: support.require,
                     }));
                 }
@@ -14135,9 +14150,20 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
                 checkPassphraseSafety(method, device.features);
                 if (passphraseState) {
                     DevicePool.clearDeviceCache(method.payload.connectId);
-                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError));
+                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError));
                 }
             }
+            try {
+                yield method.checkSafetyLevelOnTestNet();
+            }
+            catch (e) {
+                const error = e instanceof HardwareError
+                    ? e
+                    : ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'open safety check failed.');
+                messageResponse = createResponseMessage(method.responseID, false, { error });
+                _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.resolve(messageResponse);
+                return;
+            }
             try {
                 const response = yield method.run();
                 Log.debug('Call API - Inner Method Run: ');
@@ -14153,7 +14179,7 @@ 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, runOptions);
-        _callPromise = hdShared.createDeferred(deviceRun);
+        _callPromise = createDeferred(deviceRun);
         try {
             return yield _callPromise.promise;
         }
@@ -14164,7 +14190,7 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
     }
     catch (error) {
         messageResponse = createResponseMessage(method.responseID, false, { error });
-        _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, error.message));
+        _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.reject(ERRORS.TypedError(HardwareErrorCode.CallMethodError, error.message));
         Log.debug('Call API - Run Error: ', error);
     }
     finally {
@@ -14203,7 +14229,7 @@ function initDeviceList(method) {
 }
 function initDevice(method) {
     if (!_deviceList) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceListNotInitialized);
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceListNotInitialized);
     }
     let device;
     const allDevices = _deviceList.allDevices();
@@ -14214,17 +14240,17 @@ function initDevice(method) {
         [device] = allDevices;
     }
     else if (allDevices.length > 1) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.SelectDevice);
+        throw ERRORS.TypedError(HardwareErrorCode.SelectDevice);
     }
     if (!device) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
     }
     device.deviceConnector = _connector;
     return device;
 }
 function initDeviceForBle(method) {
     if (!method.connectId && !_deviceList) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceListNotInitialized);
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceListNotInitialized);
     }
     if (!method.connectId) {
         return initDevice(method);
@@ -14251,14 +14277,14 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
         return new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
             if (!pollingState[pollingId]) {
                 Log.debug('EnsureConnected function stop, polling id: ', pollingId);
-                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PollingStop));
+                reject(ERRORS.TypedError(HardwareErrorCode.PollingStop));
                 return;
             }
             if (timer) {
                 clearTimeout(timer);
             }
             timer = setTimeout(() => {
-                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PollingTimeout));
+                reject(ERRORS.TypedError(HardwareErrorCode.PollingTimeout));
             }, TIME_OUT);
             tryCount += 1;
             Log.debug('EnsureConnected function try count: ', tryCount, ' poll interval time: ', time);
@@ -14267,12 +14293,12 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
             }
             catch (error) {
                 Log.debug('device list error: ', error);
-                if ([hdShared.HardwareErrorCode.BridgeNotInstalled, hdShared.HardwareErrorCode.BridgeTimeoutError].includes(error.errorCode)) {
+                if ([HardwareErrorCode.BridgeNotInstalled, HardwareErrorCode.BridgeTimeoutError].includes(error.errorCode)) {
                     _deviceList = undefined;
                     reject(error);
                     return;
                 }
-                if (error.errorCode === hdShared.HardwareErrorCode.TransportNotConfigured) {
+                if (error.errorCode === HardwareErrorCode.TransportNotConfigured) {
                     yield TransportManager.configure();
                 }
             }
@@ -14300,12 +14326,12 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
             catch (error) {
                 Log.debug('device error: ', error);
                 if ([
-                    hdShared.HardwareErrorCode.BlePermissionError,
-                    hdShared.HardwareErrorCode.BleLocationError,
-                    hdShared.HardwareErrorCode.BleDeviceNotBonded,
-                    hdShared.HardwareErrorCode.BleCharacteristicNotifyError,
-                    hdShared.HardwareErrorCode.BleWriteCharacteristicError,
-                    hdShared.HardwareErrorCode.BleAlreadyConnected,
+                    HardwareErrorCode.BlePermissionError,
+                    HardwareErrorCode.BleLocationError,
+                    HardwareErrorCode.BleDeviceNotBonded,
+                    HardwareErrorCode.BleCharacteristicNotifyError,
+                    HardwareErrorCode.BleWriteCharacteristicError,
+                    HardwareErrorCode.BleAlreadyConnected,
                 ].includes(error.errorCode)) {
                     reject(error);
                     return;
@@ -14316,7 +14342,7 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
                     clearTimeout(timer);
                 }
                 Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
-                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound));
+                reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotFound));
                 return;
             }
             return setTimeout(() => resolve(poll(time * 1.5)), time);
@@ -14350,11 +14376,11 @@ const checkPassphraseSafety = (method, features) => {
         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);
+        throw ERRORS.TypedError(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);
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
     }
 };
 const cleanup = () => {
@@ -14416,7 +14442,7 @@ const postMessage = (message) => {
     _core.emit(CORE_EVENT, message);
 };
 const createUiPromise = (promiseEvent, device) => {
-    const uiPromise = hdShared.createDeferred(promiseEvent, device);
+    const uiPromise = createDeferred(promiseEvent, device);
     _uiPromises.push(uiPromise);
     return uiPromise;
 };
@@ -14499,56 +14525,4 @@ const HardwareSdk = ({ init, call, dispose, eventEmitter, uiResponse, cancel, })
     cancel,
 });
 
-Object.defineProperty(exports, 'PROTO', {
-    enumerable: true,
-    get: function () { return hdTransport.Messages; }
-});
-exports.CORE_EVENT = CORE_EVENT;
-exports.Core = Core;
-exports.DEFAULT_PRIORITY = DEFAULT_PRIORITY;
-exports.DEVICE = DEVICE;
-exports.DEVICE_EVENT = DEVICE_EVENT;
-exports.DataManager = DataManager;
-exports.FIRMWARE = FIRMWARE;
-exports.FIRMWARE_EVENT = FIRMWARE_EVENT;
-exports.IFRAME = IFRAME;
-exports.LOG = LOG;
-exports.LOG_EVENT = LOG_EVENT;
-exports.RESPONSE_EVENT = RESPONSE_EVENT;
-exports.UI_EVENT = UI_EVENT;
-exports.UI_REQUEST = UI_REQUEST$1;
-exports.UI_RESPONSE = UI_RESPONSE;
-exports.corsValidator = corsValidator;
-exports.createDeviceMessage = createDeviceMessage;
-exports.createErrorMessage = createErrorMessage;
-exports.createFirmwareMessage = createFirmwareMessage;
-exports.createIFrameMessage = createIFrameMessage;
-exports.createLogMessage = createLogMessage;
-exports.createResponseMessage = createResponseMessage;
-exports.createUiMessage = createUiMessage;
-exports.createUiResponse = createUiResponse;
-exports["default"] = HardwareSdk;
-exports.enableLog = enableLog;
-exports.getDeviceLabel = getDeviceLabel;
-exports.getDeviceType = getDeviceType;
-exports.getDeviceTypeByBleName = getDeviceTypeByBleName;
-exports.getDeviceTypeByDeviceId = getDeviceTypeByDeviceId;
-exports.getDeviceUUID = getDeviceUUID;
-exports.getEnv = getEnv;
-exports.getHDPath = getHDPath;
-exports.getLog = getLog;
-exports.getLogger = getLogger;
-exports.getScriptType = getScriptType;
-exports.getTimeStamp = getTimeStamp;
-exports.httpRequest = httpRequest;
-exports.initCore = init;
-exports.isValidVersionArray = isValidVersionArray;
-exports.isValidVersionString = isValidVersionString;
-exports.normalizeVersionArray = normalizeVersionArray;
-exports.parseConnectSettings = parseConnectSettings;
-exports.parseMessage = parseMessage;
-exports.patchFeatures = patchFeatures;
-exports.safeThrowError = safeThrowError;
-exports.setLoggerPostMessage = setLoggerPostMessage;
-exports.versionCompare = versionCompare;
-exports.versionSplit = versionSplit;
+export { CORE_EVENT, Core, DEFAULT_PRIORITY, DEVICE, DEVICE_EVENT, DataManager, FIRMWARE, FIRMWARE_EVENT, IFRAME, LOG, LOG_EVENT, LoggerNames, RESPONSE_EVENT, UI_EVENT, UI_REQUEST$1 as UI_REQUEST, UI_RESPONSE, corsValidator, createDeviceMessage, createErrorMessage, createFirmwareMessage, createIFrameMessage, createLogMessage, createResponseMessage, createUiMessage, createUiResponse, HardwareSdk as default, enableLog, getDeviceLabel, getDeviceType, getDeviceTypeByBleName, getDeviceTypeByDeviceId, getDeviceUUID, getEnv, getHDPath, getLog, getLogger, getScriptType, getTimeStamp, httpRequest, init as initCore, isValidVersionArray, isValidVersionString, normalizeVersionArray, parseConnectSettings, parseMessage, patchFeatures, safeThrowError, setLoggerPostMessage, versionCompare, versionSplit };