@onekeyfe/hd-web-sdk 0.1.5 → 0.1.6

package/build/onekey-js-sdk.js

@@ -4025,12 +4025,14 @@ __webpack_unused_export__ = ({
 
 var semver = __webpack_require__(7699);
 
-var hdTransport = __webpack_require__(7495);
+var hdShared = __webpack_require__(8402);
 
 var axios = __webpack_require__(9644);
 
 var BigNumber = __webpack_require__(6391);
 
+var hdTransport = __webpack_require__(7495);
+
 function _interopDefaultLegacy(e) {
   return e && typeof e === 'object' && 'default' in e ? e : {
     'default': e
@@ -4772,55 +4774,6 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   }
 }
 
-const ERROR_CODES = {
-  Method_InvalidParameter: '',
-  Call_API: '',
-  Call_NotResponse: 'No response data',
-  Method_FirmwareUpdate_DownloadFailed: '',
-  Transport_InvalidProtobuf: '',
-  Device_FwException: '',
-  Device_UnexpectedMode: '',
-  Device_CallInProgress: '',
-  Device_InitializeFailed: '',
-  Device_Interrupted: 'The device is performing other operations',
-  Not_Use_Onekey_Device: 'Please use onekey device',
-  Runtime: '',
-  Init_NotInitialized: 'Init_NotInitialized',
-  Init_IframeBlocked: 'Init_IframeBlocked',
-  Init_IframeTimeout: 'Init_IframeTimeout',
-  Init_AlreadyInitialized: 'Init_AlreadyInitialized',
-  Init_IframeLoadFail: 'Init_IframeLoadFail'
-};
-
-class OnekeyError extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.message = message;
-  }
-
-}
-
-const TypedError = (id, message) => new OnekeyError(id, message || ERROR_CODES[id]);
-
-const serializeError = payload => {
-  if (payload && payload.error instanceof Error) {
-    return {
-      error: payload.error.message,
-      code: payload.error.code
-    };
-  }
-
-  return payload;
-};
-
-var errors = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  ERROR_CODES: ERROR_CODES,
-  OnekeyError: OnekeyError,
-  TypedError: TypedError,
-  serializeError: serializeError
-});
 const colors = {
   '@onekey/connect': 'color: #f4a742; background: #000;',
   IFrame: 'color: #f4a742; background: #000;',
@@ -5015,35 +4968,6 @@ const versionCompare = (a, b) => {
   return 0;
 };
 
-function create(arg, data) {
-  let localResolve = _t => {};
-
-  let localReject = _e => {};
-
-  let id;
-  const promise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-    localResolve = resolve;
-    localReject = reject;
-
-    if (typeof arg === 'function') {
-      try {
-        yield arg();
-      } catch (error) {
-        reject(error);
-      }
-    }
-
-    if (typeof arg === 'string') id = arg;
-  }));
-  return {
-    id,
-    data,
-    resolve: localResolve,
-    reject: localReject,
-    promise
-  };
-}
-
 const getDeviceModel = features => {
   if (!features || typeof features !== 'object') {
     return 'model_mini';
@@ -5129,8 +5053,8 @@ const toHardened = n => (n | HD_HARDENED) >>> 0;
 
 const fromHardened = n => (n & ~HD_HARDENED) >>> 0;
 
-const PATH_NOT_VALID = TypedError('Method_InvalidParameter', 'Not a valid path');
-const PATH_NEGATIVE_VALUES = TypedError('Method_InvalidParameter', 'Path cannot contain negative values');
+const PATH_NOT_VALID = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Not a valid path');
+const PATH_NEGATIVE_VALUES = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Path cannot contain negative values');
 
 const getHDPath = path => {
   const parts = path.toLowerCase().split('/');
@@ -14124,7 +14048,7 @@ class TransportManager {
         yield this.transport.configure(JSON.stringify(messages));
         this.currentMessages = messages;
       } catch (error) {
-        throw TypedError('Transport_InvalidProtobuf', error.message);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
       }
     });
   }
@@ -14181,13 +14105,24 @@ const parseMessage = messageData => {
   return message;
 };
 
