@onekeyfe/hd-core 0.1.4 → 0.1.7

package/dist/index.js

@@ -3,9 +3,10 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var semver = require('semver');
-var hdTransport = require('@onekeyfe/hd-transport');
+var hdShared = require('@onekeyfe/hd-shared');
 var axios = require('axios');
 var BigNumber = require('bignumber.js');
+var hdTransport = require('@onekeyfe/hd-transport');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -605,48 +606,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;',
@@ -804,33 +763,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';
@@ -902,8 +834,8 @@ const getDeviceBLEFirmwareVersion = (features) => {
 const HD_HARDENED = 0x80000000;
 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('/');
     if (parts[0] !== 'm')
@@ -9941,7 +9873,7 @@ class TransportManager {
                 this.currentMessages = messages;
             }
             catch (error) {
-                throw TypedError('Transport_InvalidProtobuf', error.message);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportInvalidProtobuf, `Transport_InvalidProtobuf:  ${error.message}`);
             }
         });
     }
@@ -9983,13 +9915,16 @@ const parseMessage = (messageData) => {
     }
     return message;
 };
-const createErrorMessage = (error) => ({
-    success: false,
-    payload: {
-        error: error.message,
-        code: error.code,
-    },
-});
+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 = {
@@ -10025,7 +9960,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 = {
@@ -10065,7 +10000,7 @@ const createDeviceMessage = (type, payload) => ({
 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}`);
     }
 };
 const Log$4 = initLog('DeviceCommands');
@@ -10104,7 +10039,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);
             try {
@@ -10127,14 +10062,24 @@ class DeviceCommands {
         console.log('_filterCommonTypes: ', res);
         if (res.type === 'Failure') {
             const { code } = res.message;
-            let { message } = res.message;
+            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') {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ActionCancelled);
             }
-            if (code === 'Failure_ActionCancelled' && !message) {
-                message = 'Action cancelled by user';
+            if (code === 'Failure_PinInvalid') {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinInvalid, message);
             }
-            return Promise.reject(new OnekeyError(code || 'Failure_UnknownCode', message || 'Failure_UnknownMessage'));
+            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') {
             return Promise.resolve(res);
@@ -10178,7 +10123,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'));
             }
         });
     }
@@ -10455,7 +10400,7 @@ class Device extends events.exports {
         this.features = feat;
         this.featuresNeedsReload = false;
     }
-    updateDescriptor(descriptor) {
+    updateDescriptor(descriptor, forceUpdate = false) {
         const env = DataManager.getSettings('env');
         if (env === 'react-native') {
             return;
@@ -10465,11 +10410,14 @@ class Device extends events.exports {
         if (originalSession !== upcomingSession) {
             this.originalDescriptor.session = upcomingSession;
         }
+        if (forceUpdate) {
+            this.originalDescriptor = descriptor;
+        }
     }
     updateFromCache(device) {
         this.mainId = device.mainId;
         this.commands = device.commands;
-        this.updateDescriptor(device.originalDescriptor);
+        this.updateDescriptor(device.originalDescriptor, true);
         if (device.features) {
             this._updateFeatures(device.features);
         }
@@ -10481,7 +10429,7 @@ class Device extends events.exports {
                 Log$3.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
             }
             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;
         });
     }
@@ -10496,7 +10444,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}`));
                 }
             }
             if (options.keepSession) {
@@ -10522,7 +10470,7 @@ class Device extends events.exports {
             this.commands.dispose();
         }
         if (this.runPromise) {
-            this.runPromise.reject(TypedError('Device_Interrupted'));
+            this.runPromise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInterruptedFromOutside));
         }
     }
     getMode() {
@@ -10753,7 +10701,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 => {
         const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
@@ -11068,13 +11016,13 @@ 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);
         }
     }
     return coinInfo;
