@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.58

package/dist/index.js

@@ -87,94 +87,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const TEST_API_METHOD_NAMES = [
-    'btcGetOwnershipId',
-    'btcGetOwnershipProof',
-    'btcAuthorizeCoinJoin',
-    'cryptoBatchGetPublickeys',
-    'cryptoCipherKeyValue',
-    'cryptoCosiCommit',
-    'cryptoCosiSign',
-    'cryptoGetECDHSessionKey',
-    'cryptoSignIdentity',
-    'evmGetAddressTrezor',
-    'evmGetPublicKeyTrezor',
-    'evmSignMessageTrezor',
-    'evmSignTransactionTrezor',
-    'evmSignTypedDataTrezor',
-    'evmVerifyMessageTrezor',
-    'nemDecryptMessage',
-    'deviceSpiFlashWrite',
-    'deviceSpiFlashRead',
-    'deviceInfoSettings',
-    'deviceGetInfo',
-    'deviceReadSEPublicCert',
-    'deviceWriteSEPrivateKey',
-    'deviceWriteSEPublicCert',
-    'deviceSESignMessage',
-    'devicePing',
-    'deviceGetEntropy',
-    'deviceGetFirmwareHash',
-    'deviceUnlockPath',
-    'deviceSdProtect',
-    'deviceChangeWipeCode',
-    'deviceEndSession',
-    'deviceLoad',
-    'deviceDoPreauthorized',
-    'deviceCancelAuthorization',
-    'emmcDirList',
-    'emmcDirMake',
-    'emmcDirRemove',
-    'emmcFileDelete',
-    'emmcFileRead',
-    'emmcFileWrite',
-    'emmcFixPermission',
-    'emmcPathInfo',
-    'debugLinkDecision',
-    'debugLinkEraseSdCard',
-    'debugLinkFlashErase',
-    'debugLinkGetState',
-    'debugLinkMemoryRead',
-    'debugLinkMemoryWrite',
-    'debugLinkRecordScreen',
-    'debugLinkReseedRandom',
-    'debugLinkStop',
-    'debugLinkWatchLayout',
-    'firmwareErase',
-    'firmwareEraseEx',
-    'firmwareUpdateEmmcTest',
-    'firmwareUploadTest',
-    'reboot',
-    'selfTest',
-    'tezosGetAddress',
-    'tezosGetPublicKey',
-    'tezosSignTx',
-    'moneroGetAddress',
-    'moneroGetWatchKey',
-    'eosGetPublicKey',
-    'eosSignTx',
-    'binanceGetAddress',
-    'binanceGetPublicKey',
-    'binanceSignTx',
-    'webAuthnAddResidentCredential',
-    'webAuthnListResidentCredentials',
-    'webAuthnRemoveResidentCredential',
-    'getPublicKeyMultiple',
-    'listResDir',
-    'nftWriteData',
-    'nftWriteInfo',
-    'readSEPublicKey',
-    'resourceUpdate',
-    'bixinBackupDevice',
-    'bixinLoadDevice',
-    'bixinMessageSE',
-    'bixinVerifyDeviceRequest',
-];
-const FACTORY_API_METHOD_NAMES = [
-    'deviceProvisionFactoryInfo',
-    'deviceWriteFactoryCertificate',
-];
-
 const callbackManager = new Map();
 const generateCallbackId = () => `callback_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 const registerCallback = (id, callback) => {
@@ -235,7 +147,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, updateSettings, swi
         switchTransport }, createCoreApi(protocolAwareCall.call));
     return api;
 };
-const createAllCoreApi = (call) => ({
+const createCoreApi = (call) => ({
     getLogs: () => call({ method: 'getLogs' }),
     clearSessionCache: params => call(Object.assign(Object.assign({}, params), { method: 'clearSessionCache' })),
     searchDevices: params => call(Object.assign(Object.assign({}, params), { method: 'searchDevices' })),
@@ -268,11 +180,6 @@ const createAllCoreApi = (call) => ({
     deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
     deviceReboot: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceReboot' })),
     deviceGetOnboardingStatus: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceGetOnboardingStatus' })),
-    deviceProvisionFactoryInfo: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceProvisionFactoryInfo' })),
-    deviceReadFactoryInfo: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceReadFactoryInfo' })),
-    deviceWriteFactoryCertificate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceWriteFactoryCertificate' })),
-    deviceReadFactoryCertificate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceReadFactoryCertificate' })),
-    deviceSignFactoryChallenge: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceSignFactoryChallenge' })),
     deviceUploadWallpaper: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceUploadWallpaper' })),
     deviceUploadNft: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceUploadNft' })),
     uploadPortfolio: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'uploadPortfolio' })),
@@ -315,27 +222,12 @@ const createAllCoreApi = (call) => ({
     evmSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmSignTransaction' })),
     evmSignTypedData: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmSignTypedData' })),
     evmVerifyMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmVerifyMessage' })),
-    evmGetAddressTrezor: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmGetAddressTrezor' })),
-    evmGetPublicKeyTrezor: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmGetPublicKeyTrezor' })),
-    evmSignMessageTrezor: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmSignMessageTrezor' })),
-    evmSignTransactionTrezor: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmSignTransactionTrezor' })),
-    evmSignTypedDataTrezor: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmSignTypedDataTrezor' })),
-    evmVerifyMessageTrezor: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'evmVerifyMessageTrezor' })),
     btcGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcGetAddress' })),
     btcGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcGetPublicKey' })),
     btcSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcSignMessage' })),
     btcSignPsbt: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcSignPsbt' })),
     btcSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcSignTransaction' })),
     btcVerifyMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcVerifyMessage' })),
-    btcGetOwnershipId: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcGetOwnershipId' })),
-    btcGetOwnershipProof: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcGetOwnershipProof' })),
-    btcAuthorizeCoinJoin: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'btcAuthorizeCoinJoin' })),
-    cryptoBatchGetPublickeys: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cryptoBatchGetPublickeys' })),
-    cryptoCipherKeyValue: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cryptoCipherKeyValue' })),
-    cryptoCosiCommit: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cryptoCosiCommit' })),
-    cryptoCosiSign: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cryptoCosiSign' })),
-    cryptoGetECDHSessionKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cryptoGetECDHSessionKey' })),
-    cryptoSignIdentity: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cryptoSignIdentity' })),
     starcoinGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'starcoinGetAddress' })),
     starcoinGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'starcoinGetPublicKey' })),
     starcoinSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'starcoinSignMessage' })),
@@ -343,7 +235,6 @@ const createAllCoreApi = (call) => ({
     starcoinVerifyMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'starcoinVerifyMessage' })),
     nemGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'nemGetAddress' })),
     nemSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'nemSignTransaction' })),
-    nemDecryptMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'nemDecryptMessage' })),
     solGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'solGetAddress' })),
     solSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'solSignTransaction' })),
     solSignOffchainMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'solSignOffchainMessage' })),
@@ -416,91 +307,9 @@ const createAllCoreApi = (call) => ({
     benfenGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'benfenGetPublicKey' })),
     benfenSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'benfenSignTransaction' })),
     benfenSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'benfenSignMessage' })),
-    tezosGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tezosGetAddress' })),
-    tezosGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tezosGetPublicKey' })),
-    tezosSignTx: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tezosSignTx' })),
-    binanceGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'binanceGetAddress' })),
-    binanceGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'binanceGetPublicKey' })),
-    binanceSignTx: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'binanceSignTx' })),
-    moneroGetWatchKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'moneroGetWatchKey' })),
-    moneroGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'moneroGetAddress' })),
-    eosGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'eosGetPublicKey' })),
-    eosSignTx: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'eosSignTx' })),
-    webAuthnAddResidentCredential: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'webAuthnAddResidentCredential' })),
-    webAuthnListResidentCredentials: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'webAuthnListResidentCredentials' })),
-    webAuthnRemoveResidentCredential: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'webAuthnRemoveResidentCredential' })),
-    getPublicKeyMultiple: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'getPublicKeyMultiple' })),
-    listResDir: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'listResDir' })),
-    nftWriteData: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'nftWriteData' })),
-    nftWriteInfo: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'nftWriteInfo' })),
-    readSEPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'readSEPublicKey' })),
-    resourceUpdate: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'resourceUpdate' })),
-    bixinBackupDevice: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'bixinBackupDevice' })),
-    bixinLoadDevice: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'bixinLoadDevice' })),
-    bixinMessageSE: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'bixinMessageSE' })),
-    bixinVerifyDeviceRequest: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'bixinVerifyDeviceRequest' })),
-    deviceSpiFlashWrite: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceSpiFlashWrite' })),
-    deviceSpiFlashRead: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceSpiFlashRead' })),
-    deviceInfoSettings: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceInfoSettings' })),
-    deviceGetInfo: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceGetInfo' })),
-    deviceReadSEPublicCert: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceReadSEPublicCert' })),
-    deviceWriteSEPrivateKey: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceWriteSEPrivateKey' })),
-    deviceWriteSEPublicCert: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceWriteSEPublicCert' })),
-    deviceSESignMessage: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceSESignMessage' })),
-    deviceGetFirmwareHash: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceGetFirmwareHash' })),
-    deviceUnlockPath: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceUnlockPath' })),
-    devicePing: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'devicePing' })),
-    deviceGetEntropy: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceGetEntropy' })),
-    deviceSdProtect: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceSdProtect' })),
-    deviceChangeWipeCode: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceChangeWipeCode' })),
-    deviceEndSession: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceEndSession' })),
-    deviceLoad: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceLoad' })),
-    deviceDoPreauthorized: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceDoPreauthorized' })),
-    deviceCancelAuthorization: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceCancelAuthorization' })),
-    emmcDirList: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcDirList' })),
-    emmcDirMake: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcDirMake' })),
-    emmcDirRemove: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcDirRemove' })),
-    emmcFileDelete: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcFileDelete' })),
-    emmcFileRead: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcFileRead' })),
-    emmcFileWrite: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcFileWrite' })),
-    emmcFixPermission: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcFixPermission' })),
-    emmcPathInfo: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'emmcPathInfo' })),
-    debugLinkDecision: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkDecision' })),
-    debugLinkEraseSdCard: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkEraseSdCard' })),
-    debugLinkFlashErase: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkFlashErase' })),
-    debugLinkGetState: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkGetState' })),
-    debugLinkMemoryRead: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkMemoryRead' })),
-    debugLinkMemoryWrite: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkMemoryWrite' })),
-    debugLinkRecordScreen: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkRecordScreen' })),
-    debugLinkReseedRandom: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkReseedRandom' })),
-    debugLinkStop: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkStop' })),
-    debugLinkWatchLayout: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'debugLinkWatchLayout' })),
-    firmwareEraseEx: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareEraseEx' })),
-    firmwareErase: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareErase' })),
-    firmwareUpdateEmmcTest: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdateEmmcTest' })),
-    firmwareUploadTest: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUploadTest' })),
-    reboot: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'reboot' })),
-    selfTest: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'selfTest' })),
     neoGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'neoGetAddress' })),
     neoSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'neoSignTransaction' })),
 });
-const pickApiMethods = (api, methodNames) => {
-    const selected = {};
-    methodNames.forEach(methodName => {
-        selected[methodName] = api[methodName];
-    });
-    return selected;
-};
-const createCoreApi = (call) => {
-    const api = createAllCoreApi(call);
-    const extensionMethodNames = new Set([
-        ...TEST_API_METHOD_NAMES,
-        ...FACTORY_API_METHOD_NAMES,
-    ]);
-    return Object.fromEntries(Object.entries(api).filter(([methodName]) => !extensionMethodNames.has(methodName)));
-};
-const createTestApi = (call) => pickApiMethods(createAllCoreApi(call), TEST_API_METHOD_NAMES);
-const createFactoryApi = (call) => pickApiMethods(createAllCoreApi(call), FACTORY_API_METHOD_NAMES);
 
 const lowLevelInject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, updateSettings, switchTransport, addHardwareGlobalEventListener, }) => {
     const protocolAwareCall = createProtocolAwareCall(call);
@@ -1028,7 +837,7 @@ const createLogMessage = (type, payload) => ({
 
 const MAX_ENTRIES = 500;
 let postMessage$1;
-class Log$k {
+class Log$l {
     constructor(prefix, enabled) {
         this.prefix = prefix;
         this.enabled = enabled;
@@ -1080,7 +889,7 @@ class Log$k {
 }
 const _logs = {};
 const initLog = (prefix, enabled) => {
-    const instance = new Log$k(prefix, !!enabled);
+    const instance = new Log$l(prefix, !!enabled);
     _logs[prefix] = instance;
     return instance;
 };
@@ -1478,7 +1287,7 @@ function patchFeatures(response) {
     return response;
 }
 
-const Log$j = getLogger(exports.LoggerNames.Core);
+const Log$k = getLogger(exports.LoggerNames.Core);
 let globalInstanceCounter = 0;
 let sdkInstanceCounter = 0;
 function generateSdkInstanceId() {
@@ -1538,7 +1347,7 @@ function completeRequestContext(responseID, error) {
         context.status = error ? 'error' : 'success';
         if (error) {
             context.error = error.message;
-            Log$j.debug(`[RequestContext] [completeRequestContext] Error: ${formatRequestContext(context)}`);
+            Log$k.debug(`[RequestContext] [completeRequestContext] Error: ${formatRequestContext(context)}`);
         }
         globalActiveRequests.delete(responseID);
         if (context.sdkInstanceId) {
@@ -39907,7 +39716,7 @@ function isProtocolV2ResourceFileValid(binary, resource) {
 }
 
 var _a$1;
-const Log$i = getLogger(exports.LoggerNames.Core);
+const Log$j = getLogger(exports.LoggerNames.Core);
 const FIRMWARE_FIELDS = [
     'firmware',
     'firmware-v1',
@@ -39962,6 +39771,7 @@ class DataManager {
         var _b;
         return __awaiter(this, void 0, void 0, function* () {
             this.settings = settings;
+            this.protocolV2ResourcesConfigError = undefined;
             if (!settings.fetchConfig) {
                 return false;
             }
@@ -39972,38 +39782,48 @@ class DataManager {
             let data = null;
             let fetchMethod = 'none';
             if (settings.configFetcher) {
-                Log$i.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
+                Log$j.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
                 try {
                     data = yield settings.configFetcher(urlWithCache);
                     if (data) {
                         fetchMethod = 'configFetcher';
-                        Log$i.log('[DataConfig] ConfigFetcher success');
+                        Log$j.log('[DataConfig] ConfigFetcher success');
                     }
                     else {
-                        Log$i.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
+                        Log$j.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
                     }
                 }
                 catch (e) {
-                    Log$i.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
+                    Log$j.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
                 }
             }
             if (!data) {
-                Log$i.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+                Log$j.debug('[DataConfig] Trying axios (SDK default fetcher)...');
                 try {
                     const response = yield axios__default["default"].get(urlWithCache, {
                         timeout: 7000,
                     });
                     data = response.data;
                     fetchMethod = 'axios';
-                    Log$i.log('[DataConfig] Axios fetch success');
+                    Log$j.log('[DataConfig] Axios fetch success');
                 }
                 catch (e) {
-                    Log$i.warn('[DataConfig] Axios fetch error:', e);
+                    Log$j.warn('[DataConfig] Axios fetch error:', e);
                 }
             }
             if (data) {
-                const pro2Resources = parseProtocolV2Resources((_b = data.pro2) === null || _b === void 0 ? void 0 : _b.resources);
-                Log$i.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
+                let pro2Resources;
+                try {
+                    pro2Resources = parseProtocolV2Resources((_b = data.pro2) === null || _b === void 0 ? void 0 : _b.resources);
+                }
+                catch (error) {
+                    this.protocolV2ResourcesConfigError =
+                        error instanceof Error ? error : new Error(String(error));
+                    Log$j.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
+                }
+                const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
+                const pro2Config = __rest(enrichedPro2Config, ["resources"]);
+                Log$j.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
                 this.deviceMap = {
                     [hdShared.EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
                     [hdShared.EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
@@ -40011,14 +39831,14 @@ class DataManager {
                     [hdShared.EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
                     [hdShared.EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
                     [hdShared.EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-                    [hdShared.EDeviceType.Pro2]: Object.assign(Object.assign({}, this.enrichFirmwareReleaseInfo(data.pro2)), (pro2Resources ? { resources: pro2Resources } : undefined)),
+                    [hdShared.EDeviceType.Pro2]: Object.assign(Object.assign({}, pro2Config), (pro2Resources ? { resources: pro2Resources } : undefined)),
                 };
                 this.assets = {
                     bridge: data.bridge,
                 };
                 return true;
             }
-            Log$i.warn('[DataConfig] All fetch methods failed, using built-in default config');
+            Log$j.warn('[DataConfig] All fetch methods failed, using built-in default config');
             return false;
         });
     }
@@ -40048,6 +39868,9 @@ class DataManager {
             if (!loaded) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Unable to refresh the latest remote config');
             }
+            if (this.protocolV2ResourcesConfigError) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`);
+            }
             this.lastCheckTimestamp = getTimeStamp();
         });
     }
@@ -41600,7 +41423,7 @@ function validateNonEmptyString(value, name) {
 }
 const PROTOCOL_V2_FILESYSTEM_VOLUMES = new Set(['vol0', 'vol1']);
 const MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES = 127;