-const createErrorMessage = error => ({
-  success: false,
-  payload: {
+const createErrorMessage = error => {
+  let payload = {
     error: error.message,
     code: error.code
+  };
+
+  if (error instanceof hdShared.HardwareError) {
+    payload = {
+      error: error.message,
+      code: error.errorCode
+    };
   }
-});
+
+  return {
+    success: false,
+    payload
+  };
+};
 
 const UI_EVENT = 'UI_EVENT';
 const UI_REQUEST$1 = {
@@ -14226,7 +14161,7 @@ const createResponseMessage = (id, success, payload) => ({
   type: RESPONSE_EVENT,
   id,
   success,
-  payload: success ? payload : serializeError(payload)
+  payload: success ? payload : hdShared.serializeError(payload)
 });
 
 const UI_RESPONSE = {
@@ -14269,7 +14204,7 @@ const assertType = (res, resType) => {
   const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
 
   if (!splitResTypes.includes(res.type)) {
-    throw TypedError('Runtime', `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `assertType: Response of unexpected type: ${res.type}. Should be ${resType}`);
   }
 };
 
@@ -14316,7 +14251,7 @@ class DeviceCommands {
   typedCall(type, resType, msg) {
     return __awaiter(this, void 0, void 0, function* () {
       if (this.disposed) {
-        throw TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'typedCall: DeviceCommands already disposed');
       }
 
       const response = yield this._commonCall(type, msg);
@@ -14346,19 +14281,32 @@ class DeviceCommands {
       const {
         code
       } = res.message;
-      let {
+      const {
         message
       } = res.message;
+      let error = null;
 
       if (code === 'Failure_FirmwareError' && !message) {
-        message = 'Firmware installation failed';
+        error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError);
       }
 
-      if (code === 'Failure_ActionCancelled' && !message) {
-        message = 'Action cancelled by user';
+      if (code === 'Failure_ActionCancelled') {
+        error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ActionCancelled);
       }
 
-      return Promise.reject(new OnekeyError(code || 'Failure_UnknownCode', message || 'Failure_UnknownMessage'));
+      if (code === 'Failure_PinInvalid') {
+        error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinInvalid, message);
+      }
+
+      if (code === 'Failure_PinCancelled') {
+        error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinCancelled);
+      }
+
+      if (error) {
+        return Promise.reject(error);
+      }
+
+      return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${code || 'Failure_UnknownCode'},${message || 'Failure_UnknownMessage'}`));
     }
 
     if (res.type === 'Features') {
@@ -14410,7 +14358,7 @@ class DeviceCommands {
         });
       } else {
         console.warn('[DeviceCommands] [call] PIN callback not configured, cancelling request');
-        reject(TypedError('Runtime', '_promptPin: PIN callback not configured'));
+        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, '_promptPin: PIN callback not configured'));
       }
     });
   }
@@ -14763,7 +14711,7 @@ class Device extends events.exports {
       }
 
       options = parseRunOptions(options);
-      this.runPromise = create(this._runInner.bind(this, fn, options));
+      this.runPromise = hdShared.createDeferred(this._runInner.bind(this, fn, options));
       return this.runPromise.promise;
     });
   }
