@onekeyfe/hd-core 0.1.41 → 0.1.44

package/dist/index.js

@@ -1,10 +1,10 @@
 import semver from 'semver';
 import { ERRORS, HardwareErrorCode, HardwareError, serializeError, createDeferred } from '@onekeyfe/hd-shared';
+import { FailureType, EthereumDataType, StellarMemoType } from '@onekeyfe/hd-transport';
+export { Messages as PROTO } from '@onekeyfe/hd-transport';
 import axios from 'axios';
 import BigNumber from 'bignumber.js';
 import sha256 from 'js-sha256';
-import { EthereumDataType } from '@onekeyfe/hd-transport';
-export { Messages as PROTO } from '@onekeyfe/hd-transport';
 
 const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
     const api = {
@@ -67,6 +67,17 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
         stellarSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'stellarSignTransaction' })),
         firmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdate' })),
         requestWebUsbDevice: () => call({ method: 'requestWebUsbDevice' }),
+        tronGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tronGetAddress' })),
+        tronSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tronSignMessage' })),
+        tronSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tronSignTransaction' })),
+        confluxGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'confluxGetAddress' })),
+        confluxSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'confluxSignMessage' })),
+        confluxSignMessageCIP23: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'confluxSignMessageCIP23' })),
+        confluxSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'confluxSignTransaction' })),
+        nearGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'nearGetAddress' })),
+        nearSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'nearSignTransaction' })),
+        aptosGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'aptosGetAddress' })),
+        aptosSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'aptosSignTransaction' })),
     };
     return api;
 };
