@onekeyfe/hd-web-sdk 0.1.11 → 0.1.14

package/build/onekey-js-sdk.js

@@ -4031,6 +4031,8 @@ var axios = __webpack_require__(9644);
 
 var BigNumber = __webpack_require__(6391);
 
+var sha256 = __webpack_require__(1965);
+
 var hdTransport = __webpack_require__(7495);
 
 function _interopDefaultLegacy(e) {
@@ -4045,6 +4047,8 @@ var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 
 var BigNumber__default = /*#__PURE__*/_interopDefaultLegacy(BigNumber);
 
+var sha256__default = /*#__PURE__*/_interopDefaultLegacy(sha256);
+
 const inject = ({
   call,
   cancel,
@@ -4781,92 +4785,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,
@@ -14030,7 +13948,7 @@ DataManager.getTransportStatus = localVersion => {
   return isLatest ? 'valid' : 'outdated';
 };
 
-const Log$5 = initLog('Transport');
+const Log$5 = hdShared.initLog('Transport');
 
 class TransportManager {
   static load() {
@@ -14061,6 +13979,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);
+        }
       }
     });
   }
@@ -14236,11 +14158,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 = hdShared.initLog('DeviceCommands');
 
 class DeviceCommands {
   constructor(device, mainId) {
@@ -14264,8 +14186,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);
+      console.log('[DeviceCommands] [call] Sending', type);
 
       try {
         const promise = this.transport.call(this.mainId, type, msg);
@@ -14275,6 +14199,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;
       }
     });
@@ -14292,7 +14224,16 @@ class DeviceCommands {
         assertType(response, resType);
       } catch (error) {
         console.log('DeviceCommands typedcall error: ', error);
-        throw 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;
@@ -14409,12 +14350,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,
@@ -14511,7 +14451,7 @@ const parseRunOptions = options => {
   return options;
 };
 
-const Log$3 = initLog('Device');
+const Log$3 = hdShared.initLog('Device');
 
 class Device extends events.exports {
   constructor(descriptor) {
@@ -14873,7 +14813,7 @@ class Device extends events.exports {
 }
 
 const cacheDeviceMap = new Map();
-const Log$2 = initLog('DeviceList');
+const Log$2 = hdShared.initLog('DeviceList');
 
 class DeviceList extends events.exports {
   constructor() {
@@ -16355,12 +16295,19 @@ class CheckBridgeStatus extends BaseMethod {
 
   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);
+          }
+        });
       });
     });
   }
@@ -16635,7 +16582,9 @@ class DeviceVerify extends BaseMethod {
       let response;
 
       if (deviceType === 'classic') {
-        const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign({}, this.params));
+        const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign(Object.assign({}, this.params), {
+          data: sha256__default["default"].sha256(this.params.data)
+        }));
         response = res.message;
       } else if (deviceType === 'mini') {
         const signatureRes = yield this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', {
@@ -18668,7 +18617,7 @@ const resolveAfter = (msec, value) => new Promise(resolve => {
   setTimeout(resolve, msec, value);
 });
 
-const Log$1 = initLog('DeviceConnector');
+const Log$1 = hdShared.initLog('DeviceConnector');
 
 const getDiff = (current, descriptors) => {
   const env = DataManager.getSettings('env');
@@ -18824,7 +18773,7 @@ class DeviceConnector {
 
 }
 
-const Log = initLog('Core');
+const Log = hdShared.initLog('Core');
 
 let _core;
 
@@ -18930,7 +18879,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) {
@@ -19189,7 +19138,7 @@ const init = (settings, Transport) => __awaiter(void 0, void 0, void 0, function
       Log.error('DataManager.load error');
     }
 
-    enableLog(DataManager.getSettings('debug'));
+    hdShared.enableLog(DataManager.getSettings('debug'));
     initCore();
     initConnector();
     return _core;
@@ -19214,6 +19163,18 @@ 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 () {
@@ -19239,7 +19200,6 @@ __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;
@@ -19251,7 +19211,6 @@ __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;
@@ -20439,7 +20398,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.',
@@ -20480,7 +20442,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) => {
@@ -20512,21 +20477,157 @@ 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
 });
+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;
 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;
 
 /***/ }),
 
@@ -31212,6 +31313,532 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
 }
 
 