@@ -11228,49 +11176,49 @@ class BTCSignMessage extends BaseMethod {
 const requestPrevTxInfo$1 = ({ typedCall, txRequest: { request_type, details }, refTxs }) => {
     const { tx_hash } = 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}`);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXINPUT: ${tx_hash}`);
         return typedCall('TxAckPrevInput', 'TxRequest', {
             tx: { input: tx.inputs[details.request_index] },
         });
     }
     if (request_type === 'TXOUTPUT') {
         if (!tx.bin_outputs)
-            throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXOUTPUT: ${tx_hash}`);
+            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] },
         });
     }
     if (request_type === 'TXORIGINPUT') {
         if (!tx.outputs)
-            throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGINPUT: ${tx_hash}`);
         return typedCall('TxAckInput', 'TxRequest', {
             tx: { input: tx.inputs[details.request_index] },
         });
     }
     if (request_type === 'TXORIGOUTPUT') {
         if (!tx.outputs)
-            throw TypedError('Runtime', `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `requestPrevTxInfo: Requested unknown TXORIGOUTPUT: ${tx_hash}`);
         return typedCall('TxAckOutput', 'TxRequest', {
             tx: { output: tx.outputs[details.request_index] },
         });
     }
     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;
         const dataLen = details.extra_data_len;
@@ -11293,7 +11241,7 @@ const requestPrevTxInfo$1 = ({ typedCall, txRequest: { request_type, details },
         };
         return typedCall('TxAckPrevMeta', 'TxRequest', { tx: 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$1 = ({ typedCall, txRequest: { request_type, details }, inputs, outputs, }) => {
     if (request_type === 'TXINPUT') {
@@ -11305,12 +11253,12 @@ const requestSignedTxInfo$1 = ({ typedCall, txRequest: { request_type, details }
         });
     }
     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) => {
     const { tx_hash } = props.txRequest.details;
@@ -11328,7 +11276,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;
     }
@@ -11373,14 +11321,14 @@ var signtx = (typedCall, inputs, outputs, refTxsArray, options, coinName) => __a
 const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) => {
     const { tx_hash } = 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') {
         return { inputs: [tx.inputs[details.request_index]] };
@@ -11390,13 +11338,13 @@ const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) =>
     }
     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;
         const dataLen = details.extra_data_len;
@@ -11421,7 +11369,7 @@ const requestPrevTxInfo = ({ txRequest: { request_type, details }, refTxs, }) =>
         }
         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 = ({ txRequest: { request_type, details }, inputs, outputs, }) => {
     if (request_type === 'TXINPUT') {
@@ -11431,12 +11379,12 @@ const requestSignedTxInfo = ({ txRequest: { request_type, details }, inputs, out
         return { outputs: [outputs[details.request_index]] };
     }
     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) => {
     const { tx_hash } = props.txRequest.details;
@@ -11454,7 +11402,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;
     }
@@ -11548,12 +11496,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}`);
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
             }
         });
         const { inputs, outputs, refTxs, account, coin } = this.payload;
@@ -12003,7 +11951,7 @@ class EVMSignTransaction extends BaseMethod {
                 const r = request.signature_r;
                 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) {
                     v += 2 * chain_id + 35;
@@ -12143,7 +12091,7 @@ class EVMSignTypedData extends BaseMethod {
                 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');
             }
         }
     }
@@ -12168,7 +12116,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 { addressN } = this.params;
             const deviceType = getDeviceType(this.device.features);
@@ -12195,7 +12143,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'));
         });
     }
 }
@@ -12576,7 +12524,7 @@ class NEMSignTransaction extends BaseMethod {
                     message.supply_change = this.supplyChangeMessage(transaction);
                     break;
                 default:
-                    throw TypedError('Method_InvalidParameter', 'Unknown transaction type');
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unknown transaction type');
             }
             return message;
         };
@@ -12909,14 +12857,20 @@ class StellarSignTransaction extends BaseMethod {
 const getBinary = ({ features, updateType, version }) => __awaiter(void 0, void 0, void 0, function* () {
     const releaseInfo = getInfo({ features, updateType });
     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 });
 });
 const getInfo = ({ features, updateType }) => {
@@ -12949,6 +12903,7 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload })
         const { message } = yield typedCall('FirmwareUpload', 'Success', {
             payload,
         });
