@onekeyfe/hd-core 0.1.44 → 0.1.45

package/dist/index.js

@@ -1,10 +1,20 @@
-import semver from 'semver';
-import { ERRORS, HardwareErrorCode, HardwareError, serializeError, createDeferred } from '@onekeyfe/hd-shared';
-import { FailureType, EthereumDataType, StellarMemoType } from '@onekeyfe/hd-transport';
-export { Messages as PROTO } from '@onekeyfe/hd-transport';
-import axios from 'axios';
-import BigNumber from 'bignumber.js';
-import sha256 from 'js-sha256';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var semver = require('semver');
+var hdShared = require('@onekeyfe/hd-shared');
+var hdTransport = require('@onekeyfe/hd-transport');
+var axios = require('axios');
+var BigNumber = require('bignumber.js');
+var sha256 = require('js-sha256');
+
+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);
 
 const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
     const api = {
@@ -618,8 +628,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 = ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Not a valid path');
-const PATH_NEGATIVE_VALUES = ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Path cannot contain negative values');
+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')
@@ -785,7 +795,7 @@ const getDeviceBLEFirmwareVersion = (features) => {
     if (!features.ble_ver) {
         return null;
     }
-    if (!semver.valid(features.ble_ver)) {
+    if (!semver__default["default"].valid(features.ble_ver)) {
         return null;
     }
     return features.ble_ver.split('.');
@@ -798,7 +808,7 @@ const supportInputPinOnSoftware = (features) => {
         return { support: false };
     }
     const currentVersion = getDeviceFirmwareVersion(features).join('.');
-    return { support: semver.gte(currentVersion, '2.3.0'), require: '2.3.0' };
+    return { support: semver__default["default"].gte(currentVersion, '2.3.0'), require: '2.3.0' };
 };
 const supportNewPassphrase = (features) => {
     if (!features)
@@ -808,7 +818,7 @@ const supportNewPassphrase = (features) => {
         return { support: true };
     }
     const currentVersion = getDeviceFirmwareVersion(features).join('.');
-    return { support: semver.gte(currentVersion, '2.4.0'), require: '2.4.0' };
+    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)
@@ -10030,7 +10040,7 @@ var MessagesJSON = {
 };
 
 const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield axios.request({
+    const response = yield axios__default["default"].request({
         url,
         withCredentials: false,
         responseType: type === 'binary' ? 'arraybuffer' : 'json',
@@ -10241,7 +10251,7 @@ const getCircularReplacer = () => {
 const sendLogMessage = (prefix, ...args) => {
     postMessage$1 === null || postMessage$1 === void 0 ? void 0 : postMessage$1(createLogMessage(LOG.OUTPUT, serializeLog(prefix, ...args)));
 };
-var LoggerNames;
+exports.LoggerNames = void 0;
 (function (LoggerNames) {
     LoggerNames["Core"] = "Core";
     LoggerNames["Transport"] = "Transport";
@@ -10258,28 +10268,28 @@ var LoggerNames;
     LoggerNames["Iframe"] = "IFrame";
     LoggerNames["SendMessage"] = "[SendMessage]";
     LoggerNames["Method"] = "[Method]";
-})(LoggerNames || (LoggerNames = {}));
+})(exports.LoggerNames || (exports.LoggerNames = {}));
 const LoggerMap = {
-    [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),
+    [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),
 };
 const getLogger = (key) => LoggerMap[key];
 
 const getReleaseStatus = (releases, currentVersion) => {
-    const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+    const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
     if (newVersions.length === 0) {
         return 'valid';
     }
@@ -10289,7 +10299,7 @@ const getReleaseStatus = (releases, currentVersion) => {
     return 'outdated';
 };
 const getReleaseChangelog = (releases, currentVersion) => {
-    const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+    const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
     return newVersions.map(r => r.changelog);
 };
 
@@ -10299,7 +10309,7 @@ class DataManager {
         return __awaiter(this, void 0, void 0, function* () {
             this.settings = settings;
             try {
-                const { data } = yield axios.get(`https://data.onekey.so/config.json?noCache=${getTimeStamp()}`);
+                const { data } = yield axios__default["default"].get(`https://data.onekey.so/config.json?noCache=${getTimeStamp()}`);
                 this.deviceMap = {
                     classic: data.classic,
                     mini: data.mini,
@@ -10414,7 +10424,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.gte(localVersion, latestTransportVersion.join('.'));
+    const isLatest = semver__default["default"].gte(localVersion, latestTransportVersion.join('.'));
     return isLatest ? 'valid' : 'outdated';
 };
 
@@ -10436,7 +10446,7 @@ const parseMessage = (messageData) => {
 };
 const createErrorMessage = (error) => {
     let payload = { error: error.message, code: error.code };
-    if (error instanceof HardwareError) {
+    if (error instanceof hdShared.HardwareError) {
         payload = { error: error.message, code: error.errorCode };
     }
     return {
@@ -10481,7 +10491,7 @@ const createResponseMessage = (id, success, payload) => ({
     type: RESPONSE_EVENT,
     id,
     success,
-    payload: success ? payload : serializeError(payload),
+    payload: success ? payload : hdShared.serializeError(payload),
 });
 
 const UI_RESPONSE = {
@@ -10531,7 +10541,7 @@ const createFirmwareMessage = (type, payload) => ({
     payload,
 });
 
-const Log$7 = getLogger(LoggerNames.DevicePool);
+const Log$7 = getLogger(exports.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);
@@ -10734,9 +10744,9 @@ DevicePool.disconnectPool = [];
 DevicePool.devicesCache = {};
 DevicePool.emitter = new events.exports();
 
-const Log$6 = getLogger(LoggerNames.Transport);
-const BleLogger = getLogger(LoggerNames.HdBleTransport);
-const HttpLogger = getLogger(LoggerNames.HdTransportHttp);
+const Log$6 = getLogger(exports.LoggerNames.Transport);
+const BleLogger = getLogger(exports.LoggerNames.HdBleTransport);
+const HttpLogger = getLogger(exports.LoggerNames.HdTransportHttp);
 class TransportManager {
     static load() {
         Log$6.debug('transport manager load');
@@ -10767,7 +10777,7 @@ class TransportManager {
             catch (error) {
                 Log$6.debug('Initializing transports error: ', error);
                 if (error.code === 'ECONNABORTED') {
-                    throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
                 }
             }
         });
@@ -10785,7 +10795,7 @@ class TransportManager {
                 this.currentMessages = messages;
             }
             catch (error) {
-                throw ERRORS.TypedError(HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
             }
         });
     }
@@ -10814,10 +10824,10 @@ TransportManager.reactNativeInit = false;
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
     if (!splitResTypes.includes(res.type)) {
-        throw ERRORS.TypedError(HardwareErrorCode.ResponseUnexpectTypeError, `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError, `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
     }
 };
-const Log$5 = getLogger(LoggerNames.DeviceCommands);
+const Log$5 = getLogger(exports.LoggerNames.DeviceCommands);
 class DeviceCommands {
     constructor(device, mainId) {
         this.device = device;
@@ -10859,7 +10869,7 @@ class DeviceCommands {
     typedCall(type, resType, msg) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.disposed) {
-                throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'typedCall: DeviceCommands already disposed');
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'typedCall: DeviceCommands already disposed');
             }
             const response = yield this._commonCall(type, msg);
             try {
@@ -10867,10 +10877,10 @@ class DeviceCommands {
             }
             catch (error) {
                 Log$5.debug('DeviceCommands typedcall error: ', error);
-                if (error instanceof HardwareError) {
-                    if (error.errorCode === HardwareErrorCode.ResponseUnexpectTypeError) {
+                if (error instanceof hdShared.HardwareError) {
+                    if (error.errorCode === hdShared.HardwareErrorCode.ResponseUnexpectTypeError) {
                         if (error.message.indexOf('BridgeNetworkError') > -1) {
-                            throw ERRORS.TypedError(HardwareErrorCode.BridgeNetworkError);
+                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNetworkError);
                         }
                     }
                 }
@@ -10893,25 +10903,25 @@ class DeviceCommands {
             const { code } = res.message;
             const { message } = res.message;
             let error = null;
-            if (code === FailureType.Failure_FirmwareError && !message) {
-                error = ERRORS.TypedError(HardwareErrorCode.FirmwareError);
+            if (code === hdTransport.FailureType.Failure_FirmwareError && !message) {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError);
             }
-            if (code === FailureType.Failure_ActionCancelled) {
-                error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled);
+            if (code === hdTransport.FailureType.Failure_ActionCancelled) {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ActionCancelled);
             }
-            if (code === FailureType.Failure_PinInvalid) {
-                error = ERRORS.TypedError(HardwareErrorCode.PinInvalid, message);
+            if (code === hdTransport.FailureType.Failure_PinInvalid) {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinInvalid, message);
             }
-            if (code === FailureType.Failure_PinCancelled) {
-                error = ERRORS.TypedError(HardwareErrorCode.PinCancelled);
+            if (code === hdTransport.FailureType.Failure_PinCancelled) {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinCancelled);
             }
-            if (code === FailureType.Failure_DataError && message === 'Please confirm the BlindSign enabled') {
-                error = ERRORS.TypedError(HardwareErrorCode.BlindSignDisabled);
+            if (code === hdTransport.FailureType.Failure_DataError && message === 'Please confirm the BlindSign enabled') {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlindSignDisabled);
             }
             if (error) {
                 return Promise.reject(error);
             }
-            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, `${code || 'Failure_UnknownCode'},${message || 'Failure_UnknownMessage'}`));
+            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${code || 'Failure_UnknownCode'},${message || 'Failure_UnknownMessage'}`));
         }
         if (res.type === 'Features') {
             return Promise.resolve(patchFeatures(res));
@@ -10929,7 +10939,7 @@ class DeviceCommands {
         const isWebusbEnv = DataManager.getSettings('env') === 'webusb';
         if (res.type === 'PinMatrixRequest') {
             if (isWebusbEnv) {
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please unlock your device'));
+                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please unlock your device'));
             }
             return this._promptPin(res.message.type).then(pin => {
                 if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
@@ -10939,7 +10949,7 @@ class DeviceCommands {
             }, () => this._commonCall('Cancel', {}));
         }
         if (res.type === 'PassphraseRequest') {
-            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportPassphrase, 'Device not support passphrase', {
+            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportPassphrase, 'Device not support passphrase', {
                 require: '2.4.0',
             }));
         }
@@ -10963,7 +10973,7 @@ class DeviceCommands {
             }
             else {
                 console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
-                reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, '_promptPin: PIN callback not configured'));
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, '_promptPin: PIN callback not configured'));
             }
         });
     }
@@ -10982,7 +10992,9 @@ const UI_REQUEST = {
     NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device',
 };
 
-const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${process.env.VERSION}/`;
+const pkg = require('../package.json');
+const getSDKVersion = () => pkg.version;
+const DEFAULT_DOMAIN = `https://jssdk.onekey.so/${getSDKVersion()}/`;
 
 const DEFAULT_PRIORITY = 2;
 const initialSettings = {
@@ -10993,7 +11005,7 @@ const initialSettings = {
     trustedHost: false,
     connectSrc: DEFAULT_DOMAIN,
     iframeSrc: `${DEFAULT_DOMAIN}iframe.html`,
-    parentOrigin: window && window.location ? window.location.origin : '',
+    parentOrigin: typeof window !== 'undefined' && window.location ? window.location.origin : '',
     supportedBrowser: typeof navigator !== 'undefined' ? !/Trident|MSIE|Edge/.test(navigator.userAgent) : true,
     env: 'web',
     lazyLoad: false,
@@ -11073,7 +11085,7 @@ const parseRunOptions = (options) => {
         options = {};
     return options;
 };
-const Log$4 = getLogger(LoggerNames.Device);
+const Log$4 = getLogger(exports.LoggerNames.Device);
 const deviceSessionCache = {};
 class Device extends events.exports {
     constructor(descriptor) {
@@ -11323,7 +11335,7 @@ class Device extends events.exports {
                 Log$4.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
             }
             options = parseRunOptions(options);
-            this.runPromise = createDeferred(this._runInner.bind(this, fn, options));
+            this.runPromise = hdShared.createDeferred(this._runInner.bind(this, fn, options));
             return this.runPromise.promise;
         });
     }
@@ -11340,10 +11352,10 @@ class Device extends events.exports {
                     }
                     catch (error) {
                         this.runPromise = null;
-                        if (error instanceof HardwareError) {
+                        if (error instanceof hdShared.HardwareError) {
                             return Promise.reject(error);
                         }
-                        return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed, `Initialize failed: ${error.message}, code: ${error.code}`));
+                        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed, `Initialize failed: ${error.message}, code: ${error.code}`));
                     }
                 }
             }
@@ -11380,7 +11392,7 @@ class Device extends events.exports {
                 yield this.commands.dispose(false);
             }
             if (this.runPromise) {
-                this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromOutside));
+                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside));
             }
         });
     }
@@ -11390,7 +11402,7 @@ class Device extends events.exports {
                 yield this.commands.dispose(true);
             }
             if (this.runPromise) {
-                this.runPromise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser));
+                this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser));
             }
         });
     }
