@onekeyfe/hd-web-sdk 0.1.17 → 0.1.18

package/build/onekey-js-sdk.js

@@ -4096,8 +4096,9 @@ const inject = ({
     checkBridgeStatus: () => call({
       method: 'checkBridgeStatus'
     }),
-    cipherKeyValue: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    cipherKeyValue: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'cipherKeyValue'
     })),
     deviceBackup: connectId => call({
@@ -4140,96 +4141,119 @@ const inject = ({
       connectId,
       method: 'deviceWipe'
     }),
-    evmGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    evmGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'evmGetAddress'
     })),
-    evmGetPublicKey: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    evmGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'evmGetPublicKey'
     })),
-    evmSignMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    evmSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'evmSignMessage'
     })),
-    evmSignMessageEIP712: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    evmSignMessageEIP712: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'evmSignMessageEIP712'
     })),
-    evmSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    evmSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'evmSignTransaction'
     })),
-    evmSignTypedData: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    evmSignTypedData: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'evmSignTypedData'
     })),
-    evmVerifyMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    evmVerifyMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'evmVerifyMessage'
     })),
-    btcGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    btcGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'btcGetAddress'
     })),
-    btcGetPublicKey: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    btcGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'btcGetPublicKey'
     })),
-    btcSignMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    btcSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'btcSignMessage'
     })),
-    btcSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    btcSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'btcSignTransaction'
     })),
-    btcVerifyMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    btcVerifyMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'btcVerifyMessage'
     })),
-    starcoinGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    starcoinGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'starcoinGetAddress'
     })),
-    starcoinGetPublicKey: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    starcoinGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'starcoinGetPublicKey'
     })),
-    starcoinSignMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    starcoinSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'starcoinSignMessage'
     })),
-    starcoinSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    starcoinSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'starcoinSignTransaction'
     })),
-    starcoinVerifyMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    starcoinVerifyMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'starcoinVerifyMessage'
     })),
-    nemGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    nemGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'nemGetAddress'
     })),
-    nemSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    nemSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'nemSignTransaction'
     })),
-    solGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    solGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'solGetAddress'
     })),
-    solSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    solSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'solSignTransaction'
     })),
-    stellarGetAddress: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    stellarGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'stellarGetAddress'
     })),
-    stellarSignTransaction: (connectId, params) => call(Object.assign(Object.assign({}, params), {
+    stellarSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), {
       connectId,
+      deviceId,
       method: 'stellarSignTransaction'
     })),
     firmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), {
@@ -14335,6 +14359,18 @@ const createDeviceMessage = (type, payload) => ({
   payload
 });
 
+const FIRMWARE_EVENT = 'FIRMWARE_EVENT';
+const FIRMWARE = {
+  RELEASE_INFO: 'firmware-release-info',
+  BLE_RELEASE_INFO: 'ble-firmware-release-info'
+};
+
+const createFirmwareMessage = (type, payload) => ({
+  event: FIRMWARE_EVENT,
+  type,
+  payload
+});
+
 const assertType = (res, resType) => {
   const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
 
@@ -14353,17 +14389,19 @@ class DeviceCommands {
     this.disposed = false;
   }
 
-  dispose() {
+  dispose(cancelRequest) {
     var _a, _b;
 
-    this.disposed = true;
+    return __awaiter(this, void 0, void 0, function* () {
+      this.disposed = true;
 
-    if (this._cancelableRequest) {
-      this._cancelableRequest();
-    }
+      if (cancelRequest && this._cancelableRequest) {
+        this._cancelableRequest();
+      }
 
-    this._cancelableRequest = undefined;
-    (_b = (_a = this.transport).cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
+      this._cancelableRequest = undefined;
+      yield (_b = (_a = this.transport).cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
+    });
   }
 
   call(type, msg = {}) {
@@ -14491,7 +14529,12 @@ class DeviceCommands {
       }, () => this._commonCall('Cancel', {}));
     }
 
-    if (res.type === 'PassphraseRequest') ;
+    if (res.type === 'PassphraseRequest') {
+      return this._commonCall('PassphraseAck', {
+        passphrase: ''
+      });
+    }
+
     if (res.type === 'Deprecated_PassphraseStateRequest') ;
     if (res.type === 'WordRequest') ;
     return Promise.resolve(res);
@@ -14729,7 +14772,7 @@ class Device extends events.exports {
         });
 
         if (this.commands) {
-          this.commands.dispose();
+          yield this.commands.dispose(false);
         }
 
         this.commands = new DeviceCommands(this, (_d = this.mainId) !== null && _d !== void 0 ? _d : '');
@@ -14753,7 +14796,7 @@ class Device extends events.exports {
 
       if (this.isUsedHere() && !this.keepSession && this.mainId || this.mainId && env === 'react-native') {
         if (this.commands) {
-          this.commands.dispose();
+          this.commands.dispose(false);
 
           if (this.commands.callPromise) {
             try {
@@ -14859,7 +14902,7 @@ class Device extends events.exports {
   run(fn, options) {
     return __awaiter(this, void 0, void 0, function* () {
       if (this.runPromise) {
-        this.interruption();
+        yield this.interruptionFromOutside();
         Log$3.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
       }
 
@@ -14906,14 +14949,28 @@ class Device extends events.exports {
     });
   }
 
-  interruption() {
-    if (this.commands) {
-      this.commands.dispose();
-    }
+  interruptionFromOutside() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.commands) {
+        yield this.commands.dispose(false);
+      }
 
-    if (this.runPromise) {
-      this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside));
-    }
+      if (this.runPromise) {
+        this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside));
+      }
+    });
+  }
+
+  interruptionFromUser() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.commands) {
+        yield this.commands.dispose(true);
+      }
+
+      if (this.runPromise) {
+        this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromUser));
+      }
+    });
   }
 
   getMode() {
@@ -14991,9 +15048,17 @@ class Device extends events.exports {
     return null;
   }
 
+  checkDeviceId(deviceId) {
+    if (this.features) {
+      return this.features.device_id === deviceId;
+    }
+
+    return false;
+  }
+
 }
 