@@ -14779,7 +14727,7 @@ class Device extends events.exports {
           }
         } catch (error) {
           this.runPromise = null;
-          return Promise.reject(TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}, code: ${error.code}`));
+          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed, `Initialize failed: ${error.message}, code: ${error.code}`));
         }
       }
 
@@ -14811,7 +14759,7 @@ class Device extends events.exports {
     }
 
     if (this.runPromise) {
-      this.runPromise.reject(TypedError('Device_Interrupted'));
+      this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside));
     }
   }
 
@@ -15108,7 +15056,7 @@ const formatAnyHex = value => {
   return value;
 };
 
-const invalidParameter = message => TypedError('Method_InvalidParameter', message);
+const invalidParameter = message => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, message);
 
 const validateParams = (values, fields) => {
   fields.forEach(field => {
@@ -15421,11 +15369,11 @@ const getCoinInfo = (path, coin) => {
 
   if (!coinInfo) {
     if (coin) {
-      throw TypedError('Method_InvalidParameter', `Invalid coin name: ${coin}`);
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Invalid coin name: ${coin}`);
     } else if (path) {
-      throw TypedError('Method_InvalidParameter', `Invalid path: ${path[0]}`);
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Invalid path: ${path[0]}`);
     } else {
-      throw TypedError('Method_InvalidParameter');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter);
     }
   }
 
@@ -15668,17 +15616,17 @@ const requestPrevTxInfo$1 = ({
   } = details;
 
   if (!tx_hash) {
-    throw TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
   }
 
   const tx = refTxs[tx_hash.toLowerCase()];
 
   if (!tx) {
-    throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
   }
 
   if (request_type === 'TXINPUT') {
-    if (!tx.bin_outputs) throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
+    if (!tx.bin_outputs) throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
     return typedCall('TxAckPrevInput', 'TxRequest', {
       tx: {
         input: tx.inputs[details.request_index]
@@ -15687,7 +15635,7 @@ const requestPrevTxInfo$1 = ({
   }
 
   if (request_type === 'TXOUTPUT') {
-    if (!tx.bin_outputs) throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+    if (!tx.bin_outputs) throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
     return typedCall('TxAckPrevOutput', 'TxRequest', {
       tx: {
         output: tx.bin_outputs[details.request_index]
@@ -15696,7 +15644,7 @@ const requestPrevTxInfo$1 = ({
   }
 
   if (request_type === 'TXORIGINPUT') {
-    if (!tx.outputs) throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+    if (!tx.outputs) throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
     return typedCall('TxAckInput', 'TxRequest', {
       tx: {
         input: tx.inputs[details.request_index]
@@ -15705,7 +15653,7 @@ const requestPrevTxInfo$1 = ({
   }
 
   if (request_type === 'TXORIGOUTPUT') {
-    if (!tx.outputs) throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+    if (!tx.outputs) throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
     return typedCall('TxAckOutput', 'TxRequest', {
       tx: {
         output: tx.outputs[details.request_index]
@@ -15715,15 +15663,15 @@ const requestPrevTxInfo$1 = ({
 
   if (request_type === 'TXEXTRADATA') {
     if (typeof details.extra_data_len !== 'number') {
-      throw TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
     }
 
     if (typeof details.extra_data_offset !== 'number') {
-      throw TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
     }
 
     if (typeof tx.extra_data !== 'string') {
-      throw TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
     }
 
     const data = tx.extra_data;
@@ -15755,7 +15703,7 @@ const requestPrevTxInfo$1 = ({
     });
   }
 
-  throw TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 
 const requestSignedTxInfo$1 = ({
@@ -15784,14 +15732,14 @@ const requestSignedTxInfo$1 = ({
   }
 
   if (request_type === 'TXMETA') {
-    throw TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
   }
 
   if (request_type === 'TXEXTRADATA') {
-    throw TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
   }
 
-  throw TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 
 const requestTxAck$1 = props => {
@@ -15820,7 +15768,7 @@ const saveTxSignatures$1 = (serializedTx, signatures, txRequest) => {
 
   if (typeof signature_index === 'number') {
     if (!signature) {
-      throw TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
     }
 
     signatures[signature_index] = signature;
@@ -15895,17 +15843,17 @@ const requestPrevTxInfo = ({
   } = details;
 
   if (!tx_hash) {
-    throw TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: unknown details.tx_hash');
   }
 
   const tx = refTxs[tx_hash.toLowerCase()];
 
   if (!tx) {
-    throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
   }
 
   if (!tx.bin_outputs) {
-    throw TypedError('Runtime', `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
   }
 
   if (request_type === 'TXINPUT') {
@@ -15922,15 +15870,15 @@ const requestPrevTxInfo = ({
 
   if (request_type === 'TXEXTRADATA') {
     if (typeof details.extra_data_len !== 'number') {
-      throw TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_len');
     }
 
     if (typeof details.extra_data_offset !== 'number') {
-      throw TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestPrevTxInfo: Missing extra_data_offset');
     }
 
     if (typeof tx.extra_data !== 'string') {
-      throw TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
     }
 
     const data = tx.extra_data;
@@ -15964,7 +15912,7 @@ const requestPrevTxInfo = ({
     return meta;
   }
 
-  throw TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Unknown request type: ${request_type}`);
 };
 
 const requestSignedTxInfo = ({
@@ -15988,14 +15936,14 @@ const requestSignedTxInfo = ({
   }
 
   if (request_type === 'TXMETA') {
-    throw TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
   }
 
   if (request_type === 'TXEXTRADATA') {
-    throw TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
   }
 
-  throw TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestSignedTxInfo: Unknown request type: ${request_type}`);
 };
 
 const requestTxAck = props => {
@@ -16024,7 +15972,7 @@ const saveTxSignatures = (serializedTx, signatures, txRequest) => {
 
   if (typeof signature_index === 'number') {
     if (!signature) {
-      throw TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
     }
 
     signatures[signature_index] = signature;
@@ -16212,12 +16160,12 @@ class BTCSignTransaction extends BaseMethod {
       }]);
 
       if (Object.prototype.hasOwnProperty.call(output, 'address_n') && Object.prototype.hasOwnProperty.call(output, 'address')) {
-        throw TypedError('Method_InvalidParameter', 'Cannot use address and address_n in one output');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Cannot use address and address_n in one output');
       }
 
       if (output.address_n) {
         const scriptType = getOutputScriptType(output.address_n);
-        if (output.script_type !== scriptType) throw TypedError('Method_InvalidParameter', `Output change script_type should be set to ${scriptType}`);
+        if (output.script_type !== scriptType) throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
       }
     });
     const {
@@ -16846,7 +16794,7 @@ class EVMSignTransaction extends BaseMethod {
         const s = request.signature_s;
 
         if (v == null || r == null || s == null) {
-          throw TypedError('Runtime', 'processTxRequest: Unexpected request');
+          throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'processTxRequest: Unexpected request');
         }
 
         if (chain_id && v <= 1) {
@@ -17080,7 +17028,7 @@ class EVMSignTypedData extends BaseMethod {
       if (messageHash) {
         this.params.messageHash = formatAnyHex(messageHash);
       } else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
-        throw TypedError('Method_InvalidParameter', 'message_hash should only be empty when data.primaryType=EIP712Domain');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'message_hash should only be empty when data.primaryType=EIP712Domain');
       }
     }
   }
@@ -17111,7 +17059,7 @@ class EVMSignTypedData extends BaseMethod {
   run() {
     return __awaiter(this, void 0, void 0, function* () {
       if (!this.device.features) {
-        throw TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
+        throw hdShared.ERRORS.TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
       }
 
       const {
@@ -17152,7 +17100,7 @@ class EVMSignTypedData extends BaseMethod {
         return Promise.resolve(response.message);
       }
 
-      return Promise.resolve(TypedError('Runtime', 'Not implemented'));
+      return Promise.resolve(hdShared.ERRORS.TypedError('Runtime', 'Not implemented'));
     });
   }
 
@@ -17662,7 +17610,7 @@ class NEMSignTransaction extends BaseMethod {
           break;
 
         default:
-          throw TypedError('Method_InvalidParameter', 'Unknown transaction type');
+          throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unknown transaction type');
       }
 
       return message;
@@ -18140,15 +18088,22 @@ const getBinary = ({
   });
 
   if (!releaseInfo) {
-    throw TypedError('Runtime', 'no firmware found for this device');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no firmware found for this device');
   }
 
   if (version && !semver__default["default"].eq(releaseInfo.version, version)) {
-    throw TypedError('Runtime', 'firmware version mismatch');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'firmware version mismatch');
   }
 
   const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
-  const fw = yield httpRequest(url, 'binary');
+  let fw;
+
+  try {
+    fw = yield httpRequest(url, 'binary');
+  } catch (_a) {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
+  }
+
   return Object.assign(Object.assign({}, releaseInfo), {
     binary: fw
   });
@@ -18200,6 +18155,7 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, {
     } = yield typedCall('FirmwareUpload', 'Success', {
       payload
     });
+    postProgressMessage(device, 100, postMessage);
     return message;
   }
 
@@ -18228,7 +18184,7 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, {
     return response.message;
   }
 
-  throw TypedError('Runtime', 'uploadFirmware: unknown major_version');
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
 });
 
 class FirmwareUpdate extends BaseMethod {
@@ -18247,7 +18203,7 @@ class FirmwareUpdate extends BaseMethod {
     }]);
 
     if (!payload.updateType) {
-      throw TypedError('Method_InvalidParameter', 'updateType is required');
+      throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
     }
 
     this.params = {
@@ -18280,7 +18236,7 @@ class FirmwareUpdate extends BaseMethod {
           binary = this.params.binary;
         } else {
           if (!device.features) {
-            throw TypedError('Runtime', 'no features found for this device');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'no features found for this device');
           }
 
           const firmware = yield getBinary({
@@ -18291,7 +18247,7 @@ class FirmwareUpdate extends BaseMethod {
           binary = firmware.binary;
         }
       } catch (err) {
-        throw TypedError('Method_FirmwareUpdate_DownloadFailed', err);
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, err);
       }
 
       return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, {
@@ -18351,7 +18307,7 @@ function findMethod(message) {
   } = message.payload;
 
   if (typeof method !== 'string') {
-    throw TypedError('Method_InvalidParameter', 'Method is not set');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
   }
 
   const MethodConstructor = ApiMethods[method];
@@ -18360,9 +18316,17 @@ function findMethod(message) {
     return new MethodConstructor(message);
   }
 
-  throw TypedError('Method_InvalidParameter', `Method ${method} is not set`);
+  throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
 }
 
+const safeThrowError = error => {
+  if (error instanceof hdShared.HardwareError) {
+    throw error;
+  } else {
+    throw hdShared.ERRORS.TypedError(error);
+  }
+};
+
 const resolveAfter = (msec, value) => new Promise(resolve => {
   setTimeout(resolve, msec, value);
 });
@@ -18437,7 +18401,7 @@ class DeviceConnector {
         Log$1.debug('diff result: ', diff);
         return diff;
       } catch (error) {
-        throw new Error(error);
+        safeThrowError(error);
       }
     });
   }