@@ -11532,7 +11544,7 @@ const getBleFirmwareReleaseInfo = (features) => {
     };
 };
 
-const Log$3 = getLogger(LoggerNames.Method);
+const Log$3 = getLogger(exports.LoggerNames.Method);
 class BaseMethod {
     constructor(message) {
         this.shouldEnsureConnected = true;
@@ -11637,7 +11649,7 @@ class GetPassphraseState extends BaseMethod {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device.features)
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
+                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);
@@ -11718,7 +11730,7 @@ class CheckBridgeStatus extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                axios
+                axios__default["default"]
                     .request({
                     url: 'http://localhost:21320',
                     method: 'POST',
@@ -11728,7 +11740,7 @@ class CheckBridgeStatus extends BaseMethod {
                     .then(() => resolve(true))
                     .catch(e => {
                     if (e.code === 'ECONNABORTED') {
-                        reject(ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError));
+                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError));
                     }
                     else {
                         resolve(false);
@@ -11787,7 +11799,7 @@ const formatAnyHex = value => {
     return value;
 };
 
-const invalidParameter = (message) => ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
+const invalidParameter = (message) => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, message);
 const validateParams = (values, fields) => {
     fields.forEach(field => {
         const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
@@ -11810,7 +11822,7 @@ const validateParams = (values, fields) => {
                         throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
                     }
                     try {
-                        const bn = new BigNumber(value);
+                        const bn = new BigNumber__default["default"](value);
                         if (bn.toFixed(0) !== value) {
                             throw new Error('');
                         }
@@ -12028,7 +12040,7 @@ class DeviceSupportFeatures extends BaseMethod {
     }
     run() {
         if (!this.device.features)
-            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not initialized'));
+            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device not initialized'));
         const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
         return Promise.resolve({
             inputPinOnSoftware,
@@ -12050,7 +12062,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.sha256(this.params.data) }));
+                const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign(Object.assign({}, this.params), { data: sha256__default["default"].sha256(this.params.data) }));
                 response = res.message;
             }
             else {
@@ -12065,7 +12077,7 @@ class DeviceVerify extends BaseMethod {
             }
             if (response)
                 return Promise.resolve(response);
-            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not support verify'));
+            return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device not support verify'));
         });
     }
 }
@@ -12085,11 +12097,11 @@ class DeviceWipe extends BaseMethod {
 const getBinary = ({ features, updateType, version }) => __awaiter(void 0, void 0, void 0, function* () {
     const releaseInfo = getInfo({ features, updateType });
     if (!releaseInfo) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no firmware found for this device');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no firmware found for this device');
     }
     if (version &&
-        !semver.eq(releaseInfo.version, version)) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware version mismatch');
+        !semver__default["default"].eq(releaseInfo.version, version)) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'firmware version mismatch');
     }
     const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
     let fw;