-const cacheDeviceMap = new Map();
+const cacheDeviceMap = {};
 const Log$2 = getLogger(exports.d0.DeviceList);
 
 class DeviceList extends events.exports {
@@ -15002,7 +15067,7 @@ class DeviceList extends events.exports {
     this.devices = {};
   }
 
-  getDeviceLists() {
+  getDeviceLists(connectId) {
     var e_1, _a;
 
     var _b, _c;
@@ -15014,6 +15079,21 @@ class DeviceList extends events.exports {
       const deviceList = [];
       Log$2.debug('get device list');
 
+      if (connectId) {
+        const device = cacheDeviceMap[connectId];
+
+        if (device) {
+          const exist = descriptorList.find(d => d.path === device.originalDescriptor.path);
+
+          if (exist) {
+            device.updateDescriptor(exist, true);
+            Log$2.debug('find existed Device: ', connectId);
+            this.devices[connectId] = device;
+            return [device];
+          }
+        }
+      }
+
       try {
         for (var descriptorList_1 = __asyncValues(descriptorList), descriptorList_1_1; descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
           const descriptor = descriptorList_1_1.value;
@@ -15027,15 +15107,14 @@ class DeviceList extends events.exports {
           if (device.features) {
             const uuid = getDeviceUUID(device.features);
 
-            if (cacheDeviceMap.has(uuid)) {
-              const cache = cacheDeviceMap.get(uuid);
+            if (cacheDeviceMap[uuid]) {
+              const cache = cacheDeviceMap[uuid];
               cache === null || cache === void 0 ? void 0 : cache.updateFromCache(device);
               device = cache;
-              Log$2.debug('use cache device: ', uuid);
             }
 
             this.devices[uuid] = device;
-            cacheDeviceMap.set(uuid, device);
+            cacheDeviceMap[uuid] = device;
           }
         }
       } catch (e_1_1) {
@@ -15064,8 +15143,32 @@ class DeviceList extends events.exports {
 
 }
 
+const getFirmwareReleaseInfo = features => {
+  const firmwareStatus = DataManager.getFirmwareStatus(features);
+  const changelog = DataManager.getFirmwareChangelog(features);
+  const release = DataManager.getFirmwareLeatestRelease(features);
+  return {
+    status: firmwareStatus,
+    changelog,
+    release
+  };
+};
+
+const getBleFirmwareReleaseInfo = features => {
+  const firmwareStatus = DataManager.getBLEFirmwareStatus(features);
+  const changelog = DataManager.getBleFirmwareChangelog(features);
+  const release = DataManager.getBleFirmwareLeatestRelease(features);
+  return {
+    status: firmwareStatus,
+    changelog,
+    release
+  };
+};
+
 class BaseMethod {
   constructor(message) {
+    this.shouldEnsureConnected = true;
+    this.checkDeviceId = false;
     const {
       payload
     } = message;
@@ -15073,6 +15176,7 @@ class BaseMethod {
     this.payload = payload;
     this.responseID = message.id || 0;
     this.connectId = payload.connectId || '';
+    this.deviceId = payload.deviceId || '';
     this.useDevice = true;
     this.allowDeviceMode = [UI_REQUEST.INITIALIZE];
     this.requireDeviceMode = [];
@@ -15087,6 +15191,21 @@ class BaseMethod {
     this.connectId = device.originalDescriptor.path;
   }
 
+  checkFirmwareRelease() {
+    if (!this.device || !this.device.features) return;
+    const releaseInfo = getFirmwareReleaseInfo(this.device.features);
+
+    if (['outdated', 'required'].includes(releaseInfo.status)) {
+      this.postMessage(createFirmwareMessage(FIRMWARE.RELEASE_INFO, releaseInfo));
+    }
+
+    const bleReleaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+
+    if (['outdated', 'required'].includes(bleReleaseInfo.status)) {
+      this.postMessage(createFirmwareMessage(FIRMWARE.BLE_RELEASE_INFO, bleReleaseInfo));
+    }
+  }
+
   dispose() {}
 
 }
@@ -16416,14 +16535,8 @@ class CheckFirmwareRelease extends BaseMethod {
 
   run() {
     if (this.device.features) {
-      const firmwareStatus = DataManager.getFirmwareStatus(this.device.features);
-      const changelog = DataManager.getFirmwareChangelog(this.device.features);
-      const release = DataManager.getFirmwareLeatestRelease(this.device.features);
-      return Promise.resolve({
-        status: firmwareStatus,
-        changelog,
-        release
-      });
+      const releaseInfo = getFirmwareReleaseInfo(this.device.features);
+      return Promise.resolve(releaseInfo);
     }
 
     return Promise.resolve(null);
@@ -16434,18 +16547,13 @@ class CheckFirmwareRelease extends BaseMethod {
 class CheckBLEFirmwareRelease extends BaseMethod {
   init() {
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+    this.checkDeviceId = true;
   }
 
   run() {
     if (this.device.features) {
-      const firmwareStatus = DataManager.getBLEFirmwareStatus(this.device.features);
-      const changelog = DataManager.getBleFirmwareChangelog(this.device.features);
-      const release = DataManager.getBleFirmwareLeatestRelease(this.device.features);
-      return Promise.resolve({
-        status: firmwareStatus,
-        changelog,
-        release
-      });
+      const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+      return Promise.resolve(releaseInfo);
     }
 
     return Promise.resolve(null);
@@ -18806,6 +18914,10 @@ function findMethod(message) {
 const safeThrowError = error => {
   if (error instanceof hdShared.HardwareError) {
     throw error;
+  } else if (error.code === 'ERR_NETWORK') {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNotInstalled);
+  } else if (error.code === 'ECONNABORTED') {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
   } else {
     throw hdShared.ERRORS.TypedError(error);
   }
@@ -18983,7 +19095,10 @@ let _uiPromises = [];
 
 let _callPromise;
 
+const callApiQueue = [];
 const deviceCacheMap = new Map();
+let pollingId = 1;
+const pollingState = {};
 
 const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
   var _a;
@@ -19015,23 +19130,25 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
     }
   }
 
-  try {
-    yield initDeviceList(method);
-  } catch (error) {
-    return Promise.reject(error);
+  callApiQueue.push(method);
+
+  if (callApiQueue.length > 1) {
+    Log.debug('should cancel the previous method execution: ', callApiQueue);
   }
 
-  const env = DataManager.getSettings('env');
+  if (pollingState[pollingId]) {
+    pollingState[pollingId] = false;
+  }
+
+  pollingId += 1;
   let device;
 
   try {
-    if (env === 'react-native') {
-      device = initDeviceForBle(method);
-    } else {
-      device = initDevice(method);
-    }
-  } catch (error) {
-    return Promise.reject(error);
+    device = yield ensureConnected(method, pollingId);
+  } catch (e) {
+    return createResponseMessage(method.responseID, false, {
+      error: e
+    });
   }
 
   Log.debug('Call API - setDevice: ', device.mainId);
@@ -19071,6 +19188,16 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
         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(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError));
+        }
+      }
+
+      method.checkFirmwareRelease();
+
       if (_deviceList) {
         yield TransportManager.reconfigure(device.getFirmwareVersion());
       }
@@ -19118,6 +19245,13 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
       }
     }
 
+    const index = messageResponse && messageResponse.id ? callApiQueue.findIndex(m => m.responseID === messageResponse.id) : -1;
+
+    if (index > -1) {
+      callApiQueue.splice(index, 1);
+      Log.debug('Remove the finished method from the queue： ', callApiQueue);
+    }
+
     closePopup();
     cleanup();
   }
@@ -19138,7 +19272,7 @@ function initDeviceList(method) {
       _deviceList.connector = _connector;
     }
 
-    yield _deviceList.getDeviceLists();
+    yield _deviceList.getDeviceLists(method.connectId);
   });
 }
 
@@ -19191,23 +19325,118 @@ function initDeviceForBle(method) {
   return device;
 }
 
+const ensureConnected = (method, pollingId) => __awaiter(void 0, void 0, void 0, function* () {
+  let tryCount = 0;
+  const MAX_RETRY_COUNT = method.payload && method.payload.retryCount || 5;
+  const POLL_INTERVAL_TIME = method.payload && method.payload.pollIntervalTime || 1000;
+  const TIME_OUT = method.payload && method.payload.timeout || 10000;
+  let timer = null;
+  Log.debug(`EnsureConnected function start, MAX_RETRY_COUNT=${MAX_RETRY_COUNT}, POLL_INTERVAL_TIME=${POLL_INTERVAL_TIME}  `);
+
+  const poll = (time = POLL_INTERVAL_TIME) => __awaiter(void 0, void 0, void 0, function* () {
+    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.RuntimeError, 'Polling stop'));
+        return;
+      }
+
+      if (timer) {
+        clearTimeout(timer);
+      }
+
+      timer = setTimeout(() => {
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Polling timeout'));
+      }, TIME_OUT);
+      tryCount += 1;
+      Log.debug('EnsureConnected function try count: ', tryCount, ' poll interval time: ', time);
+
+      try {
+        yield initDeviceList(method);
+      } catch (error) {
+        Log.debug('device list error: ', error);
+
+        if (error.errorCode === hdShared.HardwareErrorCode.BridgeNotInstalled) {
+          reject(error);
+          return;
+        }
+
+        if (error.errorCode === hdShared.HardwareErrorCode.TransportNotConfigured) {
+          yield TransportManager.configure();
+        }
+      }
+
+      const env = DataManager.getSettings('env');
+      let device;
+
+      try {
+        if (env === 'react-native') {
+          device = initDeviceForBle(method);
+        } else {
+          device = initDevice(method);
+        }
+
+        if (device) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+
+          if (env === 'react-native') {
+            yield device.acquire();
+            yield device.initialize();
+          }
+
+          resolve(device);
+          return;
+        }
+      } catch (error) {
+        Log.debug('device error: ', error);
+
+        if (error.errorCode === hdShared.HardwareErrorCode.BlePermissionError) {
+          reject(error);
+          return;
+        }
+      }
+
+      if (tryCount > 5) {
+        if (timer) {
+          clearTimeout(timer);
+        }
+
+        Log.debug('EnsureConnected get to max try count, will return: ', tryCount);
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound));
+        return;
+      }
+
+      return setTimeout(() => resolve(poll(time * 1.5)), time);
+    }));
+  });
+
+  pollingState[pollingId] = true;
+  return poll();
+});
+
 const cancel = connectId => {
   const env = DataManager.getSettings('env');
 
-  if (connectId) {
-    let device;
+  try {
+    if (connectId) {
+      let device;
 
-    if (env === 'react-native') {
-      device = initDeviceForBle({
-        connectId
-      });
-    } else {
-      device = initDevice({
-        connectId
-      });
-    }
+      if (env === 'react-native') {
+        device = initDeviceForBle({
+          connectId
+        });
+      } else {
+        device = initDevice({
+          connectId
+        });
+      }
 
-    device === null || device === void 0 ? void 0 : device.interruption();
+      device === null || device === void 0 ? void 0 : device.interruptionFromUser();
+    }
+  } catch (e) {
+    Log.error('Cancel API Error: ', e);
   }
 
   cleanup();
@@ -19378,6 +19607,8 @@ __webpack_unused_export__ = DEFAULT_PRIORITY;
 __webpack_unused_export__ = DEVICE;
 __webpack_unused_export__ = DEVICE_EVENT;
 __webpack_unused_export__ = DataManager;
+__webpack_unused_export__ = FIRMWARE;
+exports.SI = FIRMWARE_EVENT;
 exports.Bg = IFRAME;
 __webpack_unused_export__ = LOG;
 exports.og = LOG_EVENT;
@@ -19388,6 +19619,7 @@ __webpack_unused_export__ = UI_RESPONSE;
 __webpack_unused_export__ = corsValidator;
 __webpack_unused_export__ = createDeviceMessage;
 exports.xG = createErrorMessage;
+__webpack_unused_export__ = createFirmwareMessage;
 __webpack_unused_export__ = createIFrameMessage;
 __webpack_unused_export__ = createLogMessage;
 __webpack_unused_export__ = createResponseMessage;
@@ -20568,6 +20800,8 @@ const HardwareErrorCode = {
   DeviceInitializeFailed: 106,
   DeviceInterruptedFromOutside: 107,
   DeviceUnexpectedBootloaderMode: 108,
+  DeviceInterruptedFromUser: 109,
+  DeviceCheckDeviceIdError: 110,
   NotInitialized: 200,
   IFrameNotInitialized: 300,
   IFrameAleradyInitialized: 301,
@@ -20600,7 +20834,8 @@ const HardwareErrorCode = {
   FirmwareError: 804,
   ResponseUnexpectTypeError: 805,
   BridgeNetworkError: 806,
-  BridgeTimeoutError: 807
+  BridgeTimeoutError: 807,
+  BridgeNotInstalled: 808
 };
 const HardwareErrorCodeMessage = {
   [HardwareErrorCode.UnknownError]: 'Unknown error occurred. Check message property.',
@@ -20611,7 +20846,9 @@ const HardwareErrorCodeMessage = {
   [HardwareErrorCode.DeviceNotFound]: 'Device not found',
   [HardwareErrorCode.DeviceInitializeFailed]: 'Device initialization failed',
   [HardwareErrorCode.DeviceInterruptedFromOutside]: 'Device interrupted',
+  [HardwareErrorCode.DeviceInterruptedFromUser]: 'Device interrupted',
   [HardwareErrorCode.DeviceUnexpectedBootloaderMode]: 'Device should be in bootloader mode',
+  [HardwareErrorCode.DeviceCheckDeviceIdError]: 'Device Id in the features is not same.',
   [HardwareErrorCode.NotInitialized]: 'Not initialized',
   [HardwareErrorCode.IFrameNotInitialized]: 'IFrame not initialized',
   [HardwareErrorCode.IFrameAleradyInitialized]: 'IFrame alerady initialized',
@@ -20644,7 +20881,8 @@ const HardwareErrorCodeMessage = {
   [HardwareErrorCode.FirmwareError]: 'Firmware installation failed',
   [HardwareErrorCode.ResponseUnexpectTypeError]: 'Response type is not expected',
   [HardwareErrorCode.BridgeNetworkError]: 'Bridge network error',
-  [HardwareErrorCode.BridgeTimeoutError]: 'Bridge network timeout'
+  [HardwareErrorCode.BridgeTimeoutError]: 'Bridge network timeout',
+  [HardwareErrorCode.BridgeNotInstalled]: 'Bridge not installed'
 };
 
 const TypedError = (hardwareError, message) => {
@@ -45776,6 +46014,7 @@ const handleMessage = async message => {
       break;
 
     case dist/* LOG_EVENT */.og:
+    case dist/* FIRMWARE_EVENT */.SI:
       eventEmitter.emit(message.event, message);
       break;
 
@@ -45867,7 +46106,7 @@ const src_init = async settings => {
 
   try {
     await init({ ..._settings,
-      version: "0.1.17"
+      version: "0.1.18"
     });
     return true;
   } catch (e) {