@@ -748,11 +759,12 @@ const getDeviceTypeByDeviceId = (deviceId) => {
     return 'classic';
 };
 const getDeviceUUID = (features) => {
+    var _a, _b;
     const deviceType = getDeviceType(features);
     if (deviceType === 'classic') {
-        return features.onekey_serial;
+        return (_a = features.onekey_serial) !== null && _a !== void 0 ? _a : '';
     }
-    return features.serial_no;
+    return (_b = features.serial_no) !== null && _b !== void 0 ? _b : '';
 };
 const getDeviceLabel = (features) => {
     const deviceType = getDeviceType(features);
@@ -811,6 +823,61 @@ const getPassphraseState = (features, commands) => __awaiter(void 0, void 0, voi
 });
 
 var nested = {
+	AptosGetAddress: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			show_display: {
+				type: "bool",
+				id: 2
+			}
+		}
+	},
+	AptosAddress: {
+		fields: {
+			address: {
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	AptosSignTx: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			raw_tx: {
+				rule: "required",
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	AptosSignedTx: {
+		fields: {
+			public_key: {
+				rule: "required",
+				type: "bytes",
+				id: 1
+			},
+			signature: {
+				rule: "required",
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
 	BinanceGetAddress: {
 		fields: {
 			address_n: {
@@ -3435,6 +3502,162 @@ var nested = {
 		fields: {
 		}
 	},
+	ConfluxGetAddress: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			show_display: {
+				type: "bool",
+				id: 2
+			},
+			chain_id: {
+				type: "uint32",
+				id: 3
+			}
+		}
+	},
+	ConfluxAddress: {
+		fields: {
+			address: {
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	ConfluxSignTx: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			nonce: {
+				type: "bytes",
+				id: 2
+			},
+			gas_price: {
+				type: "bytes",
+				id: 3
+			},
+			gas_limit: {
+				type: "bytes",
+				id: 4
+			},
+			to: {
+				type: "string",
+				id: 5
+			},
+			value: {
+				type: "bytes",
+				id: 6
+			},
+			epoch_height: {
+				type: "bytes",
+				id: 7
+			},
+			storage_limit: {
+				type: "bytes",
+				id: 8
+			},
+			data_initial_chunk: {
+				type: "bytes",
+				id: 9
+			},
+			data_length: {
+				type: "uint32",
+				id: 10
+			},
+			chain_id: {
+				type: "uint32",
+				id: 11
+			}
+		}
+	},
+	ConfluxTxRequest: {
+		fields: {
+			data_length: {
+				type: "uint32",
+				id: 1
+			},
+			signature_v: {
+				type: "uint32",
+				id: 2
+			},
+			signature_r: {
+				type: "bytes",
+				id: 3
+			},
+			signature_s: {
+				type: "bytes",
+				id: 4
+			}
+		}
+	},
+	ConfluxTxAck: {
+		fields: {
+			data_chunk: {
+				type: "bytes",
+				id: 1
+			}
+		}
+	},
+	ConfluxSignMessage: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			message: {
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	ConfluxMessageSignature: {
+		fields: {
+			signature: {
+				type: "bytes",
+				id: 2
+			},
+			address: {
+				type: "string",
+				id: 3
+			}
+		}
+	},
+	ConfluxSignMessageCIP23: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			domain_hash: {
+				type: "bytes",
+				id: 2
+			},
+			message_hash: {
+				type: "bytes",
+				id: 3
+			}
+		}
+	},
 	CipherKeyValue: {
 		fields: {
 			address_n: {
@@ -5121,6 +5344,10 @@ var nested = {
 			coin_switch: {
 				type: "uint32",
 				id: 517
+			},
+			build_id: {
+				type: "string",
+				id: 518
 			}
 		},
 		nested: {
@@ -6835,6 +7062,55 @@ var nested = {
 			}
 		}
 	},
+	NearGetAddress: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			show_display: {
+				type: "bool",
+				id: 2
+			}
+		}
+	},
+	NearAddress: {
+		fields: {
+			address: {
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	NearSignTx: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			raw_tx: {
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	NearSignedTx: {
+		fields: {
+			signature: {
+				rule: "required",
+				type: "bytes",
+				id: 1
+			}
+		}
+	},
 	NEMGetAddress: {
 		fields: {
 			address_n: {
@@ -7351,6 +7627,7 @@ var nested = {
 				}
 			},
 			raw_tx: {
+				rule: "required",
 				type: "bytes",
 				id: 2
 			}
@@ -8388,15 +8665,180 @@ var nested = {
 			}
 		}
 	},
-	WebAuthnListResidentCredentials: {
-		fields: {
-		}
-	},
-	WebAuthnAddResidentCredential: {
+	TronGetAddress: {
 		fields: {
-			credential_id: {
-				type: "bytes",
-				id: 1
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			show_display: {
+				type: "bool",
+				id: 2
+			}
+		}
+	},
+	TronAddress: {
+		fields: {
+			address: {
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	TronSignTx: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			ref_block_bytes: {
+				rule: "required",
+				type: "bytes",
+				id: 2
+			},
+			ref_block_hash: {
+				rule: "required",
+				type: "bytes",
+				id: 3
+			},
+			expiration: {
+				rule: "required",
+				type: "uint64",
+				id: 4
+			},
+			data: {
+				type: "string",
+				id: 5
+			},
+			contract: {
+				rule: "required",
+				type: "TronContract",
+				id: 6
+			},
+			timestamp: {
+				rule: "required",
+				type: "uint64",
+				id: 7
+			},
+			fee_limit: {
+				type: "uint64",
+				id: 8
+			}
+		},
+		nested: {
+			TronContract: {
+				fields: {
+					transfer_contract: {
+						type: "TronTransferContract",
+						id: 2
+					},
+					trigger_smart_contract: {
+						type: "TronTriggerSmartContract",
+						id: 31
+					}
+				},
+				nested: {
+					TronTransferContract: {
+						fields: {
+							to_address: {
+								type: "string",
+								id: 2
+							},
+							amount: {
+								type: "uint64",
+								id: 3
+							}
+						}
+					},
+					TronTriggerSmartContract: {
+						fields: {
+							contract_address: {
+								type: "string",
+								id: 2
+							},
+							call_value: {
+								type: "uint64",
+								id: 3
+							},
+							data: {
+								type: "bytes",
+								id: 4
+							},
+							call_token_value: {
+								type: "uint64",
+								id: 5
+							},
+							asset_id: {
+								type: "uint64",
+								id: 6
+							}
+						}
+					}
+				}
+			}
+		}
+	},
+	TronSignedTx: {
+		fields: {
+			signature: {
+				rule: "required",
+				type: "bytes",
+				id: 1
+			},
+			serialized_tx: {
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	TronSignMessage: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			message: {
+				rule: "required",
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	TronMessageSignature: {
+		fields: {
+			address: {
+				rule: "required",
+				type: "bytes",
+				id: 1
+			},
+			signature: {
+				rule: "required",
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
+	WebAuthnListResidentCredentials: {
+		fields: {
+		}
+	},
+	WebAuthnAddResidentCredential: {
+		fields: {
+			credential_id: {
+				type: "bytes",
+				id: 1
 			}
 		}
 	},
@@ -8783,6 +9225,20 @@ var nested = {
 			MessageType_StarcoinSignMessage: 10306,
 			MessageType_StarcoinMessageSignature: 10307,
 			MessageType_StarcoinVerifyMessage: 10308,
+			MessageType_ConfluxGetAddress: 10401,
+			MessageType_ConfluxAddress: 10402,
+			MessageType_ConfluxSignTx: 10403,
+			MessageType_ConfluxTxRequest: 10404,
+			MessageType_ConfluxTxAck: 10405,
+			MessageType_ConfluxSignMessage: 10406,
+			MessageType_ConfluxSignMessageCIP23: 10407,
+			MessageType_ConfluxMessageSignature: 10408,
+			MessageType_ConfluxVerifyMessage: 10409,
+			MessageType_ConfluxVerifyMessageCIP23: 10410,
+			MessageType_AptosGetAddress: 10600,
+			MessageType_AptosAddress: 10601,
+			MessageType_AptosSignTx: 10602,
+			MessageType_AptosSignedTx: 10603,
 			MessageType_WebAuthnListResidentCredentials: 800,
 			MessageType_WebAuthnCredentials: 801,
 			MessageType_WebAuthnAddResidentCredential: 802,
@@ -8806,6 +9262,16 @@ var nested = {
 			MessageType_EthereumSignMessageEIP712: 10200,
 			MessageType_GetPublicKeyMultiple: 10210,
 			MessageType_PublicKeyMultiple: 10211,
+			MessageType_TronGetAddress: 10501,
+			MessageType_TronAddress: 10502,
+			MessageType_TronSignTx: 10503,
+			MessageType_TronSignedTx: 10504,
+			MessageType_TronSignMessage: 10505,
+			MessageType_TronMessageSignature: 10506,
+			MessageType_NearGetAddress: 10701,
+			MessageType_NearAddress: 10702,
+			MessageType_NearSignTx: 10703,
+			MessageType_NearSignedTx: 10704,
 			MessageType_DeviceInfoSettings: 10001,
 			MessageType_GetDeviceInfo: 10002,
 			MessageType_DeviceInfo: 10003,
@@ -10427,19 +10893,19 @@ class DeviceCommands {
             const { code } = res.message;
             const { message } = res.message;
             let error = null;
-            if (code === 'Failure_FirmwareError' && !message) {
+            if (code === FailureType.Failure_FirmwareError && !message) {
                 error = ERRORS.TypedError(HardwareErrorCode.FirmwareError);
             }
-            if (code === 'Failure_ActionCancelled') {
+            if (code === FailureType.Failure_ActionCancelled) {
                 error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled);
             }
-            if (code === 'Failure_PinInvalid') {
+            if (code === FailureType.Failure_PinInvalid) {
                 error = ERRORS.TypedError(HardwareErrorCode.PinInvalid, message);
             }
-            if (code === 'Failure_PinCancelled') {
+            if (code === FailureType.Failure_PinCancelled) {
                 error = ERRORS.TypedError(HardwareErrorCode.PinCancelled);
             }
-            if (code === 'Failure_DataError' && message === 'Please confirm the BlindSign enabled') {
+            if (code === FailureType.Failure_DataError && message === 'Please confirm the BlindSign enabled') {
                 error = ERRORS.TypedError(HardwareErrorCode.BlindSignDisabled);
             }
             if (error) {
@@ -11113,7 +11579,8 @@ class BaseMethod {
             if (deviceType !== 'touch')
                 return;
             let checkFlag = false;
-            if (this.name === 'evmSignTransaction' && Number((_b = (_a = this.payload) === null || _a === void 0 ? void 0 : _a.transaction) === null || _b === void 0 ? void 0 : _b.chainId) !== 1) {
+            if (this.name === 'evmSignTransaction' &&
+                [3, 4, 5, 42].includes(Number((_b = (_a = this.payload) === null || _a === void 0 ? void 0 : _a.transaction) === null || _b === void 0 ? void 0 : _b.chainId))) {
                 checkFlag = true;
             }
             if (checkFlag && ((_c = this.device.features) === null || _c === void 0 ? void 0 : _c.safety_checks) === 'Strict') {
@@ -11161,68 +11628,191 @@ class GetFeatures extends BaseMethod {
     }
 }
 
-const hasHexPrefix = (str) => str.slice(0, 2).toLowerCase() === '0x';
-const stripHexPrefix = (str) => (hasHexPrefix(str) ? str.slice(2) : str);
-const addHexPrefix = (str) => (hasHexPrefix(str) ? str : `0x${str}`);
-const isHexString = (value, length) => {
-    if (typeof value !== 'string' || !value.match(/^(0x|0X)?[0-9A-Fa-f]*$/)) {
-        return false;
+class GetPassphraseState extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.useDevicePassphraseState = false;
     }
-    if (length && value.length !== 2 + 2 * length) {
-        return false;
+    run() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device.features)
+                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
+            let { features } = this.device;
+            const locked = ((_b = (_a = this.device) === null || _a === void 0 ? void 0 : _a.features) === null || _b === void 0 ? void 0 : _b.unlocked) === true;
+            const passphraseState = yield getPassphraseState(this.device.features, this.device.commands);
+            const isModeT = getDeviceType(features) === 'touch' || getDeviceType(features) === 'pro';
+            if (isModeT && locked) {
+                const { message } = yield this.device.commands.typedCall('GetFeatures', 'Features', {});
+                features = message;
+            }
+            if (features && features.passphrase_protection === true) {
+                return Promise.resolve(passphraseState);
+            }
+            return Promise.resolve(undefined);
+        });
     }
-    return true;
-};
-const stripHexStartZeroes = (str) => {
-    while (/^00/.test(str)) {
-        str = str.slice(2);
+}
+
+class CheckBridgeStatus$1 extends BaseMethod {
+    init() {
+        this.useDevice = false;
+        this.useDevicePassphraseState = false;
     }
-    return str;
-};
-const modifyValues = (object, transformer) => Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transformer(value, key)]));
-const formatAnyHex = value => {
-    if (typeof value === 'string') {
-        let stripped = stripHexPrefix(value);
-        if (stripped.length % 2 !== 0) {
-            stripped = `0${stripped}`;
-        }
-        return stripped;
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logs = getLog();
+            return Promise.resolve(logs);
+        });
     }
-    if (Array.isArray(value)) {
-        return value.map(formatAnyHex);
+}
+
+class CheckFirmwareRelease extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
     }
-    if (typeof value === 'object') {
-        return modifyValues(value, value => formatAnyHex(value));
+    run() {
+        if (this.device.features) {
+            const releaseInfo = getFirmwareReleaseInfo(this.device.features);
+            return Promise.resolve(releaseInfo);
+        }
+        return Promise.resolve(null);
     }
-    return value;
-};
+}
 
-const invalidParameter = (message) => ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
-const validateParams = (values, fields) => {
-    fields.forEach(field => {
-        const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
-        if (!existsProp && field.required) {
-            throw invalidParameter(`Missing required parameter: ${field.name}`);
+class CheckBLEFirmwareRelease extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+        this.checkDeviceId = true;
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        if (this.device.features) {
+            const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+            return Promise.resolve(releaseInfo);
         }
-        const value = values[field.name];
-        if (value && field.type) {
-            switch (field.type) {
-                case 'array':
-                    if (!Array.isArray(value)) {
-                        throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [${field.type}].`);
-                    }
-                    else if (!field.allowEmpty && value.length < 1) {
-                        throw invalidParameter(`Parameter "${field.name}" is empty.`);
-                    }
-                    break;
-                case 'bigNumber':
-                    if (typeof value !== 'string') {
-                        throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
-                    }
-                    try {
-                        const bn = new BigNumber(value);
-                        if (bn.toFixed(0) !== value) {
-                            throw new Error('');
+        return Promise.resolve(null);
+    }
+}
+
+class CheckTransportRelease extends BaseMethod {
+    init() {
+        this.useDevice = false;
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = TransportManager.getTransport();
+            const localVersion = yield transport.init();
+            const response = DataManager.getTransportStatus(localVersion);
+            return Promise.resolve(response);
+        });
+    }
+}
+
+class CheckBridgeStatus extends BaseMethod {
+    init() {
+        this.useDevice = false;
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                axios
+                    .request({
+                    url: 'http://localhost:21320',
+                    method: 'POST',
+                    withCredentials: false,
+                    timeout: 3000,
+                })
+                    .then(() => resolve(true))
+                    .catch(e => {
+                    if (e.code === 'ECONNABORTED') {
+                        reject(ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError));
+                    }
+                    else {
+                        resolve(false);
+                    }
+                });
+            });
+        });
+    }
+}
+
+class DeviceBackup extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('BackupDevice', 'Success');
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+const hasHexPrefix = (str) => str.slice(0, 2).toLowerCase() === '0x';
+const stripHexPrefix = (str) => (hasHexPrefix(str) ? str.slice(2) : str);
+const addHexPrefix = (str) => (hasHexPrefix(str) ? str : `0x${str}`);
+const isHexString = (value, length) => {
+    if (typeof value !== 'string' || !value.match(/^(0x|0X)?[0-9A-Fa-f]*$/)) {
+        return false;
+    }
+    if (length && value.length !== 2 + 2 * length) {
+        return false;
+    }
+    return true;
+};
+const stripHexStartZeroes = (str) => {
+    while (/^00/.test(str)) {
+        str = str.slice(2);
+    }
+    return str;
+};
+const modifyValues = (object, transformer) => Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transformer(value, key)]));
+const formatAnyHex = value => {
+    if (typeof value === 'string') {
+        let stripped = stripHexPrefix(value);
+        if (stripped.length % 2 !== 0) {
+            stripped = `0${stripped}`;
+        }
+        return stripped;
+    }
+    if (Array.isArray(value)) {
+        return value.map(formatAnyHex);
+    }
+    if (typeof value === 'object') {
+        return modifyValues(value, value => formatAnyHex(value));
+    }
+    return value;
+};
+
+const invalidParameter = (message) => ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, message);
+const validateParams = (values, fields) => {
+    fields.forEach(field => {
+        const existsProp = Object.prototype.hasOwnProperty.call(values, field.name);
+        if (!existsProp && field.required) {
+            throw invalidParameter(`Missing required parameter: ${field.name}`);
+        }
+        const value = values[field.name];
+        if (value && field.type) {
+            switch (field.type) {
+                case 'array':
+                    if (!Array.isArray(value)) {
+                        throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [${field.type}].`);
+                    }
+                    else if (!field.allowEmpty && value.length < 1) {
+                        throw invalidParameter(`Parameter "${field.name}" is empty.`);
+                    }
+                    break;
+                case 'bigNumber':
+                    if (typeof value !== 'string') {
+                        throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
+                    }
+                    try {
+                        const bn = new BigNumber(value);
+                        if (bn.toFixed(0) !== value) {
+                            throw new Error('');
                         }
                     }
                     catch (error) {
@@ -11247,8 +11837,404 @@ const validateParams = (values, fields) => {
                     break;
             }
         }
-    });
-};
+    });
+};
+
+class DeviceChangePin extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+        validateParams(this.payload, [{ name: 'remove', type: 'boolean' }]);
+        this.params = {
+            remove: this.payload.remove,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('ChangePin', 'Success', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DeviceFlags extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+        validateParams(this.payload, [{ name: 'flags', type: 'number' }]);
+        this.params = {
+            flags: this.payload.flags,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('ApplyFlags', 'Success', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DeviceRebootToBootloader extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+    }
+    getVersionRange() {
+        return {
+            classic: {
+                min: '2.1.11',
+            },
+            mini: {
+                min: '2.1.11',
+            },
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('RebootToBootloader', 'Success');
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DeviceRecovery extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+        validateParams(this.payload, [
+            { name: 'wordCount', type: 'number' },
+            { name: 'passphraseProtection', type: 'boolean' },
+            { name: 'pinProtection', type: 'boolean' },
+            { name: 'language', type: 'string' },
+            { name: 'label', type: 'string' },
+            { name: 'enforceWordlist', type: 'boolean' },
+            { name: 'type', type: 'object' },
+            { name: 'u2fCounter', type: 'number' },
+            { name: 'dryRun', type: 'boolean' },
+        ]);
+        this.params = {
+            word_count: this.payload.wordCount,
+            passphrase_protection: this.payload.passphraseProtection,
+            pin_protection: this.payload.pinProtection,
+            language: this.payload.language,
+            label: this.payload.label,
+            enforce_wordlist: this.payload.enforceWordlist,
+            type: this.payload.type,
+            u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
+            dry_run: this.payload.dryRun,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('RecoveryDevice', 'Success', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DeviceReset extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+        validateParams(this.payload, [
+            { name: 'displayRandom', type: 'boolean' },
+            { name: 'strength', type: 'number' },
+            { name: 'passphraseProtection', type: 'boolean' },
+            { name: 'pinProtection', type: 'boolean' },
+            { name: 'language', type: 'string' },
+            { name: 'label', type: 'string' },
+            { name: 'u2fCounter', type: 'number' },
+            { name: 'skipBackup', type: 'boolean' },
+            { name: 'noBackup', type: 'boolean' },
+            { name: 'backupType' },
+        ]);
+        this.params = {
+            display_random: this.payload.displayRandom,
+            strength: this.payload.strength || 256,
+            passphrase_protection: this.payload.passphraseProtection,
+            pin_protection: this.payload.pinProtection,
+            language: this.payload.language,
+            label: this.payload.label,
+            u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
+            skip_backup: this.payload.skipBackup,
+            no_backup: this.payload.noBackup,
+            backup_type: this.payload.backupType,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('ResetDevice', 'Success', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DeviceSettings extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+        validateParams(this.payload, [
+            { name: 'language', type: 'string' },
+            { name: 'label', type: 'string' },
+            { name: 'usePassphrase', type: 'boolean' },
+            { name: 'homescreen', type: 'string' },
+            { name: 'passphraseSource', type: 'number' },
+            { name: 'autoLockDelayMs', type: 'number' },
+            { name: 'displayRotation', type: 'number' },
+            { name: 'passphraseAlwaysOnDevice', type: 'boolean' },
+            { name: 'safetyChecks', type: 'number' },
+            { name: 'experimentalFeatures', type: 'boolean' },
+        ]);
+        this.params = {
+            language: this.payload.language,
+            label: this.payload.label,
+            use_passphrase: this.payload.usePassphrase,
+            homescreen: this.payload.homescreen,
+            _passphrase_source: this.payload.passphraseSource,
+            auto_lock_delay_ms: this.payload.autoLockDelayMs,
+            display_rotation: this.payload.displayRotation,
+            passphrase_always_on_device: this.payload.passphraseAlwaysOnDevice,
+            safety_checks: this.payload.safetyChecks,
+            experimental_features: this.payload.experimentalFeatures,
+        };
+    }
+    getVersionRange() {
+        if (this.payload.usePassphrase) {
+            return {
+                model_mini: {
+                    min: '2.4.0',
+                },
+            };
+        }
+        return {};
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('ApplySettings', 'Success', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DeviceUpdateReboot extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('BixinReboot', 'Success');
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DeviceSupportFeatures extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        if (!this.device.features)
+            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not initialized'));
+        const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+        return Promise.resolve({
+            inputPinOnSoftware,
+            device: this.device.toMessageObject(),
+        });
+    }
+}
+
+class DeviceVerify extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+        validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);
+        this.params = {
+            data: formatAnyHex(this.payload.dataHex),
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const deviceType = getDeviceType(this.device.features);
+            let response;
+            if (deviceType === 'classic') {
+                const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign(Object.assign({}, this.params), { data: sha256.sha256(this.params.data) }));
+                response = res.message;
+            }
+            else {
+                const signatureRes = yield this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', {
+                    message: this.params.data,
+                });
+                const certRes = yield this.device.commands.typedCall('ReadSEPublicCert', 'SEPublicCert');
+                response = {
+                    cert: certRes.message.public_cert,
+                    signature: signatureRes.message.signature,
+                };
+            }
+            if (response)
+                return Promise.resolve(response);
+            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not support verify'));
+        });
+    }
+}
+
+class DeviceWipe extends BaseMethod {
+    init() {
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('WipeDevice', 'Success');
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+const getBinary = ({ features, updateType, version }) => __awaiter(void 0, void 0, void 0, function* () {
+    const releaseInfo = getInfo({ features, updateType });
+    if (!releaseInfo) {
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no firmware found for this device');
+    }
+    if (version &&
+        !semver.eq(releaseInfo.version, version)) {
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware version mismatch');
+    }
+    const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
+    let fw;
+    try {
+        fw = yield httpRequest(url, 'binary');
+    }
+    catch (_a) {
+        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
+    }
+    return Object.assign(Object.assign({}, releaseInfo), { binary: fw });
+});
+const getInfo = ({ features, updateType }) => {
+    var _a, _b, _c;
+    const deviceType = getDeviceType(features);
+    const { deviceMap } = DataManager;
+    const releaseInfo = (_c = (_b = (_a = deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap[deviceType]) === null || _a === void 0 ? void 0 : _a[updateType]) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
+    return releaseInfo;
+};
+
+const postConfirmationMessage = (device) => {
+    var _a;
+    if ((_a = device.features) === null || _a === void 0 ? void 0 : _a.firmware_present) {
+        device.emit(DEVICE.BUTTON, device, { code: 'ButtonRequest_FirmwareUpdate' });
+    }
+};
+const postProgressMessage = (device, progress, postMessage) => {
+    postMessage(createUiMessage(UI_REQUEST$1.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        progress,
+    }));
+};
+const uploadFirmware = (updateType, typedCall, postMessage, device, { payload }) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    if (((_a = device.features) === null || _a === void 0 ? void 0 : _a.major_version) === 1) {
+        postConfirmationMessage(device);
+        const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
+        yield typedCall(eraseCommand, 'Success', {});
+        postProgressMessage(device, 0, postMessage);
+        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) {
+        postConfirmationMessage(device);
+        const length = payload.byteLength;
+        let response = yield typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
+        while (response.type !== 'Success') {
+            const start = response.message.offset;
+            const end = response.message.offset + response.message.length;
+            const chunk = payload.slice(start, end);
+            if (start > 0) {
+                postProgressMessage(device, Math.round((start / length) * 100), postMessage);
+            }
+            response = yield typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
+                payload: chunk,
+            });
+        }
+        postProgressMessage(device, 100, postMessage);
+        return response.message;
+    }
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
+});
+
+class FirmwareUpdate extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
+        this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
+        this.useDevicePassphraseState = false;
+        const { payload } = this;
+        validateParams(payload, [
+            { name: 'version', type: 'array' },
+            { name: 'binary', type: 'buffer' },
+        ]);
+        if (!payload.updateType) {
+            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
+        }
+        this.params = { updateType: payload.updateType };
+        if ('version' in payload) {
+            this.params = Object.assign(Object.assign({}, this.params), { version: payload.version });
+        }
+        if ('binary' in payload) {
+            this.params = Object.assign(Object.assign({}, this.params), { binary: payload.binary });
+        }
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { device, params } = this;
+            let binary;
+            try {
+                if (params.binary) {
+                    binary = this.params.binary;
+                }
+                else {
+                    if (!device.features) {
+                        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no features found for this device');
+                    }
+                    const firmware = yield getBinary({
+                        features: device.features,
+                        version: params.version,
+                        updateType: params.updateType,
+                    });
+                    binary = firmware.binary;
+                }
+            }
+            catch (err) {
+                throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, (_a = err.message) !== null && _a !== void 0 ? _a : err);
+            }
+            return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: binary });
+        });
+    }
+}
+
+const Log$2 = getLogger(LoggerNames.Method);
+class RequestWebUsbDevice extends BaseMethod {
+    init() {
+        this.useDevice = false;
+        this.useDevicePassphraseState = false;
+    }
+    run() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield TransportManager.configure();
+            const env = DataManager.getSettings('env');
+            if (env !== 'webusb') {
+                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Not webusb environment'));
+            }
+            try {
+                const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
+                const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
+                const { deviceList } = yield DevicePool.getDevices(devicesDescriptor);
+                if (deviceList.length > 0) {
+                    return { device: deviceList[0].toMessageObject() };
+                }
+                return yield Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+            }
+            catch (error) {
+                Log$2.debug(error);
+                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
+            }
+        });
+    }
+}
 
 class CipherKeyValue extends BaseMethod {
     constructor() {
@@ -11973,419 +12959,298 @@ class BTCSignTransaction extends BaseMethod {
                 { name: 'extra_data', type: 'string' },
                 { name: 'timestamp', type: 'number' },
                 { name: 'version_group_id', type: 'number' },
-            ]);
-        });
-        this.payload.inputs.forEach((input) => {
-            validatePath(input.address_n);
-            const useAmount = isSegwitPath(input.address_n);
-            validateParams(input, [
-                { name: 'prev_hash', type: 'hexString', required: true },
-                { name: 'prev_index', type: 'number', required: true },
-                { name: 'script_type', type: 'string' },
-                { name: 'amount', type: 'string', required: useAmount },
-                { name: 'sequence', type: 'number' },
-                { name: 'multisig', type: 'object' },
-            ]);
-        });
-        this.payload.outputs.forEach((output) => {
-            validateParams(output, [
-                { name: 'address_n', type: 'array' },
-                { name: 'address', type: 'string' },
-                { name: 'amount', type: 'string' },
-                { name: 'op_return_data', type: 'string' },
-                { name: 'multisig', type: 'object' },
-            ]);
-            if (Object.prototype.hasOwnProperty.call(output, 'address_n') &&
-                Object.prototype.hasOwnProperty.call(output, 'address')) {
-                throw ERRORS.TypedError(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 ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
-            }
-        });
-        const { inputs, outputs, refTxs, account, coin } = this.payload;
-        const coinName = getCoinInfo(undefined, coin).name;
-        this.params = {
-            inputs,
-            outputs,
-            refTxs,
-            addresses: account ? account.addresses : undefined,
-            options: {
-                lock_time: this.payload.locktime,
-                timestamp: this.payload.timestamp,
-                version: this.payload.version,
-                expiry: this.payload.expiry,
-                overwintered: this.payload.overwintered,
-                version_group_id: this.payload.versionGroupId,
-                branch_id: this.payload.branchId,
-            },
-            coinName,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { device, params } = this;
-            const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
-            const { refTxs } = params;
-            const signTxMethod = !useLegacySignProcess ? signtx : signtxLegacy;
-            const response = yield signTxMethod(device.commands.typedCall.bind(device.commands), params.inputs, params.outputs, refTxs, params.options, params.coinName);
-            return response;
-        });
-    }
-}
-
-class BTCVerifyMessage extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
-        validateParams(this.payload, [
-            { name: 'address', type: 'string', required: true },
-            { name: 'messageHex', type: 'hexString', required: true },
-            { name: 'signature', type: 'hexString', required: true },
-            { name: 'coin', type: 'string', required: true },
-        ]);
-        const { coin } = this.payload;
-        const { address, messageHex, signature } = formatAnyHex(this.payload);
-        const coinName = getCoinInfo(undefined, coin).name;
-        this.params = {
-            address,
-            message: messageHex,
-            signature,
-            coin_name: coinName,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('VerifyMessage', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class CheckFirmwareRelease extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        if (this.device.features) {
-            const releaseInfo = getFirmwareReleaseInfo(this.device.features);
-            return Promise.resolve(releaseInfo);
-        }
-        return Promise.resolve(null);
-    }
-}
-
-class CheckBLEFirmwareRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.checkDeviceId = true;
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        if (this.device.features) {
-            const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
-            return Promise.resolve(releaseInfo);
-        }
-        return Promise.resolve(null);
-    }
-}
-
-class CheckTransportRelease extends BaseMethod {
-    init() {
-        this.useDevice = false;
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const transport = TransportManager.getTransport();
-            const localVersion = yield transport.init();
-            const response = DataManager.getTransportStatus(localVersion);
-            return Promise.resolve(response);
-        });
-    }
-}
-
-class CheckBridgeStatus$1 extends BaseMethod {
-    init() {
-        this.useDevice = false;
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                axios
-                    .request({
-                    url: 'http://localhost:21320',
-                    method: 'POST',
-                    withCredentials: false,
-                    timeout: 3000,
-                })
-                    .then(() => resolve(true))
-                    .catch(e => {
-                    if (e.code === 'ECONNABORTED') {
-                        reject(ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError));
-                    }
-                    else {
-                        resolve(false);
-                    }
-                });
-            });
+            ]);
         });