@@ -12097,7 +12109,7 @@ const getBinary = ({ features, updateType, version }) => __awaiter(void 0, void
         fw = yield httpRequest(url, 'binary');
     }
     catch (_a) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
     }
     return Object.assign(Object.assign({}, releaseInfo), { binary: fw });
 });
@@ -12152,7 +12164,7 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload })
         postProgressMessage(device, 100, postMessage);
         return response.message;
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
 });
 
 class FirmwareUpdate extends BaseMethod {
@@ -12166,7 +12178,7 @@ class FirmwareUpdate extends BaseMethod {
             { name: 'binary', type: 'buffer' },
         ]);
         if (!payload.updateType) {
-            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
         }
         this.params = { updateType: payload.updateType };
         if ('version' in payload) {
@@ -12187,7 +12199,7 @@ class FirmwareUpdate extends BaseMethod {
                 }
                 else {
                     if (!device.features) {
-                        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no features found for this device');
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no features found for this device');
                     }
                     const firmware = yield getBinary({
                         features: device.features,
@@ -12198,14 +12210,14 @@ class FirmwareUpdate extends BaseMethod {
                 }
             }
             catch (err) {
-                throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, (_a = err.message) !== null && _a !== void 0 ? _a : err);
+                throw hdShared.ERRORS.TypedError(hdShared.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(LoggerNames.Method);
+const Log$2 = getLogger(exports.LoggerNames.Method);
 class RequestWebUsbDevice extends BaseMethod {
     init() {
         this.useDevice = false;
@@ -12217,7 +12229,7 @@ class RequestWebUsbDevice extends BaseMethod {
             yield TransportManager.configure();
             const env = DataManager.getSettings('env');
             if (env !== 'webusb') {
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Not webusb environment'));
+                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Not webusb environment'));
             }
             try {
                 const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
@@ -12226,11 +12238,11 @@ class RequestWebUsbDevice extends BaseMethod {
                 if (deviceList.length > 0) {
                     return { device: deviceList[0].toMessageObject() };
                 }
-                return yield Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+                return yield Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
             }
             catch (error) {
                 Log$2.debug(error);
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
             }
         });
     }
@@ -12499,13 +12511,13 @@ const getCoinInfo = (path, coin) => {
     }
     if (!coinInfo) {
         if (coin) {
-            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Invalid coin name: ${coin}`);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Invalid coin name: ${coin}`);
         }
         else if (path) {
-            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Invalid path: ${path[0]}`);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Invalid path: ${path[0]}`);
         }
         else {
-            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter);
         }
     }
     return coinInfo;
@@ -12662,49 +12674,49 @@ class BTCSignMessage extends BaseMethod {
 const requestPrevTxInfo$1 = ({ typedCall, txRequest: { request_type, details }, refTxs }) => {
     const { tx_hash } = details;
     if (!tx_hash) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
     }
     const tx = refTxs[tx_hash.toLowerCase()];
     if (!tx) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
     }
     if (request_type === 'TXINPUT') {
         if (!tx.bin_outputs)
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.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 ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.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 ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.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 ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.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 ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
         }
         if (typeof details.extra_data_offset !== 'number') {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
         }
         if (typeof tx.extra_data !== 'string') {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
         }
         const data = tx.extra_data;
         const dataLen = details.extra_data_len;
@@ -12727,7 +12739,7 @@ const requestPrevTxInfo$1 = ({ typedCall, txRequest: { request_type, details },
         };
         return typedCall('TxAckPrevMeta', 'TxRequest', { tx: meta });
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 const requestSignedTxInfo$1 = ({ typedCall, txRequest: { request_type, details }, inputs, outputs, }) => {
     if (request_type === 'TXINPUT') {
@@ -12739,12 +12751,12 @@ const requestSignedTxInfo$1 = ({ typedCall, txRequest: { request_type, details }
         });
     }
     if (request_type === 'TXMETA') {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
     }
     if (request_type === 'TXEXTRADATA') {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 const requestTxAck$1 = (props) => {
     const { tx_hash } = props.txRequest.details;
@@ -12762,7 +12774,7 @@ const saveTxSignatures$1 = (serializedTx, signatures, txRequest) => {
     }
     if (typeof signature_index === 'number') {
         if (!signature) {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
         }
         signatures[signature_index] = signature;
     }
@@ -12807,14 +12819,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 ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
     }
     const tx = refTxs[tx_hash.toLowerCase()];
     if (!tx) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
     }
     if (!tx.bin_outputs) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
     }
     if (request_type === 'TXINPUT') {
         return { inputs: [tx.inputs[details.request_index]] };
@@ -12824,13 +12836,13 @@ const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) =>
     }
     if (request_type === 'TXEXTRADATA') {
         if (typeof details.extra_data_len !== 'number') {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
         }
         if (typeof details.extra_data_offset !== 'number') {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
         }
         if (typeof tx.extra_data !== 'string') {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
         }
         const data = tx.extra_data;
         const dataLen = details.extra_data_len;
@@ -12855,7 +12867,7 @@ const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) =>
         }
         return meta;
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 const requestSignedTxInfo = ({ txRequest: { request_type, details }, inputs, outputs, }) => {
     if (request_type === 'TXINPUT') {
@@ -12865,12 +12877,12 @@ const requestSignedTxInfo = ({ txRequest: { request_type, details }, inputs, out
         return { outputs: [outputs[details.request_index]] };
     }
     if (request_type === 'TXMETA') {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
     }
     if (request_type === 'TXEXTRADATA') {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 const requestTxAck = (props) => {
     const { tx_hash } = props.txRequest.details;
@@ -12888,7 +12900,7 @@ const saveTxSignatures = (serializedTx, signatures, txRequest) => {
     }
     if (typeof signature_index === 'number') {
         if (!signature) {
-            throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
         }
         signatures[signature_index] = signature;
     }
@@ -12983,12 +12995,12 @@ class BTCSignTransaction extends BaseMethod {
             ]);
             if (Object.prototype.hasOwnProperty.call(output, 'address_n') &&
                 Object.prototype.hasOwnProperty.call(output, 'address')) {
-                throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Cannot use address and address_n in one output');
+                throw hdShared.ERRORS.TypedError(hdShared.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 ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
             }
         });
         const { inputs, outputs, refTxs, account, coin } = this.payload;
@@ -13177,7 +13189,7 @@ class ConfluxSignTransaction extends BaseMethod {
                 const r = request.signature_r;
                 const s = request.signature_s;
                 if (v == null || r == null || s == null) {
-                    throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'sign transaction failed');
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, 'sign transaction failed');
                 }
                 return Promise.resolve({
                     v: `0x${v.toString(16)}`,
@@ -13247,7 +13259,7 @@ class ConfluxSignTransaction extends BaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             const { addressN, formattedTx } = this;
             if (formattedTx == null) {
-                throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'ConfluxSignTransaction: format tx error');
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'ConfluxSignTransaction: format tx error');
             }
             const signedTx = yield this.evmSignTx(addressN, formattedTx);
             return Promise.resolve(signedTx);
@@ -13405,7 +13417,7 @@ class EVMSignTransaction extends BaseMethod {
                 const r = request.signature_r;
                 const s = request.signature_s;
                 if (v == null || r == null || s == null) {
-                    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'processTxRequest: Unexpected request');
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'processTxRequest: Unexpected request');
                 }
                 if (chain_id && v <= 1) {
                     v += 2 * chain_id + 35;
@@ -13525,13 +13537,13 @@ class EVMSignTransaction extends BaseMethod {
 
 const twosComplement = (number, bytes) => {
     if (bytes < 1 || bytes > 32) {
-        throw ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
+        throw hdShared.ERRORS.TypedError('Runtime', 'Int byte size must be between 1 and 32 (8 and 256 bits)');
     }
-    const minValue = new BigNumber(2).exponentiatedBy(bytes * 8 - 1).negated();
+    const minValue = new BigNumber__default["default"](2).exponentiatedBy(bytes * 8 - 1).negated();
     const maxValue = minValue.negated().minus(1);
-    const bigNumber = new BigNumber(number);
+    const bigNumber = new BigNumber__default["default"](number);
     if (bigNumber.isGreaterThan(maxValue) || bigNumber.isLessThan(minValue)) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
     }
     if (bigNumber.isPositive()) {
         return bigNumber;
@@ -13539,17 +13551,17 @@ const twosComplement = (number, bytes) => {
     return bigNumber.minus(minValue).minus(minValue);
 };
 const intToHex = (number, bytes, signed) => {
-    let bigNumber = new BigNumber(number);
+    let bigNumber = new BigNumber__default["default"](number);
     if (signed) {
         bigNumber = twosComplement(bigNumber, bytes);
     }
     if (bigNumber.isNegative()) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Cannot convert negative number to unsigned interger: ${number.toString()}`);
+        throw hdShared.ERRORS.TypedError(hdShared.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 ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Overflow when trying to convert number ${number.toString()} into ${bytes} bytes`);
     }
     return hex.padStart(bytes * 2, '0');
 };
@@ -13560,7 +13572,7 @@ const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
 const parseArrayType = (arrayTypeName) => {
     const arrayMatch = paramTypeArray.exec(arrayTypeName);
     if (arrayMatch === null) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `typename ${arrayTypeName} could not be parsed as an EIP-712 array`);
     }
     const [_, entryTypeName, arraySize] = arrayMatch;
     return {
@@ -13584,12 +13596,12 @@ const encodeData = (typeName, data) => {
     if (typeName === 'bool') {
         return data ? '01' : '00';
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Unsupported data type for direct field encoding: ${typeName}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Unsupported data type for direct field encoding: ${typeName}`);
 };
 const paramTypesMap = {
-    string: EthereumDataType.STRING,
-    bool: EthereumDataType.BOOL,
-    address: EthereumDataType.ADDRESS,
+    string: hdTransport.EthereumDataType.STRING,
+    bool: hdTransport.EthereumDataType.BOOL,
+    address: hdTransport.EthereumDataType.ADDRESS,
 };
 const getFieldType = (typeName, types) => {
     const arrayMatch = paramTypeArray.exec(typeName);
@@ -13597,7 +13609,7 @@ const getFieldType = (typeName, types) => {
         const [_, arrayItemTypeName, arraySize] = arrayMatch;
         const entryType = getFieldType(arrayItemTypeName, types);
         return {
-            data_type: EthereumDataType.ARRAY,
+            data_type: hdTransport.EthereumDataType.ARRAY,
             size: parseInt(arraySize, 10) || undefined,
             entry_type: entryType,
         };
@@ -13606,7 +13618,7 @@ const getFieldType = (typeName, types) => {
     if (numberMatch) {
         const [_, type, bits] = numberMatch;
         return {
-            data_type: type === 'uint' ? EthereumDataType.UINT : EthereumDataType.INT,
+            data_type: type === 'uint' ? hdTransport.EthereumDataType.UINT : hdTransport.EthereumDataType.INT,
             size: Math.floor(parseInt(bits, 10) / 8),
         };
     }
@@ -13614,7 +13626,7 @@ const getFieldType = (typeName, types) => {
     if (bytesMatch) {
         const [_, size] = bytesMatch;
         return {
-            data_type: EthereumDataType.BYTES,
+            data_type: hdTransport.EthereumDataType.BYTES,
             size: parseInt(size, 10) || undefined,
         };
     }
@@ -13626,12 +13638,12 @@ const getFieldType = (typeName, types) => {
     }
     if (typeName in types) {
         return {
-            data_type: EthereumDataType.STRUCT,
+            data_type: hdTransport.EthereumDataType.STRUCT,
             size: types[typeName].length,
             struct_name: typeName,
         };
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `No type definition specified: ${typeName}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `No type definition specified: ${typeName}`);
 };
 
 class EVMSignTypedData extends BaseMethod {
@@ -13658,7 +13670,7 @@ class EVMSignTypedData extends BaseMethod {
                 this.params.messageHash = formatAnyHex(messageHash);
             }
             else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
-                throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'message_hash should only be empty when data.primaryType=EIP712Domain');
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'message_hash should only be empty when data.primaryType=EIP712Domain');
             }
         }
     }