+/***/ }),
+
+/***/ 1965:
+/***/ ((module, exports, __webpack_require__) => {
+
+var __WEBPACK_AMD_DEFINE_RESULT__;/**
+ * [js-sha256]{@link https://github.com/emn178/js-sha256}
+ *
+ * @version 0.9.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2017
+ * @license MIT
+ */
+/*jslint bitwise: true */
+(function () {
+  'use strict';
+
+  var ERROR = 'input is invalid type';
+  var WINDOW = typeof window === 'object';
+  var root = WINDOW ? window : {};
+  if (root.JS_SHA256_NO_WINDOW) {
+    WINDOW = false;
+  }
+  var WEB_WORKER = !WINDOW && typeof self === 'object';
+  var NODE_JS = !root.JS_SHA256_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
+  if (NODE_JS) {
+    root = __webpack_require__.g;
+  } else if (WEB_WORKER) {
+    root = self;
+  }
+  var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && "object" === 'object' && module.exports;
+  var AMD =  true && __webpack_require__.amdO;
+  var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
+  var HEX_CHARS = '0123456789abcdef'.split('');
+  var EXTRA = [-2147483648, 8388608, 32768, 128];
+  var SHIFT = [24, 16, 8, 0];
+  var K = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+  ];
+  var OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];
+
+  var blocks = [];
+
+  if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) {
+    Array.isArray = function (obj) {
+      return Object.prototype.toString.call(obj) === '[object Array]';
+    };
+  }
+
+  if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
+    ArrayBuffer.isView = function (obj) {
+      return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+    };
+  }
+
+  var createOutputMethod = function (outputType, is224) {
+    return function (message) {
+      return new Sha256(is224, true).update(message)[outputType]();
+    };
+  };
+
+  var createMethod = function (is224) {
+    var method = createOutputMethod('hex', is224);
+    if (NODE_JS) {
+      method = nodeWrap(method, is224);
+    }
+    method.create = function () {
+      return new Sha256(is224);
+    };
+    method.update = function (message) {
+      return method.create().update(message);
+    };
+    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+      var type = OUTPUT_TYPES[i];
+      method[type] = createOutputMethod(type, is224);
+    }
+    return method;
+  };
+
+  var nodeWrap = function (method, is224) {
+    var crypto = eval("require('crypto')");
+    var Buffer = eval("require('buffer').Buffer");
+    var algorithm = is224 ? 'sha224' : 'sha256';
+    var nodeMethod = function (message) {
+      if (typeof message === 'string') {
+        return crypto.createHash(algorithm).update(message, 'utf8').digest('hex');
+      } else {
+        if (message === null || message === undefined) {
+          throw new Error(ERROR);
+        } else if (message.constructor === ArrayBuffer) {
+          message = new Uint8Array(message);
+        }
+      }
+      if (Array.isArray(message) || ArrayBuffer.isView(message) ||
+        message.constructor === Buffer) {
+        return crypto.createHash(algorithm).update(new Buffer(message)).digest('hex');
+      } else {
+        return method(message);
+      }
+    };
+    return nodeMethod;
+  };
+
+  var createHmacOutputMethod = function (outputType, is224) {
+    return function (key, message) {
+      return new HmacSha256(key, is224, true).update(message)[outputType]();
+    };
+  };
+
+  var createHmacMethod = function (is224) {
+    var method = createHmacOutputMethod('hex', is224);
+    method.create = function (key) {
+      return new HmacSha256(key, is224);
+    };
+    method.update = function (key, message) {
+      return method.create(key).update(message);
+    };
+    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+      var type = OUTPUT_TYPES[i];
+      method[type] = createHmacOutputMethod(type, is224);
+    }
+    return method;
+  };
+
+  function Sha256(is224, sharedMemory) {
+    if (sharedMemory) {
+      blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+        blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+        blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+      this.blocks = blocks;
+    } else {
+      this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+    }
+
+    if (is224) {
+      this.h0 = 0xc1059ed8;
+      this.h1 = 0x367cd507;
+      this.h2 = 0x3070dd17;
+      this.h3 = 0xf70e5939;
+      this.h4 = 0xffc00b31;
+      this.h5 = 0x68581511;
+      this.h6 = 0x64f98fa7;
+      this.h7 = 0xbefa4fa4;
+    } else { // 256
+      this.h0 = 0x6a09e667;
+      this.h1 = 0xbb67ae85;
+      this.h2 = 0x3c6ef372;
+      this.h3 = 0xa54ff53a;
+      this.h4 = 0x510e527f;
+      this.h5 = 0x9b05688c;
+      this.h6 = 0x1f83d9ab;
+      this.h7 = 0x5be0cd19;
+    }
+
+    this.block = this.start = this.bytes = this.hBytes = 0;
+    this.finalized = this.hashed = false;
+    this.first = true;
+    this.is224 = is224;
+  }
+
+  Sha256.prototype.update = function (message) {
+    if (this.finalized) {
+      return;
+    }
+    var notString, type = typeof message;
+    if (type !== 'string') {
+      if (type === 'object') {
+        if (message === null) {
+          throw new Error(ERROR);
+        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
+          message = new Uint8Array(message);
+        } else if (!Array.isArray(message)) {
+          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
+            throw new Error(ERROR);
+          }
+        }
+      } else {
+        throw new Error(ERROR);
+      }
+      notString = true;
+    }
+    var code, index = 0, i, length = message.length, blocks = this.blocks;
+
+    while (index < length) {
+      if (this.hashed) {
+        this.hashed = false;
+        blocks[0] = this.block;
+        blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+          blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+          blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+          blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+      }
+
+      if (notString) {
+        for (i = this.start; index < length && i < 64; ++index) {
+          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
+        }
+      } else {
+        for (i = this.start; index < length && i < 64; ++index) {
+          code = message.charCodeAt(index);
+          if (code < 0x80) {
+            blocks[i >> 2] |= code << SHIFT[i++ & 3];
+          } else if (code < 0x800) {
+            blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+          } else if (code < 0xd800 || code >= 0xe000) {
+            blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+          } else {
+            code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
+            blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+          }
+        }
+      }
+
+      this.lastByteIndex = i;
+      this.bytes += i - this.start;
+      if (i >= 64) {
+        this.block = blocks[16];
+        this.start = i - 64;
+        this.hash();
+        this.hashed = true;
+      } else {
+        this.start = i;
+      }
+    }
+    if (this.bytes > 4294967295) {
+      this.hBytes += this.bytes / 4294967296 << 0;
+      this.bytes = this.bytes % 4294967296;
+    }
+    return this;
+  };
+
+  Sha256.prototype.finalize = function () {
+    if (this.finalized) {
+      return;
+    }
+    this.finalized = true;
+    var blocks = this.blocks, i = this.lastByteIndex;
+    blocks[16] = this.block;
+    blocks[i >> 2] |= EXTRA[i & 3];
+    this.block = blocks[16];
+    if (i >= 56) {
+      if (!this.hashed) {
+        this.hash();
+      }
+      blocks[0] = this.block;
+      blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+        blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+        blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+    }
+    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
+    blocks[15] = this.bytes << 3;
+    this.hash();
+  };
+
+  Sha256.prototype.hash = function () {
+    var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f = this.h5, g = this.h6,
+      h = this.h7, blocks = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;
+
+    for (j = 16; j < 64; ++j) {
+      // rightrotate
+      t1 = blocks[j - 15];
+      s0 = ((t1 >>> 7) | (t1 << 25)) ^ ((t1 >>> 18) | (t1 << 14)) ^ (t1 >>> 3);
+      t1 = blocks[j - 2];
+      s1 = ((t1 >>> 17) | (t1 << 15)) ^ ((t1 >>> 19) | (t1 << 13)) ^ (t1 >>> 10);
+      blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 << 0;
+    }
+
+    bc = b & c;
+    for (j = 0; j < 64; j += 4) {
+      if (this.first) {
+        if (this.is224) {
+          ab = 300032;
+          t1 = blocks[0] - 1413257819;
+          h = t1 - 150054599 << 0;
+          d = t1 + 24177077 << 0;
+        } else {
+          ab = 704751109;
+          t1 = blocks[0] - 210244248;
+          h = t1 - 1521486534 << 0;
+          d = t1 + 143694565 << 0;
+        }
+        this.first = false;
+      } else {
+        s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+        s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+        ab = a & b;
+        maj = ab ^ (a & c) ^ bc;
+        ch = (e & f) ^ (~e & g);
+        t1 = h + s1 + ch + K[j] + blocks[j];
+        t2 = s0 + maj;
+        h = d + t1 << 0;
+        d = t1 + t2 << 0;
+      }
+      s0 = ((d >>> 2) | (d << 30)) ^ ((d >>> 13) | (d << 19)) ^ ((d >>> 22) | (d << 10));
+      s1 = ((h >>> 6) | (h << 26)) ^ ((h >>> 11) | (h << 21)) ^ ((h >>> 25) | (h << 7));
+      da = d & a;
+      maj = da ^ (d & b) ^ ab;
+      ch = (h & e) ^ (~h & f);
+      t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];
+      t2 = s0 + maj;
+      g = c + t1 << 0;
+      c = t1 + t2 << 0;
+      s0 = ((c >>> 2) | (c << 30)) ^ ((c >>> 13) | (c << 19)) ^ ((c >>> 22) | (c << 10));
+      s1 = ((g >>> 6) | (g << 26)) ^ ((g >>> 11) | (g << 21)) ^ ((g >>> 25) | (g << 7));
+      cd = c & d;
+      maj = cd ^ (c & a) ^ da;
+      ch = (g & h) ^ (~g & e);
+      t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];
+      t2 = s0 + maj;
+      f = b + t1 << 0;
+      b = t1 + t2 << 0;
+      s0 = ((b >>> 2) | (b << 30)) ^ ((b >>> 13) | (b << 19)) ^ ((b >>> 22) | (b << 10));
+      s1 = ((f >>> 6) | (f << 26)) ^ ((f >>> 11) | (f << 21)) ^ ((f >>> 25) | (f << 7));
+      bc = b & c;
+      maj = bc ^ (b & d) ^ cd;
+      ch = (f & g) ^ (~f & h);
+      t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];
+      t2 = s0 + maj;
+      e = a + t1 << 0;
+      a = t1 + t2 << 0;
+    }
+
+    this.h0 = this.h0 + a << 0;
+    this.h1 = this.h1 + b << 0;
+    this.h2 = this.h2 + c << 0;
+    this.h3 = this.h3 + d << 0;
+    this.h4 = this.h4 + e << 0;
+    this.h5 = this.h5 + f << 0;
+    this.h6 = this.h6 + g << 0;
+    this.h7 = this.h7 + h << 0;
+  };
+
+  Sha256.prototype.hex = function () {
+    this.finalize();
+
+    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
+      h6 = this.h6, h7 = this.h7;
+
+    var hex = HEX_CHARS[(h0 >> 28) & 0x0F] + HEX_CHARS[(h0 >> 24) & 0x0F] +
+      HEX_CHARS[(h0 >> 20) & 0x0F] + HEX_CHARS[(h0 >> 16) & 0x0F] +
+      HEX_CHARS[(h0 >> 12) & 0x0F] + HEX_CHARS[(h0 >> 8) & 0x0F] +
+      HEX_CHARS[(h0 >> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
+      HEX_CHARS[(h1 >> 28) & 0x0F] + HEX_CHARS[(h1 >> 24) & 0x0F] +
+      HEX_CHARS[(h1 >> 20) & 0x0F] + HEX_CHARS[(h1 >> 16) & 0x0F] +
+      HEX_CHARS[(h1 >> 12) & 0x0F] + HEX_CHARS[(h1 >> 8) & 0x0F] +
+      HEX_CHARS[(h1 >> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
+      HEX_CHARS[(h2 >> 28) & 0x0F] + HEX_CHARS[(h2 >> 24) & 0x0F] +
+      HEX_CHARS[(h2 >> 20) & 0x0F] + HEX_CHARS[(h2 >> 16) & 0x0F] +
+      HEX_CHARS[(h2 >> 12) & 0x0F] + HEX_CHARS[(h2 >> 8) & 0x0F] +
+      HEX_CHARS[(h2 >> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
+      HEX_CHARS[(h3 >> 28) & 0x0F] + HEX_CHARS[(h3 >> 24) & 0x0F] +
+      HEX_CHARS[(h3 >> 20) & 0x0F] + HEX_CHARS[(h3 >> 16) & 0x0F] +
+      HEX_CHARS[(h3 >> 12) & 0x0F] + HEX_CHARS[(h3 >> 8) & 0x0F] +
+      HEX_CHARS[(h3 >> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
+      HEX_CHARS[(h4 >> 28) & 0x0F] + HEX_CHARS[(h4 >> 24) & 0x0F] +
+      HEX_CHARS[(h4 >> 20) & 0x0F] + HEX_CHARS[(h4 >> 16) & 0x0F] +
+      HEX_CHARS[(h4 >> 12) & 0x0F] + HEX_CHARS[(h4 >> 8) & 0x0F] +
+      HEX_CHARS[(h4 >> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] +
+      HEX_CHARS[(h5 >> 28) & 0x0F] + HEX_CHARS[(h5 >> 24) & 0x0F] +
+      HEX_CHARS[(h5 >> 20) & 0x0F] + HEX_CHARS[(h5 >> 16) & 0x0F] +
+      HEX_CHARS[(h5 >> 12) & 0x0F] + HEX_CHARS[(h5 >> 8) & 0x0F] +
+      HEX_CHARS[(h5 >> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] +
+      HEX_CHARS[(h6 >> 28) & 0x0F] + HEX_CHARS[(h6 >> 24) & 0x0F] +
+      HEX_CHARS[(h6 >> 20) & 0x0F] + HEX_CHARS[(h6 >> 16) & 0x0F] +
+      HEX_CHARS[(h6 >> 12) & 0x0F] + HEX_CHARS[(h6 >> 8) & 0x0F] +
+      HEX_CHARS[(h6 >> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];
+    if (!this.is224) {
+      hex += HEX_CHARS[(h7 >> 28) & 0x0F] + HEX_CHARS[(h7 >> 24) & 0x0F] +
+        HEX_CHARS[(h7 >> 20) & 0x0F] + HEX_CHARS[(h7 >> 16) & 0x0F] +
+        HEX_CHARS[(h7 >> 12) & 0x0F] + HEX_CHARS[(h7 >> 8) & 0x0F] +
+        HEX_CHARS[(h7 >> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F];
+    }
+    return hex;
+  };
+
+  Sha256.prototype.toString = Sha256.prototype.hex;
+
+  Sha256.prototype.digest = function () {
+    this.finalize();
+
+    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
+      h6 = this.h6, h7 = this.h7;
+
+    var arr = [
+      (h0 >> 24) & 0xFF, (h0 >> 16) & 0xFF, (h0 >> 8) & 0xFF, h0 & 0xFF,
+      (h1 >> 24) & 0xFF, (h1 >> 16) & 0xFF, (h1 >> 8) & 0xFF, h1 & 0xFF,
+      (h2 >> 24) & 0xFF, (h2 >> 16) & 0xFF, (h2 >> 8) & 0xFF, h2 & 0xFF,
+      (h3 >> 24) & 0xFF, (h3 >> 16) & 0xFF, (h3 >> 8) & 0xFF, h3 & 0xFF,
+      (h4 >> 24) & 0xFF, (h4 >> 16) & 0xFF, (h4 >> 8) & 0xFF, h4 & 0xFF,
+      (h5 >> 24) & 0xFF, (h5 >> 16) & 0xFF, (h5 >> 8) & 0xFF, h5 & 0xFF,
+      (h6 >> 24) & 0xFF, (h6 >> 16) & 0xFF, (h6 >> 8) & 0xFF, h6 & 0xFF
+    ];
+    if (!this.is224) {
+      arr.push((h7 >> 24) & 0xFF, (h7 >> 16) & 0xFF, (h7 >> 8) & 0xFF, h7 & 0xFF);
+    }
+    return arr;
+  };
+
+  Sha256.prototype.array = Sha256.prototype.digest;
+
+  Sha256.prototype.arrayBuffer = function () {
+    this.finalize();
+
+    var buffer = new ArrayBuffer(this.is224 ? 28 : 32);
+    var dataView = new DataView(buffer);
+    dataView.setUint32(0, this.h0);
+    dataView.setUint32(4, this.h1);
+    dataView.setUint32(8, this.h2);
+    dataView.setUint32(12, this.h3);
+    dataView.setUint32(16, this.h4);
+    dataView.setUint32(20, this.h5);
+    dataView.setUint32(24, this.h6);
+    if (!this.is224) {
+      dataView.setUint32(28, this.h7);
+    }
+    return buffer;
+  };
+
+  function HmacSha256(key, is224, sharedMemory) {
+    var i, type = typeof key;
+    if (type === 'string') {
+      var bytes = [], length = key.length, index = 0, code;
+      for (i = 0; i < length; ++i) {
+        code = key.charCodeAt(i);
+        if (code < 0x80) {
+          bytes[index++] = code;
+        } else if (code < 0x800) {
+          bytes[index++] = (0xc0 | (code >> 6));
+          bytes[index++] = (0x80 | (code & 0x3f));
+        } else if (code < 0xd800 || code >= 0xe000) {
+          bytes[index++] = (0xe0 | (code >> 12));
+          bytes[index++] = (0x80 | ((code >> 6) & 0x3f));
+          bytes[index++] = (0x80 | (code & 0x3f));
+        } else {
+          code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff));
+          bytes[index++] = (0xf0 | (code >> 18));
+          bytes[index++] = (0x80 | ((code >> 12) & 0x3f));
+          bytes[index++] = (0x80 | ((code >> 6) & 0x3f));
+          bytes[index++] = (0x80 | (code & 0x3f));
+        }
+      }
+      key = bytes;
+    } else {
+      if (type === 'object') {
+        if (key === null) {
+          throw new Error(ERROR);
+        } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {
+          key = new Uint8Array(key);
+        } else if (!Array.isArray(key)) {
+          if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {
+            throw new Error(ERROR);
+          }
+        }
+      } else {
+        throw new Error(ERROR);
+      }
+    }
+
+    if (key.length > 64) {
+      key = (new Sha256(is224, true)).update(key).array();
+    }
+
+    var oKeyPad = [], iKeyPad = [];
+    for (i = 0; i < 64; ++i) {
+      var b = key[i] || 0;
+      oKeyPad[i] = 0x5c ^ b;
+      iKeyPad[i] = 0x36 ^ b;
+    }
+
+    Sha256.call(this, is224, sharedMemory);
+
+    this.update(iKeyPad);
+    this.oKeyPad = oKeyPad;
+    this.inner = true;
+    this.sharedMemory = sharedMemory;
+  }
+  HmacSha256.prototype = new Sha256();
+
+  HmacSha256.prototype.finalize = function () {
+    Sha256.prototype.finalize.call(this);
+    if (this.inner) {
+      this.inner = false;
+      var innerHash = this.array();
+      Sha256.call(this, this.is224, this.sharedMemory);
+      this.update(this.oKeyPad);
+      this.update(innerHash);
+      Sha256.prototype.finalize.call(this);
+    }
+  };
+
+  var exports = createMethod();
+  exports.sha256 = exports;
+  exports.sha224 = createMethod(true);
+  exports.sha256.hmac = createHmacMethod();
+  exports.sha224.hmac = createHmacMethod(true);
+
+  if (COMMON_JS) {
+    module.exports = exports;
+  } else {
+    root.sha256 = exports.sha256;
+    root.sha224 = exports.sha224;
+    if (AMD) {
+      !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {
+        return exports;
+      }).call(exports, __webpack_require__, exports, module),
+		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+    }
+  }
+})();
+
+
 /***/ }),
 
 /***/ 857:
@@ -42690,6 +43317,11 @@ try {
 /******/ 	}
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/amd options */
+/******/ 	(() => {
+/******/ 		__webpack_require__.amdO = {};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/compat get default export */
 /******/ 	(() => {
 /******/ 		// getDefaultExport function for compatibility with non-harmony modules
@@ -44999,6 +45631,7 @@ 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
@@ -45028,7 +45661,7 @@ const sendMessage = async (messages, isHost = true) => {
     return result;
   } catch (error) {
     Log.error(error);
-    throw error;
+    throw shared_dist.ERRORS.CreateErrorByMessage(error.message);
   }
 };
 
@@ -45138,7 +45771,9 @@ const src_init = async settings => {
   window.addEventListener('unload', src_dispose);
 
   try {
-    await init(_settings);
+    await init({ ..._settings,
+      version: "0.1.14"
+    });
     return true;
   } catch (e) {
     console.log('init error: ', e);
@@ -45177,7 +45812,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);
   }
 };