-    }
-}
-
-class DeviceBackup extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('BackupDevice', 'Success');
-            return Promise.resolve(res.message);
+        this.payload.inputs.forEach((input) => {
+            validatePath(input.address_n);
+            const useAmount = isSegwitPath(input.address_n);
+            validateParams(input, [
+                { name: 'prev_hash', type: 'hexString', required: true },
+                { name: 'prev_index', type: 'number', required: true },
+                { name: 'script_type', type: 'string' },
+                { name: 'amount', type: 'string', required: useAmount },
+                { name: 'sequence', type: 'number' },
+                { name: 'multisig', type: 'object' },
+            ]);
         });
-    }
-}
-
-class DeviceChangePin extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        validateParams(this.payload, [{ name: 'remove', type: 'boolean' }]);
-        this.params = {
-            remove: this.payload.remove,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ChangePin', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
+        this.payload.outputs.forEach((output) => {
+            validateParams(output, [
+                { name: 'address_n', type: 'array' },
+                { name: 'address', type: 'string' },
+                { name: 'amount', type: 'string' },
+                { name: 'op_return_data', type: 'string' },
+                { name: 'multisig', type: 'object' },
+            ]);
+            if (Object.prototype.hasOwnProperty.call(output, 'address_n') &&
+                Object.prototype.hasOwnProperty.call(output, 'address')) {
+                throw ERRORS.TypedError(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 ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, `Output change script_type should be set to ${scriptType}`);
+            }
         });
-    }
-}
-
-class DeviceFlags extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        validateParams(this.payload, [{ name: 'flags', type: 'number' }]);
+        const { inputs, outputs, refTxs, account, coin } = this.payload;
+        const coinName = getCoinInfo(undefined, coin).name;
         this.params = {
-            flags: this.payload.flags,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ApplyFlags', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceRebootToBootloader extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-    }
-    getVersionRange() {
-        return {
-            classic: {
-                min: '2.1.11',
-            },
-            mini: {
-                min: '2.1.11',
+            inputs,
+            outputs,
+            refTxs,
+            addresses: account ? account.addresses : undefined,
+            options: {
+                lock_time: this.payload.locktime,
+                timestamp: this.payload.timestamp,
+                version: this.payload.version,
+                expiry: this.payload.expiry,
+                overwintered: this.payload.overwintered,
+                version_group_id: this.payload.versionGroupId,
+                branch_id: this.payload.branchId,
             },
+            coinName,
         };
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('RebootToBootloader', 'Success');
-            return Promise.resolve(res.message);
+            const { device, params } = this;
+            const useLegacySignProcess = device.unavailableCapabilities.replaceTransaction;
+            const { refTxs } = params;
+            const signTxMethod = !useLegacySignProcess ? signtx : signtxLegacy;
+            const response = yield signTxMethod(device.commands.typedCall.bind(device.commands), params.inputs, params.outputs, refTxs, params.options, params.coinName);
+            return response;
         });
     }
 }
 
