@onekeyfe/hd-web-sdk 0.1.14 → 0.1.18

package/build/onekey-js-sdk.js

@@ -4072,6 +4072,9 @@ const inject = ({
     dispose,
     uiResponse,
     cancel,
+    getLogs: () => call({
+      method: 'getLogs'
+    }),
     searchDevices: () => call({
       method: 'searchDevices'
     }),
@@ -4093,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({
@@ -4137,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), {
@@ -4785,337 +4812,6 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0, function* () {
-  const response = yield axios__default["default"].request({
-    url,
-    withCredentials: false,
-    responseType: type === 'binary' ? 'arraybuffer' : 'json'
-  });
-
-  if (+response.status === 200) {
-    if (type === 'json') {
-      return response.data;
-    }
-
-    if (type === 'binary') {
-      return response.data;
-    }
-
-    return response.data;
-  }
-
-  throw new Error(`httpRequest error: ${url} ${response.statusText}`);
-});
-
-const httpRequest = (url, type) => httpRequest$1(url, type);
-
-const getTimeStamp = () => new Date().getTime();
-
-const VER_NUMS = 3;
-const versionRegex = new RegExp(/^[0-9]{1,3}(\.[0-9]{1,3}){0,2}$/);
-
-const isValidVersionString = version => versionRegex.test(version);
-
-const isValidVersionArray = version => {
-  if (!Array.isArray(version)) {
-    return false;
-  }
-
-  if (version.length === 0 || version.length > VER_NUMS) {
-    return false;
-  }
-
-  if (version[0] === 0) {
-    return false;
-  }
-
-  for (let i = 0; i < version.length; i++) {
-    if (typeof version[i] !== 'number' || version[i] < 0) {
-      return false;
-    }
-  }
-
-  return true;
-};
-
-const normalizeVersionArray = version => {
-  if (version.length === VER_NUMS) {
-    return version;
-  }
-
-  const partialVersion = [...version];
-
-  for (let i = version.length; i < VER_NUMS; i++) {
-    partialVersion.push(0);
-  }
-
-  return partialVersion;
-};
-
-const versionSplit = version => {
-  if (!isValidVersionString(version)) {
-    return [0, 0, 0];
-  }
-
-  return version.split('.').map(v => Number(v));
-};
-
-const versionCompare = (a, b) => {
-  if (typeof a === 'string' && typeof b === 'string' && a === b) {
-    return 0;
-  }
-
-  const pa = typeof a === 'string' ? versionSplit(a) : a;
-  const pb = typeof b === 'string' ? versionSplit(b) : b;
-  const vpa = isValidVersionArray(pa);
-  const vpb = isValidVersionArray(pb);
-
-  if (!vpa && !vpb) {
-    return 0;
-  }
-
-  if (!vpa && vpb) {
-    return -1;
-  }
-
-  if (vpa && !vpb) {
-    return 1;
-  }
-
-  const npa = normalizeVersionArray(pa);
-  const npb = normalizeVersionArray(pb);
-
-  for (let i = 0; i < VER_NUMS; i++) {
-    if (npa[i] > npb[i]) return 1;
-    if (npb[i] > npa[i]) return -1;
-  }
-
-  return 0;
-};
-
-function patchFeatures(response) {
-  if (response.type !== 'Features') {
-    return response;
-  }
-
-  if (response.message.major_version < 1) {
-    response.message.major_version = 1;
-  }
-
-  return response;
-}
-
-const getDeviceModel = features => {
-  if (!features || typeof features !== 'object') {
-    return 'model_mini';
-  }
-
-  if (features.model === '1') {
-    return 'model_mini';
-  }
-
-  return 'model_touch';
-};
-
-const getDeviceType = features => {
-  if (!features || typeof features !== 'object' || !features.serial_no) {
-    return 'classic';
-  }
-
-  const serialNo = features.serial_no;
-  const miniFlag = serialNo.slice(0, 2);
-  if (miniFlag.toLowerCase() === 'mi') return 'mini';
-  if (miniFlag.toLowerCase() === 'tc') return 'touch';
-  return 'classic';
-};
-
-const getDeviceTypeOnBootloader = features => {
-  if (!features || typeof features !== 'object') {
-    return 'classic';
-  }
-
-  if (features.model === 'T') {
-    return 'touch';
-  }
-
-  return getDeviceType(features);
-};
-
-const getDeviceTypeByBleName = name => {
-  if (!name) return 'classic';
-  if (name.startsWith('MI')) return 'mini';
-  if (name.startsWith('T')) return 'touch';
-  return 'classic';
-};
-
-const getDeviceTypeByDeviceId = deviceId => {
-  if (!deviceId) {
-    return 'classic';
-  }
-
-  const miniFlag = deviceId.slice(0, 2);
-  if (miniFlag.toLowerCase() === 'mi') return 'mini';
-  return 'classic';
-};
-
-const getDeviceUUID = features => {
-  const deviceType = getDeviceType(features);
-
-  if (deviceType === 'classic') {
-    return features.onekey_serial;
-  }
-
-  return features.serial_no;
-};
-
-const getDeviceLabel = features => {
-  const deviceType = getDeviceType(features);
-
-  if (typeof features.label === 'string') {
-    return features.label;
-  }
-
-  return `My OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
-};
-
-const getDeviceFirmwareVersion = features => {
-  if (!features) return [0, 0, 0];
-
-  if (features.onekey_version) {
-    return features.onekey_version.split('.');
-  }
-
-  return [features.major_version, features.minor_version, features.patch_version];
-};
-
-const getDeviceBLEFirmwareVersion = features => {
-  if (!features.ble_ver) {
-    return null;
-  }
-
-  return features.ble_ver.split('.');
-};
-
-const HD_HARDENED = 0x80000000;
-
-const toHardened = n => (n | HD_HARDENED) >>> 0;
-
-const fromHardened = n => (n & ~HD_HARDENED) >>> 0;
-
-const PATH_NOT_VALID = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Not a valid path');
-const PATH_NEGATIVE_VALUES = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Path cannot contain negative values');
-
-const getHDPath = path => {
-  const parts = path.toLowerCase().split('/');
-  if (parts[0] !== 'm') throw PATH_NOT_VALID;
-  return parts.filter(p => p !== 'm' && p !== '').map(p => {
-    let hardened = false;
-
-    if (p.substr(p.length - 1) === "'") {
-      hardened = true;
-      p = p.substr(0, p.length - 1);
-    }
-
-    let n = parseInt(p);
-
-    if (Number.isNaN(n)) {
-      throw PATH_NOT_VALID;
-    } else if (n < 0) {
-      throw PATH_NEGATIVE_VALUES;
-    }
-
-    if (hardened) {
-      n = toHardened(n);
-    }
-
-    return n;
-  });
-};
-
-const isMultisigPath = path => Array.isArray(path) && path[0] === toHardened(48);
-
-const isSegwitPath = path => Array.isArray(path) && path[0] === toHardened(49);
-
-const getScriptType = path => {
-  if (!Array.isArray(path) || path.length < 1) return 'SPENDADDRESS';
-  const p1 = fromHardened(path[0]);
-
-  switch (p1) {
-    case 48:
-      return 'SPENDMULTISIG';
-
-    case 49:
-      return 'SPENDP2SHWITNESS';
-
-    case 84:
-      return 'SPENDWITNESS';
-
-    default:
-      return 'SPENDADDRESS';
-  }
-};
-
-const getOutputScriptType = path => {
-  if (!Array.isArray(path) || path.length < 1) return 'PAYTOADDRESS';
-
-  if (path[0] === 49) {
-    return 'PAYTOP2SHWITNESS';
-  }
-
-  const p = fromHardened(path[0]);
-
-  switch (p) {
-    case 48:
-      return 'PAYTOMULTISIG';
-
-    case 49:
-      return 'PAYTOP2SHWITNESS';
-
-    case 84:
-      return 'PAYTOWITNESS';
-
-    default:
-      return 'PAYTOADDRESS';
-  }
-};
-
-const serializedPath = path => {
-  const pathStr = path.map(p => {
-    if (p & HD_HARDENED) {
-      return `${p & ~HD_HARDENED}'`;
-    }
-
-    return p;
-  }).join('/');
-  return `m/${pathStr}`;
-};
-
-const validatePath = (path, length = 0, base = false) => {
-  let valid;
-
-  if (typeof path === 'string') {
-    valid = getHDPath(path);
-  } else if (Array.isArray(path)) {
-    valid = path.map(p => {
-      const n = parseInt(p);
-
-      if (Number.isNaN(n)) {
-        throw PATH_NOT_VALID;
-      } else if (n < 0) {
-        throw PATH_NEGATIVE_VALUES;
-      }
-
-      return n;
-    });
-  } else {
-    valid = undefined;
-  }
-
-  if (!valid) throw PATH_NOT_VALID;
-  if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
-  return base ? valid.splice(0, 3) : valid;
-};
-
 var nested = {
   BinanceGetAddress: {
     fields: {
@@ -13776,6 +13472,513 @@ var MessagesJSON = {
   nested: nested
 };
 
+const httpRequest$1 = (url, type = 'text') => __awaiter(void 0, void 0, void 0, function* () {
+  const response = yield axios__default["default"].request({
+    url,
+    withCredentials: false,
+    responseType: type === 'binary' ? 'arraybuffer' : 'json'
+  });
+
+  if (+response.status === 200) {
+    if (type === 'json') {
+      return response.data;
+    }
+
+    if (type === 'binary') {
+      return response.data;
+    }
+
+    return response.data;
+  }
+
+  throw new Error(`httpRequest error: ${url} ${response.statusText}`);
+});
+
+const httpRequest = (url, type) => httpRequest$1(url, type);
+
+const getTimeStamp = () => new Date().getTime();
+
+const VER_NUMS = 3;
+const versionRegex = new RegExp(/^[0-9]{1,3}(\.[0-9]{1,3}){0,2}$/);
+
+const isValidVersionString = version => versionRegex.test(version);
+
+const isValidVersionArray = version => {
+  if (!Array.isArray(version)) {
+    return false;
+  }
+
+  if (version.length === 0 || version.length > VER_NUMS) {
+    return false;
+  }
+
+  if (version[0] === 0) {
+    return false;
+  }
+
+  for (let i = 0; i < version.length; i++) {
+    if (typeof version[i] !== 'number' || version[i] < 0) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const normalizeVersionArray = version => {
+  if (version.length === VER_NUMS) {
+    return version;
+  }
+
+  const partialVersion = [...version];
+
+  for (let i = version.length; i < VER_NUMS; i++) {
+    partialVersion.push(0);
+  }
+
+  return partialVersion;
+};
+
+const versionSplit = version => {
+  if (!isValidVersionString(version)) {
+    return [0, 0, 0];
+  }
+
+  return version.split('.').map(v => Number(v));
+};
+
+const versionCompare = (a, b) => {
+  if (typeof a === 'string' && typeof b === 'string' && a === b) {
+    return 0;
+  }
+
+  const pa = typeof a === 'string' ? versionSplit(a) : a;
+  const pb = typeof b === 'string' ? versionSplit(b) : b;
+  const vpa = isValidVersionArray(pa);
+  const vpb = isValidVersionArray(pb);
+
+  if (!vpa && !vpb) {
+    return 0;
+  }
+
+  if (!vpa && vpb) {
+    return -1;
+  }
+
+  if (vpa && !vpb) {
+    return 1;
+  }
+
+  const npa = normalizeVersionArray(pa);
+  const npb = normalizeVersionArray(pb);
+
+  for (let i = 0; i < VER_NUMS; i++) {
+    if (npa[i] > npb[i]) return 1;
+    if (npb[i] > npa[i]) return -1;
+  }
+
+  return 0;
+};
+
+function patchFeatures(response) {
+  if (response.type !== 'Features') {
+    return response;
+  }
+
+  if (response.message.major_version < 1) {
+    response.message.major_version = 1;
+  }
+
+  return response;
+}
+
+const getDeviceModel = features => {
+  if (!features || typeof features !== 'object') {
+    return 'model_mini';
+  }
+
+  if (features.model === '1') {
+    return 'model_mini';
+  }
+
+  return 'model_touch';
+};
+
+const getDeviceType = features => {
+  if (!features || typeof features !== 'object' || !features.serial_no) {
+    return 'classic';
+  }
+
+  const serialNo = features.serial_no;
+  const miniFlag = serialNo.slice(0, 2);
+  if (miniFlag.toLowerCase() === 'mi') return 'mini';
+  if (miniFlag.toLowerCase() === 'tc') return 'touch';
+  return 'classic';
+};
+
+const getDeviceTypeOnBootloader = features => getDeviceType(features);
+
+const getDeviceTypeByBleName = name => {
+  if (!name) return 'classic';
+  if (name.startsWith('MI')) return 'mini';
+  if (name.startsWith('T')) return 'touch';
+  return 'classic';
+};
+
+const getDeviceTypeByDeviceId = deviceId => {
+  if (!deviceId) {
+    return 'classic';
+  }
+
+  const miniFlag = deviceId.slice(0, 2);
+  if (miniFlag.toLowerCase() === 'mi') return 'mini';
+  return 'classic';
+};
+
+const getDeviceUUID = features => {
+  const deviceType = getDeviceType(features);
+
+  if (deviceType === 'classic') {
+    return features.onekey_serial;
+  }
+
+  return features.serial_no;
+};
+
+const getDeviceLabel = features => {
+  const deviceType = getDeviceType(features);
+
+  if (typeof features.label === 'string') {
+    return features.label;
+  }
+
+  return `My OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
+};
+
+const getDeviceFirmwareVersion = features => {
+  if (!features) return [0, 0, 0];
+
+  if (features.onekey_version) {
+    return features.onekey_version.split('.');
+  }
+
+  return [features.major_version, features.minor_version, features.patch_version];
+};
+
+const getDeviceBLEFirmwareVersion = features => {
+  if (!features.ble_ver) {
+    return null;
+  }
+
+  return features.ble_ver.split('.');
+};
+
+const HD_HARDENED = 0x80000000;
+
+const toHardened = n => (n | HD_HARDENED) >>> 0;
+
+const fromHardened = n => (n & ~HD_HARDENED) >>> 0;
+
+const PATH_NOT_VALID = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Not a valid path');
+const PATH_NEGATIVE_VALUES = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Path cannot contain negative values');
+
+const getHDPath = path => {
+  const parts = path.toLowerCase().split('/');
+  if (parts[0] !== 'm') throw PATH_NOT_VALID;
+  return parts.filter(p => p !== 'm' && p !== '').map(p => {
+    let hardened = false;
+
+    if (p.substr(p.length - 1) === "'") {
+      hardened = true;
+      p = p.substr(0, p.length - 1);
+    }
+
+    let n = parseInt(p);
+
+    if (Number.isNaN(n)) {
+      throw PATH_NOT_VALID;
+    } else if (n < 0) {
+      throw PATH_NEGATIVE_VALUES;
+    }
+
+    if (hardened) {
+      n = toHardened(n);
+    }
+
+    return n;
+  });
+};
+
+const isMultisigPath = path => Array.isArray(path) && path[0] === toHardened(48);
+
+const isSegwitPath = path => Array.isArray(path) && path[0] === toHardened(49);
+
+const getScriptType = path => {
+  if (!Array.isArray(path) || path.length < 1) return 'SPENDADDRESS';
+  const p1 = fromHardened(path[0]);
+
+  switch (p1) {
+    case 48:
+      return 'SPENDMULTISIG';
+
+    case 49:
+      return 'SPENDP2SHWITNESS';
+
+    case 84:
+      return 'SPENDWITNESS';
+
+    default:
+      return 'SPENDADDRESS';
+  }
+};
+
+const getOutputScriptType = path => {
+  if (!Array.isArray(path) || path.length < 1) return 'PAYTOADDRESS';
+
+  if (path[0] === 49) {
+    return 'PAYTOP2SHWITNESS';
+  }
+
+  const p = fromHardened(path[0]);
+
+  switch (p) {
+    case 48:
+      return 'PAYTOMULTISIG';
+
+    case 49:
+      return 'PAYTOP2SHWITNESS';
+
+    case 84:
+      return 'PAYTOWITNESS';
+
+    default:
+      return 'PAYTOADDRESS';
+  }
+};
+
+const serializedPath = path => {
+  const pathStr = path.map(p => {
+    if (p & HD_HARDENED) {
+      return `${p & ~HD_HARDENED}'`;
+    }
+
+    return p;
+  }).join('/');
+  return `m/${pathStr}`;
+};
+
+const validatePath = (path, length = 0, base = false) => {
+  let valid;
+
+  if (typeof path === 'string') {
+    valid = getHDPath(path);
+  } else if (Array.isArray(path)) {
+    valid = path.map(p => {
+      const n = parseInt(p);
+
+      if (Number.isNaN(n)) {
+        throw PATH_NOT_VALID;
+      } else if (n < 0) {
+        throw PATH_NEGATIVE_VALUES;
+      }
+
+      return n;
+    });
+  } else {
+    valid = undefined;
+  }
+
+  if (!valid) throw PATH_NOT_VALID;
+  if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
+  return base ? valid.splice(0, 3) : valid;
+};
+
+const LOG_EVENT = 'LOG_EVENT';
+const LOG = {
+  OUTPUT: 'log-output'
+};
+
+const createLogMessage = (type, payload) => ({
+  event: LOG_EVENT,
+  type,
+  payload
+});
+
+const MAX_ENTRIES = 500;
+let postMessage$1;
+
+class Log$6 {
+  constructor(prefix, enabled) {
+    this.prefix = prefix;
+    this.enabled = enabled;
+    this.messages = [];
+  }
+
+  addMessage(level, prefix, ...args) {
+    this.messages.push({
+      level,
+      prefix,
+      message: args,
+      timestamp: new Date().getTime()
+    });
+
+    if (this.messages.length > MAX_ENTRIES) {
+      this.messages.shift();
+    }
+  }
+
+  log(...args) {
+    this.addMessage('log', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    console.log(this.prefix, ...args);
+  }
+
+  error(...args) {
+    this.addMessage('error', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    console.error(this.prefix, ...args);
+  }
+
+  warn(...args) {
+    this.addMessage('warn', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    console.warn(this.prefix, ...args);
+  }
+
+  debug(...args) {
+    this.addMessage('debug', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    console.log(this.prefix, ...args);
+  }
+
+}
+
+const _logs = {};
+
+const initLog = (prefix, enabled) => {
+  const instance = new Log$6(prefix, !!enabled);
+  _logs[prefix] = instance;
+  return instance;
+};
+
+const enableLog = enabled => {
+  Object.keys(_logs).forEach(key => {
+    _logs[key].enabled = !!enabled;
+  });
+};
+
+const getLog = () => {
+  let logs = [];
+  Object.keys(_logs).forEach(key => {
+    logs = logs.concat(_logs[key].messages);
+  });
+  logs.sort((a, b) => a.timestamp - b.timestamp);
+  return logs;
+};
+
+const setLoggerPostMessage = postMessageFn => {
+  postMessage$1 = postMessageFn;
+};
+
+const serializeLog = (...args) => args.map(arg => {
+  if (typeof arg === 'string') {
+    return arg;
+  }
+
+  if (typeof arg === 'number') {
+    return arg;
+  }
+
+  if (typeof arg === 'boolean') {
+    return arg;
+  }
+
+  if (typeof arg === 'undefined') {
+    return arg;
+  }
+
+  if (typeof arg === 'object') {
+    return JSON.stringify(arg, getCircularReplacer());
+  }
+
+  return arg;
+});
+
+const getCircularReplacer = () => {
+  const seen = new WeakSet();
+  return (_, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return;
+      }
+
+      seen.add(value);
+    }
+
+    return value;
+  };
+};
+
+const sendLogMessage = (prefix, ...args) => {
+  postMessage$1 === null || postMessage$1 === void 0 ? void 0 : postMessage$1(createLogMessage(LOG.OUTPUT, serializeLog(prefix, ...args)));
+};
+
+exports.d0 = void 0;
+
+(function (LoggerNames) {
+  LoggerNames["Core"] = "Core";
+  LoggerNames["Transport"] = "Transport";
+  LoggerNames["Device"] = "Device";
+  LoggerNames["DeviceCommands"] = "DeviceCommands";
+  LoggerNames["DeviceConnector"] = "DeviceConnector";
+  LoggerNames["DeviceList"] = "DeviceList";
+  LoggerNames["HdBleSdk"] = "@onekey/hd-ble-sdk";
+  LoggerNames["HdTransportHttp"] = "@onekey/hd-transport-http";
+  LoggerNames["HdBleTransport"] = "@onekey/hd-ble-transport";
+  LoggerNames["Connect"] = "@onekey/connect";
+  LoggerNames["Iframe"] = "IFrame";
+  LoggerNames["SendMessage"] = "[SendMessage]";
+  LoggerNames["Method"] = "[Method]";
+})(exports.d0 || (exports.d0 = {}));
+
+const LoggerMap = {
+  [exports.d0.Core]: initLog(exports.d0.Core),
+  [exports.d0.Transport]: initLog(exports.d0.Transport),
+  [exports.d0.Device]: initLog(exports.d0.Device),
+  [exports.d0.DeviceCommands]: initLog(exports.d0.DeviceCommands),
+  [exports.d0.DeviceConnector]: initLog(exports.d0.DeviceConnector),
+  [exports.d0.DeviceList]: initLog(exports.d0.DeviceList),
+  [exports.d0.HdBleSdk]: initLog(exports.d0.HdBleSdk),
+  [exports.d0.HdTransportHttp]: initLog(exports.d0.HdTransportHttp),
+  [exports.d0.HdBleTransport]: initLog(exports.d0.HdBleTransport),
+  [exports.d0.Connect]: initLog(exports.d0.Connect),
+  [exports.d0.Iframe]: initLog(exports.d0.Iframe),
+  [exports.d0.SendMessage]: initLog(exports.d0.SendMessage),
+  [exports.d0.Method]: initLog(exports.d0.Method)
+};
+
+const getLogger = key => LoggerMap[key];
+
 const getReleaseStatus = (releases, currentVersion) => {
   const newVersions = releases.filter(r => semver__default["default"].gt(r.version.join('.'), currentVersion));
 
@@ -13948,11 +14151,13 @@ DataManager.getTransportStatus = localVersion => {
   return isLatest ? 'valid' : 'outdated';
 };
 
-const Log$5 = hdShared.initLog('Transport');
+const Log$5 = getLogger(exports.d0.Transport);
+const BleLogger = getLogger(exports.d0.HdBleTransport);
+const HttpLogger = getLogger(exports.d0.HdTransportHttp);
 
 class TransportManager {
   static load() {
-    console.log('transport manager load');
+    Log$5.debug('transport manager load');
     this.defaultMessages = DataManager.getProtobufMessages();
     this.currentMessages = this.defaultMessages;
   }
@@ -13965,13 +14170,13 @@ class TransportManager {
 
         if (env === 'react-native') {
           if (!this.reactNativeInit) {
-            yield this.transport.init();
+            yield this.transport.init(BleLogger);
             this.reactNativeInit = true;
           } else {
             Log$5.debug('React Native Do Not Initializing transports');
           }
         } else {
-          yield this.transport.init();
+          yield this.transport.init(HttpLogger);
         }
 
         Log$5.debug('Configuring transports');
@@ -14017,7 +14222,7 @@ class TransportManager {
       this.transport = new TransportConstructor();
     }
 
-    console.log('set transport: ', this.transport);
+    Log$5.debug('set transport: ', this.transport);
   }
 
   static getTransport() {
@@ -14154,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('|');
 
@@ -14162,7 +14379,7 @@ const assertType = (res, resType) => {
   }
 };
 
-const Log$4 = hdShared.initLog('DeviceCommands');
+const Log$4 = getLogger(exports.d0.DeviceCommands);
 
 class DeviceCommands {
   constructor(device, mainId) {
@@ -14172,24 +14389,26 @@ 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 = {}) {
     var _a, _b;
 
     return __awaiter(this, void 0, void 0, function* () {
-      console.log('[DeviceCommands] [call] Sending', type);
+      Log$4.debug('[DeviceCommands] [call] Sending', type);
 
       try {
         const promise = this.transport.call(this.mainId, type, msg);
@@ -14223,7 +14442,7 @@ class DeviceCommands {
       try {
         assertType(response, resType);
       } catch (error) {
-        console.log('DeviceCommands typedcall error: ', error);
+        Log$4.debug('DeviceCommands typedcall error: ', error);
 
         if (error instanceof hdShared.HardwareError) {
           if (error.errorCode === hdShared.HardwareErrorCode.ResponseUnexpectTypeError) {
@@ -14248,7 +14467,7 @@ class DeviceCommands {
   }
 
   _filterCommonTypes(res) {
-    console.log('_filterCommonTypes: ', res);
+    Log$4.debug('_filterCommonTypes: ', res);
 
     if (res.type === 'Failure') {
       const {
@@ -14310,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);
@@ -14451,7 +14675,7 @@ const parseRunOptions = options => {
   return options;
 };
 
-const Log$3 = hdShared.initLog('Device');
+const Log$3 = getLogger(exports.d0.Device);
 
 class Device extends events.exports {
   constructor(descriptor) {
@@ -14548,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 : '');
@@ -14572,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 {
@@ -14678,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');
       }
 
@@ -14725,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() {
@@ -14810,10 +15048,18 @@ 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 Log$2 = hdShared.initLog('DeviceList');
+const cacheDeviceMap = {};
+const Log$2 = getLogger(exports.d0.DeviceList);
 
 class DeviceList extends events.exports {
   constructor() {
@@ -14821,7 +15067,7 @@ class DeviceList extends events.exports {
     this.devices = {};
   }
 
-  getDeviceLists() {
+  getDeviceLists(connectId) {
     var e_1, _a;
 
     var _b, _c;
@@ -14831,7 +15077,22 @@ class DeviceList extends events.exports {
       const descriptorList = (_c = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _c !== void 0 ? _c : [];
       this.devices = {};
       const deviceList = [];
-      console.log('get device list');
+      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;) {
@@ -14846,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) {
@@ -14883,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;
@@ -14892,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 = [];
@@ -14906,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() {}
 
 }
@@ -16235,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);
@@ -16253,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);
@@ -16288,7 +16577,7 @@ class CheckTransportRelease extends BaseMethod {
 
 }
 
-class CheckBridgeStatus extends BaseMethod {
+class CheckBridgeStatus$1 extends BaseMethod {
   init() {
     this.useDevice = false;
   }
@@ -16586,7 +16875,7 @@ class DeviceVerify extends BaseMethod {
           data: sha256__default["default"].sha256(this.params.data)
         }));
         response = res.message;
-      } else if (deviceType === 'mini') {
+      } else {
         const signatureRes = yield this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', {
           message: this.params.data
         });
@@ -18508,6 +18797,8 @@ class FirmwareUpdate extends BaseMethod {
   }
 
   run() {
+    var _a;
+
     return __awaiter(this, void 0, void 0, function* () {
       const {
         device,
@@ -18531,7 +18822,7 @@ class FirmwareUpdate extends BaseMethod {
           binary = firmware.binary;
         }
       } catch (err) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 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, {
@@ -18542,6 +18833,20 @@ class FirmwareUpdate extends BaseMethod {
 
 }
 
+class CheckBridgeStatus extends BaseMethod {
+  init() {
+    this.useDevice = false;
+  }
+
+  run() {
+    return __awaiter(this, void 0, void 0, function* () {
+      const logs = getLog();
+      return Promise.resolve(logs);
+    });
+  }
+
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
   __proto__: null,
   searchDevices: SearchDevices,
@@ -18555,7 +18860,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   checkFirmwareRelease: CheckFirmwareRelease,
   checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
   checkTransportRelease: CheckTransportRelease,
-  checkBridgeStatus: CheckBridgeStatus,
+  checkBridgeStatus: CheckBridgeStatus$1,
   deviceBackup: DeviceBackup,
   deviceChangePin: DeviceChangePin,
   deviceFlags: DeviceFlags,
@@ -18584,7 +18889,8 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   solSignTransaction: SolSignTransaction,
   stellarGetAddress: StellarGetAddress,
   stellarSignTransaction: StellarSignTransaction,
-  firmwareUpdate: FirmwareUpdate
+  firmwareUpdate: FirmwareUpdate,
+  getLogs: CheckBridgeStatus
 });
 
 function findMethod(message) {
@@ -18608,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);
   }
@@ -18617,7 +18927,7 @@ const resolveAfter = (msec, value) => new Promise(resolve => {
   setTimeout(resolve, msec, value);
 });
 
-const Log$1 = hdShared.initLog('DeviceConnector');
+const Log$1 = getLogger(exports.d0.DeviceConnector);
 
 const getDiff = (current, descriptors) => {
   const env = DataManager.getSettings('env');
@@ -18730,7 +19040,7 @@ class DeviceConnector {
 
   acquire(path, session) {
     return __awaiter(this, void 0, void 0, function* () {
-      console.log('acquire', path, session);
+      Log$1.debug('acquire', path, session);
       const env = DataManager.getSettings('env');
 
       try {
@@ -18773,7 +19083,7 @@ class DeviceConnector {
 
 }
 
-const Log = hdShared.initLog('Core');
+const Log = getLogger(exports.d0.Core);
 
 let _core;
 
@@ -18785,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;
@@ -18817,26 +19130,28 @@ 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);
+  Log.debug('Call API - setDevice: ', device.mainId);
   (_a = method.setDevice) === null || _a === void 0 ? void 0 : _a.call(method, device);
   device.on(DEVICE.PIN, onDevicePinHandler);
   device.on(DEVICE.BUTTON, (d, code) => {
@@ -18873,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());
       }
@@ -18891,7 +19216,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
       }
     });
 
-    Log.debug('Call API - Device Run: ', device);
+    Log.debug('Call API - Device Run: ', device.mainId);
 
     const deviceRun = () => device.run(inner);
 
@@ -18900,7 +19225,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
     try {
       return yield _callPromise.promise;
     } catch (e) {
-      console.log('Device Run Error: ', e);
+      Log.debug('Device Run Error: ', e);
       return createResponseMessage(method.responseID, false, {
         error: e
       });
@@ -18920,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();
   }
@@ -18940,7 +19272,7 @@ function initDeviceList(method) {
       _deviceList.connector = _connector;
     }
 
-    yield _deviceList.getDeviceLists();
+    yield _deviceList.getDeviceLists(method.connectId);
   });
 }
 
@@ -18993,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();
@@ -19026,7 +19453,7 @@ const closePopup = () => {
 };
 
 const onDevicePinHandler = (...[device, type, callback]) => __awaiter(void 0, void 0, void 0, function* () {
-  console.log('onDevicePinHandler');
+  Log.debug('onDevicePinHandler');
   const uiPromise = createUiPromise(UI_RESPONSE.RECEIVE_PIN, device);
   postMessage(createUiMessage(UI_REQUEST$1.REQUEST_PIN, {
     device: device.toMessageObject(),
@@ -19138,7 +19565,12 @@ const init = (settings, Transport) => __awaiter(void 0, void 0, void 0, function
       Log.error('DataManager.load error');
     }
 
-    hdShared.enableLog(DataManager.getSettings('debug'));
+    enableLog(DataManager.getSettings('debug'));
+
+    if (DataManager.getSettings('env') !== 'react-native') {
+      setLoggerPostMessage(postMessage);
+    }
+
     initCore();
     initConnector();
     return _core;
@@ -19163,18 +19595,6 @@ const HardwareSdk = ({
   cancel
 });
 
-Object.defineProperty(exports, "yI", ({
-  enumerable: true,
-  get: function () {
-    return hdShared.enableLog;
-  }
-}));
-Object.defineProperty(exports, "KR", ({
-  enumerable: true,
-  get: function () {
-    return hdShared.initLog;
-  }
-}));
 __webpack_unused_export__ = ({
   enumerable: true,
   get: function () {
@@ -19187,7 +19607,11 @@ __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;
 __webpack_unused_export__ = RESPONSE_EVENT;
 exports.rF = UI_EVENT;
 __webpack_unused_export__ = UI_REQUEST$1;
@@ -19195,11 +19619,14 @@ __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;
 __webpack_unused_export__ = createUiMessage;
 __webpack_unused_export__ = createUiResponse;
 exports.ZP = HardwareSdk;
+exports.yI = enableLog;
 __webpack_unused_export__ = getDeviceLabel;
 __webpack_unused_export__ = getDeviceType;
 __webpack_unused_export__ = getDeviceTypeByBleName;
@@ -19207,6 +19634,8 @@ __webpack_unused_export__ = getDeviceTypeByDeviceId;
 __webpack_unused_export__ = getDeviceUUID;
 __webpack_unused_export__ = getEnv;
 __webpack_unused_export__ = getHDPath;
+__webpack_unused_export__ = getLog;
+exports.jl = getLogger;
 __webpack_unused_export__ = getScriptType;
 __webpack_unused_export__ = getTimeStamp;
 __webpack_unused_export__ = httpRequest;
@@ -19218,6 +19647,7 @@ exports._4 = parseConnectSettings;
 exports.kW = parseMessage;
 __webpack_unused_export__ = patchFeatures;
 __webpack_unused_export__ = safeThrowError;
+exports.hZ = setLoggerPostMessage;
 __webpack_unused_export__ = versionCompare;
 __webpack_unused_export__ = versionSplit;
 
@@ -20328,6 +20758,7 @@ function createDeferred(arg, data) {
 }
 
 function fillStringWithArguments(value, object) {
+  if (typeof value !== 'string') return value;
   return value.replace(/\{([^}]+)\}/g, (_, arg) => object[arg] || '?');
 }
 
@@ -20369,6 +20800,8 @@ const HardwareErrorCode = {
   DeviceInitializeFailed: 106,
   DeviceInterruptedFromOutside: 107,
   DeviceUnexpectedBootloaderMode: 108,
+  DeviceInterruptedFromUser: 109,
+  DeviceCheckDeviceIdError: 110,
   NotInitialized: 200,
   IFrameNotInitialized: 300,
   IFrameAleradyInitialized: 301,
@@ -20401,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.',
@@ -20412,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',
@@ -20445,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) => {
@@ -20496,125 +20933,6 @@ var HardwareError$1 = /*#__PURE__*/Object.freeze({
   serializeError: serializeError,
   CreateErrorByMessage: CreateErrorByMessage
 });
-const MAX_ENTRIES = 100;
-
-class Log {
-  constructor(prefix, enabled, logger) {
-    this.prefix = prefix;
-    this.enabled = enabled;
-    this.messages = [];
-
-    if (logger) {
-      this.logger = logger;
-    }
-  }
-
-  addMessage(level, prefix, ...args) {
-    this.messages.push({
-      level,
-      prefix,
-      message: args,
-      timestamp: new Date().getTime()
-    });
-
-    if (this.messages.length > MAX_ENTRIES) {
-      this.messages.shift();
-    }
-  }
-
-  log(...args) {
-    this.addMessage('log', this.prefix, ...args);
-
-    if (!this.enabled) {
-      return;
-    }
-
-    if (this.logger) {
-      this.logger.info(this.prefix, ...args);
-    } else {
-      console.log(this.prefix, ...args);
-    }
-  }
-
-  error(...args) {
-    this.addMessage('error', this.prefix, ...args);
-
-    if (!this.enabled) {
-      return;
-    }
-
-    if (this.logger) {
-      this.logger.error(this.prefix, ...args);
-    } else {
-      console.error(this.prefix, ...args);
-    }
-  }
-
-  warn(...args) {
-    this.addMessage('warn', this.prefix, ...args);
-
-    if (!this.enabled) {
-      return;
-    }
-
-    if (this.logger) {
-      this.logger.warn(this.prefix, ...args);
-    } else {
-      console.warn(this.prefix, ...args);
-    }
-  }
-
-  debug(...args) {
-    this.addMessage('debug', this.prefix, ...args);
-
-    if (!this.enabled) {
-      return;
-    }
-
-    if (this.logger) {
-      this.logger.debug(this.prefix, ...args);
-    } else {
-      console.log(this.prefix, ...args);
-    }
-  }
-
-}
-
-const _logs = {};
-
-const initLog = (prefix, enabled, logger) => {
-  const instance = new Log(prefix, !!enabled, logger);
-  _logs[prefix] = instance;
-  return instance;
-};
-
-const enableLog = enabled => {
-  Object.keys(_logs).forEach(key => {
-    _logs[key].enabled = !!enabled;
-  });
-};
-
-const setOutsideLogger = logger => {
-  Object.keys(_logs).forEach(key => {
-    _logs[key].logger = logger;
-  });
-};
-
-const enableLogByPrefix = (prefix, enabled) => {
-  if (_logs[prefix]) {
-    _logs[prefix].enabled = enabled;
-  }
-};
-
-const getLog = () => {
-  let logs = [];
-  Object.keys(_logs).forEach(key => {
-    logs = logs.concat(_logs[key].messages);
-  });
-  logs.sort((a, b) => a.timestamp - b.timestamp);
-  return logs;
-};
-
 exports.CreateErrorByMessage = CreateErrorByMessage;
 exports.ERRORS = HardwareError$1;
 exports.HardwareError = HardwareError;
@@ -20622,12 +20940,7 @@ exports.HardwareErrorCode = HardwareErrorCode;
 exports.HardwareErrorCodeMessage = HardwareErrorCodeMessage;
 exports.TypedError = TypedError;
 exports.createDeferred = createDeferred;
-exports.enableLog = enableLog;
-exports.enableLogByPrefix = enableLogByPrefix;
-exports.getLog = getLog;
-exports.initLog = initLog;
 exports.serializeError = serializeError;
-exports.setOutsideLogger = setOutsideLogger;
 
 /***/ }),
 
@@ -45637,7 +45950,7 @@ function createCodeJsBridgeReceive(payloadStr) {
 let frameBridge; // eslint-disable-next-line import/no-mutable-exports
 
 let hostBridge;
-const Log = (0,dist/* initLog */.KR)('[SendMessage]');
+const Log = (0,dist/* getLogger */.jl)(dist/* LoggerNames.SendMessage */.d0.SendMessage);
 const createJsBridge = params => {
   const bridge = new JsBridgeIframe(params);
 
@@ -45651,13 +45964,20 @@ const sendMessage = async (messages, isHost = true) => {
   const bridge = isHost ? hostBridge : frameBridge;
 
   try {
-    Log.debug('request: ', messages);
+    if (messages.event !== 'LOG_EVENT') {
+      Log.debug('request: ', messages);
+    }
+
     const result = await (bridge === null || bridge === void 0 ? void 0 : bridge.request({
       scope: bridge_config.scope,
       data: { ...messages
       }
     }));
-    Log.debug('response: ', result);
+
+    if (messages.event !== 'LOG_EVENT') {
+      Log.debug('response: ', result);
+    }
+
     return result;
   } catch (error) {
     Log.error(error);
@@ -45673,7 +45993,7 @@ const sendMessage = async (messages, isHost = true) => {
 
 
 const eventEmitter = new (events_default())();
-const src_Log = (0,dist/* initLog */.KR)('@onekey/connect');
+const src_Log = (0,dist/* getLogger */.jl)(dist/* LoggerNames.Connect */.d0.Connect);
 
 let _settings = (0,dist/* parseConnectSettings */._4)();
 
@@ -45693,6 +46013,11 @@ const handleMessage = async message => {
       eventEmitter.emit(message.type, message.payload);
       break;
 
+    case dist/* LOG_EVENT */.og:
+    case dist/* FIRMWARE_EVENT */.SI:
+      eventEmitter.emit(message.event, message);
+      break;
+
     default:
       src_Log.log('No need to be captured message', message.event);
   }
@@ -45748,9 +46073,17 @@ const createJSBridge = messageEvent => {
       targetOrigin: origin,
       receiveHandler: async messageEvent => {
         const message = (0,dist/* parseMessage */.kW)(messageEvent);
-        console.log('Host Bridge Receive message: ', message);
+
+        if (message.event !== 'LOG_EVENT') {
+          src_Log.debug('Host Bridge Receive message: ', message);
+        }
+
         const response = await handleMessage(message);
-        src_Log.debug('Host Bridge response: ', response);
+
+        if (message.event !== 'LOG_EVENT') {
+          src_Log.debug('Host Bridge response: ', response);
+        }
+
         return response;
       }
     });
@@ -45766,13 +46099,14 @@ const src_init = async settings => {
     ...settings
   });
   (0,dist/* enableLog */.yI)(!!settings.debug);
+  (0,dist/* setLoggerPostMessage */.hZ)(handleMessage);
   src_Log.debug('init');
   window.addEventListener('message', createJSBridge);
   window.addEventListener('unload', src_dispose);
 
   try {
     await init({ ..._settings,
-      version: "0.1.14"
+      version: "0.1.18"
     });
     return true;
   } catch (e) {