@@ -18499,7 +18463,7 @@ class DeviceConnector {
 
         return res;
       } catch (error) {
-        throw new Error(error);
+        safeThrowError(error);
       }
     });
   }
@@ -18510,7 +18474,7 @@ class DeviceConnector {
         const res = yield this.transport.release(session, onclose);
         return res;
       } catch (error) {
-        throw new Error(error);
+        safeThrowError(error);
       }
     });
   }
@@ -18538,10 +18502,10 @@ let _callPromise;
 const deviceCacheMap = new Map();
 
 const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
-  var _a, _b;
+  var _a;
 
   if (!message.id || !message.payload || message.type !== IFRAME.CALL) {
-    return Promise.reject(TypedError('Method_InvalidParameter', 'onCall: message.id or message.payload is missing'));
+    return Promise.reject(hdShared.ERRORS.TypedError('on call: message.id or message.payload is missing'));
   }
 
   let method;
@@ -18562,8 +18526,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
       return createResponseMessage(method.responseID, true, response);
     } catch (error) {
       return createResponseMessage(method.responseID, false, {
-        code: error.code,
-        error: (_a = error.message) !== null && _a !== void 0 ? _a : error
+        error
       });
     }
   }
@@ -18588,7 +18551,7 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
   }
 
   Log.debug('Call API - setDevice: ', device);