+        postProgressMessage(device, 100, postMessage);
         return message;
     }
     if (((_b = device.features) === null || _b === void 0 ? void 0 : _b.major_version) === 2) {
@@ -12969,7 +12924,7 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload })
         postProgressMessage(device, 100, postMessage);
         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 {
@@ -12982,7 +12937,7 @@ class FirmwareUpdate extends BaseMethod {
             { name: 'binary', type: 'buffer' },
         ]);
         if (!payload.updateType) {
-            throw TypedError('Method_InvalidParameter', 'updateType is required');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
         }
         this.params = { updateType: payload.updateType };
         if ('version' in payload) {
@@ -13002,7 +12957,7 @@ class FirmwareUpdate extends BaseMethod {
                 }
                 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({
                         features: device.features,
@@ -13013,7 +12968,7 @@ class FirmwareUpdate extends BaseMethod {
                 }
             }
             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, { payload: binary });
         });
@@ -13066,15 +13021,24 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
 function findMethod(message) {
     const { method } = 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];
     if (MethodConstructor) {
         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);
 });
@@ -13140,7 +13104,7 @@ class DeviceConnector {
                 return diff;
             }
             catch (error) {
-                throw new Error(error);
+                safeThrowError(error);
             }
         });
     }
@@ -13196,7 +13160,7 @@ class DeviceConnector {
                 return res;
             }
             catch (error) {
-                throw new Error(error);
+                safeThrowError(error);
             }
         });
     }
@@ -13207,7 +13171,7 @@ class DeviceConnector {
                 return res;
             }
             catch (error) {
-                throw new Error(error);
+                safeThrowError(error);
             }
         });
     }
@@ -13226,9 +13190,9 @@ let _uiPromises = [];
 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;
     let messageResponse;
@@ -13247,10 +13211,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,
-            });
+            return createResponseMessage(method.responseID, false, { error });
         }
     }
     try {
@@ -13273,7 +13234,7 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
         return Promise.reject(error);
     }
     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);
@@ -13288,17 +13249,17 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
             if (versionRange && device.features) {
                 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) {
                 yield TransportManager.reconfigure(device.getFirmwareVersion());
@@ -13311,24 +13272,24 @@ const callAPI = (message) => __awaiter(void 0, void 0, void 0, function* () {
             }
             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);
             }
         });
         Log.debug('Call API - Device Run: ', device);
         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 {
@@ -13359,7 +13320,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;
     const allDevices = _deviceList.allDevices();
@@ -13370,17 +13331,17 @@ function initDevice(method) {
         [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;
     return device;
 }
 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) {
         return initDevice(method);
@@ -13444,7 +13405,7 @@ const postMessage = (message) => {
     _core.emit(CORE_EVENT, message);
 };
 const createUiPromise = (promiseEvent, device) => {
-    const uiPromise = create(promiseEvent, device);
+    const uiPromise = hdShared.createDeferred(promiseEvent, device);
     _uiPromises.push(uiPromise);
     return uiPromise;
 };
@@ -13501,7 +13462,7 @@ const init = (settings, Transport) => __awaiter(void 0, void 0, void 0, function
             yield DataManager.load(settings);
             initTransport(Transport);
         }
-        catch (_c) {
+        catch (_b) {
             Log.error('DataManager.load error');
         }
         enableLog(DataManager.getSettings('debug'));
@@ -13533,14 +13494,12 @@ exports.DEFAULT_PRIORITY = DEFAULT_PRIORITY;
 exports.DEVICE = DEVICE;
 exports.DEVICE_EVENT = DEVICE_EVENT;
 exports.DataManager = DataManager;
-exports.ERRORS = errors;
 exports.IFRAME = IFRAME;
 exports.RESPONSE_EVENT = RESPONSE_EVENT;
 exports.UI_EVENT = UI_EVENT;
 exports.UI_REQUEST = UI_REQUEST$1;
 exports.UI_RESPONSE = UI_RESPONSE;
 exports.corsValidator = corsValidator;
-exports.create = create;
 exports.createDeviceMessage = createDeviceMessage;
 exports.createErrorMessage = createErrorMessage;
 exports.createIFrameMessage = createIFrameMessage;
@@ -13566,5 +13525,6 @@ exports.isValidVersionString = isValidVersionString;
 exports.normalizeVersionArray = normalizeVersionArray;
 exports.parseConnectSettings = parseConnectSettings;
 exports.parseMessage = parseMessage;
+exports.safeThrowError = safeThrowError;
 exports.versionCompare = versionCompare;
 exports.versionSplit = versionSplit;