-class DeviceRecovery extends BaseMethod {
+class BTCVerifyMessage extends BaseMethod {
     init() {
-        this.useDevicePassphraseState = false;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
         validateParams(this.payload, [
-            { name: 'wordCount', type: 'number' },
-            { name: 'passphraseProtection', type: 'boolean' },
-            { name: 'pinProtection', type: 'boolean' },
-            { name: 'language', type: 'string' },
-            { name: 'label', type: 'string' },
-            { name: 'enforceWordlist', type: 'boolean' },
-            { name: 'type', type: 'object' },
-            { name: 'u2fCounter', type: 'number' },
-            { name: 'dryRun', type: 'boolean' },
+            { name: 'address', type: 'string', required: true },
+            { name: 'messageHex', type: 'hexString', required: true },
+            { name: 'signature', type: 'hexString', required: true },
+            { name: 'coin', type: 'string', required: true },
         ]);
+        const { coin } = this.payload;
+        const { address, messageHex, signature } = formatAnyHex(this.payload);
+        const coinName = getCoinInfo(undefined, coin).name;
         this.params = {
-            word_count: this.payload.wordCount,
-            passphrase_protection: this.payload.passphraseProtection,
-            pin_protection: this.payload.pinProtection,
-            language: this.payload.language,
-            label: this.payload.label,
-            enforce_wordlist: this.payload.enforceWordlist,
-            type: this.payload.type,
-            u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
-            dry_run: this.payload.dryRun,
+            address,
+            message: messageHex,
+            signature,
+            coin_name: coinName,
         };
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('RecoveryDevice', 'Success', Object.assign({}, this.params));
+            const res = yield this.device.commands.typedCall('VerifyMessage', 'Success', Object.assign({}, this.params));
             return Promise.resolve(res.message);
         });
     }
 }
 
