@onekeyfe/hd-web-sdk 0.1.12 → 0.1.16

package/build/onekey-js-sdk.js

@@ -4072,6 +4072,9 @@ const inject = ({
     dispose,
     uiResponse,
     cancel,
+    getLogs: () => call({
+      method: 'getLogs'
+    }),
     searchDevices: () => call({
       method: 'searchDevices'
     }),
@@ -4785,423 +4788,6 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-const colors = {
-  '@onekey/connect': 'color: #f4a742; background: #000;',
-  IFrame: 'color: #f4a742; background: #000;',
-  Core: 'color: #f4a742; background: #000;',
-  DescriptorStream: 'color: #77ab59; background: #000;',
-  DeviceList: 'color: #77ab59; background: #000;',
-  Device: 'color: #bada55; background: #000;',
-  DeviceCommands: 'color: #bada55; background: #000;',
-  DeviceConnector: 'color: #bada55; background: #000;',
-  Transport: 'color: #ffb6c1; background: #000;'
-};
-const MAX_ENTRIES = 100;
-
-class Log$6 {
-  constructor(prefix, enabled) {
-    this.prefix = prefix;
-    this.enabled = enabled;
-    this.messages = [];
-    this.css = typeof window !== 'undefined' && colors[prefix] ? colors[prefix] : '';
-  }
-
-  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) {
-      console.log(this.prefix, ...args);
-    }
-  }
-
-  error(...args) {
-    this.addMessage('error', this.prefix, ...args);
-
-    if (this.enabled) {
-      console.error(this.prefix, ...args);
-    }
-  }
-
-  warn(...args) {
-    this.addMessage('warn', this.prefix, ...args);
-
-    if (this.enabled) {
-      console.warn(this.prefix, ...args);
-    }
-  }
-
-  debug(...args) {
-    this.addMessage('debug', this.prefix, ...args);
-
-    if (this.enabled) {
-      if (this.css) {
-        console.log(`%c${this.prefix}`, this.css, ...args);
-      } else {
-        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 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: {
@@ -13862,6 +13448,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);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    sendLogMessage(this.prefix, ...args);
+    console.log(this.prefix, ...args);
+  }
+
+  error(...args) {
+    this.addMessage('error', this.prefix, ...args);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    sendLogMessage(this.prefix, ...args);
+    console.error(this.prefix, ...args);
+  }
+
+  warn(...args) {
+    this.addMessage('warn', this.prefix, ...args);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    sendLogMessage(this.prefix, ...args);
+    console.warn(this.prefix, ...args);
+  }
+
+  debug(...args) {
+    this.addMessage('debug', this.prefix, ...args);
+
+    if (!this.enabled) {
+      return;
+    }
+
+    sendLogMessage(this.prefix, ...args);
+    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));
 
@@ -14034,11 +14127,13 @@ DataManager.getTransportStatus = localVersion => {
   return isLatest ? 'valid' : 'outdated';
 };
 
-const Log$5 = 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;
   }
@@ -14051,13 +14146,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');
@@ -14065,6 +14160,10 @@ class TransportManager {
         Log$5.debug('Configuring transports done');
       } catch (error) {
         Log$5.debug('Initializing transports error: ', error);
+
+        if (error.code === 'ECONNABORTED') {
+          throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
+        }
       }
     });
   }
@@ -14099,7 +14198,7 @@ class TransportManager {
       this.transport = new TransportConstructor();
     }
 