@@ -13680,7 +13692,7 @@ class EVMSignTypedData extends BaseMethod {
                 const { name: typeDefinitionName } = response.message;
                 const typeDefinition = types[typeDefinitionName];
                 if (typeDefinition === undefined) {
-                    throw ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
+                    throw hdShared.ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
                 }
                 const dataStruckAck = {
                     members: typeDefinition.map(({ name, type: typeName }) => ({
@@ -13709,7 +13721,7 @@ class EVMSignTypedData extends BaseMethod {
                         memberTypeName = primaryType;
                         break;
                     default:
-                        throw ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
+                        throw hdShared.ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
                 }
                 for (const index of nestedMemberPath) {
                     if (Array.isArray(memberData)) {
@@ -13735,7 +13747,7 @@ class EVMSignTypedData extends BaseMethod {
                 });
             }
             if (response.type !== 'EthereumTypedDataSignature') {
-                throw ERRORS.TypedError('Runtime', 'Unexpected response type');
+                throw hdShared.ERRORS.TypedError('Runtime', 'Unexpected response type');
             }
             const { address, signature } = response.message;
             return {
@@ -13756,7 +13768,7 @@ class EVMSignTypedData extends BaseMethod {
         if (deviceType === 'classic' || deviceType === 'mini') {
             const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
             const supportSignTypedVersion = '2.2.0';
-            if (semver.lt(currentVersion, supportSignTypedVersion)) {
+            if (semver__default["default"].lt(currentVersion, supportSignTypedVersion)) {
                 return false;
             }
         }
@@ -13765,7 +13777,7 @@ class EVMSignTypedData extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device.features) {
-                throw ERRORS.TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
+                throw hdShared.ERRORS.TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
             }
             const { addressN } = this.params;
             const deviceType = getDeviceType(this.device.features);
@@ -14180,7 +14192,7 @@ class NEMSignTransaction extends BaseMethod {
                     message.supply_change = this.supplyChangeMessage(transaction);
                     break;
                 default:
-                    throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Unknown transaction type');
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unknown transaction type');
             }
             return message;
         };
@@ -14480,7 +14492,7 @@ class StellarSignTransaction extends BaseMethod {
         ]);
         const { transaction, networkPassphrase } = this.payload;
         if (!transaction.timebounds) {
-            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'timebounds is required');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'timebounds is required');
         }
         const addressN = validatePath(this.payload.path, 3);
         this.params = {
@@ -14490,7 +14502,7 @@ class StellarSignTransaction extends BaseMethod {
             fee: transaction.fee,
             sequence_number: transaction.sequence,
             num_operations: transaction.operations.length,
-            memo_type: StellarMemoType.NONE,
+            memo_type: hdTransport.StellarMemoType.NONE,
             timebounds_start: transaction.timebounds.minTime,
             timebounds_end: transaction.timebounds.maxTime,
         };
@@ -14884,27 +14896,27 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
 function findMethod(message) {
     const { method } = message.payload;
     if (typeof method !== 'string') {
-        throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
     }
     const MethodConstructor = ApiMethods[method];
     if (MethodConstructor) {
         return new MethodConstructor(message);
     }
-    throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
 }
 
 const safeThrowError = (error) => {
-    if (error instanceof HardwareError) {
+    if (error instanceof hdShared.HardwareError) {
         throw error;
     }
     else if (error.code === 'ERR_NETWORK') {
-        throw ERRORS.TypedError(HardwareErrorCode.BridgeNotInstalled);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNotInstalled);
     }
     else if (error.code === 'ECONNABORTED') {
-        throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
     }
     else {
-        throw ERRORS.TypedError(error);
+        throw hdShared.ERRORS.TypedError(error);
     }
 };
 
@@ -14912,7 +14924,7 @@ const resolveAfter = (msec, value) => new Promise(resolve => {
     setTimeout(resolve, msec, value);
 });
 
-const Log$1 = getLogger(LoggerNames.DeviceConnector);
+const Log$1 = getLogger(exports.LoggerNames.DeviceConnector);
 class DeviceConnector {
     constructor() {
         this.listenTimestamp = 0;
@@ -15009,7 +15021,7 @@ class DeviceConnector {
     }
 }
 
-const Log = getLogger(LoggerNames.Core);
+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,
@@ -15030,7 +15042,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(ERRORS.TypedError('on call: message.id or message.payload is missing'));
+        return Promise.reject(hdShared.ERRORS.TypedError('on call: message.id or message.payload is missing'));
     }
     let method;
     let messageResponse;
@@ -15091,26 +15103,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.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 (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 (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 }));
+                    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 }));
                 }
             }
             const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
             if (unexpectedMode) {
                 if (unexpectedMode === UI_REQUEST$1.NOT_IN_BOOTLOADER) {
-                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceUnexpectedBootloaderMode));
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceUnexpectedBootloaderMode));
                 }
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceUnexpectedMode, unexpectedMode));
+                return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceUnexpectedMode, unexpectedMode));
             }
             if (method.deviceId && method.checkDeviceId) {
                 const isSameDeviceID = device.checkDeviceId(method.deviceId);
                 if (!isSameDeviceID) {
-                    return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError));
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError));
                 }
             }
             method.checkFirmwareRelease();