-class DeviceReset extends BaseMethod {
+class ConfluxGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
     init() {
-        this.useDevicePassphraseState = false;
-        validateParams(this.payload, [
-            { name: 'displayRandom', type: 'boolean' },
-            { name: 'strength', type: 'number' },
-            { name: 'passphraseProtection', type: 'boolean' },
-            { name: 'pinProtection', type: 'boolean' },
-            { name: 'language', type: 'string' },
-            { name: 'label', type: 'string' },
-            { name: 'u2fCounter', type: 'number' },
-            { name: 'skipBackup', type: 'boolean' },
-            { name: 'noBackup', type: 'boolean' },
-            { name: 'backupType' },
-        ]);
-        this.params = {
-            display_random: this.payload.displayRandom,
-            strength: this.payload.strength || 256,
-            passphrase_protection: this.payload.passphraseProtection,
-            pin_protection: this.payload.pinProtection,
-            language: this.payload.language,
-            label: this.payload.label,
-            u2f_counter: this.payload.u2fCounter || Math.floor(Date.now() / 1000),
-            skip_backup: this.payload.skipBackup,
-            no_backup: this.payload.noBackup,
-            backup_type: this.payload.backupType,
+        var _a;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'chainId', type: 'number' },
+                { name: 'showOnOneKey', type: 'boolean' },
+            ]);
+            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+            this.params.push({
+                address_n: addressN,
+                chain_id: batch.chainId,
+                show_display: showOnOneKey,
+            });
+        });
+    }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
         };
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ResetDevice', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('ConfluxGetAddress', 'ConfluxAddress', Object.assign({}, param));
+                responses.push(Object.assign({ path: serializedPath(param.address_n) }, res.message));
+            }
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
         });
     }
 }
 