-    console.log('set transport: ', this.transport);
+    Log$5.debug('set transport: ', this.transport);
   }
 
   static getTransport() {
@@ -14240,11 +14339,11 @@ const assertType = (res, resType) => {
   const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
 
   if (!splitResTypes.includes(res.type)) {
-    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `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$4 = initLog('DeviceCommands');
+const Log$4 = getLogger(exports.d0.DeviceCommands);
 
 class DeviceCommands {
   constructor(device, mainId) {
@@ -14268,8 +14367,10 @@ class DeviceCommands {
   }
 
   call(type, msg = {}) {
+    var _a, _b;
+
     return __awaiter(this, void 0, void 0, function* () {
-      console.log('[DeviceCommands] [call] Sending', type, this.transport);
+      Log$4.debug('[DeviceCommands] [call] Sending', type);
 
       try {
         const promise = this.transport.call(this.mainId, type, msg);
@@ -14279,6 +14380,14 @@ class DeviceCommands {
         return res;
       } catch (error) {
         Log$4.debug('[DeviceCommands] [call] Received error', error);
+
+        if (((_b = (_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === 'device disconnected during action') {
+          return {
+            type: 'BridgeNetworkError',
+            message: {}
+          };
+        }
+
         throw error;
       }
     });
@@ -14295,8 +14404,17 @@ class DeviceCommands {
       try {
         assertType(response, resType);
       } catch (error) {
-        console.log('DeviceCommands typedcall error: ', error);
-        throw error;
+        Log$4.debug('DeviceCommands typedcall error: ', error);
+
+        if (error instanceof hdShared.HardwareError) {
+          if (error.errorCode === hdShared.HardwareErrorCode.ResponseUnexpectTypeError) {
+            if (error.message.indexOf('BridgeNetworkError') > -1) {
+              throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNetworkError);
+            }
+          }
+        } else {
+          throw error;
+        }
       }
 
       return response;
@@ -14311,7 +14429,7 @@ class DeviceCommands {
   }
 
   _filterCommonTypes(res) {
-    console.log('_filterCommonTypes: ', res);
+    Log$4.debug('_filterCommonTypes: ', res);
 
     if (res.type === 'Failure') {
       const {
@@ -14413,12 +14531,11 @@ const UI_REQUEST = {
   FIRMWARE_NOT_INSTALLED: 'ui-device_firmware_not_installed',
   NOT_USE_ONEKEY_DEVICE: 'ui-device_please_use_onekey_device'
 };
-const VERSION = '1.0.0-alpha.1';
-const DEFAULT_DOMAIN = `https://hardware-sdk.onekey.so/`;
+const DEFAULT_DOMAIN = `https://jssdk.onekey.so/`;
 const DEFAULT_PRIORITY = 2;
 const initialSettings = {
   configSrc: './data/config.json',
-  version: VERSION,
+  version: '',
   debug: false,
   priority: DEFAULT_PRIORITY,
   trustedHost: false,
@@ -14515,7 +14632,7 @@ const parseRunOptions = options => {
   return options;
 };
 
-const Log$3 = initLog('Device');
+const Log$3 = getLogger(exports.d0.Device);
 
 class Device extends events.exports {
   constructor(descriptor) {
@@ -14877,7 +14994,7 @@ class Device extends events.exports {
 }
 
 const cacheDeviceMap = new Map();
-const Log$2 = initLog('DeviceList');
+const Log$2 = getLogger(exports.d0.DeviceList);
 
 class DeviceList extends events.exports {
   constructor() {
@@ -14895,7 +15012,7 @@ 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');
 
       try {
         for (var descriptorList_1 = __asyncValues(descriptorList), descriptorList_1_1; descriptorList_1_1 = yield descriptorList_1.next(), !descriptorList_1_1.done;) {
@@ -16352,19 +16469,26 @@ class CheckTransportRelease extends BaseMethod {
 
 }
 
-class CheckBridgeStatus extends BaseMethod {
+class CheckBridgeStatus$1 extends BaseMethod {
   init() {
     this.useDevice = false;
   }
 
   run() {
     return __awaiter(this, void 0, void 0, function* () {
-      return new Promise(resolve => {
+      return new Promise((resolve, reject) => {
         axios__default["default"].request({
           url: 'http://localhost:21320',
           method: 'POST',
-          withCredentials: false
-        }).then(() => resolve(true)).catch(() => resolve(false));
+          withCredentials: false,
+          timeout: 3000
+        }).then(() => resolve(true)).catch(e => {
+          if (e.code === 'ECONNABORTED') {
+            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError));
+          } else {
+            resolve(false);
+          }
+        });
       });
     });
   }
@@ -16643,7 +16767,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
         });
@@ -18565,6 +18689,8 @@ class FirmwareUpdate extends BaseMethod {
   }
 
   run() {
+    var _a;
+
     return __awaiter(this, void 0, void 0, function* () {
       const {
         device,
@@ -18588,7 +18714,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, {
@@ -18599,6 +18725,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,
@@ -18612,7 +18752,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   checkFirmwareRelease: CheckFirmwareRelease,
   checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
   checkTransportRelease: CheckTransportRelease,
-  checkBridgeStatus: CheckBridgeStatus,
+  checkBridgeStatus: CheckBridgeStatus$1,
   deviceBackup: DeviceBackup,
   deviceChangePin: DeviceChangePin,
   deviceFlags: DeviceFlags,
@@ -18641,7 +18781,8 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
   solSignTransaction: SolSignTransaction,
   stellarGetAddress: StellarGetAddress,
   stellarSignTransaction: StellarSignTransaction,
-  firmwareUpdate: FirmwareUpdate
+  firmwareUpdate: FirmwareUpdate,
+  getLogs: CheckBridgeStatus
 });
 
 function findMethod(message) {
@@ -18674,7 +18815,7 @@ const resolveAfter = (msec, value) => new Promise(resolve => {
   setTimeout(resolve, msec, value);
 });
 
-const Log$1 = initLog('DeviceConnector');
+const Log$1 = getLogger(exports.d0.DeviceConnector);
 
 const getDiff = (current, descriptors) => {
   const env = DataManager.getSettings('env');
@@ -18787,7 +18928,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 {
@@ -18830,7 +18971,7 @@ class DeviceConnector {
 
 }
 
-const Log = initLog('Core');
+const Log = getLogger(exports.d0.Core);
 
 let _core;
 
@@ -18893,7 +19034,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
     return Promise.reject(error);
   }
 
-  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) => {
@@ -18936,7 +19077,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
 
       try {
         const response = yield method.run();
-        Log.debug('Call API - Inner Method Run: ', device);
+        Log.debug('Call API - Inner Method Run: ');
         messageResponse = createResponseMessage(method.responseID, true, response);
         _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.resolve(messageResponse);
       } catch (error) {
@@ -18948,7 +19089,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);
 
@@ -18957,7 +19098,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
       });
@@ -19083,7 +19224,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(),
@@ -19196,6 +19337,11 @@ const init = (settings, Transport) => __awaiter(void 0, void 0, void 0, function
     }
 
     enableLog(DataManager.getSettings('debug'));
+
+    if (DataManager.getSettings('env') !== 'react-native') {
+      setLoggerPostMessage(postMessage);
+    }
+
     initCore();
     initConnector();
     return _core;
@@ -19233,6 +19379,8 @@ __webpack_unused_export__ = DEVICE;
 __webpack_unused_export__ = DEVICE_EVENT;
 __webpack_unused_export__ = DataManager;
 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;
@@ -19241,6 +19389,7 @@ __webpack_unused_export__ = corsValidator;
 __webpack_unused_export__ = createDeviceMessage;
 exports.xG = createErrorMessage;
 __webpack_unused_export__ = createIFrameMessage;
+__webpack_unused_export__ = createLogMessage;
 __webpack_unused_export__ = createResponseMessage;
 __webpack_unused_export__ = createUiMessage;
 __webpack_unused_export__ = createUiResponse;
@@ -19253,11 +19402,12 @@ __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;
 __webpack_unused_export__ = init;
-exports.KR = initLog;
 __webpack_unused_export__ = isValidVersionArray;
 __webpack_unused_export__ = isValidVersionString;
 __webpack_unused_export__ = normalizeVersionArray;
@@ -19265,6 +19415,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;
 
@@ -20375,6 +20526,7 @@ function createDeferred(arg, data) {
 }
 
 function fillStringWithArguments(value, object) {
+  if (typeof value !== 'string') return value;
   return value.replace(/\{([^}]+)\}/g, (_, arg) => object[arg] || '?');
 }
 
@@ -20445,7 +20597,10 @@ const HardwareErrorCode = {
   PinInvalid: 801,
   PinCancelled: 802,
   ActionCancelled: 803,
-  FirmwareError: 804
+  FirmwareError: 804,
+  ResponseUnexpectTypeError: 805,
+  BridgeNetworkError: 806,
+  BridgeTimeoutError: 807
 };
 const HardwareErrorCodeMessage = {
   [HardwareErrorCode.UnknownError]: 'Unknown error occurred. Check message property.',
@@ -20486,7 +20641,10 @@ const HardwareErrorCodeMessage = {
   [HardwareErrorCode.PinInvalid]: 'Pin invalid',
   [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
   [HardwareErrorCode.ActionCancelled]: 'Action cancelled by user',
-  [HardwareErrorCode.FirmwareError]: 'Firmware installation failed'
+  [HardwareErrorCode.FirmwareError]: 'Firmware installation failed',
+  [HardwareErrorCode.ResponseUnexpectTypeError]: 'Response type is not expected',
+  [HardwareErrorCode.BridgeNetworkError]: 'Bridge network error',
+  [HardwareErrorCode.BridgeTimeoutError]: 'Bridge network timeout'
 };
 
 const TypedError = (hardwareError, message) => {
@@ -20518,14 +20676,26 @@ const serializeError = payload => {
   return payload;
 };
 
+const CreateErrorByMessage = message => {
+  for (const code of Object.values(HardwareErrorCode)) {
+    if (HardwareErrorCodeMessage[code] === message) {
+      return TypedError(code);
+    }
+  }
+
+  return new HardwareError(message);
+};
+
 var HardwareError$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   HardwareError: HardwareError,
   HardwareErrorCode: HardwareErrorCode,
   HardwareErrorCodeMessage: HardwareErrorCodeMessage,
   TypedError: TypedError,
-  serializeError: serializeError
+  serializeError: serializeError,
+  CreateErrorByMessage: CreateErrorByMessage
 });
+exports.CreateErrorByMessage = CreateErrorByMessage;
 exports.ERRORS = HardwareError$1;
 exports.HardwareError = HardwareError;
 exports.HardwareErrorCode = HardwareErrorCode;
@@ -45536,12 +45706,13 @@ function createCodeJsBridgeReceive(payloadStr) {
 ;// CONCATENATED MODULE: ./src/utils/bridgeUtils.ts
 
 
+
  // eslint-disable-next-line import/no-mutable-exports
 
 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);
 
@@ -45555,17 +45726,24 @@ 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);
-    throw error;
+    throw shared_dist.ERRORS.CreateErrorByMessage(error.message);
   }
 };
 
@@ -45577,7 +45755,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)();
 
@@ -45597,6 +45775,10 @@ const handleMessage = async message => {
       eventEmitter.emit(message.type, message.payload);
       break;
 
+    case dist/* LOG_EVENT */.og:
+      eventEmitter.emit(message.event, message);
+      break;
+
     default:
       src_Log.log('No need to be captured message', message.event);
   }
@@ -45652,9 +45834,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;
       }
     });
@@ -45670,12 +45860,15 @@ 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);
+    await init({ ..._settings,
+      version: "0.1.16"
+    });
     return true;
   } catch (e) {
     console.log('init error: ', e);
@@ -45714,7 +45907,13 @@ const call = async params => {
     return (0,dist/* createErrorMessage */.xG)(shared_dist.ERRORS.TypedError(shared_dist.HardwareErrorCode.CallMethodNotResponse));
   } catch (error) {
     src_Log.error('__call error: ', error);
-    return (0,dist/* createErrorMessage */.xG)(error);
+    let err = error;
+
+    if (!(err instanceof shared_dist.HardwareError)) {
+      err = shared_dist.ERRORS.CreateErrorByMessage(error.message);
+    }
+
+    return (0,dist/* createErrorMessage */.xG)(err);
   }
 };