@@ -15122,7 +15134,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(ERRORS.TypedError(HardwareErrorCode.DeviceNotSupportPassphrase, `Device not support passphrase, please update to ${support.require}`, {
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportPassphrase, `Device not support passphrase, please update to ${support.require}`, {
                         require: support.require,
                     }));
                 }
@@ -15130,16 +15142,16 @@ 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(ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError));
+                    return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError));
                 }
             }
             try {
                 yield method.checkSafetyLevelOnTestNet();
             }
             catch (e) {
-                const error = e instanceof HardwareError
+                const error = e instanceof hdShared.HardwareError
                     ? e
-                    : ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'open safety check failed.');
+                    : hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'open safety check failed.');
                 messageResponse = createResponseMessage(method.responseID, false, { error });
                 _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.resolve(messageResponse);
                 return;
@@ -15159,7 +15171,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 = createDeferred(deviceRun);
+        _callPromise = hdShared.createDeferred(deviceRun);
         try {
             return yield _callPromise.promise;
         }
@@ -15170,7 +15182,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(ERRORS.TypedError(HardwareErrorCode.CallMethodError, error.message));
+        _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, error.message));
         Log.debug('Call API - Run Error: ', error);
     }
     finally {
@@ -15209,7 +15221,7 @@ function initDeviceList(method) {
 }
 function initDevice(method) {
     if (!_deviceList) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceListNotInitialized);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceListNotInitialized);
     }
     let device;
     const allDevices = _deviceList.allDevices();