-class DeviceSettings extends BaseMethod {
+class ConfluxSignMessage extends BaseMethod {
     init() {
-        this.useDevicePassphraseState = false;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
         validateParams(this.payload, [
-            { name: 'language', type: 'string' },
-            { name: 'label', type: 'string' },
-            { name: 'usePassphrase', type: 'boolean' },
-            { name: 'homescreen', type: 'string' },
-            { name: 'passphraseSource', type: 'number' },
-            { name: 'autoLockDelayMs', type: 'number' },
-            { name: 'displayRotation', type: 'number' },
-            { name: 'passphraseAlwaysOnDevice', type: 'boolean' },
-            { name: 'safetyChecks', type: 'number' },
-            { name: 'experimentalFeatures', type: 'boolean' },
+            { name: 'path', required: true },
+            { name: 'messageHex', type: 'hexString', required: true },
         ]);
+        const { path, messageHex } = this.payload;
+        const addressN = validatePath(path, 3);
         this.params = {
-            language: this.payload.language,
-            label: this.payload.label,
-            use_passphrase: this.payload.usePassphrase,
-            homescreen: this.payload.homescreen,
-            _passphrase_source: this.payload.passphraseSource,
-            auto_lock_delay_ms: this.payload.autoLockDelayMs,
-            display_rotation: this.payload.displayRotation,
-            passphrase_always_on_device: this.payload.passphraseAlwaysOnDevice,
-            safety_checks: this.payload.safetyChecks,
-            experimental_features: this.payload.experimentalFeatures,
+            address_n: addressN,
+            message: formatAnyHex(messageHex),
         };
     }
     getVersionRange() {
-        if (this.payload.usePassphrase) {
-            return {
-                model_mini: {
-                    min: '2.4.0',
-                },
-            };
-        }
-        return {};
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ApplySettings', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceUpdateReboot extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('BixinReboot', 'Success');
+            const res = yield this.device.commands.typedCall('ConfluxSignMessage', 'ConfluxMessageSignature', Object.assign({}, this.params));
             return Promise.resolve(res.message);
         });
     }
 }
 
-class DeviceSupportFeatures extends BaseMethod {
+class ConfluxSignMessageCIP23 extends BaseMethod {
     init() {
-        this.useDevicePassphraseState = false;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'domainHash', type: 'hexString', required: true },
+            { name: 'messageHash', type: 'hexString', required: true },
+        ]);
+        const { path, domainHash, messageHash } = this.payload;
+        const addressN = validatePath(path, 3);
+        this.params = {
+            address_n: addressN,
+            domain_hash: formatAnyHex(domainHash),
+            message_hash: formatAnyHex(messageHash),
+        };
+    }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
     }
     run() {
-        if (!this.device.features)
-            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not initialized'));
-        const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
-        return Promise.resolve({
-            inputPinOnSoftware,
-            device: this.device.toMessageObject(),
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('ConfluxSignMessageCIP23', 'ConfluxMessageSignature', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
         });
     }
 }
 
-class DeviceVerify extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);
-        this.params = {
-            data: formatAnyHex(this.payload.dataHex),
-        };
+const cutString = (str, cutLen) => {
+    if (!str) {
+        return ['', ''];
     }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const deviceType = getDeviceType(this.device.features);
-            let response;
-            if (deviceType === 'classic') {
-                const res = yield this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign(Object.assign({}, this.params), { data: sha256.sha256(this.params.data) }));
-                response = res.message;
-            }
-            else {
-                const signatureRes = yield this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', {
-                    message: this.params.data,
+    const first = str.slice(0, cutLen);
+    const second = str.slice(cutLen);
+    return [first, second];
+};
+
+class ConfluxSignTransaction extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.addressN = [];
+        this.processTxRequest = (request, data) => __awaiter(this, void 0, void 0, function* () {
+            if (!request.data_length) {
+                const v = request.signature_v;
+                const r = request.signature_r;
+                const s = request.signature_s;
+                if (v == null || r == null || s == null) {
+                    throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'sign transaction failed');
+                }
+                return Promise.resolve({
+                    v: `0x${v.toString(16)}`,
+                    r: `0x${r}`,
+                    s: `0x${s}`,
                 });
-                const certRes = yield this.device.commands.typedCall('ReadSEPublicCert', 'SEPublicCert');
-                response = {
-                    cert: certRes.message.public_cert,
-                    signature: signatureRes.message.signature,
-                };
             }
-            if (response)
-                return Promise.resolve(response);
-            return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not support verify'));
+            const [first, rest] = cutString(data, request.data_length * 2);
+            const response = yield this.device.commands.typedCall('ConfluxTxAck', 'ConfluxTxRequest', {
+                data_chunk: first,
+            });
+            return this.processTxRequest(response.message, rest);
+        });
+        this.evmSignTx = (addressN, tx) => __awaiter(this, void 0, void 0, function* () {
+            const { to, value, gasPrice, gasLimit, nonce, data, chainId, epochHeight, storageLimit } = tx;
+            const length = data == null ? 0 : data.length / 2;
+            const [first, rest] = cutString(data, 1024 * 2);
+            let message = {
+                address_n: addressN,
+                nonce: stripHexStartZeroes(nonce),
+                gas_price: stripHexStartZeroes(gasPrice),
+                gas_limit: stripHexStartZeroes(gasLimit),
+                to,
+                value: stripHexStartZeroes(value),
+                epoch_height: stripHexStartZeroes(epochHeight),
+                storage_limit: stripHexStartZeroes(storageLimit),
+                chain_id: chainId,
+            };
+            if (length !== 0) {
+                message = Object.assign(Object.assign({}, message), { data_length: length, data_initial_chunk: first });
+            }
+            const response = yield this.device.commands.typedCall('ConfluxSignTx', 'ConfluxTxRequest', message);
+            return this.processTxRequest(response.message, rest);
         });
     }
-}
-
-class DeviceWipe extends BaseMethod {
     init() {
-        this.useDevicePassphraseState = false;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'transaction', type: 'object', required: true },
+        ]);
+        const { path, transaction } = this.payload;
+        this.addressN = validatePath(path, 3);
+        const tx = transaction;
+        const schema = [
+            { name: 'to', type: 'hexString', required: true },
+            { name: 'value', type: 'hexString', required: true },
+            { name: 'gasLimit', type: 'hexString', required: true },
+            { name: 'gasPrice', type: 'hexString', required: true },
+            { name: 'nonce', type: 'hexString', required: true },
+            { name: 'epochHeight', type: 'hexString', required: true },
+            { name: 'storageLimit', type: 'hexString', required: true },
+            { name: 'chainId', type: 'number', required: true },
+            { name: 'data', type: 'hexString' },
+        ];
+        validateParams(tx, schema);
+        this.formattedTx = formatAnyHex(tx);
+    }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('WipeDevice', 'Success');
-            return Promise.resolve(res.message);
+            const { addressN, formattedTx } = this;
+            if (formattedTx == null) {
+                throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'ConfluxSignTransaction: format tx error');
+            }
+            const signedTx = yield this.evmSignTx(addressN, formattedTx);
+            return Promise.resolve(signedTx);
         });
     }
 }
@@ -12529,15 +13394,6 @@ class EVMSignMessageEIP712 extends BaseMethod {
     }
 }
 
-const cutString = (str, cutLen) => {
-    if (!str) {
-        return ['', ''];
-    }
-    const first = str.slice(0, cutLen);
-    const second = str.slice(cutLen);
-    return [first, second];
-};
-
 class EVMSignTransaction extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -13622,8 +14478,11 @@ class StellarSignTransaction extends BaseMethod {
             { name: 'networkPassphrase', type: 'string', required: true },
             { name: 'transaction', type: 'object', required: true },
         ]);