-  (_b = method.setDevice) === null || _b === void 0 ? void 0 : _b.call(method, device);
+  (_a = method.setDevice) === null || _a === void 0 ? void 0 : _a.call(method, device);
   device.on(DEVICE.PIN, onDevicePinHandler);
   device.on(DEVICE.BUTTON, (d, code) => {
     onDeviceButtonHandler(d, code);
@@ -18606,18 +18569,18 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
         const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
 
         if (semver__default["default"].valid(versionRange.min) && semver__default["default"].lt(currentVersion, versionRange.min)) {
-          return Promise.reject(TypedError('Device_FwException', `Device firmware version is too low, please update to ${versionRange.min}`));
+          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceFwException, `Device firmware version is too low, please update to ${versionRange.min}`));
         }
 
         if (versionRange.max && semver__default["default"].valid(versionRange.max) && semver__default["default"].gt(currentVersion, versionRange.max)) {
-          return Promise.reject(TypedError('Device_FwException', `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`));
+          return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceFwException, `Device firmware version is too high, this method has been deprecated in ${versionRange.max}`));
         }
       }
 
       const unexpectedMode = device.hasUnexpectedMode(method.allowDeviceMode, method.requireDeviceMode);
 
       if (unexpectedMode) {
-        return Promise.reject(TypedError('Device_UnexpectedMode', unexpectedMode));
+        return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceUnexpectedMode, unexpectedMode));
       }
 
       if (_deviceList) {
@@ -18631,7 +18594,9 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
         _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.resolve(messageResponse);
       } catch (error) {
         Log.debug('Call API - Inner Method Run Error: ', error);
-        messageResponse = createResponseMessage(method.responseID, false, error.message);
+        messageResponse = createResponseMessage(method.responseID, false, {
+          error
+        });
         _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.resolve(messageResponse);
       }
     });