@@ -15220,17 +15232,17 @@ function initDevice(method) {
         [device] = allDevices;
     }
     else if (allDevices.length > 1) {
-        throw ERRORS.TypedError(HardwareErrorCode.SelectDevice);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.SelectDevice);
     }
     if (!device) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
     }
     device.deviceConnector = _connector;
     return device;
 }
 function initDeviceForBle(method) {
     if (!method.connectId && !_deviceList) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceListNotInitialized);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceListNotInitialized);
     }
     if (!method.connectId) {
         return initDevice(method);
@@ -15257,14 +15269,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(ERRORS.TypedError(HardwareErrorCode.PollingStop));
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PollingStop));
                 return;
             }
             if (timer) {
                 clearTimeout(timer);
             }
             timer = setTimeout(() => {
-                reject(ERRORS.TypedError(HardwareErrorCode.PollingTimeout));
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PollingTimeout));
             }, TIME_OUT);
             tryCount += 1;
             Log.debug('EnsureConnected function try count: ', tryCount, ' poll interval time: ', time);
@@ -15273,12 +15285,12 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
             }
             catch (error) {
                 Log.debug('device list error: ', error);
-                if ([HardwareErrorCode.BridgeNotInstalled, HardwareErrorCode.BridgeTimeoutError].includes(error.errorCode)) {
+                if ([hdShared.HardwareErrorCode.BridgeNotInstalled, hdShared.HardwareErrorCode.BridgeTimeoutError].includes(error.errorCode)) {
                     _deviceList = undefined;
                     reject(error);
                     return;
                 }
-                if (error.errorCode === HardwareErrorCode.TransportNotConfigured) {
+                if (error.errorCode === hdShared.HardwareErrorCode.TransportNotConfigured) {
                     yield TransportManager.configure();
                 }
             }
@@ -15306,12 +15318,12 @@ const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0,
             catch (error) {
                 Log.debug('device error: ', error);
                 if ([
-                    HardwareErrorCode.BlePermissionError,
-                    HardwareErrorCode.BleLocationError,
-                    HardwareErrorCode.BleDeviceNotBonded,
-                    HardwareErrorCode.BleCharacteristicNotifyError,
-                    HardwareErrorCode.BleWriteCharacteristicError,
-                    HardwareErrorCode.BleAlreadyConnected,
+                    hdShared.HardwareErrorCode.BlePermissionError,
+                    hdShared.HardwareErrorCode.BleLocationError,
+                    hdShared.HardwareErrorCode.BleDeviceNotBonded,
+                    hdShared.HardwareErrorCode.BleCharacteristicNotifyError,
+                    hdShared.HardwareErrorCode.BleWriteCharacteristicError,
+                    hdShared.HardwareErrorCode.BleAlreadyConnected,
                 ].includes(error.errorCode)) {
                     reject(error);
                     return;
@@ -15322,7 +15334,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(ERRORS.TypedError(HardwareErrorCode.DeviceNotFound));
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound));
                 return;
             }
             return setTimeout(() => resolve(poll(time * 1.5)), time);
@@ -15356,11 +15368,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 ERRORS.TypedError(HardwareErrorCode.DeviceOpenedPassphrase);
+        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 ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotOpenedPassphrase);
     }
 };
 const cleanup = () => {
@@ -15422,7 +15434,7 @@ const postMessage = (message) => {
     _core.emit(CORE_EVENT, message);
 };
 const createUiPromise = (promiseEvent, device) => {
-    const uiPromise = createDeferred(promiseEvent, device);
+    const uiPromise = hdShared.createDeferred(promiseEvent, device);
     _uiPromises.push(uiPromise);
     return uiPromise;
 };
@@ -15510,4 +15522,57 @@ const HardwareSdk = ({ init, call, dispose, eventEmitter, uiResponse, cancel, })
     cancel,
 });
 
-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 };
+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.getSDKVersion = getSDKVersion;
+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;