-        const addressN = validatePath(this.payload.path, 3);
         const { transaction, networkPassphrase } = this.payload;
+        if (!transaction.timebounds) {
+            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'timebounds is required');
+        }
+        const addressN = validatePath(this.payload.path, 3);
         this.params = {
             address_n: addressN,
             network_passphrase: networkPassphrase,
@@ -13631,11 +14490,10 @@ class StellarSignTransaction extends BaseMethod {
             fee: transaction.fee,
             sequence_number: transaction.sequence,
             num_operations: transaction.operations.length,
+            memo_type: StellarMemoType.NONE,
+            timebounds_start: transaction.timebounds.minTime,
+            timebounds_end: transaction.timebounds.maxTime,
         };
-        if (transaction.timebounds) {
-            this.params.timebounds_start = transaction.timebounds.minTime;
-            this.params.timebounds_end = transaction.timebounds.maxTime;
-        }
         if (transaction.memo) {
             this.params.memo_type = transaction.memo.type;
             this.params.memo_text = transaction.memo.text;
@@ -13659,195 +14517,306 @@ 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 ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no firmware found for this device');
+class TronGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
     }
-    if (version &&
-        !semver.eq(releaseInfo.version, version)) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware version mismatch');
+    init() {
+        var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnOneKey', type: 'boolean' },
+            ]);
+            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+            this.params.push({
+                address_n: addressN,
+                show_display: showOnOneKey,
+            });
+        });
     }
-    const url = updateType === 'ble' ? releaseInfo.webUpdate : releaseInfo.url;
-    let fw;
-    try {
-        fw = yield httpRequest(url, 'binary');
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
     }
-    catch (_a) {
-        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Method_FirmwareUpdate_DownloadFailed');
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('TronGetAddress', 'TronAddress', Object.assign({}, param));
+                const { address } = res.message;
+                responses.push({
+                    path: serializedPath(param.address_n),
+                    address,
+                });
+            }
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
+        });
     }
-    return Object.assign(Object.assign({}, releaseInfo), { binary: fw });
-});
-const getInfo = ({ features, updateType }) => {
-    var _a, _b, _c;
-    const deviceType = getDeviceType(features);
-    const { deviceMap } = DataManager;
-    const releaseInfo = (_c = (_b = (_a = deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap[deviceType]) === null || _a === void 0 ? void 0 : _a[updateType]) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : null;
-    return releaseInfo;
-};
+}
 
-const postConfirmationMessage = (device) => {
-    var _a;
-    if ((_a = device.features) === null || _a === void 0 ? void 0 : _a.firmware_present) {
-        device.emit(DEVICE.BUTTON, device, { code: 'ButtonRequest_FirmwareUpdate' });
-    }
-};
-const postProgressMessage = (device, progress, postMessage) => {
-    postMessage(createUiMessage(UI_REQUEST$1.FIRMWARE_PROGRESS, {
-        device: device.toMessageObject(),
-        progress,
-    }));
-};
-const uploadFirmware = (updateType, typedCall, postMessage, device, { payload }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    if (((_a = device.features) === null || _a === void 0 ? void 0 : _a.major_version) === 1) {
-        postConfirmationMessage(device);
-        const eraseCommand = updateType === 'firmware' ? 'FirmwareErase' : 'FirmwareErase_ex';
-        yield typedCall(eraseCommand, 'Success', {});
-        postProgressMessage(device, 0, postMessage);
-        const { message } = yield typedCall('FirmwareUpload', 'Success', {
-            payload,
-        });
-        postProgressMessage(device, 100, postMessage);
-        return message;
+class TronSignMessage extends BaseMethod {
+    init() {
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'messageHex', type: 'hexString', required: true },
+        ]);
+        const { path, messageHex } = this.payload;
+        const addressN = validatePath(path, 3);
+        this.params = {
+            address_n: addressN,
+            message: stripHexPrefix(messageHex),
+        };
     }
-    if (((_b = device.features) === null || _b === void 0 ? void 0 : _b.major_version) === 2) {
-        postConfirmationMessage(device);
-        const length = payload.byteLength;
-        let response = yield typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
-        while (response.type !== 'Success') {
-            const start = response.message.offset;
-            const end = response.message.offset + response.message.length;
-            const chunk = payload.slice(start, end);
-            if (start > 0) {
-                postProgressMessage(device, Math.round((start / length) * 100), postMessage);
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.device.commands.typedCall('TronSignMessage', 'TronMessageSignature', Object.assign({}, this.params));
+            return Promise.resolve(response.message);
+        });
+    }
+}
+
+class TronSignTransaction extends BaseMethod {
+    parseTx(tx, address_n) {
+        const unSignTx = {
+            address_n,
+            data: tx.data,
+            timestamp: tx.timestamp,
+            fee_limit: tx.feeLimit,
+            ref_block_bytes: tx.refBlockBytes,
+            ref_block_hash: tx.refBlockHash,
+            expiration: tx.expiration,
+            contract: {},
+        };
+        if (tx.contract) {
+            if (tx.contract.transferContract) {
+                unSignTx.contract = {
+                    transfer_contract: {
+                        to_address: tx.contract.transferContract.toAddress,
+                        amount: tx.contract.transferContract.amount,
+                    },
+                };
+            }
+            if (tx.contract.triggerSmartContract) {
+                unSignTx.contract = {
+                    trigger_smart_contract: {
+                        contract_address: tx.contract.triggerSmartContract.contractAddress,
+                        call_value: tx.contract.triggerSmartContract.callValue,
+                        data: tx.contract.triggerSmartContract.data,
+                        call_token_value: tx.contract.triggerSmartContract.callTokenValue,
+                        asset_id: tx.contract.triggerSmartContract.assetId,
+                    },
+                };
             }
-            response = yield typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
-                payload: chunk,
-            });
         }
-        postProgressMessage(device, 100, postMessage);
-        return response.message;
+        return unSignTx;
     }
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown major_version');
-});
-
-class FirmwareUpdate extends BaseMethod {
     init() {
-        this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.INITIALIZE];
-        this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
-        this.useDevicePassphraseState = false;
-        const { payload } = this;
-        validateParams(payload, [
-            { name: 'version', type: 'array' },
-            { name: 'binary', type: 'buffer' },
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'transaction', type: 'object', required: true },
         ]);
-        if (!payload.updateType) {
-            throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
-        }
-        this.params = { updateType: payload.updateType };
-        if ('version' in payload) {
-            this.params = Object.assign(Object.assign({}, this.params), { version: payload.version });
-        }
-        if ('binary' in payload) {
-            this.params = Object.assign(Object.assign({}, this.params), { binary: payload.binary });
-        }
+        const { path, transaction } = this.payload;
+        const addressN = validatePath(path, 3);
+        validateParams(transaction, [
+            { name: 'refBlockBytes', type: 'hexString', required: true },
+            { name: 'refBlockHash', type: 'hexString', required: true },
+            { name: 'expiration', type: 'number', required: true },
+            { name: 'timestamp', type: 'number', required: true },
+            { name: 'contract', type: 'object', required: true },
+        ]);
+        this.params = this.parseTx(formatAnyHex(transaction), addressN);
+    }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
     }
     run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.device.commands.typedCall('TronSignTx', 'TronSignedTx', Object.assign({}, this.params));
+            return Promise.resolve(response.message);
+        });
+    }
+}
+
+class NearGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
+    init() {
         var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnOneKey', type: 'boolean' },
+            ]);
+            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+            this.params.push({
+                address_n: addressN,
+                show_display: showOnOneKey,
+            });
+        });
+    }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
+    }
+    run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { device, params } = this;
-            let binary;
-            try {
-                if (params.binary) {
-                    binary = this.params.binary;
-                }
-                else {
-                    if (!device.features) {
-                        throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'no features found for this device');
-                    }
-                    const firmware = yield getBinary({
-                        features: device.features,
-                        version: params.version,
-                        updateType: params.updateType,
-                    });
-                    binary = firmware.binary;
-                }
-            }
-            catch (err) {
-                throw ERRORS.TypedError(HardwareErrorCode.FirmwareUpdateDownloadFailed, (_a = err.message) !== null && _a !== void 0 ? _a : err);
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('NearGetAddress', 'NearAddress', Object.assign({}, param));
+                const { address } = res.message;
+                responses.push({
+                    path: serializedPath(param.address_n),
+                    address,
+                });
             }
