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

package/dist/index.js

@@ -87,6 +87,94 @@ 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) => {
@@ -147,7 +235,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, updateSettings, swi
         switchTransport }, createCoreApi(protocolAwareCall.call));
     return api;
 };
-const createCoreApi = (call) => ({
+const createAllCoreApi = (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' })),
@@ -180,6 +268,11 @@ const createCoreApi = (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' })),
@@ -222,12 +315,27 @@ const createCoreApi = (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' })),
@@ -235,6 +343,7 @@ const createCoreApi = (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' })),
@@ -307,9 +416,91 @@ const createCoreApi = (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);
@@ -41409,7 +41600,7 @@ function validateNonEmptyString(value, name) {
 }
 const PROTOCOL_V2_FILESYSTEM_VOLUMES = new Set(['vol0', 'vol1']);
 const MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES = 127;
-function getUtf8ByteLength$1(value) {
+function getUtf8ByteLength$2(value) {
     return Array.from(value).reduce((length, character) => {
         var _a;
         const codePoint = (_a = character.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
@@ -41451,7 +41642,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$1(canonicalPath) > MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES) {
+    if (getUtf8ByteLength$2(canonicalPath) > MAX_PROTOCOL_V2_FILESYSTEM_PATH_BYTES) {
         throw invalidParameter$1(`Parameter [${name}] exceeds the maximum filesystem path length.`);
     }
     return canonicalPath;
@@ -45353,7 +45544,7 @@ class TestInitializeDeviceDuration extends BaseMethod {
 }
 
 const PROTOCOL_V2_PING_MAX_MESSAGE_BYTES = 63;
-const getUtf8ByteLength = (value) => Array.from(value).reduce((length, character) => {
+const getUtf8ByteLength$1 = (value) => Array.from(value).reduce((length, character) => {
     var _a;
     const codePoint = (_a = character.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
     if (codePoint <= 0x7f)
@@ -45369,7 +45560,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(message) > PROTOCOL_V2_PING_MAX_MESSAGE_BYTES) {
+    if (getUtf8ByteLength$1(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;
@@ -46545,7 +46736,7 @@ class CheckFirmwareTypeAvailable extends BaseMethod {
     }
 }
 
-class DeviceBackup extends BaseMethod {
+class DeviceBackup$1 extends BaseMethod {
     init() {
         this.useDevicePassphraseState = false;
     }
@@ -47176,6 +47367,7 @@ 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),
@@ -49176,6 +49368,99 @@ 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,
@@ -50485,7 +50770,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 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) {
@@ -50654,7 +50939,65 @@ 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')
@@ -50729,6 +51072,9 @@ function writeProtocolV2File(options) {
         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));
@@ -50772,13 +51118,24 @@ function writeProtocolV2File(options) {
             written =
                 rawProcessedByte === undefined ? written + chunk.byteLength : processedByte - startOffset;
             chunks += 1;
-            const elapsedMs = Date.now() - startTime;
+            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 > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
+                rateBytesPerSecond,
                 elapsedMs,
             });
             if (options.paceMs && options.paceMs > 0) {
@@ -53287,7 +53644,7 @@ class ConfluxSignTransaction extends BaseMethod {
     }
 }
 
-function getAddressLegacyV1 ({ typedCall, param, }) {
+function getAddressLegacyV1$1 ({ typedCall, param, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             address_n: param.address_n,
@@ -53306,7 +53663,7 @@ function getAddress ({ typedCall, param, }) {
 
 const shouldUseLegacyV1EvmMessages = (device) => !device.isProtocolV2() && TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema';
 
-class EvmGetAddress extends BaseMethod {
+class EvmGetAddress$1 extends BaseMethod {
     constructor() {
         super(...arguments);
         this.hasBundle = false;
@@ -53341,7 +53698,7 @@ class EvmGetAddress extends BaseMethod {
     getEvmAddress(param) {
         return __awaiter(this, void 0, void 0, function* () {
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return getAddressLegacyV1({
+                return getAddressLegacyV1$1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     param,
                 });
@@ -53383,7 +53740,7 @@ function getPublicKey ({ typedCall, param, }) {
     });
 }
 
-function getPublicKeyLegacyV1 ({ typedCall, param, }) {
+function getPublicKeyLegacyV1$1 ({ typedCall, param, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             address_n: param.address_n,
@@ -53394,7 +53751,7 @@ function getPublicKeyLegacyV1 ({ typedCall, param, }) {
     });
 }
 
-class EVMGetPublicKey extends BaseMethod {
+class EVMGetPublicKey$1 extends BaseMethod {
     constructor() {
         super(...arguments);
         this.hasBundle = false;
@@ -53432,7 +53789,7 @@ class EVMGetPublicKey extends BaseMethod {
     }
     getEvmPublicKey(param) {
         if (shouldUseLegacyV1EvmMessages(this.device)) {
-            return getPublicKeyLegacyV1({
+            return getPublicKeyLegacyV1$1({
                 typedCall: this.device.commands.typedCall.bind(this.device.commands),
                 param,
             });
@@ -53484,7 +53841,7 @@ function signMessage ({ typedCall, params, }) {
     });
 }
 
-function signMessageLegacyV1 ({ typedCall, params, }) {
+function signMessageLegacyV1$1 ({ typedCall, params, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             address_n: params.address_n,
@@ -53496,7 +53853,7 @@ function signMessageLegacyV1 ({ typedCall, params, }) {
     });
 }
 
-class EVMSignMessage$2 extends BaseMethod {
+class EVMSignMessage$4 extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -53521,7 +53878,7 @@ class EVMSignMessage$2 extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return signMessageLegacyV1({
+                return signMessageLegacyV1$1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     params: this.params,
                 });
@@ -53727,7 +54084,7 @@ const evmSignTxEip7702 = ({ typedCall, addressN, tx, supportTrezor, }) => __awai
         supportTrezor,
     });
 });
-const signTransaction$1 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTransaction$2 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) => __awaiter(void 0, void 0, void 0, function* () {
     if (isEIP7702) {
         return evmSignTxEip7702({ typedCall, addressN, tx: tx });
     }
@@ -53736,7 +54093,7 @@ const signTransaction$1 = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) =
         : evmSignTx({ typedCall, addressN, tx: tx });
 });
 
-const signTransaction = ({ 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,
@@ -53756,7 +54113,7 @@ const signTransaction = ({ typedCall, isEIP1559, isEIP7702, addressN, tx, }) =>
     return evmSignTx({ typedCall, addressN, tx: tx, supportTrezor: true });
 });
 
-class EVMSignTransaction extends BaseMethod {
+class EVMSignTransaction$1 extends BaseMethod {
     constructor() {
         super(...arguments);
         this.addressN = [];
@@ -53841,7 +54198,7 @@ class EVMSignTransaction extends BaseMethod {
             if (formattedTx == null)
                 throw hdShared.ERRORS.TypedError('Runtime', 'formattedTx is not set');
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return signTransaction({
+                return signTransaction$1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     addressN,
                     tx: formattedTx,
@@ -53849,7 +54206,7 @@ class EVMSignTransaction extends BaseMethod {
                     isEIP7702,
                 });
             }
-            return signTransaction$1({
+            return signTransaction$2({
                 typedCall: this.device.commands.typedCall.bind(this.device.commands),
                 addressN,
                 tx: formattedTx,
@@ -53860,7 +54217,7 @@ class EVMSignTransaction extends BaseMethod {
     }
 }
 
-const signTypedHash$1 = ({ typedCall, addressN, device, chainId, domainHash, messageHash, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTypedHash$2 = ({ 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) {
@@ -53879,7 +54236,7 @@ const signTypedHash$1 = ({ typedCall, addressN, device, chainId, domainHash, mes
     return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', message);
 });
 
-const signTypedHash = ({ 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) {
@@ -53897,7 +54254,7 @@ const signTypedHash = ({ typedCall, addressN, device, chainId, domainHash, messa
     });
 });
 
-const signTypedData$1 = ({ typedCall, addressN, data, metamaskV4Compat, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
+const signTypedData$2 = ({ typedCall, addressN, data, metamaskV4Compat, chainId, }) => __awaiter(void 0, void 0, void 0, function* () {
     const { primaryType } = data;
     const message = {
         address_n: addressN,
@@ -53914,7 +54271,7 @@ const signTypedData$1 = ({ typedCall, addressN, data, metamaskV4Compat, chainId,
     return response;
 });
 
-const signTypedData = ({ 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;
     return typedCall('EthereumSignTypedDataOneKey', [
         'EthereumTypedDataStructRequestOneKey',
@@ -54048,7 +54405,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 extends BaseMethod {
+class EVMSignTypedData$1 extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -54203,7 +54560,7 @@ class EVMSignTypedData extends BaseMethod {
             let response;
             if (shouldUseLegacyV1EvmMessages(this.device)) {
                 supportTrezor = true;
-                response = yield signTypedData$1({
+                response = yield signTypedData$2({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     addressN,
                     data,
@@ -54212,7 +54569,7 @@ class EVMSignTypedData extends BaseMethod {
                 });
             }
             else {
-                response = yield signTypedData({
+                response = yield signTypedData$1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     addressN,
                     data,
@@ -54232,7 +54589,7 @@ class EVMSignTypedData extends BaseMethod {
         if (!domainHash)
             throw hdShared.ERRORS.TypedError('Runtime', 'domainHash is required');
         if (shouldUseLegacyV1EvmMessages(this.device)) {
-            return signTypedHash$1({
+            return signTypedHash$2({
                 typedCall,
                 addressN,
                 domainHash,
@@ -54241,7 +54598,7 @@ class EVMSignTypedData extends BaseMethod {
                 device: this.device,
             });
         }
-        return signTypedHash({
+        return signTypedHash$1({
             typedCall,
             addressN,
             domainHash,
@@ -54462,7 +54819,7 @@ class EVMSignTypedData extends BaseMethod {
     }
 }
 
-function verifyMessageLegacyV1 ({ typedCall, params, }) {
+function verifyMessageLegacyV1$1 ({ typedCall, params, }) {
     return __awaiter(this, void 0, void 0, function* () {
         const message = {
             signature: params.signature,
@@ -54482,7 +54839,7 @@ function verifyMessage ({ typedCall, params, }) {
     });
 }
 
-class EVMSignMessage$1 extends BaseMethod {
+class EVMSignMessage$3 extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -54506,7 +54863,7 @@ class EVMSignMessage$1 extends BaseMethod {
     run() {
         return __awaiter(this, void 0, void 0, function* () {
             if (shouldUseLegacyV1EvmMessages(this.device)) {
-                return verifyMessageLegacyV1({
+                return verifyMessageLegacyV1$1({
                     typedCall: this.device.commands.typedCall.bind(this.device.commands),
                     params: this.params,
                 });
@@ -54670,7 +55027,7 @@ class StarcoinSignTransaction extends BaseMethod {
     }
 }
 
-class EVMSignMessage extends BaseMethod {
+class EVMSignMessage$2 extends BaseMethod {
     getSupportedProtocols() {
         return ['V1', 'V2'];
     }
@@ -54697,7 +55054,7 @@ class EVMSignMessage extends BaseMethod {
     }
 }
 
-const MAINNET = 0x68;
+const MAINNET$1 = 0x68;
 class NEMGetAddress extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -54725,7 +55082,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,
+                network: batch.network || MAINNET$1,
                 show_display: showOnOneKey,
             });
         });
@@ -60825,7 +61182,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     checkBootloaderRelease: CheckBootloaderRelease,
     checkAllFirmwareRelease: CheckAllFirmwareRelease,
     checkFirmwareTypeAvailable: CheckFirmwareTypeAvailable,
-    deviceBackup: DeviceBackup,
+    deviceBackup: DeviceBackup$1,
     deviceChangePin: DeviceChangePin,
     deviceFlags: DeviceFlags,
     deviceRebootToBootloader: DeviceRebootToBootloader,
@@ -60852,6 +61209,9 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     promptWebDeviceAccess: PromptWebDeviceAccess,
     deviceReboot: DeviceReboot,
     deviceGetOnboardingStatus: DeviceGetOnboardingStatus,
+    deviceReadFactoryInfo: DeviceFactoryInfoGet,
+    deviceReadFactoryCertificate: DeviceFactoryCertificateRead,
+    deviceSignFactoryChallenge: DeviceFactoryChallengeSign,
     deviceUploadWallpaper: DeviceUploadWallpaper,
     deviceUploadNft: DeviceUploadNft,
     uploadPortfolio: UploadPortfolio,
@@ -60868,18 +61228,18 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     confluxSignMessage: ConfluxSignMessage,
     confluxSignMessageCIP23: ConfluxSignMessageCIP23,
     confluxSignTransaction: ConfluxSignTransaction,
-    evmGetAddress: EvmGetAddress,
-    evmGetPublicKey: EVMGetPublicKey,
-    evmSignMessage: EVMSignMessage$2,
+    evmGetAddress: EvmGetAddress$1,
+    evmGetPublicKey: EVMGetPublicKey$1,
+    evmSignMessage: EVMSignMessage$4,
     evmSignMessageEIP712: EVMSignMessageEIP712,
-    evmSignTransaction: EVMSignTransaction,
-    evmSignTypedData: EVMSignTypedData,
-    evmVerifyMessage: EVMSignMessage$1,
+    evmSignTransaction: EVMSignTransaction$1,
+    evmSignTypedData: EVMSignTypedData$1,
+    evmVerifyMessage: EVMSignMessage$3,
     starcoinGetAddress: StarcoinGetAddress,
     starcoinGetPublicKey: StarcoinGetPublicKey,
     starcoinSignMessage: StarcoinSignMessage,
     starcoinSignTransaction: StarcoinSignTransaction,
-    starcoinVerifyMessage: EVMSignMessage,
+    starcoinVerifyMessage: EVMSignMessage$2,
     nemGetAddress: NEMGetAddress,
     nemSignTransaction: NEMSignTransaction,
     solGetAddress: SolGetAddress,
@@ -60950,7 +61310,25 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
 });
 
 const publicMethodRegistry = ApiMethods;
-function findMethod(message) {
+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;
     const { method } = message.payload;
     if (typeof method !== 'string') {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Method is not set');
@@ -60959,6 +61337,13 @@ function findMethod(message) {
     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`);
 }
 
@@ -61361,7 +61746,10 @@ const callAPI = (context, message) => __awaiter(void 0, void 0, void 0, function
     }
     let method;
     try {
-        method = findMethod(message);
+        method = findMethod(message, {
+            extensions: context.methodExtensions,
+            allowDestructiveOperations: context.allowDestructiveOperations,
+        });
         method.connector = _connector;
         const shouldPostMessage = createUiProgressMessageFilter();
         method.postMessage = event => {
@@ -62268,18 +62656,22 @@ const createUiPromise = (promiseEvent, device) => {
 const removeUiPromise = (promise) => {
     _uiPromises = _uiPromises.filter(p => p !== promise);
 };
-class Core extends events.exports {
-    constructor() {
+class Core extends events.exports.EventEmitter {
+    constructor(options = {}) {
         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,
@@ -62388,8 +62780,8 @@ class Core extends events.exports {
         });
     }
 }
-const initCore = () => {
-    const core = new Core();
+const initCore = (options) => {
+    const core = new Core(options);
     _core = core;
     return core;
 };
@@ -62406,7 +62798,7 @@ const initConnector = () => {
 const initTransport = (Transport, plugin) => {
     TransportManager.setTransport(Transport, plugin);
 };
-const init = (settings, Transport, plugin) => __awaiter(void 0, void 0, void 0, function* () {
+const init = (settings, Transport, plugin, options) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         try {
             yield DataManager.load(settings);
@@ -62419,7 +62811,7 @@ const init = (settings, Transport, plugin) => __awaiter(void 0, void 0, void 0,
         if (DataManager.getSettings('env') !== 'react-native') {
             setLoggerPostMessage(postMessage);
         }
-        initCore();
+        initCore(options);
         initConnector();
         return _core;
     }
@@ -62436,6 +62828,2189 @@ 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,
@@ -62486,6 +65061,7 @@ 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;
@@ -62499,6 +65075,7 @@ 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;
@@ -62510,18 +65087,21 @@ 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;
@@ -62574,6 +65154,7 @@ exports.safeThrowError = safeThrowError;
 exports.setLoggerPostMessage = setLoggerPostMessage;
 exports.supportInputPinOnSoftware = supportInputPinOnSoftware;
 exports.switchTransport = switchTransport;
+exports.testApiMethodExtension = testApiMethodExtension;
 exports.updateRequestContext = updateRequestContext;
 exports.versionCompare = versionCompare;
 exports.versionSplit = versionSplit;