-function getUtf8ByteLength$2(value) {
+function getUtf8ByteLength$1(value) {
     return Array.from(value).reduce((length, character) => {
         var _a;
         const codePoint = (_a = character.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
@@ -41642,7 +41465,7 @@ function validateProtocolV2FilesystemPath(value, name, options = {}) {
         throw invalidParameter$1(`Parameter [${name}] contains an invalid path segment.`);
     }
     const canonicalPath = `${volume}:${rawSuffix.startsWith('/') ? '/' : ''}${segments.join('/')}`;
-    if (getUtf8ByteLength$2(canonicalPath) > MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES) {
+    if (getUtf8ByteLength$1(canonicalPath) > MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES) {
         throw invalidParameter$1(`Parameter [${name}] exceeds the maximum filesystem path length.`);
     }
     return canonicalPath;
@@ -42124,7 +41947,7 @@ const getDefectiveDeviceInfo = (features) => {
     };
 };
 
-const Log$h = getLogger(exports.LoggerNames.DevicePool);
+const Log$i = getLogger(exports.LoggerNames.DevicePool);
 const getDiff = (current, descriptors) => {
     const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
     const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
@@ -42182,7 +42005,7 @@ class DevicePool extends events.exports {
                         yield this._checkDevicePool(initOptions, connectId);
                         return { devices, deviceList };
                     }
-                    Log$h.debug('found device in cache, but path is different: ', connectId);
+                    Log$i.debug('found device in cache, but path is different: ', connectId);
                 }
             }
             const matchedDescriptor = connectId
@@ -42274,7 +42097,7 @@ class DevicePool extends events.exports {
                 yield device.getDeviceState({ refreshSections: ['settings'] });
             }
             catch (error) {
-                Log$h.debug('Unable to refresh Protocol V2 device label during discovery', error);
+                Log$i.debug('Unable to refresh Protocol V2 device label during discovery', error);
             }
         });
     }
@@ -42290,7 +42113,7 @@ class DevicePool extends events.exports {
                 const descriptor = this.connectedPool[i];
                 if (!connectId || descriptor.path === connectId) {
                     const device = yield this._createDevice(descriptor, initOptions);
-                    Log$h.debug('emit DEVICE.CONNECT: ', device === null || device === void 0 ? void 0 : device.features);
+                    Log$i.debug('emit DEVICE.CONNECT: ', device === null || device === void 0 ? void 0 : device.features);
                     this.emitter.emit(DEVICE.CONNECT, device);
                     this.connectedPool.splice(i, 1);
                 }
@@ -42312,9 +42135,9 @@ class DevicePool extends events.exports {
         const diff = getDiff(this.current || [], upcoming);
         this.upcoming = upcoming;
         this.current = this.upcoming;
-        Log$h.debug('device pool -> current: ', this.current);
-        Log$h.debug('device pool -> upcomming: ', this.upcoming);
-        Log$h.debug('DeviceCache.reportDeviceChange diff: ', diff);
+        Log$i.debug('device pool -> current: ', this.current);
+        Log$i.debug('device pool -> upcomming: ', this.upcoming);
+        Log$i.debug('DeviceCache.reportDeviceChange diff: ', diff);
         if (!diff.didUpdate) {
             return;
         }
@@ -42324,7 +42147,7 @@ class DevicePool extends events.exports {
                 this._addConnectedDeviceToPool(d);
                 return;
             }
-            Log$h.debug('emit DEVICE.CONNECT: ', device.features);
+            Log$i.debug('emit DEVICE.CONNECT: ', device.features);
             this.emitter.emit(DEVICE.CONNECT, device);
         });
         diff.disconnected.forEach(d => {
@@ -42334,7 +42157,7 @@ class DevicePool extends events.exports {
                 this._addDisconnectedDeviceToPool(d);
                 return;
             }
-            Log$h.debug('emit DEVICE.DISCONNECT: ', device.features);
+            Log$i.debug('emit DEVICE.DISCONNECT: ', device.features);
             device.markTransportDisconnected();
             this.emitter.emit(DEVICE.DISCONNECT, device);
         });
@@ -42370,7 +42193,7 @@ class DevicePool extends events.exports {
         this.connectedPool = [];
         this.disconnectPool = [];
         this.devicesCache = {};
-        Log$h.debug('DevicePool state has been reset');
+        Log$i.debug('DevicePool state has been reset');
     }
     static dispose() {
         this.resetState();
@@ -42384,7 +42207,7 @@ DevicePool.disconnectPool = [];
 DevicePool.devicesCache = {};
 DevicePool.emitter = new events.exports();
 
-const Log$g = getLogger(exports.LoggerNames.Transport);
+const Log$h = getLogger(exports.LoggerNames.Transport);
 const BleLogger = getLogger(exports.LoggerNames.HdBleTransport);
 const HttpLogger = getLogger(exports.LoggerNames.HdTransportHttp);
 const LowLevelLogger = getLogger(exports.LoggerNames.HdTransportLowLevel);
@@ -42394,7 +42217,7 @@ const WebUsbLogger = getLogger(exports.LoggerNames.HdTransportWebUsb);
 const REACT_NATIVE_BLE_SCAN_TIMEOUT_MS = 3000;
 class TransportManager {
     static load() {
-        Log$g.debug('transport manager load');
+        Log$h.debug('transport manager load');
         this.defaultMessages = DataManager.getProtobufMessages();
         this.currentMessages = this.defaultMessages;
         this.protocolV1MessageSchema = 'v1CurrentSchema';
@@ -42403,14 +42226,14 @@ class TransportManager {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const env = DataManager.getSettings('env');
-                Log$g.debug('Initializing transports', env);
+                Log$h.debug('Initializing transports', env);
                 if (env === 'react-native') {
                     if (!this.reactNativeInit) {
                         yield this.transport.init(BleLogger, DevicePool.emitter);
                         this.reactNativeInit = true;
                     }
                     else {
-                        Log$g.debug('React Native Do Not Initializing transports');
+                        Log$h.debug('React Native Do Not Initializing transports');
                     }
                 }
                 else if (env === 'node-usb') {
@@ -42431,15 +42254,15 @@ class TransportManager {
                 else {
                     yield this.transport.init(HttpLogger);
                 }
-                Log$g.debug('Configuring transports');
+                Log$h.debug('Configuring transports');
                 yield this.transport.configure(JSON.stringify(this.defaultMessages));
                 this.currentMessages = this.defaultMessages;
                 this.protocolV1MessageSchema = 'v1CurrentSchema';
                 yield this.configureProtocolV2Messages();
-                Log$g.debug('Configuring transports done');
+                Log$h.debug('Configuring transports done');
             }
             catch (error) {
-                Log$g.debug('Initializing transports error: ', error);
+                Log$h.debug('Initializing transports error: ', error);
                 if (error.code === 'ECONNABORTED') {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
                 }
@@ -42455,7 +42278,7 @@ class TransportManager {
             if (this.currentMessages === messages || !messages) {
                 return;
             }
-            Log$g.debug(`Reconfiguring transports Protocol V1 schema:${protocolV1MessageSchema}`);
+            Log$h.debug(`Reconfiguring transports Protocol V1 schema:${protocolV1MessageSchema}`);
             try {
                 yield this.transport.configure(JSON.stringify(messages));
                 this.currentMessages = messages;
@@ -42467,6 +42290,9 @@ class TransportManager {
         });
     }
     static setTransport(TransportConstructor, plugin) {
+        if (typeof TransportConstructor !== 'function') {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Transport constructor is not available');
+        }
         const env = DataManager.getSettings('env');
         if (env === 'react-native') {
             this.transport = new TransportConstructor({
@@ -42478,9 +42304,9 @@ class TransportManager {
         }
         if (plugin) {
             this.plugin = plugin;
-            Log$g.debug('set transport plugin: ', this.plugin);
+            Log$h.debug('set transport plugin: ', this.plugin);
         }
-        Log$g.debug('set transport: ', this.transport.name, this.transport.version, this.transport.configured);
+        Log$h.debug('set transport: ', this.transport.name, this.transport.version, this.transport.configured);
     }
     static getTransport() {
         return this.transport;
@@ -42491,7 +42317,7 @@ class TransportManager {
             const { configureProtocolV2 } = this.transport;
             if (protocolV2Messages && typeof configureProtocolV2 === 'function') {
                 yield configureProtocolV2.call(this.transport, JSON.stringify(protocolV2Messages));
-                Log$g.debug('Protocol V2 messages configured');
+                Log$h.debug('Protocol V2 messages configured');
             }
         });
     }
@@ -42524,6 +42350,7 @@ const DEVICE_SESSION_CALLS = new Set([
     'DeviceSessionAskPin',
     'DeviceSessionAskPassphrase',
 ]);
+const PROTOCOL_V2_ACTION_CANCELLED_SUBCODE = 1;
 const isProtocolV2ActionCancelledMessage = (message) => /^(?:cancel(?:led|ed)(?: on device)?|confirm dismissed|user cancel(?:led|ed)(?:\s+.*)?)$/i.test(message);
 function shouldReduceDebugForCall(type) {
     return HIGH_VOLUME_DEBUG_CALLS.has(type);
@@ -42603,7 +42430,7 @@ const cancelDeviceWithInitialize = (device) => {
         },
     }));
 };
-const Log$f = getLogger(exports.LoggerNames.DeviceCommands);
+const Log$g = getLogger(exports.LoggerNames.DeviceCommands);
 const LogCore = getLogger(exports.LoggerNames.Core);
 class DeviceCommands {
     constructor(device, mainId) {
@@ -42612,7 +42439,7 @@ class DeviceCommands {
         this.transport = TransportManager.getTransport();
         this.disposed = false;
         this.instanceId = generateInstanceId('DeviceCommands', device.sdkInstanceId);
-        Log$f.debug(`[DeviceCommands] Created: ${this.instanceId}, device: ${this.device.instanceId}`);
+        Log$g.debug(`[DeviceCommands] Created: ${this.instanceId}, device: ${this.device.instanceId}`);
     }
     dispose(_cancelRequest) {
         var _a, _b;
@@ -42692,7 +42519,7 @@ class DeviceCommands {
         return __awaiter(this, void 0, void 0, function* () {
             const shouldReduceDebug = shouldReduceDebugForCall(type);
             if (!shouldReduceDebug) {
-                Log$f.debug('[DeviceCommands] [call] Sending', type, hdTransport.getSafeTransportLogPayload(msg !== null && msg !== void 0 ? msg : {}, type));
+                Log$g.debug('[DeviceCommands] [call] Sending', type, hdTransport.getSafeTransportLogPayload(msg !== null && msg !== void 0 ? msg : {}, type));
             }
             try {
                 const promise = this.transport.call(this.mainId, type, msg !== null && msg !== void 0 ? msg : {}, options);
@@ -42754,10 +42581,10 @@ class DeviceCommands {
                 assertType(response, resType);
             }
             catch (error) {
-                Log$f.debug('DeviceCommands typedcall error: ', error);
+                Log$g.debug('DeviceCommands typedcall error: ', error);
                 if (error instanceof hdShared.HardwareError) {
                     if (error.errorCode === hdShared.HardwareErrorCode.ResponseUnexpectTypeError) {
-                        Log$f.debug('[DeviceCommands] [typedCall] Unexpected response type', {
+                        Log$g.debug('[DeviceCommands] [typedCall] Unexpected response type', {
                             request: type,
                             expected: resType,
                             received: response.type,
@@ -42791,7 +42618,7 @@ class DeviceCommands {
         var _a;
         try {
             if (!shouldReduceDebugForCall(callType)) {
-                Log$f.debug('_filterCommonTypes: ', {
+                Log$g.debug('_filterCommonTypes: ', {
                     request: callType,
                     response: callType === 'DeviceFirmwareUpdateStatusGet'
                         ? {
@@ -42843,6 +42670,11 @@ class DeviceCommands {
             if (code === 'Failure_ProcessError') {
                 const normalizedMessage = (_a = message === null || message === void 0 ? void 0 : message.trim()) !== null && _a !== void 0 ? _a : '';
                 const isProtocolV2ActionCancelledFailure = this.device.isProtocolV2() && isProtocolV2ActionCancelledMessage(normalizedMessage);
+                const isProtocolV2ActionCancelledSubcode = this.device.isProtocolV2() && subcode === PROTOCOL_V2_ACTION_CANCELLED_SUBCODE;
+                const isProtocolV2DeviceBusyFailure = this.device.isProtocolV2() &&
+                    callType.startsWith('Device') &&
+                    !DEVICE_SESSION_CALLS.has(callType) &&
+                    subcode === hdTransport.DeviceErrorCode.DeviceError_Busy;
                 const isLegacyProtocolV2LockedFailure = this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
                 if (DEVICE_SESSION_CALLS.has(callType) &&
                     subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_InvalidSession) {
@@ -42893,7 +42725,15 @@ class DeviceCommands {
                         firmwareMessage: message,
                     });
                 }
+                else if (isProtocolV2DeviceBusyFailure) {
+                    error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceBusy, message, {
+                        failureCode: code,
+                        subcode,
+                        firmwareMessage: message,
+                    });
+                }
                 else if (subcode === hdTransport.DeviceErrorCode.DeviceError_ActionCancelled ||
+                    isProtocolV2ActionCancelledSubcode ||
                     isProtocolV2ActionCancelledFailure) {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ActionCancelled, message, {
                         failureCode: code,
@@ -42996,7 +42836,7 @@ class DeviceCommands {
                 reject(error);
             });
             const listenerCount = this.device.listenerCount(DEVICE.PIN);
-            Log$f.debug(`[${this.instanceId}] _promptPin called`, {
+            Log$g.debug(`[${this.instanceId}] _promptPin called`, {
                 responseID: this.currentResponseID,
                 deviceInstanceId: this.device.instanceId,
                 listenerCount,
@@ -43903,7 +43743,7 @@ const parseRunOptions = (options) => {
         options = {};
     return options;
 };
-const Log$e = getLogger(exports.LoggerNames.Device);
+const Log$f = getLogger(exports.LoggerNames.Device);
 const isProtocolV2DeviceStatusUnsupportedError = (error) => {
     var _a, _b, _c;
     if (error instanceof hdShared.HardwareError) {
@@ -43964,7 +43804,7 @@ class Device extends events.exports {
         this.sdkInstanceId = sdkInstanceId;
         this.instanceId = generateInstanceId('Device', this.sdkInstanceId);
         this.createdAt = Date.now();
-        Log$e.debug(`[Device] Created: ${this.instanceId}${this.sdkInstanceId ? ` for SDK: ${this.sdkInstanceId}` : ''}`);
+        Log$f.debug(`[Device] Created: ${this.instanceId}${this.sdkInstanceId ? ` for SDK: ${this.sdkInstanceId}` : ''}`);
     }
     static fromDescriptor(originalDescriptor, sdkInstanceId) {
         const descriptor = Object.assign({}, originalDescriptor);
@@ -44055,12 +43895,12 @@ class Device extends events.exports {
                 if (DataManager.isBleConnect(env)) {
                     acquireResult = yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.originalDescriptor.id, undefined, true, strictProtocol, undefined));
                     this.mainId = (_b = acquireResult === null || acquireResult === void 0 ? void 0 : acquireResult.uuid) !== null && _b !== void 0 ? _b : '';
-                    Log$e.debug('Expected uuid:', this.mainId);
+                    Log$f.debug('Expected uuid:', this.mainId);
                 }
                 else {
                     acquireResult = yield ((_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.acquire(this.originalDescriptor.path, this.originalDescriptor.session, undefined, strictProtocol, undefined));
                     this.mainId = acquireResult;
-                    Log$e.debug('Expected session id:', this.mainId);
+                    Log$f.debug('Expected session id:', this.mainId);
                 }
                 const detectedProtocol = (_d = acquireResult === null || acquireResult === void 0 ? void 0 : acquireResult.protocolType) !== null && _d !== void 0 ? _d : (_f = (_e = TransportManager.transport) === null || _e === void 0 ? void 0 : _e.getProtocolType) === null || _f === void 0 ? void 0 : _f.call(_e, DataManager.isBleConnect(env) ? this.originalDescriptor.id : this.originalDescriptor.path);
                 if ((options === null || options === void 0 ? void 0 : options.forceProtocolDetection) && !detectedProtocol) {
@@ -44086,7 +43926,7 @@ class Device extends events.exports {
                             yield ((_j = (_h = this.deviceConnector) === null || _h === void 0 ? void 0 : _h.release) === null || _j === void 0 ? void 0 : _j.call(_h, failedSession, false));
                         }
                         catch (releaseError) {
-                            Log$e.debug('Failed to release an unsuccessful protocol probe', releaseError);
+                            Log$f.debug('Failed to release an unsuccessful protocol probe', releaseError);
                         }
                     }
                     if (!DataManager.isBleConnect(env)) {
@@ -44115,11 +43955,11 @@ class Device extends events.exports {
                 (this.mainId && DataManager.isBleConnect(env))) {
                 if (this.pendingCallbackPromise) {
                     try {
-                        Log$e.debug('Waiting for callback tasks to complete before releasing device (in release method)');
+                        Log$f.debug('Waiting for callback tasks to complete before releasing device (in release method)');
                         yield this.pendingCallbackPromise.promise;
                     }
                     catch (error) {
-                        Log$e.error('Error waiting for callback tasks in release method:', error);
+                        Log$f.error('Error waiting for callback tasks in release method:', error);
                     }
                 }
                 if (this.commands) {
@@ -44138,7 +43978,7 @@ class Device extends events.exports {
                     this.updateDescriptor({ session: null });
                 }
                 catch (err) {
-                    Log$e.error('[Device] release error: ', err);
+                    Log$f.error('[Device] release error: ', err);
                 }
                 finally {
                     this.needReloadDevice = true;
@@ -44340,7 +44180,7 @@ class Device extends events.exports {
         });
     }
     getInternalState(_deviceId) {
-        Log$e.debug('getInternalState session param: ', `device_id: ${_deviceId}`, `currentDeviceId: ${this.getCurrentDeviceId()}`, `hasPassphraseState: ${Boolean(this.passphraseState)}`);
+        Log$f.debug('getInternalState session param: ', `device_id: ${_deviceId}`, `currentDeviceId: ${this.getCurrentDeviceId()}`, `hasPassphraseState: ${Boolean(this.passphraseState)}`);
         const deviceId = this.getSessionCacheDeviceKey(_deviceId);
         if (!deviceId)
             return undefined;
@@ -44355,7 +44195,7 @@ class Device extends events.exports {
         return deviceWalletSessionStore.getStandard(deviceId);
     }
     updateInternalState(enablePassphrase, passphraseState, deviceId, sessionId = null, featuresSessionId = null, walletType = 'hidden') {
-        Log$e.debug('updateInternalState session param: ', `device_id: ${deviceId}`, `enablePassphrase: ${enablePassphrase}`, `hasPassphraseState: ${Boolean(passphraseState)}`, `hasSessionId: ${Boolean(sessionId)}`, `hasFeaturesSessionId: ${Boolean(featuresSessionId)}`);
+        Log$f.debug('updateInternalState session param: ', `device_id: ${deviceId}`, `enablePassphrase: ${enablePassphrase}`, `hasPassphraseState: ${Boolean(passphraseState)}`, `hasSessionId: ${Boolean(sessionId)}`, `hasFeaturesSessionId: ${Boolean(featuresSessionId)}`);
         const cacheDeviceKey = this.getSessionCacheDeviceKey(deviceId);
         if (!cacheDeviceKey)
             return;
@@ -44371,7 +44211,7 @@ class Device extends events.exports {
         deviceWalletSessionStore.deletePending(cacheDeviceKey);
     }
     setInternalState(state, initSession) {
-        Log$e.debug('setInternalState session param: ', `hasState: ${Boolean(state)}`, `initSession: ${initSession}`, `deviceId: ${this.getCurrentDeviceId()}`, `hasPassphraseState: ${Boolean(this.passphraseState)}`);
+        Log$f.debug('setInternalState session param: ', `hasState: ${Boolean(state)}`, `initSession: ${initSession}`, `deviceId: ${this.getCurrentDeviceId()}`, `hasPassphraseState: ${Boolean(this.passphraseState)}`);
         if (!this.passphraseState && !initSession)
             return;
         const deviceId = this.getSessionCacheDeviceKey();
@@ -44385,7 +44225,7 @@ class Device extends events.exports {
         }
     }
     clearInternalState(_deviceId) {
-        Log$e.debug('clearInternalState param: ', _deviceId);
+        Log$f.debug('clearInternalState param: ', _deviceId);
         const deviceId = this.getSessionCacheDeviceKey(_deviceId);
         if (!deviceId)
             return;
@@ -44452,24 +44292,24 @@ class Device extends events.exports {
                 yield callInitialize(payload, options === null || options === void 0 ? void 0 : options.initSession);
             }
             catch (error) {
-                Log$e.error('Initialization failed:', error);
+                Log$f.error('Initialization failed:', error);
                 throw error;
             }
         });
     }
     _initializeProtocolV2(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            Log$e.debug('Initialize device via Protocol V2 features adapter');
+            Log$f.debug('Initialize device via Protocol V2 features adapter');
             try {
                 const deviceInfo = yield requestProtocolV2DeviceInfo({
                     commands: this.commands,
                     timeoutMs: options === null || options === void 0 ? void 0 : options.protocolV2DeviceInfoTimeoutMs,
                 });
                 const features = yield this.probeProtocolV2RuntimeState(deviceInfo, options === null || options === void 0 ? void 0 : options.protocolV2DeviceInfoTimeoutMs);
-                Log$e.debug('Protocol V2 features:', features);
+                Log$f.debug('Protocol V2 features:', features);
             }
             catch (error) {
-                Log$e.error('Protocol V2 initialization failed:', error);
+                Log$f.error('Protocol V2 initialization failed:', error);
                 throw error;
             }
         });
@@ -44575,7 +44415,7 @@ class Device extends events.exports {
             source,
             changedKeys: result.changedKeys,
         };
-        Log$e.debug('Device state patch committed', {
+        Log$f.debug('Device state patch committed', {
             source,
             keys: result.changedKeys,
         });
@@ -44793,7 +44633,7 @@ class Device extends events.exports {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.runPromise) {
                 yield this.interruptionFromOutside();
-                Log$e.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
+                Log$f.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
             }
             options = parseRunOptions(options);
             const runPromise = hdShared.createDeferred();
@@ -44870,7 +44710,7 @@ class Device extends events.exports {
                             yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.disconnect(this.mainId));
                         }
                         yield this.release();
-                        Log$e.debug(`error code ${e.errorCode} release device, mainId: ${this.mainId}`);
+                        Log$f.debug(`error code ${e.errorCode} release device, mainId: ${this.mainId}`);
                     }
                     clearRunPromise();
                     return;
@@ -44880,7 +44720,7 @@ class Device extends events.exports {
                 options.keepSession === false) {
                 this.keepSession = false;
                 yield this.release();
-                Log$e.debug('release device, mainId: ', this.mainId);
+                Log$f.debug('release device, mainId: ', this.mainId);
             }
             runPromise.resolve();
             clearRunPromise();
@@ -44911,7 +44751,7 @@ class Device extends events.exports {
     setCancelableAction(callback) {
         this.cancelableAction = (e) => callback(e)
             .catch(e2 => {
-            Log$e.debug('cancelableAction error', e2);
+            Log$f.debug('cancelableAction error', e2);
         })
             .finally(() => {
             this.clearCancelableAction();
@@ -45192,7 +45032,7 @@ class Device extends events.exports {
                 expectedPassphraseState &&
                 expectedPassphraseState !== newPassphraseState;
             const passphraseStateMismatch = !!expectedPassphraseState && expectedPassphraseState !== newPassphraseState;
-            Log$e.debug('Check passphrase state safety: ', {
+            Log$f.debug('Check passphrase state safety: ', {
                 hasExpectedPassphraseState: Boolean(expectedPassphraseState),
                 hasNewPassphraseState: Boolean(newPassphraseState),
                 passphraseStateMatches: Boolean(expectedPassphraseState) && expectedPassphraseState === newPassphraseState,
@@ -45330,7 +45170,7 @@ const getBootloaderReleaseInfo = ({ features, willUpdateFirmwareVersion, firmwar
     };
 };
 
-const Log$d = getLogger(exports.LoggerNames.Method);
+const Log$e = getLogger(exports.LoggerNames.Method);
 const isEvmLedgerLegacyPathWithHighIndex = (path) => {
     let addressN;
     if (typeof path === 'string') {
@@ -45414,7 +45254,7 @@ class BaseMethod {
     setContext(context) {
         this.sdkInstanceId = context.sdkInstanceId;
         this.instanceId = generateInstanceId('Method', this.sdkInstanceId);
-        Log$d.debug(`[BaseMethod] Created: ${this.instanceId}, method: ${this.name}, SDK: ${this.sdkInstanceId}`);
+        Log$e.debug(`[BaseMethod] Created: ${this.instanceId}, method: ${this.name}, SDK: ${this.sdkInstanceId}`);
     }
     setDevice(device) {
         var _a, _b;
@@ -45434,7 +45274,7 @@ class BaseMethod {
         if (device.commands) {
             device.commands.currentResponseID = this.responseID;
         }
-        Log$d.debug(`[${this.instanceId}] setDevice: ${device.instanceId}, commands: ${(_b = device.commands) === null || _b === void 0 ? void 0 : _b.instanceId}`);
+        Log$e.debug(`[${this.instanceId}] setDevice: ${device.instanceId}, commands: ${(_b = device.commands) === null || _b === void 0 ? void 0 : _b.instanceId}`);
     }
     checkFirmwareRelease() {
         if (!this.device || this.device.isProtocolV2())
@@ -45509,7 +45349,7 @@ class BaseMethod {
                 checkFlag = true;
             }
             if (checkFlag && this.device.getCurrentSafetyChecks() === hdTransport.Enum_SafetyCheckLevel.Strict) {
-                Log$d.debug('will change safety_checks level');
+                Log$e.debug('will change safety_checks level');
                 yield this.device.commands.typedCall('ApplySettings', 'Success', {
                     safety_checks: hdTransport.Enum_SafetyCheckLevel.PromptTemporarily,
                 });
@@ -45544,7 +45384,7 @@ class TestInitializeDeviceDuration extends BaseMethod {
 }
 
 const PROTOCOL_V2_PING_MAX_MESSAGE_BYTES = 63;
-const getUtf8ByteLength$1 = (value) => Array.from(value).reduce((length, character) => {
+const getUtf8ByteLength = (value) => Array.from(value).reduce((length, character) => {
     var _a;
     const codePoint = (_a = character.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
     if (codePoint <= 0x7f)
@@ -45560,7 +45400,7 @@ function validateProtocolV2PingMessage(value) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Protocol V2 Ping message must be a string.');
     }
     const message = value !== null && value !== void 0 ? value : '';
-    if (getUtf8ByteLength$1(message) > PROTOCOL_V2_PING_MAX_MESSAGE_BYTES) {
+    if (getUtf8ByteLength(message) > PROTOCOL_V2_PING_MAX_MESSAGE_BYTES) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Protocol V2 Ping message must not exceed ${PROTOCOL_V2_PING_MAX_MESSAGE_BYTES} UTF-8 bytes.`);
     }
     return message;
@@ -45585,7 +45425,7 @@ class Ping extends BaseMethod {
     }
 }
 
-const Log$c = getLogger(exports.LoggerNames.Core);
+const Log$d = getLogger(exports.LoggerNames.Core);
 const parseInitOptions$1 = (payload) => ({
     initSession: payload === null || payload === void 0 ? void 0 : payload.initSession,
     passphraseState: payload === null || payload === void 0 ? void 0 : payload.passphraseState,
@@ -45611,14 +45451,14 @@ class PreInitialize extends BaseMethod {
             }
             catch (_a) {
                 this.device.clearPreInitialized();
-                Log$c.debug('[PRE-INIT][FAILED]');
+                Log$d.debug('[PRE-INIT][FAILED]');
                 return false;
             }
         });
     }
 }
 
-const Log$b = getLogger(exports.LoggerNames.DevicePool);
+const Log$c = getLogger(exports.LoggerNames.DevicePool);
 class SearchDevices extends BaseMethod {
     init() {
         this.useDevice = false;
@@ -45659,7 +45499,7 @@ class SearchDevices extends BaseMethod {
                     const errorCode = error && typeof error === 'object' && 'errorCode' in error
                         ? error.errorCode
                         : undefined;
-                    Log$b.debug('Skip unavailable device during search', Object.assign({ path: descriptor.path }, (errorCode !== undefined ? { errorCode } : {})));
+                    Log$c.debug('Skip unavailable device during search', Object.assign({ path: descriptor.path }, (errorCode !== undefined ? { errorCode } : {})));
                 }
             }
             return deviceList.map(device => device.toMessageObject());
@@ -46736,7 +46576,7 @@ class CheckFirmwareTypeAvailable extends BaseMethod {
     }
 }
 
-class DeviceBackup$1 extends BaseMethod {
+class DeviceBackup extends BaseMethod {
     init() {
         this.useDevicePassphraseState = false;
     }
@@ -47077,6 +46917,7 @@ class DeviceSettings extends BaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 if (this.device.isProtocolV2()) {
+                    const refreshStatusAndSettings = () => this.device.getDeviceState({ refreshSections: ['status', 'settings'] });
                     assertSettingsSupported(this.payload, DEVICE_SETTINGS_V1_ONLY_FIELDS, 'Protocol V2');
                     const capabilities = getDeviceSettingsCapabilities(this.device.getCurrentDeviceType(), 'V2');
                     assertProtocolV2SettingValues(this.payload, capabilities);
@@ -47099,7 +46940,7 @@ class DeviceSettings extends BaseMethod {
                         const res = yield this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
                             page: hdTransport.DeviceSettingsPage.DevicePassphrase,
                         });
-                        const updated = yield this.device.getDeviceState({ refreshSections: ['status'] });
+                        const updated = yield refreshStatusAndSettings();
                         const lockedAfterDisabling = requestedPassphrase === false &&
                             current.status.unlocked === true &&
                             updated.status.unlocked === false;
@@ -47117,7 +46958,7 @@ class DeviceSettings extends BaseMethod {
                         const res = yield this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
                             page: hdTransport.DeviceSettingsPage.DeviceAirgap,
                         });
-                        const updated = yield this.device.getDeviceState({ refreshSections: ['settings'] });
+                        const updated = yield refreshStatusAndSettings();
                         if (updated.settings.airgapMode !== requestedAirgap) {
                             throw hdShared.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 air-gap setting did not reach the requested value.');
                         }
@@ -47129,7 +46970,7 @@ class DeviceSettings extends BaseMethod {
                     const res = yield this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
                         settings,
                     });
-                    this.device.updateState(mapDeviceSettingsToState(settings), 'settings-write');
+                    yield refreshStatusAndSettings();
                     return res.message;
                 }
                 assertSettingsSupported(this.payload, DEVICE_SETTINGS_V2_ONLY_FIELDS, 'Protocol V1');
@@ -47367,7 +47208,6 @@ class DeviceSupportFeatures extends BaseMethod {
 class DeviceVerify extends BaseMethod {
     init() {
         this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);
         this.params = {
             data: formatAnyHex(this.payload.dataHex),
@@ -47495,7 +47335,7 @@ const getInfo = ({ features, updateType, targetVersion, firmwareType }) => {
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR$2 = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM$1 = 'Firmware install confirmed';
-const Log$a = getLogger(exports.LoggerNames.Method);
+const Log$b = getLogger(exports.LoggerNames.Method);
 const isDeviceDisconnectedError$1 = (error) => {
     const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
     return (message.includes('device was disconnected') ||
@@ -47544,13 +47384,13 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, r
             const newFeatures = yield typedCall('GetFeatures', 'Features', {});
             const deviceBootloaderVersion = getDeviceBootloaderVersion(buildProtocolV1FeaturesPayload(newFeatures.message, device.features)).join('.');
             const supportUpgradeFileHeader = semver__default["default"].gte(deviceBootloaderVersion, '2.1.0');
-            Log$a.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
+            Log$b.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
             if (supportUpgradeFileHeader) {
                 const HEADER_SIZE = 1024;
                 if (payload.byteLength < HEADER_SIZE) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`);
                 }
-                Log$a.debug('Uploading firmware header:', {
+                Log$b.debug('Uploading firmware header:', {
                     size: HEADER_SIZE,
                     totalSize: payload.byteLength,
                 });
@@ -47562,18 +47402,18 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, r
                     });
                     const isUnknownMessage = (_b = (_a = headerRes.message) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.includes('Failure_UnknownMessage');
                     if (headerRes.type !== 'Success' && !isUnknownMessage) {
-                        Log$a.error('Firmware header upload failed:', headerRes);
+                        Log$b.error('Firmware header upload failed:', headerRes);
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'failed to upload firmware header');
                     }
                 }
                 catch (error) {
-                    Log$a.error('Firmware header upload failed:', error);
+                    Log$b.error('Firmware header upload failed:', error);
                     const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
                     if (!message.includes('Failure_UnknownMessage')) {
                         throw error;
                     }
                 }
-                Log$a.debug('Firmware header uploaded successfully');
+                Log$b.debug('Firmware header uploaded successfully');
             }
         }
         const eraseCommand = isFirmware ? 'FirmwareErase' : 'FirmwareErase_ex';
@@ -47591,7 +47431,7 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, r
         }
         catch (error) {
             if (isDeviceDisconnectedError$1(error)) {
-                Log$a.log('Rebooting device');
+                Log$b.log('Rebooting device');
                 updateResponse = {
                     type: 'Success',
                     message: { message: FIRMWARE_UPDATE_CONFIRM$1 },
@@ -47677,7 +47517,7 @@ const newTouchUpdateProcess = (updateType, postMessage, device, { payload }, reb
     }
     catch (error) {
         if (isDeviceDisconnectedError$1(error)) {
-            Log$a.log('Rebooting device');
+            Log$b.log('Rebooting device');
             response = {
                 type: 'Success',
                 message: { message: FIRMWARE_UPDATE_CONFIRM$1 },
@@ -47708,7 +47548,7 @@ const newTouchUpdateProcess = (updateType, postMessage, device, { payload }, reb
                         ]);
                     }
                     catch (e) {
-                        Log$a.log('catch Bluetooth error when device is restarting: ', e);
+                        Log$b.log('catch Bluetooth error when device is restarting: ', e);
                     }
                 }
                 else {
@@ -47729,7 +47569,7 @@ const newTouchUpdateProcess = (updateType, postMessage, device, { payload }, reb
             }
             catch (error) {
                 console.error('Device reconnect failed: ', error);
-                Log$a.error('Device reconnect failed:', error);
+                Log$b.error('Device reconnect failed:', error);
                 yield wait(1000);
             }
         }
@@ -47769,7 +47609,7 @@ const emmcFileWriteWithRetry = (device, filePath, chunkLength, offset, chunk, ov
             return result;
         }
         catch (error) {
-            Log$a.error(`emmcWrite error: `, error);
+            Log$b.error(`emmcWrite error: `, error);
             retryCount--;
             if (retryCount === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
@@ -47914,7 +47754,7 @@ class DeviceFullyUploadResource extends BaseMethod {
     }
 }
 
-const Log$9 = getLogger(exports.LoggerNames.Method);
+const Log$a = getLogger(exports.LoggerNames.Method);
 const SESSION_ERROR$1 = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
 const isDeviceDisconnectedError = (error) => {
@@ -47940,12 +47780,9 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 type,
             }));
         };
-        this.postProgressMessage = (progress, progressType) => {
-            this.postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-                device: this.device.toMessageObject(),
-                progress,
-                progressType,
-            }));
+        this.postProgressMessage = (progress, progressType, metrics) => {
+            this.postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, Object.assign({ device: this.device.toMessageObject(), progress,
+                progressType }, metrics)));
         };
     }
     init() { }
@@ -47993,7 +47830,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
         this.checkPromise = hdShared.createDeferred();
         const env = DataManager.getSettings('env');
         const isBleReconnect = connectId && DataManager.isBleConnect(env);
-        Log$9.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+        Log$a.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
         let isFirstCheck = true;
         let checkCount = 0;
         let hasPromptedWebDevice = false;
@@ -48004,10 +47841,10 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
         const intervalTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _c, _d, _e, _f;
             checkCount += 1;
-            Log$9.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+            Log$a.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
             if (isTouchOrProDevice && isFirstCheck) {
                 isFirstCheck = false;
-                Log$9.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] wait 3000ms');
+                Log$a.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] wait 3000ms');
                 yield wait(3000);
             }
             if (checkCount > 4 &&
@@ -48027,7 +47864,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 catch (e) {
                     clearInterval(intervalTimer);
                     clearTimeout(timeoutTimer);
-                    Log$9.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ', e);
+                    Log$a.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ', e);
                     (_c = this.checkPromise) === null || _c === void 0 ? void 0 : _c.reject(e);
                 }
                 finally {
@@ -48045,7 +47882,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$9.log('catch Bluetooth error when device is restarting: ', e);
+                    Log$a.log('catch Bluetooth error when device is restarting: ', e);
                 }
             }
             else {
@@ -48128,7 +47965,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
             }
             catch (error) {
                 if (isDeviceDisconnectedError(error)) {
-                    Log$9.log('Rebooting device');
+                    Log$a.log('Rebooting device');
                     updateResponse = {
                         type: 'Success',
                         message: { message: FIRMWARE_UPDATE_CONFIRM },
@@ -48218,7 +48055,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                     return result;
                 }
                 catch (error) {
-                    Log$9.error(`emmcWrite error: `, error);
+                    Log$a.error(`emmcWrite error: `, error);
                     retryCount--;
                     if (retryCount === 0) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
@@ -48422,7 +48259,7 @@ class GetNextU2FCounter extends BaseMethod {
     }
 }
 
-const Log$8 = getLogger(exports.LoggerNames.Method);
+const Log$9 = getLogger(exports.LoggerNames.Method);
 class FirmwareUpdate extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -48460,7 +48297,7 @@ class FirmwareUpdate extends BaseMethod {
         this.checkPromise = hdShared.createDeferred();
         const env = DataManager.getSettings('env');
         const isBleReconnect = connectId && DataManager.isBleConnect(env);
-        Log$8.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+        Log$9.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
         const intervalTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             if (isBleReconnect) {
@@ -48473,7 +48310,7 @@ class FirmwareUpdate extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$8.log('catch Bluetooth error when device is restarting: ', e);
+                    Log$9.log('catch Bluetooth error when device is restarting: ', e);
                 }
             }
             else {
@@ -48529,7 +48366,7 @@ class FirmwareUpdate extends BaseMethod {
                     if (e instanceof hdShared.HardwareError) {
                         return Promise.reject(e);
                     }
-                    Log$8.log('auto go to bootloader mode failed: ', e);
+                    Log$9.log('auto go to bootloader mode failed: ', e);
                     return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure));
                 }
             }
@@ -48569,7 +48406,7 @@ class FirmwareUpdate extends BaseMethod {
     }
 }
 
-const Log$7 = getLogger(exports.LoggerNames.Method);
+const Log$8 = getLogger(exports.LoggerNames.Method);
 const FIRMWARE_DOWNLOAD_REQUEST_OPTIONS = {
     connectTimeoutMs: 60000,
     readTimeoutMs: 60000,
@@ -48685,7 +48522,7 @@ class FirmwareUpdateV2 extends BaseMethod {
         this.checkPromise = hdShared.createDeferred();
         const env = DataManager.getSettings('env');
         const isBleReconnect = connectId && DataManager.isBleConnect(env);
-        Log$7.log('FirmwareUpdateV2 [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+        Log$8.log('FirmwareUpdateV2 [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
         let isFirstCheck = true;
         let checkCount = 0;
         let timeoutTimer;
@@ -48694,10 +48531,10 @@ class FirmwareUpdateV2 extends BaseMethod {
         const intervalTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _b, _c, _d, _e;
             checkCount += 1;
-            Log$7.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+            Log$8.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
             if (isTouchOrProDevice && isFirstCheck) {
                 isFirstCheck = false;
-                Log$7.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
+                Log$8.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
                 yield wait(3000);
             }
             if (checkCount > 4 &&
@@ -48713,7 +48550,7 @@ class FirmwareUpdateV2 extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$7.log('FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ', e);
+                    Log$8.log('FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ', e);
                     (_b = this.checkPromise) === null || _b === void 0 ? void 0 : _b.reject(e);
                 }
                 return;
@@ -48728,7 +48565,7 @@ class FirmwareUpdateV2 extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$7.log('catch Bluetooth error when device is restarting: ', e);
+                    Log$8.log('catch Bluetooth error when device is restarting: ', e);
                 }
             }
             else {
@@ -48911,7 +48748,7 @@ class FirmwareUpdateV2 extends BaseMethod {
     }
 }
 
-const Log$6 = getLogger(exports.LoggerNames.Method);
+const Log$7 = getLogger(exports.LoggerNames.Method);
 const MIN_UPDATE_V3_BOOTLOADER_VERSION = '2.8.0';
 class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
     constructor() {
@@ -48952,7 +48789,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            Log$6.debug('FirmwareUpdateV3 strategy: Protocol V1');
+            Log$7.debug('FirmwareUpdateV3 strategy: Protocol V1');
             return this.runProtocolV1();
         });
     }
@@ -49023,7 +48860,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                 const resource = (yield getSysResourceBinary(resourceUrl)).binary;
                 return resource;
             }
-            Log$6.warn('No resource url found');
+            Log$7.warn('No resource url found');
             return null;
         });
     }
@@ -49148,7 +48985,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                 yield this.startEmmcFirmwareUpdate({ path: '0:updates' });
             }
             catch (error) {
-                Log$6.error('triggerFirmwareUpdateEmmc error: ', error);
+                Log$7.error('triggerFirmwareUpdateEmmc error: ', error);
                 if (error === null || error === void 0 ? void 0 : error.errorCode) {
                     const unexpectedError = [
                         hdShared.HardwareErrorCode.ActionCancelled,
@@ -49209,7 +49046,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                     yield hdShared.wait(1000);
                 }
                 catch (error) {
-                    Log$6.log('getFeatures error', error);
+                    Log$7.log('getFeatures error', error);
                     let shouldReconnect = true;
                     const progress = this.extractUpdateModeProgress(error);
                     if (progress !== null) {
@@ -49307,7 +49144,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                             return;
                         }
                         catch (e) {
-                            Log$6.log('catch Bluetooth error when device is restarting: ', e);
+                            Log$7.log('catch Bluetooth error when device is restarting: ', e);
                         }
                     }
                     else {
@@ -49322,7 +49159,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                                     yield this._promptDeviceForSwitchFirmwareWebDevice();
                                 }
                                 catch (e) {
-                                    Log$6.log('WebUSB re-authorization failed: ', e);
+                                    Log$7.log('WebUSB re-authorization failed: ', e);
                                 }
                                 webUsbCheckCount = 0;
                             }
@@ -49345,7 +49182,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                 }
                 catch (error) {
                     console.error('Device reconnect failed: ', error);
-                    Log$6.error('Device reconnect failed:', error);
+                    Log$7.error('Device reconnect failed:', error);
                     yield hdShared.wait(1000);
                 }
             }
@@ -49354,6 +49191,238 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
     }
 }
 
+const Log$6 = getLogger(exports.LoggerNames.Method);
+const MIN_FILE_CHUNK_SIZE = 64;
+const FILE_TRANSFER_RATE_WINDOW_MS = 1000;
+const FILE_TRANSFER_LOG_INTERVAL_MS = 10000;
+const SESSION_ERROR = 'session not found';
+function formatFileTransferRate(bytesPerSecond) {
+    return (Math.max(bytesPerSecond, 0) / 1024).toFixed(2);
+}
+function getAverageFileTransferRate(transferredBytes, elapsedMs) {
+    if (elapsedMs <= 0)
+        return 0;
+    return Math.round((Math.max(transferredBytes, 0) / elapsedMs) * 1000);
+}
+function getFileTransferTransport() {
+    const env = DataManager.getSettings('env');
+    return env && DataManager.isBleConnect(env) ? 'BLE' : String(env !== null && env !== void 0 ? env : 'unknown');
+}
+function logFileTransferMetrics({ transport, status, transferredBytes, totalBytes, elapsedMs, rateBytesPerSecond, }) {
+    Log$6.log(`[FileWrite] metrics transport=${transport} status=${status} bytes=${transferredBytes}/${totalBytes} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatFileTransferRate(rateBytesPerSecond)} KiB/s`);
+}
+function isProtocolV2ResponseTimeout(error) {
+    var _a, _b;
+    if (!error || typeof error !== 'object')
+        return false;
+    const candidate = error;
+    const code = (_a = candidate.errorCode) !== null && _a !== void 0 ? _a : candidate.code;
+    return (code === hdShared.HardwareErrorCode.BleTimeoutError ||
+        code === 'response-timeout' ||
+        /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test((_b = candidate.message) !== null && _b !== void 0 ? _b : ''));
+}
+function getProtocolV2FileChunkLimit() {
+    const env = DataManager.getSettings('env');
+    return env && DataManager.isBleConnect(env)
+        ? hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
+        : hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+function dataToUint8Array(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof data === 'string')
+            return new TextEncoder().encode(data);
+        if (data instanceof ArrayBuffer)
+            return new Uint8Array(data);
+        if (ArrayBuffer.isView(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        if (typeof Blob !== 'undefined' && data instanceof Blob) {
+            return new Uint8Array(yield data.arrayBuffer());
+        }
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unsupported FilesystemFileWrite data');
+    });
+}
+function normalizeChunkSize(value, maxChunkSize) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return maxChunkSize;
+    return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
+}
+function getDeviceTransferProgress(before, after, total) {
+    if (!Number.isFinite(total) || total <= 0)
+        return 100;
+    if (before <= 0 && after < total)
+        return 0;
+    if (after >= total)
+        return 100;
+    return Math.min(Math.max(Math.ceil((after / total) * 100), 1), 99);
+}
+function getConfirmedProgress(processed, total, written, length) {
+    if (Number.isFinite(processed) && Number.isFinite(total) && total > 0) {
+        if (processed >= total)
+            return 100;
+        return Math.min(Math.max(Math.floor((processed / total) * 100), 0), 99);
+    }
+    if (length > 0)
+        return written >= length ? 100 : Math.floor((written / length) * 100);
+    return 100;
+}
+function writeProtocolV2File(options) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    return __awaiter(this, void 0, void 0, function* () {
+        (_a = options.throwIfAborted) === null || _a === void 0 ? void 0 : _a.call(options);
+        const data = yield dataToUint8Array(options.data);
+        const dataLength = data.byteLength;
+        const startOffset = Number.isFinite(options.offset) && Number(options.offset) > 0 ? Number(options.offset) : 0;
+        const totalSize = Number.isFinite(options.totalSize) && Number(options.totalSize) > 0
+            ? Number(options.totalSize)
+            : startOffset + dataLength;
+        if (totalSize < startOffset + dataLength) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${startOffset + dataLength}`);
+        }
+        const chunkSize = normalizeChunkSize((_b = options.chunkSize) !== null && _b !== void 0 ? _b : options.chunkLen, getProtocolV2FileChunkLimit());
+        let written = 0;
+        let chunks = 0;
+        let lastMessage;
+        const startTime = Date.now();
+        let rateWindowStartedAt = startTime;
+        let rateWindowStartedBytes = 0;
+        let rateBytesPerSecond;
+        let lastConfirmedAt = startTime;
+        let logWindowStartedAt = startTime;
+        let logWindowStartedBytes = 0;
+        const transport = getFileTransferTransport();
+        try {
+            while (written < dataLength) {
+                (_c = options.throwIfAborted) === null || _c === void 0 ? void 0 : _c.call(options);
+                const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
+                const offset = startOffset + written;
+                const progress = (_f = (_d = options.uiPercentage) !== null && _d !== void 0 ? _d : (_e = options.getUiPercentage) === null || _e === void 0 ? void 0 : _e.call(options, {
+                    offset,
+                    chunkLength: chunk.byteLength,
+                    totalSize,
+                })) !== null && _f !== void 0 ? _f : getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
+                const request = {
+                    file: { path: options.path, offset, total_size: totalSize, data: chunk },
+                    overwrite: chunks === 0 ? (_g = options.overwrite) !== null && _g !== void 0 ? _g : false : false,
+                    append: (_h = options.append) !== null && _h !== void 0 ? _h : false,
+                    ui_percentage: progress,
+                };
+                const maxChunkRetries = Math.max(Math.floor((_j = options.maxChunkRetries) !== null && _j !== void 0 ? _j : 0), 0);
+                let retryCount = 0;
+                let response;
+                let isWritePending = true;
+                while (isWritePending) {
+                    try {
+                        const callOptions = options.writeWithResponse === undefined
+                            ? { timeoutMs: options.timeoutMs }
+                            : Object.assign(Object.assign({}, (options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs })), { writeWithResponse: options.writeWithResponse });
+                        response = yield options.commands.typedCall('FilesystemFileWrite', 'FilesystemFile', request, callOptions);
+                        isWritePending = false;
+                    }
+                    catch (error) {
+                        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error))
+                            throw error;
+                        retryCount += 1;
+                        (_k = options.throwIfAborted) === null || _k === void 0 ? void 0 : _k.call(options);
+                    }
+                }
+                if (!response) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'FilesystemFileWrite completed without a response');
+                }
+                const responseType = response.type;
+                if (responseType && responseType !== 'FilesystemFile') {
+                    const responseError = (_l = response.message) === null || _l === void 0 ? void 0 : _l.error;
+                    if (typeof responseError === 'string' && responseError.includes(SESSION_ERROR)) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR);
+                    }
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite received unexpected response ${responseType}`);
+                }
+                (_m = options.throwIfAborted) === null || _m === void 0 ? void 0 : _m.call(options);
+                lastMessage = response.message;
+                const rawProcessedByte = (_o = response.message) === null || _o === void 0 ? void 0 : _o.processed_byte;
+                const processedByte = Number(rawProcessedByte);
+                if (rawProcessedByte !== undefined &&
+                    (!Number.isFinite(processedByte) ||
+                        processedByte <= offset ||
+                        processedByte > offset + chunk.byteLength)) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite invalid processed_byte ${processedByte}`);
+                }
+                written =
+                    rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
+                chunks += 1;
+                const now = Date.now();
+                lastConfirmedAt = now;
+                const elapsedMs = now - startTime;
+                const transferredBytes = Math.min(written, dataLength);
+                const rateWindowElapsedMs = now - rateWindowStartedAt;
+                if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
+                    const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
+                    rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
+                    rateWindowStartedAt = now;
+                    rateWindowStartedBytes = transferredBytes;
+                }
+                else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
+                    rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
+                }
+                (_p = options.onProgress) === null || _p === void 0 ? void 0 : _p.call(options, {
+                    progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
+                    transferredBytes,
+                    totalBytes: dataLength,
+                    rateBytesPerSecond,
+                    elapsedMs,
+                });
+                const logWindowElapsedMs = now - logWindowStartedAt;
+                if (logWindowElapsedMs >= FILE_TRANSFER_LOG_INTERVAL_MS && transferredBytes < dataLength) {
+                    const logWindowBytes = Math.max(transferredBytes - logWindowStartedBytes, 0);
+                    logFileTransferMetrics({
+                        transport,
+                        status: 'progress',
+                        transferredBytes,
+                        totalBytes: dataLength,
+                        elapsedMs,
+                        rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+                    });
+                    logWindowStartedAt = now;
+                    logWindowStartedBytes = transferredBytes;
+                }
+                if (options.paceMs && options.paceMs > 0) {
+                    yield new Promise(resolve => {
+                        setTimeout(resolve, options.paceMs);
+                    });
+                }
+            }
+        }
+        catch (error) {
+            const now = Date.now();
+            const elapsedMs = Math.max(now - startTime, 0);
+            const logWindowElapsedMs = Math.max(now - logWindowStartedAt, 0);
+            const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+            logFileTransferMetrics({
+                transport,
+                status: 'failed',
+                transferredBytes: written,
+                totalBytes: dataLength,
+                elapsedMs,
+                rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+            });
+            throw error;
+        }
+        const elapsedMs = Math.max(lastConfirmedAt - startTime, 0);
+        const logWindowElapsedMs = Math.max(lastConfirmedAt - logWindowStartedAt, 0);
+        const logWindowBytes = Math.max(written - logWindowStartedBytes, 0);
+        logFileTransferMetrics({
+            transport,
+            status: 'completed',
+            transferredBytes: written,
+            totalBytes: dataLength,
+            elapsedMs,
+            rateBytesPerSecond: getAverageFileTransferRate(logWindowBytes, logWindowElapsedMs),
+        });
+        return Object.assign(Object.assign({}, lastMessage), { path: options.path, offset: startOffset, total_size: totalSize, processed_byte: startOffset + written, chunks });
+    });
+}
+
 const ProtocolV2FirmwareTargetType = {
     FW_MGMT_TARGET_INVALID: 0,
     FW_MGMT_TARGET_CRATE: 1,
@@ -49368,99 +49437,6 @@ const ProtocolV2FirmwareTargetType = {
     FW_MGMT_TARGET_SE04: 10,
 };
 
-const FACTORY_SERIAL_MAX_UTF8_BYTES = 24;
-const FACTORY_CERTIFICATE_MAX_BYTES = 512;
-const FACTORY_PRIVATE_KEY_BYTES = 32;
-const FACTORY_CHALLENGE_DIGEST_BYTES = 32;
-const getUtf8ByteLength = (value) => Array.from(value).reduce((length, character) => {
-    var _a;
-    const codePoint = (_a = character.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
-    if (codePoint <= 0x7f)
-        return length + 1;
-    if (codePoint <= 0x7ff)
-        return length + 2;
-    if (codePoint <= 0xffff)
-        return length + 3;
-    return length + 4;
-}, 0);
-const validateRequiredBoolean = (value, name) => {
-    if (typeof value !== 'boolean') {
-        throw invalidParameter$1(`Parameter [${name}] is required and must be a boolean.`);
-    }
-    return value;
-};
-const validateIntegerInRange = (value, name, minimum, maximum) => {
-    if (typeof value !== 'number' ||
-        !Number.isSafeInteger(value) ||
-        value < minimum ||
-        value > maximum) {
-        throw invalidParameter$1(`Parameter [${name}] must be an integer between ${minimum} and ${maximum}.`);
-    }
-    return value;
-};
-const validateHexBytes = (value, name, options) => {
-    const hex = validateNonEmptyString(value, name).trim();
-    if (!/^(?:[0-9a-fA-F]{2})+$/.test(hex)) {
-        throw invalidParameter$1(`Parameter [${name}] must be an even-length hexadecimal string.`);
-    }
-    const byteLength = hex.length / 2;
-    if (options.exactBytes !== undefined && byteLength !== options.exactBytes) {
-        throw invalidParameter$1(`Parameter [${name}] must contain exactly ${options.exactBytes} bytes.`);
-    }
-    if (options.maxBytes !== undefined && byteLength > options.maxBytes) {
-        throw invalidParameter$1(`Parameter [${name}] must not exceed ${options.maxBytes} bytes.`);
-    }
-    return hex;
-};
-function validateDeviceFactoryInfoSetParams(payload) {
-    const serialNumber = validateNonEmptyString(payload.serial_number, 'serial_number').trim();
-    if (getUtf8ByteLength(serialNumber) > FACTORY_SERIAL_MAX_UTF8_BYTES) {
-        throw invalidParameter$1(`Parameter [serial_number] must not exceed ${FACTORY_SERIAL_MAX_UTF8_BYTES} UTF-8 bytes.`);
-    }
-    const time = payload.manufacture_time;
-    if (!time || typeof time !== 'object') {
-        throw invalidParameter$1('Parameter [manufacture_time] is required.');
-    }
-    const manufactureTime = {
-        year: validateIntegerInRange(time.year, 'manufacture_time.year', 2000, 9999),
-        month: validateIntegerInRange(time.month, 'manufacture_time.month', 1, 12),
-        day: validateIntegerInRange(time.day, 'manufacture_time.day', 1, 31),
-        hour: validateIntegerInRange(time.hour, 'manufacture_time.hour', 0, 23),
-        minute: validateIntegerInRange(time.minute, 'manufacture_time.minute', 0, 59),
-        second: validateIntegerInRange(time.second, 'manufacture_time.second', 0, 59),
-    };
-    const normalizedDate = new Date(Date.UTC(manufactureTime.year, manufactureTime.month - 1, manufactureTime.day, manufactureTime.hour, manufactureTime.minute, manufactureTime.second));
-    if (normalizedDate.getUTCFullYear() !== manufactureTime.year ||
-        normalizedDate.getUTCMonth() + 1 !== manufactureTime.month ||
-        normalizedDate.getUTCDate() !== manufactureTime.day) {
-        throw invalidParameter$1('Parameter [manufacture_time] must be a valid calendar date.');
-    }
-    return {
-        version: validateIntegerInRange(payload.version, 'version', 0, 255),
-        serial_number: serialNumber,
-        burn_in_completed: validateRequiredBoolean(payload.burn_in_completed, 'burn_in_completed'),
-        factory_test_completed: validateRequiredBoolean(payload.factory_test_completed, 'factory_test_completed'),
-        manufacture_time: manufactureTime,
-    };
-}
-function validateDeviceFactoryCertificateWriteParams(payload) {
-    return Object.assign({ certificate: validateHexBytes(payload.certificate, 'certificate', {
-            maxBytes: FACTORY_CERTIFICATE_MAX_BYTES,
-        }) }, (payload.privateKey === undefined
-        ? {}
-        : {
-            privateKey: validateHexBytes(payload.privateKey, 'privateKey', {
-                exactBytes: FACTORY_PRIVATE_KEY_BYTES,
-            }),
-        }));
-}
-function validateDeviceFactoryChallengeSignParams(payload) {
-    return {
-        digest: validateHexBytes(payload.digest, 'digest', {
-            exactBytes: FACTORY_CHALLENGE_DIGEST_BYTES,
-        }),
-    };
-}
 const DEVICE_REBOOT_TYPES = {
     Normal: hdTransport.DeviceRebootType.Normal,
     normal: hdTransport.DeviceRebootType.Normal,
@@ -49544,7 +49520,6 @@ const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set([
 new Map(Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) => INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value]] : []));
 
 const Log$5 = getLogger(exports.LoggerNames.Method);
-const SESSION_ERROR = 'session not found';
 const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
 const PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
@@ -50255,14 +50230,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             }
             if (this.isProtocolV2BootloaderMode()) {
                 Log$5.debug('Protocol V2 device is already in bootloader mode, skip reboot');
+                this.postTipMessage(exports.FirmwareUpdateTipMessage.GoToBootloaderSuccess);
                 return false;
             }
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.AutoRebootToBootloader);
                 yield this.protocolV2Reboot(hdTransport.DeviceRebootType.Bootloader);
-                this.postTipMessage(exports.FirmwareUpdateTipMessage.GoToBootloaderSuccess);
                 yield hdShared.wait(1000);
                 yield this.waitForProtocolV2BootloaderMode();
+                this.postTipMessage(exports.FirmwareUpdateTipMessage.GoToBootloaderSuccess);
                 return true;
             }
             catch (error) {
@@ -50718,29 +50694,43 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     protocolV2WriteWholeFile({ payload, filePath, processedSize, totalSize, onTransferredBytes, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const chunkSize = this.getProtocolV2FirmwareChunkSize();
-            let offset = 0;
             const getUploadProgress = (fileOffset) => {
                 if (totalSize !== undefined && processedSize !== undefined) {
                     return Math.min(Math.ceil(((processedSize + fileOffset) / totalSize) * 100), 99);
                 }
                 return Math.min(Math.ceil((fileOffset / payload.byteLength) * 100), 99);
             };
-            while (offset < payload.byteLength) {
-                const chunkEnd = Math.min(offset + chunkSize, payload.byteLength);
-                const chunkLength = chunkEnd - offset;
-                const chunk = payload.slice(offset, chunkEnd);
-                const overwrite = offset === 0;
-                const progress = getProtocolV2DeviceTransferProgress((processedSize !== null && processedSize !== void 0 ? processedSize : 0) + offset, (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + chunkEnd, totalSize !== null && totalSize !== void 0 ? totalSize : payload.byteLength);
-                const writeRes = yield this.fileWriteChunk(filePath, payload.byteLength, offset, chunk, overwrite, progress);
-                const rawProcessedByte = writeRes.message.processed_byte;
-                const processedByte = Number(rawProcessedByte);
-                const nextOffset = rawProcessedByte === undefined ? offset + chunkLength : processedByte;
-                if (!Number.isFinite(nextOffset) || nextOffset <= offset || nextOffset > chunkEnd) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${writeRes.message.processed_byte} for offset ${offset}`);
+            try {
+                yield writeProtocolV2File({
+                    commands: this.device.getCommands(),
+                    path: filePath,
+                    data: payload,
+                    totalSize: payload.byteLength,
+                    chunkSize,
+                    overwrite: true,
+                    append: false,
+                    writeWithResponse: true,
+                    maxChunkRetries: 0,
+                    getUiPercentage: ({ offset, chunkLength }) => getProtocolV2DeviceTransferProgress((processedSize !== null && processedSize !== void 0 ? processedSize : 0) + offset, (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + offset + chunkLength, totalSize !== null && totalSize !== void 0 ? totalSize : payload.byteLength),
+                    onProgress: progress => {
+                        const transferredBytes = (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + progress.transferredBytes;
+                        onTransferredBytes === null || onTransferredBytes === void 0 ? void 0 : onTransferredBytes(transferredBytes);
+                        this.postProgressMessage(getUploadProgress(progress.transferredBytes), 'transferData', {
+                            transferredBytes,
+                            totalBytes: totalSize !== null && totalSize !== void 0 ? totalSize : payload.byteLength,
+                            rateBytesPerSecond: progress.rateBytesPerSecond,
+                            elapsedMs: progress.elapsedMs,
+                        });
+                    },
+                });
+            }
+            catch (error) {
+                if (error instanceof hdShared.HardwareError &&
+                    error.errorCode === hdShared.HardwareErrorCode.RuntimeError &&
+                    error.message.includes('FilesystemFileWrite')) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, error.message);
                 }
-                offset = nextOffset;
-                onTransferredBytes === null || onTransferredBytes === void 0 ? void 0 : onTransferredBytes((processedSize !== null && processedSize !== void 0 ? processedSize : 0) + offset);
-                this.postProgressMessage(getUploadProgress(offset), 'transferData');
+                throw error;
             }
             return totalSize !== undefined ? (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + payload.byteLength : 0;
         });
@@ -50756,32 +50746,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         }
         return env !== null && env !== void 0 ? env : 'unknown';
     }
-    fileWriteChunk(filePath, totalFileSize, offset, chunk, overwrite, progress) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-            const writeRes = yield typedCall('FilesystemFileWrite', 'FilesystemFile', {
-                file: {
-                    path: filePath,
-                    offset,
-                    total_size: totalFileSize,
-                    data: chunk,
-                },
-                overwrite,
-                append: false,
-                ui_percentage: progress !== null && progress !== void 0 ? progress : undefined,
-            }, { writeWithResponse: true });
-            if (writeRes.type !== 'FilesystemFile') {
-                if (writeRes.type === 'CallMethodError') {
-                    if (((_a = writeRes.message.error) !== null && _a !== void 0 ? _a : '').indexOf(SESSION_ERROR) > -1) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR);
-                    }
-                }
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
-            }
-            return writeRes;
-        });
-    }
     recoverProtocolV2FileTransfer() {
         return __awaiter(this, void 0, void 0, function* () {
             const env = DataManager.getSettings('env');
@@ -50939,215 +50903,6 @@ class DeviceGetOnboardingStatus extends BaseMethod {
     }
 }
 
-class DeviceFactoryInfoGet extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V2'];
-    }
-    init() {
-        this.skipForceUpdateCheck = true;
-        this.useDevicePassphraseState = false;
-        this.unlockPolicy = 'none';
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = undefined;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DeviceFactoryInfoGet', 'DeviceFactoryInfo', {});
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceFactoryCertificateRead extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V2'];
-    }
-    init() {
-        this.skipForceUpdateCheck = true;
-        this.useDevicePassphraseState = false;
-        this.unlockPolicy = 'none';
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = undefined;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DeviceCertificateRead', 'DeviceCertificate', {});
-            return res.message;
-        });
-    }
-}
-
-class DeviceFactoryChallengeSign extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V2'];
-    }
-    init() {
-        this.skipForceUpdateCheck = true;
-        this.useDevicePassphraseState = false;
-        this.unlockPolicy = 'none';
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = validateDeviceFactoryChallengeSignParams(this.payload);
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DeviceCertificateSign', 'DeviceCertificateSignature', { data: this.params.digest });
-            return res.message;
-        });
-    }
-}
-
-const MIN_FILE_CHUNK_SIZE = 64;
-const FILE_TRANSFER_RATE_WINDOW_MS = 1000;
-function isProtocolV2ResponseTimeout(error) {
-    var _a, _b;
-    if (!error || typeof error !== 'object')
-        return false;
-    const candidate = error;
-    const code = (_a = candidate.errorCode) !== null && _a !== void 0 ? _a : candidate.code;
-    return (code === hdShared.HardwareErrorCode.BleTimeoutError ||
-        code === 'response-timeout' ||
-        /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test((_b = candidate.message) !== null && _b !== void 0 ? _b : ''));
-}
-function getProtocolV2FileChunkLimit() {
-    const env = DataManager.getSettings('env');
-    return env && DataManager.isBleConnect(env)
-        ? hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
-        : hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
-}
-function dataToUint8Array(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof data === 'string')
-            return new TextEncoder().encode(data);
-        if (data instanceof ArrayBuffer)
-            return new Uint8Array(data);
-        if (ArrayBuffer.isView(data)) {
-            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        }
-        if (typeof Blob !== 'undefined' && data instanceof Blob) {
-            return new Uint8Array(yield data.arrayBuffer());
-        }
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Unsupported FilesystemFileWrite data');
-    });
-}
-function normalizeChunkSize(value, maxChunkSize) {
-    const numeric = Number(value);
-    if (!Number.isFinite(numeric) || numeric <= 0)
-        return maxChunkSize;
-    return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
-}
-function getDeviceTransferProgress(before, after, total) {
-    if (!Number.isFinite(total) || total <= 0)
-        return 100;
-    if (before <= 0 && after < total)
-        return 0;
-    if (after >= total)
-        return 100;
-    return Math.min(Math.max(Math.ceil((after / total) * 100), 1), 99);
-}
-function getConfirmedProgress(processed, total, written, length) {
-    if (Number.isFinite(processed) && Number.isFinite(total) && total > 0) {
-        if (processed >= total)
-            return 100;
-        return Math.min(Math.max(Math.floor((processed / total) * 100), 0), 99);
-    }
-    if (length > 0)
-        return written >= length ? 100 : Math.floor((written / length) * 100);
-    return 100;
-}
-function writeProtocolV2File(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-    return __awaiter(this, void 0, void 0, function* () {
-        (_a = options.throwIfAborted) === null || _a === void 0 ? void 0 : _a.call(options);
-        const data = yield dataToUint8Array(options.data);
-        const dataLength = data.byteLength;
-        const startOffset = Number.isFinite(options.offset) && Number(options.offset) > 0 ? Number(options.offset) : 0;
-        const totalSize = Number.isFinite(options.totalSize) && Number(options.totalSize) > 0
-            ? Number(options.totalSize)
-            : startOffset + dataLength;
-        if (totalSize < startOffset + dataLength) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${startOffset + dataLength}`);
-        }
-        const chunkSize = normalizeChunkSize((_b = options.chunkSize) !== null && _b !== void 0 ? _b : options.chunkLen, getProtocolV2FileChunkLimit());
-        let written = 0;
-        let chunks = 0;
-        let lastMessage;
-        const startTime = Date.now();
-        let rateWindowStartedAt = startTime;
-        let rateWindowStartedBytes = 0;
-        let rateBytesPerSecond;
-        while (written < dataLength) {
-            (_c = options.throwIfAborted) === null || _c === void 0 ? void 0 : _c.call(options);
-            const chunk = data.slice(written, Math.min(written + chunkSize, dataLength));
-            const offset = startOffset + written;
-            const progress = (_d = options.uiPercentage) !== null && _d !== void 0 ? _d : getDeviceTransferProgress(offset, offset + chunk.byteLength, totalSize);
-            const request = {
-                file: { path: options.path, offset, total_size: totalSize, data: chunk },
-                overwrite: chunks === 0 ? (_e = options.overwrite) !== null && _e !== void 0 ? _e : false : false,
-                append: (_f = options.append) !== null && _f !== void 0 ? _f : false,
-                ui_percentage: progress,
-            };
-            const maxChunkRetries = Math.max(Math.floor((_g = options.maxChunkRetries) !== null && _g !== void 0 ? _g : 0), 0);
-            let retryCount = 0;
-            let response;
-            let isWritePending = true;
-            while (isWritePending) {
-                try {
-                    response = yield options.commands.typedCall('FilesystemFileWrite', 'FilesystemFile', request, { timeoutMs: options.timeoutMs });
-                    isWritePending = false;
-                }
-                catch (error) {
-                    if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error))
-                        throw error;
-                    retryCount += 1;
-                    (_h = options.throwIfAborted) === null || _h === void 0 ? void 0 : _h.call(options);
-                }
-            }
-            if (!response) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'FilesystemFileWrite completed without a response');
-            }
-            (_j = options.throwIfAborted) === null || _j === void 0 ? void 0 : _j.call(options);
-            lastMessage = response.message;
-            const rawProcessedByte = (_k = response.message) === null || _k === void 0 ? void 0 : _k.processed_byte;
-            const processedByte = Number(rawProcessedByte);
-            if (rawProcessedByte !== undefined &&
-                (!Number.isFinite(processedByte) ||
-                    processedByte <= offset ||
-                    processedByte > offset + chunk.byteLength)) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite invalid processed_byte ${processedByte}`);
-            }
-            written =
-                rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
-            chunks += 1;
-            const now = Date.now();
-            const elapsedMs = now - startTime;
-            const transferredBytes = Math.min(written, dataLength);
-            const rateWindowElapsedMs = now - rateWindowStartedAt;
-            if (rateWindowElapsedMs >= FILE_TRANSFER_RATE_WINDOW_MS) {
-                const rateWindowBytes = Math.max(transferredBytes - rateWindowStartedBytes, 0);
-                rateBytesPerSecond = Math.round((rateWindowBytes / rateWindowElapsedMs) * 1000);
-                rateWindowStartedAt = now;
-                rateWindowStartedBytes = transferredBytes;
-            }
-            else if (rateBytesPerSecond === undefined && elapsedMs > 0) {
-                rateBytesPerSecond = Math.round((transferredBytes / elapsedMs) * 1000);
-            }
-            (_l = options.onProgress) === null || _l === void 0 ? void 0 : _l.call(options, {
-                progress: getConfirmedProgress(startOffset + written, totalSize, written, dataLength),
-                transferredBytes,
-                totalBytes: dataLength,
-                rateBytesPerSecond,
-                elapsedMs,
-            });
-            if (options.paceMs && options.paceMs > 0) {
-                yield new Promise(resolve => {
-                    setTimeout(resolve, options.paceMs);
-                });
-            }
-        }
-        return Object.assign(Object.assign({}, lastMessage), { path: options.path, offset: startOffset, total_size: totalSize, processed_byte: startOffset + written, chunks });
-    });
-}
-
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 function normalizeFileName(fileName, data) {
@@ -51961,9 +51716,10 @@ class AllNetworkGetAddressBase extends BaseMethod {
                             }
                         }
                         const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
+                        const deriveCardano = method.name.startsWith('cardano');
                         const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
                         if (this.device.isProtocolV2() && shouldResumeWalletSession) {
-                            const passphraseStateSafety = yield this.device.checkPassphraseStateSafety(this.payload.passphraseState, useEmptyPassphrase, this.payload.skipPassphraseCheck);
+                            const passphraseStateSafety = yield this.device.checkPassphraseStateSafety(this.payload.passphraseState, useEmptyPassphrase, this.payload.skipPassphraseCheck, deriveCardano);
                             if (!passphraseStateSafety) {
                                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError);
                             }
@@ -53644,7 +53400,7 @@ class ConfluxSignTransaction extends BaseMethod {
     }
 }
 
-function getAddressLegacyV1$1 ({ typedCall, param, }) {
+function getAddressLegacyV1 ({ typedCall, param, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             address_n: param.address_n,
@@ -53663,7 +53419,7 @@ function getAddress ({ typedCall, param, }) {
 
 const shouldUseLegacyV1EvmMessages = (device) => !device.isProtocolV2() && TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema';
 
-class EvmGetAddress$1 extends BaseMethod {
+class EvmGetAddress extends BaseMethod {
     constructor() {
         super(...arguments);
         this.hasBundle = false;
@@ -53698,7 +53454,7 @@ class EvmGetAddress$1 extends BaseMethod {
     getEvmAddress(param) {
         return __awaiter(this, void 0, void 0, function* () {
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return getAddressLegacyV1$1({
+                return getAddressLegacyV1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     param,
                 });
@@ -53740,7 +53496,7 @@ function getPublicKey ({ typedCall, param, }) {
     });
 }
 
-function getPublicKeyLegacyV1$1 ({ typedCall, param, }) {
+function getPublicKeyLegacyV1 ({ typedCall, param, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             address_n: param.address_n,
@@ -53751,7 +53507,7 @@ function getPublicKeyLegacyV1$1 ({ typedCall, param, }) {
     });
 }
 
-class EVMGetPublicKey$1 extends BaseMethod {
+class EVMGetPublicKey extends BaseMethod {
     constructor() {
         super(...arguments);
         this.hasBundle = false;
@@ -53789,7 +53545,7 @@ class EVMGetPublicKey$1 extends BaseMethod {
     }
     getEvmPublicKey(param) {
         if (shouldUseLegacyV1EvmMessages(this.device)) {
-            return getPublicKeyLegacyV1$1({
+            return getPublicKeyLegacyV1({
                 typedCall: this.device.commands.typedCall.bind(this.device.commands),
                 param,
             });
@@ -53841,7 +53597,7 @@ function signMessage ({ typedCall, params, }) {
     });
 }
 
-function signMessageLegacyV1$1 ({ typedCall, params, }) {
+function signMessageLegacyV1 ({ typedCall, params, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             address_n: params.address_n,
@@ -53853,7 +53609,7 @@ function signMessageLegacyV1$1 ({ typedCall, params, }) {
     });
 }
 
-class EVMSignMessage$4 extends BaseMethod {
+class EVMSignMessage$2 extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -53878,7 +53634,7 @@ class EVMSignMessage$4 extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return signMessageLegacyV1$1({
+                return signMessageLegacyV1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     params: this.params,
                 });
@@ -54084,7 +53840,7 @@ const evmSignTxEip7702 = ({ typedCall, addressN, tx, supportTrezor, }) => __awai
         supportTrezor,
     });
 });
-const signTransaction$2 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTransaction$1 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) => __awaiter(void 0, void 0, void 0, function* () {
     if (isEIP7702) {
         return evmSignTxEip7702({ typedCall, addressN, tx: tx });
     }
@@ -54093,7 +53849,7 @@ const signTransaction$2 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) =
         : evmSignTx({ typedCall, addressN, tx: tx });
 });
 
-const signTransaction$1 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTransaction = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) => __awaiter(void 0, void 0, void 0, function* () {
     if (isEIP7702) {
         return evmSignTxEip7702({
             typedCall,
@@ -54113,7 +53869,7 @@ const signTransaction$1 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) =
     return evmSignTx({ typedCall, addressN, tx: tx, supportTrezor: true });
 });
 
-class EVMSignTransaction$1 extends BaseMethod {
+class EVMSignTransaction extends BaseMethod {
     constructor() {
         super(...arguments);
         this.addressN = [];
@@ -54198,7 +53954,7 @@ class EVMSignTransaction$1 extends BaseMethod {
             if (formattedTx == null)
                 throw hdShared.ERRORS.TypedError('Runtime', 'formattedTx is not set');
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return signTransaction$1({
+                return signTransaction({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     addressN,
                     tx: formattedTx,
@@ -54206,7 +53962,7 @@ class EVMSignTransaction$1 extends BaseMethod {
                     isEIP7702,
                 });
             }
-            return signTransaction$2({
+            return signTransaction$1({
                 typedCall: this.device.commands.typedCall.bind(this.device.commands),
                 addressN,
                 tx: formattedTx,
@@ -54217,7 +53973,7 @@ class EVMSignTransaction$1 extends BaseMethod {
     }
 }
 
-const signTypedHash$2 = ({ typedCall, addressN, device, chainId, domainHash, messageHash, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTypedHash$1 = ({ typedCall, addressN, device, chainId, domainHash, messageHash, }) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const deviceType = device.getCurrentDeviceType();
     if (deviceType === hdShared.EDeviceType.Touch || deviceType === hdShared.EDeviceType.Pro) {
@@ -54236,7 +53992,7 @@ const signTypedHash$2 = ({ typedCall, addressN, device, chainId, domainHash, mes
     return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', message);
 });
 
-const signTypedHash$1 = ({ typedCall, addressN, device, chainId, domainHash, messageHash, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTypedHash = ({ typedCall, addressN, device, chainId, domainHash, messageHash, }) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const deviceType = device.getCurrentDeviceType();
     if (deviceType === hdShared.EDeviceType.Touch || deviceType === hdShared.EDeviceType.Pro) {
@@ -54254,7 +54010,7 @@ const signTypedHash$1 = ({ typedCall, addressN, device, chainId, domainHash, mes
     });
 });
 
-const signTypedData$2 = ({ typedCall, addressN, data, metamaskV4Compat, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTypedData$1 = ({ typedCall, addressN, data, metamaskV4Compat, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { primaryType } = data;
     const message = {
         address_n: addressN,
@@ -54271,7 +54027,7 @@ const signTypedData$2 = ({ typedCall, addressN, data, metamaskV4Compat, chainId,
     return response;
 });
 
-const signTypedData$1 = ({ typedCall, addressN, data, metamaskV4Compat, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTypedData = ({ typedCall, addressN, data, metamaskV4Compat, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { primaryType } = data;
     return typedCall('EthereumSignTypedDataOneKey', [
         'EthereumTypedDataStructRequestOneKey',
@@ -54405,7 +54161,7 @@ const MINI_MAX_NAME_LENGTH = 63;
 const MINI_MAX_DYNAMIC_VALUE_BYTES = 1536;
 const MINI_MAX_ARRAY_TYPE_FIELDS = 24;
 const MINI_MAX_ARRAY_ELEMENTS = 24;
-class EVMSignTypedData$1 extends BaseMethod {
+class EVMSignTypedData extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -54560,7 +54316,7 @@ class EVMSignTypedData$1 extends BaseMethod {
             let response;
             if (shouldUseLegacyV1EvmMessages(this.device)) {
                 supportTrezor = true;
-                response = yield signTypedData$2({
+                response = yield signTypedData$1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     addressN,
                     data,
@@ -54569,7 +54325,7 @@ class EVMSignTypedData$1 extends BaseMethod {
                 });
             }
             else {
-                response = yield signTypedData$1({
+                response = yield signTypedData({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     addressN,
                     data,
@@ -54589,7 +54345,7 @@ class EVMSignTypedData$1 extends BaseMethod {
         if (!domainHash)
             throw hdShared.ERRORS.TypedError('Runtime', 'domainHash is required');
         if (shouldUseLegacyV1EvmMessages(this.device)) {
-            return signTypedHash$2({
+            return signTypedHash$1({
                 typedCall,
                 addressN,
                 domainHash,
@@ -54598,7 +54354,7 @@ class EVMSignTypedData$1 extends BaseMethod {
                 device: this.device,
             });
         }
-        return signTypedHash$1({
+        return signTypedHash({
             typedCall,
             addressN,
             domainHash,
@@ -54819,7 +54575,7 @@ class EVMSignTypedData$1 extends BaseMethod {
     }
 }
 
-function verifyMessageLegacyV1$1 ({ typedCall, params, }) {
+function verifyMessageLegacyV1 ({ typedCall, params, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             signature: params.signature,
@@ -54839,7 +54595,7 @@ function verifyMessage ({ typedCall, params, }) {
     });
 }
 
-class EVMSignMessage$3 extends BaseMethod {
+class EVMSignMessage$1 extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -54863,7 +54619,7 @@ class EVMSignMessage$3 extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return verifyMessageLegacyV1$1({
+                return verifyMessageLegacyV1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     params: this.params,
                 });
@@ -55027,7 +54783,7 @@ class StarcoinSignTransaction extends BaseMethod {
     }
 }
 
-class EVMSignMessage$2 extends BaseMethod {
+class EVMSignMessage extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -55054,7 +54810,7 @@ class EVMSignMessage$2 extends BaseMethod {
     }
 }
 
-const MAINNET$1 = 0x68;
+const MAINNET = 0x68;
 class NEMGetAddress extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -55082,7 +54838,7 @@ class NEMGetAddress extends BaseMethod {
             const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
             this.params.push({
                 address_n: addressN,
-                network: batch.network || MAINNET$1,
+                network: batch.network || MAINNET,
                 show_display: showOnOneKey,
             });
         });
@@ -61182,7 +60938,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     checkBootloaderRelease: CheckBootloaderRelease,
     checkAllFirmwareRelease: CheckAllFirmwareRelease,
     checkFirmwareTypeAvailable: CheckFirmwareTypeAvailable,
-    deviceBackup: DeviceBackup$1,
+    deviceBackup: DeviceBackup,
     deviceChangePin: DeviceChangePin,
     deviceFlags: DeviceFlags,
     deviceRebootToBootloader: DeviceRebootToBootloader,
@@ -61209,9 +60965,6 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     promptWebDeviceAccess: PromptWebDeviceAccess,
     deviceReboot: DeviceReboot,
     deviceGetOnboardingStatus: DeviceGetOnboardingStatus,
-    deviceReadFactoryInfo: DeviceFactoryInfoGet,
-    deviceReadFactoryCertificate: DeviceFactoryCertificateRead,
-    deviceSignFactoryChallenge: DeviceFactoryChallengeSign,
     deviceUploadWallpaper: DeviceUploadWallpaper,
     deviceUploadNft: DeviceUploadNft,
     uploadPortfolio: UploadPortfolio,
@@ -61228,18 +60981,18 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     confluxSignMessage: ConfluxSignMessage,
     confluxSignMessageCIP23: ConfluxSignMessageCIP23,
     confluxSignTransaction: ConfluxSignTransaction,
-    evmGetAddress: EvmGetAddress$1,
-    evmGetPublicKey: EVMGetPublicKey$1,
-    evmSignMessage: EVMSignMessage$4,
+    evmGetAddress: EvmGetAddress,
+    evmGetPublicKey: EVMGetPublicKey,
+    evmSignMessage: EVMSignMessage$2,
     evmSignMessageEIP712: EVMSignMessageEIP712,
-    evmSignTransaction: EVMSignTransaction$1,
-    evmSignTypedData: EVMSignTypedData$1,
-    evmVerifyMessage: EVMSignMessage$3,
+    evmSignTransaction: EVMSignTransaction,
+    evmSignTypedData: EVMSignTypedData,
+    evmVerifyMessage: EVMSignMessage$1,
     starcoinGetAddress: StarcoinGetAddress,
     starcoinGetPublicKey: StarcoinGetPublicKey,
     starcoinSignMessage: StarcoinSignMessage,
     starcoinSignTransaction: StarcoinSignTransaction,
-    starcoinVerifyMessage: EVMSignMessage$2,
+    starcoinVerifyMessage: EVMSignMessage,
     nemGetAddress: NEMGetAddress,
     nemSignTransaction: NEMSignTransaction,
     solGetAddress: SolGetAddress,
@@ -61310,25 +61063,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
 });
 
 const publicMethodRegistry = ApiMethods;
-const findExtensionMethod = (method, extensions) => {
-    var _a;
-    let match;
-    for (const extension of extensions) {
-        const constructor = extension.methods[method];
-        if (constructor) {
-            if (match) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is registered by multiple extensions`);
-            }
-            match = {
-                constructor,
-                destructive: ((_a = extension.destructiveMethods) === null || _a === void 0 ? void 0 : _a.includes(method)) === true,
-            };
-        }
-    }
-    return match;
-};
-function findMethod(message, options = {}) {
-    var _a;
+function findMethod(message) {
     const { method } = message.payload;
     if (typeof method !== 'string') {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
@@ -61337,13 +61072,6 @@ function findMethod(message, options = {}) {
     if (MethodConstructor) {
         return new MethodConstructor(message);
     }
-    const extensionMethod = findExtensionMethod(method, (_a = options.extensions) !== null && _a !== void 0 ? _a : []);
-    if (extensionMethod) {
-        if (extensionMethod.destructive && options.allowDestructiveOperations !== true) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Destructive method ${method} requires allowDestructiveOperations`);
-        }
-        return new extensionMethod.constructor(message);
-    }
     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
 }
 
@@ -61362,10 +61090,19 @@ class DeviceConnector {
         this.transport = TransportManager.getTransport();
         DevicePool.setConnector(this);
     }
+    getActiveTransport() {
+        var _a;
+        const transport = (_a = this.transport) !== null && _a !== void 0 ? _a : TransportManager.getTransport();
+        if (!transport) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotConfigured, 'Device connector was created before transport initialization');
+        }
+        this.transport = transport;
+        return transport;
+    }
     enumerate() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const descriptors = yield this.transport.enumerate();
+                const descriptors = yield this.getActiveTransport().enumerate();
                 this.upcoming = descriptors;
                 this._reportDevicesChange();
                 return { descriptors };
@@ -61382,11 +61119,10 @@ class DeviceConnector {
             this.listening = true;
             let descriptors;
             try {
+                const transport = this.getActiveTransport();
                 Log$2.debug('Start listening', current);
                 this.listenTimestamp = new Date().getTime();
-                descriptors = waitForEvent
-                    ? yield this.transport.listen(current)
-                    : yield this.transport.enumerate();
+                descriptors = waitForEvent ? yield transport.listen(current) : yield transport.enumerate();
                 if (!this.listening)
                     return;
                 this.upcoming = descriptors;
@@ -61417,9 +61153,10 @@ class DeviceConnector {
             Log$2.debug('acquire', path, session, expectedProtocol, protocolHint);
             const env = DataManager.getSettings('env');
             try {
+                const transport = this.getActiveTransport();
                 let res;
                 if (DataManager.isBleConnect(env)) {
-                    res = yield this.transport.acquire({
+                    res = yield transport.acquire({
                         uuid: path,
                         forceCleanRunPromise,
                         expectedProtocol,
@@ -61427,7 +61164,7 @@ class DeviceConnector {
                     });
                 }
                 else {
-                    res = yield this.transport.acquire({
+                    res = yield transport.acquire({
                         path,
                         previous: session !== null && session !== void 0 ? session : null,
                         expectedProtocol,
@@ -61435,7 +61172,10 @@ class DeviceConnector {
                     });
                 }
                 if (expectedProtocol) {
-                    const detectedProtocol = this.transport.getProtocolType(path);
+                    const acquiredProtocol = typeof res === 'object' && res !== null
+                        ? res.protocolType
+                        : undefined;
+                    const detectedProtocol = acquiredProtocol !== null && acquiredProtocol !== void 0 ? acquiredProtocol : transport.getProtocolType(path);
                     if (detectedProtocol !== expectedProtocol) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expectedProtocol}, detected ${detectedProtocol}`);
                     }
@@ -61451,7 +61191,7 @@ class DeviceConnector {
     release(session, onclose) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const res = yield this.transport.release(session, onclose);
+                const res = yield this.getActiveTransport().release(session, onclose);
                 return res;
             }
             catch (error) {
@@ -61462,8 +61202,9 @@ class DeviceConnector {
     disconnect(session) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (this.transport.disconnect && !!session) {
-                    yield this.transport.disconnect(session);
+                const transport = this.getActiveTransport();
+                if (transport.disconnect && !!session) {
+                    yield transport.disconnect(session);
                 }
             }
             catch (error) {
@@ -61472,10 +61213,11 @@ class DeviceConnector {
         });
     }
     promptDeviceAccess() {
-        if (!this.transport.promptDeviceAccess) {
+        const transport = this.getActiveTransport();
+        if (!transport.promptDeviceAccess) {
             return Promise.resolve(null);
         }
-        return this.transport.promptDeviceAccess();
+        return transport.promptDeviceAccess();
     }
     _reportDevicesChange() {
         DevicePool.reportDeviceChange(this.upcoming);
@@ -61746,10 +61488,7 @@ const callAPI = (context, message) => __awaiter(void 0, void 0, void 0, function
     }
     let method;
     try {
-        method = findMethod(message, {
-            extensions: context.methodExtensions,
-            allowDestructiveOperations: context.allowDestructiveOperations,
-        });
+        method = findMethod(message);
         method.connector = _connector;
         const shouldPostMessage = createUiProgressMessageFilter();
         method.postMessage = event => {
@@ -62074,6 +61813,10 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
                 completeMethodRequestContext(method);
             }
             catch (error) {
+                if (!requestQueue.getTask(method.responseID)) {
+                    Log.debug(`Call API - Ignore late inner method result`, error);
+                    return;
+                }
                 Log.debug(`Call API - Inner Method Run Error`, error);
                 messageResponse = createResponseMessage(method.responseID, false, { error });
                 requestQueue.resolveRequest(method.responseID, messageResponse);
@@ -62656,22 +62399,18 @@ const createUiPromise = (promiseEvent, device) => {
 const removeUiPromise = (promise) => {
     _uiPromises = _uiPromises.filter(p => p !== promise);
 };
-class Core extends events.exports.EventEmitter {
-    constructor(options = {}) {
+class Core extends events.exports {
+    constructor() {
         super();
         this.requestQueue = new RequestQueue();
         this.methodSynchronize = getSynchronize();
-        this.options = options;
         this.tracingContext = createSdkTracingContext();
         this.sdkInstanceId = this.tracingContext.sdkInstanceId;
         Log.debug(`[Core] Created SDK instance: ${this.sdkInstanceId}`);
     }
     getCoreContext() {
-        var _a;
         return {
             sdkInstanceId: this.sdkInstanceId,
-            methodExtensions: (_a = this.options.methodExtensions) !== null && _a !== void 0 ? _a : [],
-            allowDestructiveOperations: this.options.allowDestructiveOperations === true,
             tracingContext: this.tracingContext,
             requestQueue: this.requestQueue,
             methodSynchronize: this.methodSynchronize,
@@ -62780,8 +62519,8 @@ class Core extends events.exports.EventEmitter {
         });
     }
 }
-const initCore = (options) => {
-    const core = new Core(options);
+const initCore = () => {
+    const core = new Core();
     _core = core;
     return core;
 };
@@ -62798,25 +62537,21 @@ const initConnector = () => {
 const initTransport = (Transport, plugin) => {
     TransportManager.setTransport(Transport, plugin);
 };
-const init = (settings, Transport, plugin, options) => __awaiter(void 0, void 0, void 0, function* () {
+const init = (settings, Transport, plugin) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        try {
-            yield DataManager.load(settings);
-            initTransport(Transport, plugin);
-        }
-        catch (_s) {
-            Log.error('DataManager.load error');
-        }
+        yield DataManager.load(settings);
+        initTransport(Transport, plugin);
         enableLog(DataManager.getSettings('debug'));
         if (DataManager.getSettings('env') !== 'react-native') {
             setLoggerPostMessage(postMessage);
         }
-        initCore(options);
+        initCore();
         initConnector();
         return _core;
     }
     catch (error) {
         Log.error('core init', error);
+        throw error;
     }
 });
 const switchTransport = ({ env, Transport, plugin, }) => {
@@ -62828,2189 +62563,6 @@ const switchTransport = ({ env, Transport, plugin, }) => {
     initConnector();
 };
 
-class DeviceFactoryInfoSet extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V2'];
-    }
-    init() {
-        this.skipForceUpdateCheck = true;
-        this.useDevicePassphraseState = false;
-        this.unlockPolicy = 'none';
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
-        this.params = validateDeviceFactoryInfoSetParams(this.payload);
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DeviceFactoryInfoSet', 'Success', {
-                info: {
-                    version: this.params.version,
-                    serial_number: this.params.serial_number,
-                    burn_in_completed: this.params.burn_in_completed,
-                    factory_test_completed: this.params.factory_test_completed,
-                    manufacture_time: this.params.manufacture_time,
-                },
-            });
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceFactoryCertificateWrite extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V2'];
-    }
-    init() {
-        this.skipForceUpdateCheck = true;
-        this.useDevicePassphraseState = false;
-        this.unlockPolicy = 'none';
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.requireDeviceMode = [UI_REQUEST.BOOTLOADER];
-        this.params = validateDeviceFactoryCertificateWriteParams(this.payload);
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DeviceCertificateWrite', 'Success', {
-                cert: {
-                    cert_and_pubkey: this.params.certificate,
-                    private_key: this.params.privateKey,
-                },
-            });
-            return res.message;
-        });
-    }
-}
-
-var FactoryMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    deviceProvisionFactoryInfo: DeviceFactoryInfoSet,
-    deviceWriteFactoryCertificate: DeviceFactoryCertificateWrite
-});
-
-class BTCGetOwnershipId extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const { path, coin } = this.payload;
-        const addressN = validatePath(path);
-        const { coinName, scriptType } = getCoinAndScriptType(addressN, coin, false);
-        this.params = {
-            address_n: addressN,
-            coin_name: coinName,
-            multisig: this.payload.multisig,
-            script_type: scriptType || 'SPENDADDRESS',
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('GetOwnershipId', 'OwnershipId', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class BTCGetOwnershipProof extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const { path, coin } = this.payload;
-        const addressN = validatePath(path);
-        const { coinName, scriptType } = getCoinAndScriptType(addressN, coin, false);
-        this.params = {
-            address_n: addressN,
-            coin_name: coinName,
-            multisig: this.payload.multisig,
-            script_type: scriptType || 'SPENDADDRESS',
-            user_confirmation: this.payload.user_confirmation,
-            ownership_ids: this.payload.ownership_ids,
-            commitment_data: this.payload.commitment_data,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('GetOwnershipProof', 'OwnershipProof', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class BTCAuthorizeCoinJoin extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const { path, coin } = this.payload;
-        const addressN = validatePath(path);
-        const { coinName, scriptType } = getCoinAndScriptType(addressN, coin, false);
-        this.params = {
-            address_n: addressN,
-            coin_name: coinName,
-            script_type: scriptType || 'SPENDADDRESS',
-            coordinator: this.payload.coordinator,
-            max_total_fee: this.payload.max_total_fee,
-            fee_per_anonymity: this.payload.fee_per_anonymity,
-            amount_unit: this.payload.amount_unit,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('AuthorizeCoinJoin', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class CryptoBatchGetPublickeys extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.params = {
-            ecdsa_curve_name: this.payload.ecdsa_curve_name,
-            paths: this.payload.paths.map((path) => {
-                const addressN = validatePath(path);
-                return {
-                    address_n: addressN,
-                    show_display: this.payload.show_display,
-                };
-            }),
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('BatchGetPublickeys', 'EcdsaPublicKeys', this.params);
-        });
-    }
-}
-
-class CryptoCipherKeyValue extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const addressN = validatePath(this.payload.path);
-        this.params = {
-            address_n: addressN,
-            key: this.payload.key,
-            value: this.payload.key,
-            encrypt: this.payload.key,
-            ask_on_encrypt: this.payload.key,
-            ask_on_decrypt: this.payload.key,
-            iv: this.payload.key,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('CipherKeyValue', 'CipheredKeyValue', this.params);
-        });
-    }
-}
-
-class CryptoCosiCommit extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const addressN = validatePath(this.payload.path);
-        this.params = {
-            address_n: addressN,
-            data: this.payload.data,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('CosiCommit', 'CosiCommitment', this.params);
-        });
-    }
-}
-
-class CryptoCosiSign extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const addressN = validatePath(this.payload.path);
-        this.params = {
-            address_n: addressN,
-            data: this.payload.data,
-            global_commitment: this.payload.global_commitment,
-            global_pubkey: this.payload.global_pubkey,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('CosiSign', 'CosiSignature', this.params);
-        });
-    }
-}
-
-class CryptoGetECDHSessionKey extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.params = {
-            identity: this.payload.identity,
-            peer_public_key: this.payload.peer_public_key,
-            ecdsa_curve_name: this.payload.ecdsa_curve_name,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('GetECDHSessionKey', 'ECDHSessionKey', this.params);
-        });
-    }
-}
-
-class CryptoSignIdentity extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.params = {
-            identity: this.payload.identity,
-            challenge_hidden: this.payload.challenge_hidden,
-            challenge_visual: this.payload.challenge_visual,
-            ecdsa_curve_name: this.payload.ecdsa_curve_name,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('SignIdentity', 'ECDHSessionKey', this.params);
-        });
-    }
-}
-
-function getAddressLegacyV1 ({ typedCall, param, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const message = {
-            address_n: param.address_n,
-            show_display: param.show_display,
-            chain_id: param.chain_id,
-        };
-        return typedCall('EthereumGetAddress', 'EthereumAddress', message);
-    });
-}
-
-class EvmGetAddress extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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' },
-                { name: 'chainId', type: 'number' },
-            ]);
-            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
-            this.params.push({
-                address_n: addressN,
-                show_display: showOnOneKey,
-                chain_id: batch.chainId,
-            });
-        });
-    }
-    getEvmAddress(param) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return getAddressLegacyV1({
-                typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                param,
-            });
-        });
-    }
-    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.getEvmAddress(param);
-                const { address } = res.message;
-                if (!address) {
-                    throw new Error('EthereumGetAddress: address is undefined');
-                }
-                const result = {
-                    path: serializedPath(param.address_n),
-                    address,
-                };
-                responses.push(result);
-                this.postPreviousAddressMessage(result);
-            }
-            return Promise.resolve(this.hasBundle ? responses : responses[0]);
-        });
-    }
-}
-
-function getPublicKeyLegacyV1 ({ typedCall, param, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const message = {
-            address_n: param.address_n,
-            show_display: param.show_display,
-            chain_id: param.chain_id,
-        };
-        return typedCall('EthereumGetPublicKey', 'EthereumPublicKey', message);
-    });
-}
-
-class EVMGetPublicKey extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-        this.confirmShowOnOneKey = false;
-        this.useBatch = false;
-    }
-    init() {
-        var _a, _b, _c;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
-        this.confirmShowOnOneKey = (_c = (_b = this.payload) === null || _b === void 0 ? void 0 : _b.bundle) === null || _c === void 0 ? void 0 : _c.some((item) => !!item.showOnOneKey);
-        this.useBatch = !this.confirmShowOnOneKey && this.hasBundle && this.payload.useBatch;
-        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' },
-                { name: 'chainId', type: 'number' },
-            ]);
-            const showOnOneKey = (_a = batch.showOnOneKey) !== null && _a !== void 0 ? _a : true;
-            this.params.push({
-                address_n: addressN,
-                show_display: showOnOneKey,
-                chain_id: batch.chainId,
-            });
-        });
-    }
-    getEvmPublicKey(param) {
-        return getPublicKeyLegacyV1({
-            typedCall: this.device.commands.typedCall.bind(this.device.commands),
-            param,
-        });
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const responses = [];
-            if (this.useBatch && supportBatchPublicKeyByDevice(this.device)) {
-                try {
-                    const res = yield batchGetPublickeys(this.device, this.params, 'secp256k1', 60, {
-                        includeNode: false,
-                        ignoreCoinType: true,
-                    });
-                    const result = res.public_keys.map((publicKey, index) => ({
-                        path: serializedPath(this.params[index].address_n),
-                        pub: publicKey,
-                        publicKey,
-                    }));
-                    validateResult(result, ['pub'], {
-                        expectedLength: this.params.length,
-                    });
-                    return yield Promise.resolve(result);
-                }
-                catch (e) {
-                }
-            }
-            for (let i = 0; i < this.params.length; i++) {
-                const param = this.params[i];
-                const res = yield this.getEvmPublicKey(param);
-                responses.push(Object.assign({ path: serializedPath(param.address_n), pub: res.message.node.public_key, publicKey: res.message.node.public_key }, res.message));
-            }
-            validateResult(responses, ['pub'], {
-                expectedLength: this.params.length,
-            });
-            return Promise.resolve(this.hasBundle ? responses : responses[0]);
-        });
-    }
-}
-
-function signMessageLegacyV1 ({ typedCall, params, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const message = {
-            address_n: params.address_n,
-            message: params.message,
-            chain_id: params.chain_id,
-        };
-        const res = yield typedCall('EthereumSignMessage', 'EthereumMessageSignature', message);
-        return Promise.resolve(res.message);
-    });
-}
-
-class EVMSignMessage$1 extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        validateParams(this.payload, [
-            { name: 'path', required: true },
-            { name: 'messageHex', type: 'hexString', required: true },
-            { name: 'chainId', type: 'number' },
-        ]);
-        const { path, messageHex, chainId } = this.payload;
-        const addressN = validatePath(path, 3);
-        this.params = {
-            address_n: addressN,
-            message: formatAnyHex(messageHex),
-            chain_id: chainId,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return signMessageLegacyV1({
-                typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                params: this.params,
-            });
-        });
-    }
-}
-
-const signTransaction = ({ typedCall, isEIP1559, addressN, tx, }) => __awaiter(void 0, void 0, void 0, function* () {
-    return isEIP1559
-        ? evmSignTxEip1559({
-            typedCall,
-            addressN,
-            tx: tx,
-            supportTrezor: true,
-        })
-        : evmSignTx({ typedCall, addressN, tx: tx, supportTrezor: true });
-});
-
-class EVMSignTransaction extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.addressN = [];
-        this.isEIP1559 = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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;
-        this.isEIP1559 = !!tx.maxFeePerGas && !!tx.maxPriorityFeePerGas;
-        const schema = [
-            { name: 'to', type: 'hexString', required: true },
-            { name: 'value', type: 'hexString', required: true },
-            { name: 'gasLimit', type: 'hexString', required: true },
-            { name: 'nonce', type: 'hexString', required: true },
-            { name: 'chainId', type: 'number', required: true },
-            { name: 'data', type: 'hexString' },
-        ];
-        if (this.isEIP1559) {
-            schema.push({ name: 'maxFeePerGas', type: 'hexString', required: true });
-            schema.push({ name: 'maxPriorityFeePerGas', type: 'hexString', required: true });
-        }
-        else {
-            schema.push({ name: 'gasPrice', type: 'hexString', required: true });
-            schema.push({ name: 'txType', type: 'number' });
-        }
-        validateParams(tx, schema);
-        this.formattedTx = formatAnyHex(tx);
-    }
-    getVersionRange() {
-        if (this.isEIP1559) {
-            return {
-                model_mini: {
-                    min: '2.1.11',
-                },
-            };
-        }
-        return {
-            model_mini: {
-                min: '1.0.0',
-            },
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { addressN, isEIP1559, formattedTx } = this;
-            if (formattedTx == null)
-                throw hdShared.ERRORS.TypedError('Runtime', 'formattedTx is not set');
-            return signTransaction({
-                typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                addressN,
-                tx: formattedTx,
-                isEIP1559,
-            });
-        });
-    }
-}
-
-const signTypedHash = ({ typedCall, addressN, device, chainId, domainHash, messageHash, }) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const deviceType = device.getCurrentDeviceType();
-    if (deviceType === hdShared.EDeviceType.Touch || deviceType === hdShared.EDeviceType.Pro) {
-        const currentVersion = (_a = device.getCurrentFirmwareVersionString()) !== null && _a !== void 0 ? _a : '0.0.0';
-        const supportNestedArraysSignVersion = '4.2.0';
-        if (semver__default["default"].lt(currentVersion, supportNestedArraysSignVersion)) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodNeedUpgradeFirmware, `Device firmware version is too low, please update to ${supportNestedArraysSignVersion}`, { current: currentVersion, require: supportNestedArraysSignVersion });
-        }
-    }
-    const message = {
-        address_n: addressN,
-        domain_separator_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
-        message_hash: messageHash,
-        chain_id: chainId,
-    };
-    return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', message);
-});
-
-const signTypedData = ({ typedCall, addressN, data, metamaskV4Compat, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
-    const { primaryType } = data;
-    const message = {
-        address_n: addressN,
-        primary_type: primaryType,
-        metamask_v4_compat: metamaskV4Compat,
-        chain_id: chainId,
-    };
-    const response = yield typedCall('EthereumSignTypedData', [
-        'EthereumTypedDataStructRequest',
-        'EthereumTypedDataValueRequest',
-        'EthereumTypedDataSignature',
-        'EthereumGnosisSafeTxRequest',
-    ], message);
-    return response;
-});
-
-class EVMSignTypedData extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        validateParams(this.payload, [
-            { name: 'path', required: true },
-            { name: 'metamaskV4Compat', type: 'boolean' },
-            { name: 'data', type: 'object' },
-            { name: 'domainHash', type: 'hexString' },
-            { name: 'messageHash', type: 'hexString' },
-            { name: 'chainId', type: 'number' },
-        ]);
-        const { path, data, metamaskV4Compat, domainHash, messageHash, chainId } = this.payload;
-        const addressN = validatePath(path, 3);
-        this.params = {
-            addressN,
-            metamaskV4Compat,
-            data,
-            chainId,
-        };
-        if (domainHash) {
-            this.params.domainHash = formatAnyHex(domainHash);
-            if (messageHash) {
-                this.params.messageHash = formatAnyHex(messageHash);
-            }
-            else if (!!data && (!data.primaryType || data.primaryType !== 'EIP712Domain')) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'message_hash should only be empty when data.primaryType=EIP712Domain');
-            }
-        }
-    }
-    handleSignTypedData({ typedCall, signData, response, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { types, primaryType, domain, message, } = signData;
-            while (response.type === 'EthereumTypedDataStructRequest') {
-                const { name: typeDefinitionName } = response.message;
-                const typeDefinition = types[typeDefinitionName];
-                if (typeDefinition === undefined) {
-                    throw hdShared.ERRORS.TypedError('Runtime', `Type ${typeDefinitionName} was not defined in types object`);
-                }
-                const dataStruckAck = {
-                    members: typeDefinition.map(({ name, type: typeName }) => ({
-                        name,
-                        type: getFieldType(typeName, types),
-                    })),
-                };
-                response = yield typedCall('EthereumTypedDataStructAck', [
-                    'EthereumTypedDataStructRequest',
-                    'EthereumTypedDataValueRequest',
-                    'EthereumTypedDataSignature',
-                ], dataStruckAck);
-            }
-            while (response.type === 'EthereumTypedDataValueRequest') {
-                const { member_path } = response.message;
-                let memberData;
-                let memberTypeName;
-                const [rootIndex, ...nestedMemberPath] = member_path;
-                switch (rootIndex) {
-                    case 0:
-                        memberData = domain;
-                        memberTypeName = 'EIP712Domain';
-                        break;
-                    case 1:
-                        memberData = message;
-                        memberTypeName = primaryType;
-                        break;
-                    default:
-                        throw hdShared.ERRORS.TypedError('Runtime', 'Root index can only be 0 or 1');
-                }
-                for (const index of nestedMemberPath) {
-                    if (Array.isArray(memberData)) {
-                        memberTypeName = parseArrayType(memberTypeName).entryTypeName;
-                        memberData = memberData[index];
-                    }
-                    else if (typeof memberData === 'object' && memberData !== null) {
-                        const memberTypeDefinition = types[memberTypeName][index];
-                        memberTypeName = memberTypeDefinition.type;
-                        memberData = memberData[memberTypeDefinition.name];
-                    }
-                    else ;
-                }
-                let encodedData;
-                if (Array.isArray(memberData)) {
-                    encodedData = encodeData('uint16', memberData.length);
-                }
-                else {
-                    encodedData = encodeData(memberTypeName, memberData);
-                }
-                response = yield typedCall('EthereumTypedDataValueAck', ['EthereumTypedDataValueRequest', 'EthereumTypedDataSignature'], {
-                    value: encodedData,
-                });
-            }
-            if (response.type !== 'EthereumTypedDataSignature') {
-                throw hdShared.ERRORS.TypedError('Runtime', 'Unexpected response type');
-            }
-            const { address, signature } = response.message;
-            return {
-                address,
-                signature,
-            };
-        });
-    }
-    signTypedData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { addressN, data, metamaskV4Compat, chainId } = this.params;
-            const response = yield signTypedData({
-                typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                addressN,
-                data,
-                metamaskV4Compat,
-                chainId,
-            });
-            return this.handleSignTypedData({
-                typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                signData: data,
-                response,
-            });
-        });
-    }
-    signTypedHash({ typedCall, addressN, domainHash, messageHash, chainId, }) {
-        if (!domainHash)
-            throw hdShared.ERRORS.TypedError('Runtime', 'domainHash is required');
-        return signTypedHash({
-            typedCall,
-            addressN,
-            chainId,
-            domainHash,
-            messageHash,
-            device: this.device,
-        });
-    }
-    getVersionRange() {
-        return {
-            model_mini: {
-                min: '2.1.9',
-            },
-        };
-    }
-    hasBiggerData(item) {
-        const data = lodash.get(item.message, 'data', undefined);
-        if (!data)
-            return false;
-        let biggerLimit = 1024;
-        const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
-        const supportBiggerDataVersion = '4.4.0';
-        if (semver__default["default"].gte(currentVersion, supportBiggerDataVersion)) {
-            biggerLimit = 1536;
-        }
-        const startIndex = data.startsWith('0x') ? 2 : 0;
-        return (data.length - startIndex) / 2 > biggerLimit;
-    }
-    hasNestedArrays(item) {
-        if (!item)
-            return false;
-        if (Array.isArray(item)) {
-            for (const element of item) {
-                if (Array.isArray(element)) {
-                    return true;
-                }
-                if (typeof element === 'object' && element !== null) {
-                    if (this.hasNestedArrays(element)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        else if (typeof item === 'object' && item !== null) {
-            for (const property in item) {
-                if (this.hasNestedArrays(item[property])) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    supportSignTyped() {
-        const deviceType = getDeviceType(this.device.features);
-        if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-            const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
-            const supportSignTypedVersion = '2.2.0';
-            if (semver__default["default"].lt(currentVersion, supportSignTypedVersion)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device.features) {
-                throw hdShared.ERRORS.TypedError('Device_InitializeFailed', 'Device initialization failed. Please try again.');
-            }
-            const { addressN, chainId } = this.params;
-            const deviceType = getDeviceType(this.device.features);
-            if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-                validateParams(this.params, [
-                    { name: 'domainHash', type: 'hexString', required: true },
-                    { name: 'messageHash', type: 'hexString', required: true },
-                ]);
-                const { domainHash, messageHash } = this.params;
-                let response;
-                if (this.supportSignTyped()) {
-                    response = yield this.signTypedHash({
-                        typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                        addressN,
-                        chainId,
-                        domainHash,
-                        messageHash,
-                    });
-                }
-                else {
-                    response = yield this.device.commands.typedCall('EthereumSignMessageEIP712', 'EthereumMessageSignature', {
-                        address_n: addressN,
-                        domain_hash: domainHash !== null && domainHash !== void 0 ? domainHash : '',
-                        message_hash: messageHash !== null && messageHash !== void 0 ? messageHash : '',
-                    });
-                }
-                return Promise.resolve(response.message);
-            }
-            if (this.hasNestedArrays(this.params.data) || this.hasBiggerData(this.params.data)) {
-                validateParams(this.params, [
-                    { name: 'domainHash', type: 'hexString', required: true },
-                    { name: 'messageHash', type: 'hexString', required: true },
-                ]);
-                const { domainHash, messageHash } = this.params;
-                if (!domainHash)
-                    throw hdShared.ERRORS.TypedError('Runtime', 'domainHash is required');
-                const response = yield this.signTypedHash({
-                    typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                    addressN,
-                    chainId,
-                    domainHash,
-                    messageHash,
-                });
-                return Promise.resolve(response.message);
-            }
-            return this.signTypedData();
-        });
-    }
-}
-
-function verifyMessageLegacyV1 ({ typedCall, params, }) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const message = {
-            signature: params.signature,
-            message: params.message,
-            address: params.address,
-            chain_id: params.chain_id,
-        };
-        const res = yield typedCall('EthereumVerifyMessage', 'Success', message);
-        return Promise.resolve(res.message);
-    });
-}
-
-class EVMSignMessage extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        validateParams(this.payload, [
-            { name: 'address', type: 'string', required: true },
-            { name: 'messageHex', type: 'hexString', required: true },
-            { name: 'signature', type: 'hexString', required: true },
-            { name: 'chainId', type: 'number' },
-        ]);
-        const { address, messageHex, signature } = formatAnyHex(this.payload);
-        this.params = {
-            address,
-            message: messageHex,
-            signature,
-            chain_id: this.payload.chainId,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return verifyMessageLegacyV1({
-                typedCall: this.device.commands.typedCall.bind(this.device.commands),
-                params: this.params,
-            });
-        });
-    }
-}
-
-const MAINNET = 0x68;
-class NEMDecryptMessage extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.params = {
-            address_n: validatePath(this.payload.path, 3),
-            network: (_a = this.payload.network) !== null && _a !== void 0 ? _a : MAINNET,
-            public_key: this.payload.public_key,
-            payload: this.payload.payload,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('NEMDecryptMessage', 'NEMDecryptedMessage', Object.assign({}, this.params));
-        });
-    }
-}
-
-class DeviceSpiFlashWrite extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            address: this.payload.address,
-            data: formatAnyHex(this.payload.data),
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('SpiFlashWrite', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceSpiFlashRead extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            address: this.payload.address,
-            len: formatAnyHex(this.payload.data),
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('SpiFlashRead', 'SpiFlashData', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceInfoSettings extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.skipForceUpdateCheck = true;
-        this.params = {
-            serial_no: this.payload.serial_no,
-            cpu_info: this.payload.cpu_info,
-            pre_firmware: this.payload.pre_firmware,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DeviceInfoSettings', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class GetDeviceInfoSettings extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.skipForceUpdateCheck = true;
-        this.params = {};
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('GetDeviceInfo', 'DeviceInfo');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceReadSEPublicCert extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ReadSEPublicCert', 'SEPublicCert');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceWriteSEPrivateKey extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            private_key: this.payload.private_key,
-        };
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('WriteSEPrivateKey', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceWriteSEPublicCert extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            public_cert: this.payload.public_cert,
-        };
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('WriteSEPublicCert', 'Success', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceSESignMessage extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            message: this.payload.message,
-        };
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('SESignMessage', 'SEMessageSignature', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DevicePing extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            message: this.payload.message,
-            button_protection: this.payload.button_protection,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('Ping', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceGetEntropy extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            size: this.payload.size,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('GetEntropy', 'Entropy', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceGetFirmwareHash extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            challenge: this.payload.challenge,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('GetFirmwareHash', 'FirmwareHash', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceUnlockPath extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        const addressN = validatePath(this.payload.address_n, 3);
-        this.params = {
-            address_n: addressN,
-            mac: this.payload.mac,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('UnlockPath', 'UnlockedPathRequest', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceSdProtect extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            operation: this.payload.operation,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('SdProtect', 'Success');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceChangeWipeCode extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            remove: this.payload.remove,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ChangeWipeCode', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceEndSession extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            size: this.payload.size,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EndSession', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceLoad extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            mnemonics: this.payload.mnemonics.split(' '),
-            pin: this.payload.pin,
-            passphrase_protection: this.payload.passphrase_protection,
-            language: this.payload.language,
-            label: this.payload.label,
-            skip_checksum: this.payload.skip_checksum,
-            u2f_counter: this.payload.u2f_counter,
-            needs_backup: this.payload.needs_backup,
-            no_backup: this.payload.no_backup,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('LoadDevice', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceDoPreauthorized extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DoPreauthorized', 'Success');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DeviceCancelAuthorization extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('CancelAuthorization', 'Success');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcDirList extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            path: this.payload.path,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcDirList', 'EmmcDir', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcDirMake extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            path: this.payload.path,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcDirMake', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcDirRemove extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            path: this.payload.path,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcDirRemove', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcFileDelete extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            path: this.payload.path,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcFileDelete', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcFileRead extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            file: this.payload.file,
-            ui_percentage: this.payload.ui_percentage,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcFileRead', 'EmmcFile', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcFileWrite extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            file: this.payload.file,
-            overwrite: this.payload.overwrite,
-            append: this.payload.append,
-            ui_percentage: this.payload.ui_percentage,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcFileWrite', 'EmmcFile', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcFixPermission extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcFixPermission', 'Success');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class EmmcPathInfo extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {
-            path: this.payload.path,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EmmcPathInfo', 'EmmcFile');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkDecision extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            yes_no: this.payload.yes_no,
-            swipe: this.payload.swipe,
-            input: this.payload.input,
-            x: this.payload.x,
-            y: this.payload.y,
-            wait: this.payload.wait,
-            hold_ms: this.payload.hold_ms,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkDecision', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkEraseSdCard extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            format: this.payload.format,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkEraseSdCard', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkFlashErase extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            sector: this.payload.sector,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkFlashErase', 'DebugLinkLayout', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkGetState extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {};
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkGetState', 'DebugLinkLog', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkMemoryRead extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            address: this.payload.address,
-            length: this.payload.length,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkMemoryRead', 'DebugLinkMemory', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkMemoryWrite extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            address: this.payload.address,
-            memory: this.payload.memory,
-            flash: this.payload.flash,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkMemoryWrite', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkRecordScreen extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            target_directory: this.payload.target_directory,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkRecordScreen', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkReseedRandom extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            value: this.payload.value,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkReseedRandom', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkStop extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            wait_word_list: this.payload.wait_word_list,
-            wait_word_pos: this.payload.wait_word_pos,
-            wait_layout: this.payload.wait_layout,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkGetState', 'DebugLinkState', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class DebugLinkWatchLayout extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            watch: this.payload.watch,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('DebugLinkWatchLayout', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class FirmwareErase extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.getCommands().typedCall('FirmwareErase', 'Success');
-        });
-    }
-}
-
-class FirmwareEraseEx extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.getCommands().typedCall('FirmwareErase_ex', 'Success');
-        });
-    }
-}
-
-class FirmwareUpdateEmmcTest extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-        this.params = {
-            path: this.payload.path,
-            reboot_on_success: this.payload.reboot_on_success,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.getCommands().typedCall('FirmwareUpdateEmmc', 'Success', this.params);
-        });
-    }
-}
-
-class FirmwareUploadTest extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-        this.params = {
-            payload: new ArrayBuffer(0),
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.getCommands().typedCall('FirmwareUpload', 'Success', this.params);
-        });
-    }
-}
-
-class Reboot extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-        this.params = {
-            reboot_type: this.payload.reboot_type,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.getCommands().typedCall('Reboot', 'Success', this.params);
-        });
-    }
-}
-
-class SelfTest extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-        this.params = {
-            payload: this.payload.payload,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.getCommands().typedCall('SelfTest', 'Success', this.params);
-        });
-    }
-}
-
-class TezosGetAddress extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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,
-            });
-        });
-    }
-    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('TezosGetAddress', 'TezosAddress', Object.assign({}, param));
-                const { address } = res.message;
-                const result = {
-                    path: serializedPath(param.address_n),
-                    address,
-                };
-                responses.push(result);
-                this.postPreviousAddressMessage(result);
-            }
-            return Promise.resolve(this.hasBundle ? responses : responses[0]);
-        });
-    }
-}
-
-class TezosGetPublicKey extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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,
-            });
-        });
-    }
-    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('TezosGetPublicKey', 'TezosPublicKey', Object.assign({}, param));
-                const { public_key } = res.message;
-                const result = {
-                    path: serializedPath(param.address_n),
-                    public_key,
-                };
-                responses.push(result);
-                this.postPreviousAddressMessage(result);
-            }
-            return Promise.resolve(this.hasBundle ? responses : responses[0]);
-        });
-    }
-}
-
-class TezosSignTx extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const { path } = this.payload;
-        const addressN = validatePath(path, 3);
-        this.params = {
-            address_n: addressN,
-            branch: new Uint8Array(4),
-            reveal: this.payload.reveal,
-            transaction: this.payload.transaction,
-            origination: this.payload.origination,
-            delegation: this.payload.delegation,
-            proposal: this.payload.proposal,
-            ballot: this.payload.ballot,
-        };
-    }
-    getVersionRange() {
-        return {
-            model_mini: {
-                min: '2.5.0',
-            },
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('TezosSignTx', 'TezosSignedTx', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class MoneroGetAddress extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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,
-            });
-        });
-    }
-    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('MoneroGetAddress', 'MoneroAddress', Object.assign({}, param));
-                const { address } = res.message;
-                const result = {
-                    path: serializedPath(param.address_n),
-                    address,
-                };
-                responses.push(result);
-                this.postPreviousAddressMessage(result);
-            }
-            return Promise.resolve(this.hasBundle ? responses : responses[0]);
-        });
-    }
-}
-
-class MoneroGetWatchKey extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_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) => {
-            const addressN = validatePath(batch.path, 3);
-            const { network_type } = batch;
-            this.params.push({
-                address_n: addressN,
-                network_type,
-            });
-        });
-    }
-    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('MoneroGetWatchKey', 'MoneroWatchKey', Object.assign({}, param));
-                const { address, watch_key } = res.message;
-                const result = {
-                    path: serializedPath(param.address_n),
-                    address,
-                    watch_key,
-                };
-                responses.push(result);
-                this.postPreviousAddressMessage(result);
-            }
-            return Promise.resolve(this.hasBundle ? responses : responses[0]);
-        });
-    }
-}
-
-class EosGetPublicKey extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.params = {
-            address_n: validatePath(this.payload.path, 3),
-            show_display: (_a = this.payload.showOnOneKey) !== null && _a !== void 0 ? _a : true,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('EosGetPublicKey', 'EosPublicKey', Object.assign({}, this.params));
-        });
-    }
-}
-
-class EosSignTx extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const { path } = this.payload;
-        const addressN = validatePath(path, 3);
-        this.params = {
-            address_n: addressN,
-            chain_id: this.payload.chain_id,
-            header: this.payload.header,
-            num_actions: this.payload.num_actions,
-        };
-    }
-    getVersionRange() {
-        return {
-            model_mini: {
-                min: '2.5.0',
-            },
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('EosSignTx', 'EosTxActionRequest', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class BinanceGetAddress extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.params = {
-            address_n: validatePath(this.payload.path, 3),
-            show_display: (_a = this.payload.showOnOneKey) !== null && _a !== void 0 ? _a : true,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('BinanceGetAddress', 'BinanceAddress', Object.assign({}, this.params));
-        });
-    }
-}
-
-class BinanceGetPublicKey extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        var _a;
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        this.params = {
-            address_n: validatePath(this.payload.path, 3),
-            show_display: (_a = this.payload.showOnOneKey) !== null && _a !== void 0 ? _a : true,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('BinanceGetPublicKey', 'BinancePublicKey', Object.assign({}, this.params));
-        });
-    }
-}
-
-class BinanceSignTx extends BaseMethod {
-    init() {
-        this.checkDeviceId = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-        const { path } = this.payload;
-        const addressN = validatePath(path, 3);
-        this.params = {
-            address_n: addressN,
-            msg_count: this.payload.msg_count,
-            account_number: this.payload.account_number,
-            chain_id: this.payload.chain_id,
-            memo: this.payload.memo,
-            sequence: this.payload.sequence,
-            source: this.payload.source,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('BinanceSignTx', 'BinanceTxRequest', Object.assign({}, this.params));
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class WebAuthnAddResidentCredential extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.params = {
-            credential_id: this.payload.credential_id,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('WebAuthnAddResidentCredential', 'Success', Object.assign({}, this.params));
-        });
-    }
-}
-
-class WebAuthnListResidentCredentials extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.params = {};
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('WebAuthnListResidentCredentials', 'WebAuthnCredentials', Object.assign({}, this.params));
-        });
-    }
-}
-
-class WebAuthnRemoveResidentCredential extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.params = {
-            index: this.payload.index,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('WebAuthnRemoveResidentCredential', 'Success', Object.assign({}, this.params));
-        });
-    }
-}
-
-class GetPublicKeyMultiple extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            addresses: this.payload.addresses,
-            ecdsa_curve_name: this.payload.ecdsa_curve_name,
-            show_display: this.payload.show_display,
-            coin_name: this.payload.coin_name,
-            script_type: this.payload.script_type,
-            ignore_xpub_magic: this.payload.ignore_xpub_magic,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('GetPublicKeyMultiple', 'PublicKeyMultiple');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class ListResDir extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            path: this.payload.path,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ListResDir', 'FileInfoList');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class NFTWriteData extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            index: this.payload.index,
-            data: this.payload.data,
-            offset: this.payload.offset,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('NFTWriteData', 'Success');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class NFTWriteInfo extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            index: this.payload.index,
-            width: this.payload.width,
-            height: this.payload.height,
-            name_zh: this.payload.name_zh,
-            name_en: this.payload.name_en,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('NFTWriteInfo', 'Success');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class ReadSEPublicKey extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.params = {};
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('ReadSEPublicKey', 'SEPublicKey');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class ResourceUpdate extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            name: this.payload.name,
-            data: this.payload.data,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield updateResource(this.device.commands.typedCall.bind(this.device.commands), this.payload.name, this.payload.data);
-            return Promise.resolve(true);
-        });
-    }
-}
-
-class DeviceBackup extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('BixinBackupDevice', 'Success');
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class BixinLoadDevice extends BaseMethod {
-    init() {
-        this.useDevicePassphraseState = false;
-        this.params = {
-            mnemonics: this.payload.mnemonics,
-            language: this.payload.language,
-            label: this.payload.label,
-            skip_checksum: this.payload.skip_checksum,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('BixinLoadDevice', 'Success', this.params);
-            return Promise.resolve(res.message);
-        });
-    }
-}
-
-class BixinMessageSE extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.params = {
-            inputmessage: this.payload.inputmessage,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('BixinMessageSE', 'BixinOutMessageSE', Object.assign({}, this.params));
-        });
-    }
-}
-
-class BixinVerifyDeviceRequest extends BaseMethod {
-    constructor() {
-        super(...arguments);
-        this.hasBundle = false;
-    }
-    init() {
-        this.checkDeviceId = true;
-        this.params = {
-            data: this.payload.data,
-        };
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.device.commands.typedCall('BixinVerifyDeviceRequest', 'BixinVerifyDeviceAck', Object.assign({}, this.params));
-        });
-    }
-}
-
-var TestMethods = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    btcGetOwnershipId: BTCGetOwnershipId,
-    btcGetOwnershipProof: BTCGetOwnershipProof,
-    btcAuthorizeCoinJoin: BTCAuthorizeCoinJoin,
-    cryptoBatchGetPublickeys: CryptoBatchGetPublickeys,
-    cryptoCipherKeyValue: CryptoCipherKeyValue,
-    cryptoCosiCommit: CryptoCosiCommit,
-    cryptoCosiSign: CryptoCosiSign,
-    cryptoGetECDHSessionKey: CryptoGetECDHSessionKey,
-    cryptoSignIdentity: CryptoSignIdentity,
-    evmGetAddressTrezor: EvmGetAddress,
-    evmGetPublicKeyTrezor: EVMGetPublicKey,
-    evmSignMessageTrezor: EVMSignMessage$1,
-    evmSignTransactionTrezor: EVMSignTransaction,
-    evmSignTypedDataTrezor: EVMSignTypedData,
-    evmVerifyMessageTrezor: EVMSignMessage,
-    nemDecryptMessage: NEMDecryptMessage,
-    deviceSpiFlashWrite: DeviceSpiFlashWrite,
-    deviceSpiFlashRead: DeviceSpiFlashRead,
-    deviceInfoSettings: DeviceInfoSettings,
-    deviceGetInfo: GetDeviceInfoSettings,
-    deviceReadSEPublicCert: DeviceReadSEPublicCert,
-    deviceWriteSEPrivateKey: DeviceWriteSEPrivateKey,
-    deviceWriteSEPublicCert: DeviceWriteSEPublicCert,
-    deviceSESignMessage: DeviceSESignMessage,
-    devicePing: DevicePing,
-    deviceGetEntropy: DeviceGetEntropy,
-    deviceGetFirmwareHash: DeviceGetFirmwareHash,
-    deviceUnlockPath: DeviceUnlockPath,
-    deviceSdProtect: DeviceSdProtect,
-    deviceChangeWipeCode: DeviceChangeWipeCode,
-    deviceEndSession: DeviceEndSession,
-    deviceLoad: DeviceLoad,
-    deviceDoPreauthorized: DeviceDoPreauthorized,
-    deviceCancelAuthorization: DeviceCancelAuthorization,
-    emmcDirList: EmmcDirList,
-    emmcDirMake: EmmcDirMake,
-    emmcDirRemove: EmmcDirRemove,
-    emmcFileDelete: EmmcFileDelete,
-    emmcFileRead: EmmcFileRead,
-    emmcFileWrite: EmmcFileWrite,
-    emmcFixPermission: EmmcFixPermission,
-    emmcPathInfo: EmmcPathInfo,
-    debugLinkDecision: DebugLinkDecision,
-    debugLinkEraseSdCard: DebugLinkEraseSdCard,
-    debugLinkFlashErase: DebugLinkFlashErase,
-    debugLinkGetState: DebugLinkGetState,
-    debugLinkMemoryRead: DebugLinkMemoryRead,
-    debugLinkMemoryWrite: DebugLinkMemoryWrite,
-    debugLinkRecordScreen: DebugLinkRecordScreen,
-    debugLinkReseedRandom: DebugLinkReseedRandom,
-    debugLinkStop: DebugLinkStop,
-    debugLinkWatchLayout: DebugLinkWatchLayout,
-    firmwareErase: FirmwareErase,
-    firmwareEraseEx: FirmwareEraseEx,
-    firmwareUpdateEmmcTest: FirmwareUpdateEmmcTest,
-    firmwareUploadTest: FirmwareUploadTest,
-    reboot: Reboot,
-    selfTest: SelfTest,
-    tezosGetAddress: TezosGetAddress,
-    tezosGetPublicKey: TezosGetPublicKey,
-    tezosSignTx: TezosSignTx,
-    moneroGetAddress: MoneroGetAddress,
-    moneroGetWatchKey: MoneroGetWatchKey,
-    eosGetPublicKey: EosGetPublicKey,
-    eosSignTx: EosSignTx,
-    binanceGetAddress: BinanceGetAddress,
-    binanceGetPublicKey: BinanceGetPublicKey,
-    binanceSignTx: BinanceSignTx,
-    webAuthnAddResidentCredential: WebAuthnAddResidentCredential,
-    webAuthnListResidentCredentials: WebAuthnListResidentCredentials,
-    webAuthnRemoveResidentCredential: WebAuthnRemoveResidentCredential,
-    getPublicKeyMultiple: GetPublicKeyMultiple,
-    listResDir: ListResDir,
-    nftWriteData: NFTWriteData,
-    nftWriteInfo: NFTWriteInfo,
-    readSEPublicKey: ReadSEPublicKey,
-    resourceUpdate: ResourceUpdate,
-    bixinBackupDevice: DeviceBackup,
-    bixinLoadDevice: BixinLoadDevice,
-    bixinMessageSE: BixinMessageSE,
-    bixinVerifyDeviceRequest: BixinVerifyDeviceRequest
-});
-
-const testApiMethodExtension = {
-    name: 'test-api',
-    methods: TestMethods,
-};
-const factoryApiMethodExtension = {
-    name: 'factory-api',
-    methods: FactoryMethods,
-    destructiveMethods: FACTORY_API_METHOD_NAMES,
-};
-
 const HardwareSdk = ({ init, call, dispose, eventEmitter, uiResponse, cancel, updateSettings, switchTransport, }) => inject({
     init,
     call,
@@ -65061,7 +62613,6 @@ exports.DEVICE_SETTINGS_V2_ONLY_FIELDS = DEVICE_SETTINGS_V2_ONLY_FIELDS;
 exports.DataManager = DataManager;
 exports.DeviceModelToTypes = DeviceModelToTypes;
 exports.DeviceTypeToModels = DeviceTypeToModels;
-exports.FACTORY_API_METHOD_NAMES = FACTORY_API_METHOD_NAMES;
 exports.FIRMWARE = FIRMWARE;
 exports.FIRMWARE_EVENT = FIRMWARE_EVENT;
 exports.HardwareSDKLowLevel = HardwareSDKLowLevel;
@@ -65075,7 +62626,6 @@ exports.PRO2_WALLPAPER_HEIGHT = PRO2_WALLPAPER_HEIGHT;
 exports.PRO2_WALLPAPER_WIDTH = PRO2_WALLPAPER_WIDTH;
 exports.PROTOCOL_V2_NEVER_TIMEOUT_MS = PROTOCOL_V2_NEVER_TIMEOUT_MS;
 exports.RESPONSE_EVENT = RESPONSE_EVENT;
-exports.TEST_API_METHOD_NAMES = TEST_API_METHOD_NAMES;
 exports.UI_EVENT = UI_EVENT;
 exports.UI_REQUEST = UI_REQUEST;
 exports.UI_RESPONSE = UI_RESPONSE;
@@ -65087,21 +62637,18 @@ exports.completeRequestContext = completeRequestContext;
 exports.corsValidator = corsValidator;
 exports.createDeviceMessage = createDeviceMessage;
 exports.createErrorMessage = createErrorMessage;
-exports.createFactoryApi = createFactoryApi;
 exports.createFirmwareMessage = createFirmwareMessage;
 exports.createIFrameMessage = createIFrameMessage;
 exports.createLogMessage = createLogMessage;
 exports.createRequestContext = createRequestContext;
 exports.createResponseMessage = createResponseMessage;
 exports.createSdkTracingContext = createSdkTracingContext;
-exports.createTestApi = createTestApi;
 exports.createUiMessage = createUiMessage;
 exports.createUiResponse = createUiResponse;
 exports["default"] = HardwareSdk;
 exports.enableLog = enableLog;
 exports.encodePro2Wallpaper = encodePro2Wallpaper;
 exports.executeCallback = executeCallback;
-exports.factoryApiMethodExtension = factoryApiMethodExtension;
 exports.formatLogMethodLabel = formatLogMethodLabel;
 exports.formatRequestContext = formatRequestContext;
 exports.generateInstanceId = generateInstanceId;
@@ -65154,7 +62701,6 @@ exports.safeThrowError = safeThrowError;
 exports.setLoggerPostMessage = setLoggerPostMessage;
 exports.supportInputPinOnSoftware = supportInputPinOnSoftware;
 exports.switchTransport = switchTransport;
-exports.testApiMethodExtension = testApiMethodExtension;
 exports.updateRequestContext = updateRequestContext;
 exports.versionCompare = versionCompare;
 exports.versionSplit = versionSplit;