-            return uploadFirmware(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, { payload: binary });
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
         });
     }
 }
 
-const Log$2 = getLogger(LoggerNames.Method);
-class RequestWebUsbDevice extends BaseMethod {
+class NearSignTransaction extends BaseMethod {
     init() {
-        this.useDevice = false;
-        this.useDevicePassphraseState = false;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'rawTx', type: 'hexString', required: true },
+        ]);
+        const { path, rawTx } = this.payload;
+        const addressN = validatePath(path, 3);
+        this.params = {
+            address_n: addressN,
+            raw_tx: formatAnyHex(rawTx),
+        };
+    }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
     }
     run() {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            yield TransportManager.configure();
-            const env = DataManager.getSettings('env');
-            if (env !== 'webusb') {
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Not webusb environment'));
-            }
-            try {
-                const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
-                const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
-                const { deviceList } = yield DevicePool.getDevices(devicesDescriptor);
-                if (deviceList.length > 0) {
-                    return { device: deviceList[0].toMessageObject() };
-                }
-                return yield Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
-            }
-            catch (error) {
-                Log$2.debug(error);
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Please select the device to connect'));
-            }
+            const res = yield this.device.commands.typedCall('NearSignTx', 'NearSignedTx', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
         });
     }
 }
 
-class GetPassphraseState extends BaseMethod {
+class AptosGetAddress extends BaseMethod {
+    constructor() {
+        super(...arguments);
+        this.hasBundle = false;
+    }
     init() {
+        var _a;
+        this.checkDeviceId = true;
         this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
-        this.useDevicePassphraseState = false;
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = [];
+        payload.bundle.forEach((batch) => {
+            var _a;
+            const addressN = validatePath(batch.path, 3);
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'showOnOneKey', type: 'boolean' },
+            ]);
+            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
+            this.params.push({
+                address_n: addressN,
+                show_display: showOnOneKey,
+            });
+        });
     }
     run() {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device.features)
-                return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
-            let { features } = this.device;
-            const locked = ((_b = (_a = this.device) === null || _a === void 0 ? void 0 : _a.features) === null || _b === void 0 ? void 0 : _b.unlocked) === true;
-            const passphraseState = yield getPassphraseState(this.device.features, this.device.commands);
-            const isModeT = getDeviceType(features) === 'touch' || getDeviceType(features) === 'pro';
-            if (isModeT && locked) {
-                const { message } = yield this.device.commands.typedCall('GetFeatures', 'Features', {});
-                features = message;
-            }
-            if (features && features.passphrase_protection === true) {
-                return Promise.resolve(passphraseState);
+            const responses = [];
+            for (let i = 0; i < this.params.length; i++) {
+                const param = this.params[i];
+                const res = yield this.device.commands.typedCall('AptosGetAddress', 'AptosAddress', Object.assign({}, param));
+                const { address } = res.message;
+                responses.push({
+                    path: serializedPath(param.address_n),
+                    address,
+                });
             }
-            return Promise.resolve(undefined);
+            return Promise.resolve(this.hasBundle ? responses : responses[0]);
         });
     }
 }
 
-class CheckBridgeStatus extends BaseMethod {
+class AptosSignTransaction extends BaseMethod {
     init() {
-        this.useDevice = false;
-        this.useDevicePassphraseState = false;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'rawTx', type: 'hexString', required: true },
+        ]);
+        const { path, rawTx } = this.payload;
+        const addressN = validatePath(path, 3);
+        this.params = {
+            address_n: addressN,
+            raw_tx: formatAnyHex(rawTx),
+        };
+    }
+    getVersionRange() {
+        return {
+            model_mini: {
+                min: '2.4.0',
+            },
+        };
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logs = getLog();
-            return Promise.resolve(logs);
+            const res = yield this.device.commands.typedCall('AptosSignTx', 'AptosSignedTx', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
         });
     }
 }
@@ -13856,16 +14825,12 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     __proto__: null,
     searchDevices: SearchDevices,
     getFeatures: GetFeatures,
-    cipherKeyValue: CipherKeyValue,
-    btcGetAddress: BTCGetAddress,
-    btcGetPublicKey: BTCGetPublicKey,
-    btcSignMessage: BTCSignMessage,
-    btcSignTransaction: BTCSignTransaction,
-    btcVerifyMessage: BTCVerifyMessage,
+    getPassphraseState: GetPassphraseState,
+    getLogs: CheckBridgeStatus$1,
     checkFirmwareRelease: CheckFirmwareRelease,
     checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
     checkTransportRelease: CheckTransportRelease,
-    checkBridgeStatus: CheckBridgeStatus$1,
+    checkBridgeStatus: CheckBridgeStatus,
     deviceBackup: DeviceBackup,
     deviceChangePin: DeviceChangePin,
     deviceFlags: DeviceFlags,
@@ -13877,6 +14842,18 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     deviceSupportFeatures: DeviceSupportFeatures,
     deviceVerify: DeviceVerify,
     deviceWipe: DeviceWipe,
+    firmwareUpdate: FirmwareUpdate,
+    requestWebUsbDevice: RequestWebUsbDevice,
+    cipherKeyValue: CipherKeyValue,
+    btcGetAddress: BTCGetAddress,
+    btcGetPublicKey: BTCGetPublicKey,
+    btcSignMessage: BTCSignMessage,
+    btcSignTransaction: BTCSignTransaction,
+    btcVerifyMessage: BTCVerifyMessage,
+    confluxGetAddress: ConfluxGetAddress,
+    confluxSignMessage: ConfluxSignMessage,
+    confluxSignMessageCIP23: ConfluxSignMessageCIP23,
+    confluxSignTransaction: ConfluxSignTransaction,
     evmGetAddress: EvmGetAddress,
     evmGetPublicKey: EVMGetPublicKey,
     evmSignMessage: EVMSignMessage$2,
@@ -13895,10 +14872,13 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     solSignTransaction: SolSignTransaction,
     stellarGetAddress: StellarGetAddress,
     stellarSignTransaction: StellarSignTransaction,
-    firmwareUpdate: FirmwareUpdate,
-    requestWebUsbDevice: RequestWebUsbDevice,
-    getPassphraseState: GetPassphraseState,
-    getLogs: CheckBridgeStatus
+    tronGetAddress: TronGetAddress,
+    tronSignMessage: TronSignMessage,
+    tronSignTransaction: TronSignTransaction,
+    nearGetAddress: NearGetAddress,
+    nearSignTransaction: NearSignTransaction,
+    aptosGetAddress: AptosGetAddress,
+    aptosSignTransaction: AptosSignTransaction
 });
 
 function findMethod(message) {
@@ -14452,6 +15432,7 @@ const removeUiPromise = (promise) => {
 };
 class Core extends events.exports {
     handleMessage(message) {
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             switch (message.type) {
                 case UI_RESPONSE.RECEIVE_PIN: {
@@ -14469,7 +15450,11 @@ class Core extends events.exports {
                 }
                 case IFRAME.CALL: {
                     const response = yield callAPI(message);
-                    return response;
+                    const { success, payload } = response;
+                    if (success) {
+                        return response;
+                    }
+                    return Object.assign(Object.assign({}, response), { payload: Object.assign(Object.assign({}, payload), { connectId: (_b = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.connectId) !== null && _b !== void 0 ? _b : '', deviceId: (_d = (_c = message.payload) === null || _c === void 0 ? void 0 : _c.deviceId) !== null && _d !== void 0 ? _d : '' }) });
                 }
                 case IFRAME.CANCEL: {
                     cancel(message.payload.connectId);