@@ -18640,17 +18605,21 @@ const callAPI = message => __awaiter(void 0, void 0, void 0, function* () {
 
     const deviceRun = () => device.run(inner);
 
-    _callPromise = create(deviceRun);
+    _callPromise = hdShared.createDeferred(deviceRun);
 
     try {
       return yield _callPromise.promise;
     } catch (e) {
       console.log('Device Run Error: ', e);
-      return createResponseMessage(method.responseID, false, e.message);
+      return createResponseMessage(method.responseID, false, {
+        error: e
+      });
     }
   } catch (error) {
-    messageResponse = createResponseMessage(method.responseID, false, error);
-    _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.reject(TypedError('Call_API', error));
+    messageResponse = createResponseMessage(method.responseID, false, {
+      error
+    });
+    _callPromise === null || _callPromise === void 0 ? void 0 : _callPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodError, error.message));
     Log.debug('Call API - Run Error: ', error);
   } finally {
     const response = messageResponse;
@@ -18687,7 +18656,7 @@ function initDeviceList(method) {
 
 function initDevice(method) {
   if (!_deviceList) {
-    throw TypedError('Call_API', 'DeviceList is not initialized');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceListNotInitialized);
   }
 
   let device;
@@ -18699,11 +18668,11 @@ function initDevice(method) {
   } else if (allDevices.length === 1) {
     [device] = allDevices;
   } else if (allDevices.length > 1) {
-    throw TypedError('Call_API', '请选择连接设备');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.SelectDevice);
   }
 
   if (!device) {
-    throw TypedError('Call_API', 'Device Not Found');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
   }
 
   device.deviceConnector = _connector;
@@ -18712,7 +18681,7 @@ function initDevice(method) {
 
 function initDeviceForBle(method) {
   if (!method.connectId && !_deviceList) {
-    throw TypedError('Call_API', 'DeviceList is not initialized');
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceListNotInitialized);
   }
 
   if (!method.connectId) {
@@ -18799,7 +18768,7 @@ const postMessage = message => {
 };
 
 const createUiPromise = (promiseEvent, device) => {
-  const uiPromise = create(promiseEvent, device);
+  const uiPromise = hdShared.createDeferred(promiseEvent, device);
 
   _uiPromises.push(uiPromise);
 
@@ -18875,7 +18844,7 @@ const init = (settings, Transport) => __awaiter(void 0, void 0, void 0, function
     try {
       yield DataManager.load(settings);
       initTransport(Transport);
-    } catch (_c) {
+    } catch (_b) {
       Log.error('DataManager.load error');
     }
 
@@ -18916,14 +18885,12 @@ __webpack_unused_export__ = DEFAULT_PRIORITY;
 __webpack_unused_export__ = DEVICE;
 __webpack_unused_export__ = DEVICE_EVENT;
 __webpack_unused_export__ = DataManager;
-exports.Sg = errors;
 exports.Bg = IFRAME;
 __webpack_unused_export__ = RESPONSE_EVENT;
 exports.rF = UI_EVENT;
 __webpack_unused_export__ = UI_REQUEST$1;
 __webpack_unused_export__ = UI_RESPONSE;
 __webpack_unused_export__ = corsValidator;
-exports.Ue = create;
 __webpack_unused_export__ = createDeviceMessage;
 exports.xG = createErrorMessage;
 __webpack_unused_export__ = createIFrameMessage;
@@ -18949,6 +18916,7 @@ __webpack_unused_export__ = isValidVersionString;
 __webpack_unused_export__ = normalizeVersionArray;
 exports._4 = parseConnectSettings;
 exports.kW = parseMessage;
+__webpack_unused_export__ = safeThrowError;
 __webpack_unused_export__ = versionCompare;
 __webpack_unused_export__ = versionSplit;
 
@@ -19973,6 +19941,249 @@ exports["default"] = index;
 
 /***/ }),
 
+/***/ 8402:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+}
+
+function createDeferred(arg, data) {
+  let localResolve = _t => {};
+
+  let localReject = _e => {};
+
+  let id;
+  const promise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+    localResolve = resolve;
+    localReject = reject;
+
+    if (typeof arg === 'function') {
+      try {
+        yield arg();
+      } catch (error) {
+        reject(error);
+      }
+    }
+
+    if (typeof arg === 'string') id = arg;
+  }));
+  return {
+    id,
+    data,
+    resolve: localResolve,
+    reject: localReject,
+    promise
+  };
+}
+
+function fillStringWithArguments(value, object) {
+  return value.replace(/\{([^}]+)\}/g, (_, arg) => object[arg] || '?');
+}
+
+class HardwareError extends Error {
+  constructor(hardwareError) {
+    var _a;
+
+    super();
+    this.errorCode = HardwareErrorCode.UnknownError;
+    this.message = '';
+    const errorMessageMapping = HardwareErrorCodeMessage;
+    this.message = errorMessageMapping[HardwareErrorCode.UnknownError];
+
+    if (typeof hardwareError === 'string') {
+      this.errorCode = HardwareErrorCode.UnknownError;
+      this.message = hardwareError;
+    } else {
+      const message = (_a = hardwareError.message || errorMessageMapping[hardwareError.errorCode]) !== null && _a !== void 0 ? _a : '';
+
+      if (message) {
+        this.message = fillStringWithArguments(message, hardwareError);
+      }
+
+      this.errorCode = hardwareError.errorCode;
+    }
+
+    this.name = 'HardwareError';
+  }
+
+}
+
+const HardwareErrorCode = {
+  UnknownError: 0,
+  DeviceFwException: 101,
+  DeviceUnexpectedMode: 102,
+  DeviceListNotInitialized: 103,
+  SelectDevice: 104,
+  DeviceNotFound: 105,
+  DeviceInitializeFailed: 106,
+  DeviceInterruptedFromOutside: 107,
+  NotInitialized: 200,
+  IFrameNotInitialized: 300,
+  IFrameAleradyInitialized: 301,
+  IFrameLoadFail: 302,
+  IframeTimeout: 303,
+  IframeBlocked: 304,
+  CallMethodError: 400,
+  CallMethodNotResponse: 404,
+  CallMethodInvalidParameter: 405,
+  FirmwareUpdateDownloadFailed: 406,
+  NetworkError: 500,
+  TransportNotConfigured: 600,
+  TransportCallInProgress: 601,
+  TransportNotFound: 602,
+  TransportInvalidProtobuf: 603,
+  BleScanError: 700,
+  BlePermissionError: 701,
+  BleLocationError: 702,
+  BleRequiredUUID: 703,
+  BleConnectedError: 704,
+  BleDeviceNotBonded: 705,
+  BleServiceNotFound: 706,
+  BleCharacteristicNotFound: 707,
+  BleMonitorError: 708,
+  RuntimeError: 800,
+  PinInvalid: 801,
+  PinCancelled: 802,
+  ActionCancelled: 803,
+  FirmwareError: 804
+};
+const HardwareErrorCodeMessage = {
+  [HardwareErrorCode.UnknownError]: 'Unknown error occurred. Check message property.',
+  [HardwareErrorCode.DeviceFwException]: 'Firmware version mismatch',
+  [HardwareErrorCode.DeviceUnexpectedMode]: 'Device unexpected mode',
+  [HardwareErrorCode.DeviceListNotInitialized]: 'Device list is not initialized',
+  [HardwareErrorCode.SelectDevice]: 'Please select the connected device',
+  [HardwareErrorCode.DeviceNotFound]: 'Device not found',
+  [HardwareErrorCode.DeviceInitializeFailed]: 'Device initialization failed',
+  [HardwareErrorCode.DeviceInterruptedFromOutside]: 'Device interrupted',
+  [HardwareErrorCode.NotInitialized]: 'Not initialized',
+  [HardwareErrorCode.IFrameNotInitialized]: 'IFrame not initialized',
+  [HardwareErrorCode.IFrameAleradyInitialized]: 'IFrame alerady initialized',
+  [HardwareErrorCode.IFrameLoadFail]: 'IFrame load fail',
+  [HardwareErrorCode.IframeTimeout]: 'init iframe time out',
+  [HardwareErrorCode.IframeBlocked]: 'IFrame blocked',
+  [HardwareErrorCode.CallMethodError]: 'Runtime errors during method execution',
+  [HardwareErrorCode.CallMethodNotResponse]: 'Method does not responding',
+  [HardwareErrorCode.CallMethodInvalidParameter]: 'Call method invalid parameter',
+  [HardwareErrorCode.FirmwareUpdateDownloadFailed]: 'Firmware update download failed',
+  [HardwareErrorCode.NetworkError]: 'Network request error',
+  [HardwareErrorCode.TransportNotConfigured]: 'Transport not configured',
+  [HardwareErrorCode.TransportCallInProgress]: 'Transport call in progress',
+  [HardwareErrorCode.TransportNotFound]: 'Transport not found',
+  [HardwareErrorCode.TransportInvalidProtobuf]: 'Transport invalid protobuf',
+  [HardwareErrorCode.BleScanError]: 'BLE scan error',
+  [HardwareErrorCode.BlePermissionError]: 'Bluetooth required to be turned on',
+  [HardwareErrorCode.BleLocationError]: 'Device is not authorized to use BluetoothLE',
+  [HardwareErrorCode.BleRequiredUUID]: 'uuid is required',
+  [HardwareErrorCode.BleConnectedError]: 'connected error is always runtime error',
+  [HardwareErrorCode.BleDeviceNotBonded]: 'device is not bonded',
+  [HardwareErrorCode.BleServiceNotFound]: 'BLEServiceNotFound: service not found',
+  [HardwareErrorCode.BleCharacteristicNotFound]: 'BLEServiceNotFound: service not found',
+  [HardwareErrorCode.BleMonitorError]: 'Monitor Error: characteristic not found',
+  [HardwareErrorCode.RuntimeError]: 'Runtime error',
+  [HardwareErrorCode.PinInvalid]: 'Pin invalid',
+  [HardwareErrorCode.PinCancelled]: 'Pin cancelled',
+  [HardwareErrorCode.ActionCancelled]: 'Action cancelled by user',
+  [HardwareErrorCode.FirmwareError]: 'Firmware installation failed'
+};
+
+const TypedError = (hardwareError, message) => {
+  if (typeof hardwareError === 'string') {
+    return new HardwareError(hardwareError);
+  }
+
+  return new HardwareError({
+    errorCode: hardwareError,
+    message: message !== null && message !== void 0 ? message : ''
+  });
+};
+
+const serializeError = payload => {
+  if (payload && payload.error instanceof HardwareError) {
+    return {
+      error: payload.error.message,
+      code: payload.error.errorCode
+    };
+  }
+
+  if (payload && payload.error instanceof Error) {
+    return {
+      error: payload.error.message,
+      code: payload.error.code
+    };
+  }
+
+  return payload;
+};
+
+var HardwareError$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  HardwareError: HardwareError,
+  HardwareErrorCode: HardwareErrorCode,
+  HardwareErrorCodeMessage: HardwareErrorCodeMessage,
+  TypedError: TypedError,
+  serializeError: serializeError
+});
+exports.ERRORS = HardwareError$1;
+exports.HardwareError = HardwareError;
+exports.HardwareErrorCode = HardwareErrorCode;
+exports.HardwareErrorCodeMessage = HardwareErrorCodeMessage;
+exports.TypedError = TypedError;
+exports.createDeferred = createDeferred;
+exports.serializeError = serializeError;
+
+/***/ }),
+
 /***/ 5766:
 /***/ ((__unused_webpack_module, exports) => {
 
@@ -42190,6 +42401,8 @@ var events = __webpack_require__(2699);
 var events_default = /*#__PURE__*/__webpack_require__.n(events);
 // EXTERNAL MODULE: ../core/dist/index.js
 var dist = __webpack_require__(5890);
+// EXTERNAL MODULE: ../shared/dist/index.js
+var shared_dist = __webpack_require__(8402);
 ;// CONCATENATED MODULE: ./src/utils/urlUtils.ts
 const getOrigin = url => {
   if (typeof url !== 'string') return 'unknown';
@@ -42205,12 +42418,12 @@ const getOrigin = url => {
 
 let instance;
 let origin;
-let initPromise = (0,dist/* create */.Ue)();
+let initPromise = (0,shared_dist.createDeferred)();
 let timeout = 0;
 /* eslint-disable import/no-mutable-exports */
 
 const init = async settings => {
-  initPromise = (0,dist/* create */.Ue)();
+  initPromise = (0,shared_dist.createDeferred)();
   const existedFrame = document.getElementById('onekey-connect');
 
   if (existedFrame) {
@@ -42233,14 +42446,14 @@ const init = async settings => {
   instance.setAttribute('src', src);
   origin = getOrigin(instance.src);
   timeout = window.setTimeout(() => {
-    initPromise.reject(dist/* ERRORS.TypedError */.Sg.TypedError('Init_IframeTimeout'));
+    initPromise.reject(shared_dist.ERRORS.TypedError(shared_dist.HardwareErrorCode.IframeTimeout));
   }, 10000);
 
   const onLoad = () => {
     var _instance$contentWind;
 
     if (!instance) {
-      initPromise.reject(dist/* ERRORS.TypedError */.Sg.TypedError('Init_IframeBlocked'));
+      initPromise.reject(shared_dist.ERRORS.TypedError(shared_dist.HardwareErrorCode.IframeBlocked));
       return;
     }
 
@@ -44479,6 +44692,7 @@ const sendMessage = async (messages, isHost = true) => {
 
 
 
+
 const eventEmitter = new (events_default())();
 const src_Log = (0,dist/* initLog */.KR)('@onekey/connect');
 
@@ -44514,7 +44728,7 @@ const src_dispose = () => {
 
 const uiResponse = response => {
   if (!instance) {
-    throw dist/* ERRORS.TypedError */.Sg.TypedError('Init_NotInitialized');
+    throw shared_dist.ERRORS.TypedError(shared_dist.HardwareErrorCode.IFrameNotInitialized);
   }
 
   const {
@@ -44566,7 +44780,7 @@ const createJSBridge = messageEvent => {
 
 const src_init = async settings => {
   if (instance) {
-    throw dist/* ERRORS.TypedError */.Sg.TypedError('Init_AlreadyInitialized');
+    throw shared_dist.ERRORS.TypedError(shared_dist.HardwareErrorCode.IFrameAleradyInitialized);
   }
 
   _settings = (0,dist/* parseConnectSettings */._4)({ ..._settings,
@@ -44600,7 +44814,7 @@ const call = async params => {
   }
 
   if (timeout) {
-    return (0,dist/* createErrorMessage */.xG)(dist/* ERRORS.TypedError */.Sg.TypedError('Init_IframeLoadFail'));
+    return (0,dist/* createErrorMessage */.xG)(shared_dist.ERRORS.TypedError(shared_dist.HardwareErrorCode.IFrameLoadFail));
   }
 
   try {
@@ -44614,7 +44828,7 @@ const call = async params => {
       return response;
     }
 
-    return (0,dist/* createErrorMessage */.xG)(dist/* ERRORS.TypedError */.Sg.TypedError('Call_NotResponse'));
+    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);