@onekeyfe/hd-core 1.1.26-alpha.2 → 1.1.26-alpha.30

package/dist/index.js

@@ -119,7 +119,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, updateSettings, swi
 };
 const createCoreApi = (call) => ({
     getLogs: () => call({ method: 'getLogs' }),
-    searchDevices: () => call({ method: 'searchDevices' }),
+    searchDevices: params => call(Object.assign(Object.assign({}, params), { method: 'searchDevices' })),
     getFeatures: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'getFeatures' })),
     getOnekeyFeatures: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'getOnekeyFeatures' })),
     checkFirmwareRelease: connectId => call({ connectId, method: 'checkFirmwareRelease' }),
@@ -136,6 +136,31 @@ const createCoreApi = (call) => ({
     deviceFlags: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceFlags' })),
     deviceRebootToBoardloader: connectId => call({ connectId, method: 'deviceRebootToBoardloader' }),
     deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
+    getProtoVersion: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'getProtoVersion' })),
+    ping: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'ping' })),
+    devReboot: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'devReboot' })),
+    devGetDeviceInfo: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'devGetDeviceInfo' })),
+    devGetOnboardingStatus: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'devGetOnboardingStatus' })),
+    devFirmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'devFirmwareUpdate' })),
+    devGetFirmwareUpdateStatus: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'devGetFirmwareUpdateStatus' })),
+    factoryDeviceInfoSettings: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'factoryDeviceInfoSettings' })),
+    factoryGetDeviceInfo: connectId => call({ connectId, method: 'factoryGetDeviceInfo' }),
+    filesystemFixPermission: connectId => call({ connectId, method: 'filesystemFixPermission' }),
+    fileRead: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'fileRead' })),
+    fileWrite: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'fileWrite' })),
+    fileDelete: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'fileDelete' })),
+    dirList: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'dirList' })),
+    dirMake: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'dirMake' })),
+    dirRemove: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'dirRemove' })),
+    pathInfo: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'pathInfo' })),
+    filesystemFileRead: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'filesystemFileRead' })),
+    filesystemFileWrite: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'filesystemFileWrite' })),
+    filesystemFileDelete: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'filesystemFileDelete' })),
+    filesystemDirList: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'filesystemDirList' })),
+    filesystemDirMake: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'filesystemDirMake' })),
+    filesystemDirRemove: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'filesystemDirRemove' })),
+    filesystemPathInfoQuery: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'filesystemPathInfoQuery' })),
+    filesystemFormat: connectId => call({ connectId, method: 'filesystemFormat' }),
     deviceRecovery: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceRecovery' })),
     deviceReset: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceReset' })),
     deviceSettings: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceSettings' })),
@@ -196,6 +221,7 @@ const createCoreApi = (call) => ({
     firmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdate' })),
     firmwareUpdateV2: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdateV2' })),
     firmwareUpdateV3: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdateV3' })),
+    firmwareUpdateV4: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'firmwareUpdateV4' })),
     promptWebDeviceAccess: params => call(Object.assign(Object.assign({}, params), { method: 'promptWebDeviceAccess' })),
     tronGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tronGetAddress' })),
     tronSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tronSignMessage' })),
@@ -247,6 +273,7 @@ const createCoreApi = (call) => ({
     tonGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tonGetAddress' })),
     tonSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tonSignMessage' })),
     tonSignProof: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tonSignProof' })),
+    tonSignData: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'tonSignData' })),
     scdoGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'scdoGetAddress' })),
     scdoSignMessage: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'scdoSignMessage' })),
     scdoSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'scdoSignTransaction' })),
@@ -787,7 +814,7 @@ const createLogMessage = (type, payload) => ({
 
 const MAX_ENTRIES = 500;
 let postMessage$1;
-class Log$g {
+class Log$h {
     constructor(prefix, enabled) {
         this.prefix = prefix;
         this.enabled = enabled;
@@ -839,7 +866,7 @@ class Log$g {
 }
 const _logs = {};
 const initLog = (prefix, enabled) => {
-    const instance = new Log$g(prefix, !!enabled);
+    const instance = new Log$h(prefix, !!enabled);
     _logs[prefix] = instance;
     return instance;
 };
@@ -1037,7 +1064,7 @@ function patchFeatures(response) {
     return response;
 }
 
-const Log$f = getLogger(exports.LoggerNames.Core);
+const Log$g = getLogger(exports.LoggerNames.Core);
 let globalInstanceCounter = 0;
 let sdkInstanceCounter = 0;
 function generateSdkInstanceId() {
@@ -1097,7 +1124,7 @@ function completeRequestContext(responseID, error) {
         context.status = error ? 'error' : 'success';
         if (error) {
             context.error = error.message;
-            Log$f.error(`[RequestContext] [completeRequestContext] Error: ${formatRequestContext(context)}`);
+            Log$g.error(`[RequestContext] [completeRequestContext] Error: ${formatRequestContext(context)}`);
         }
         globalActiveRequests.delete(responseID);
         if (context.sdkInstanceId) {
@@ -1164,6 +1191,7 @@ const DeviceTypeToModels = {
     [hdShared.EDeviceType.Mini]: ['model_mini'],
     [hdShared.EDeviceType.Touch]: ['model_touch'],
     [hdShared.EDeviceType.Pro]: ['model_touch'],
+    [hdShared.EDeviceType.Pro2]: [],
     [hdShared.EDeviceType.Unknown]: [],
 };
 
@@ -1184,6 +1212,9 @@ const getDeviceType = (features) => {
             return hdShared.EDeviceType.Touch;
         case 'PRO':
             return hdShared.EDeviceType.Pro;
+        case 'PRO2':
+        case 'pro2':
+            return hdShared.EDeviceType.Pro2;
         case 'PURE':
             return hdShared.EDeviceType.ClassicPure;
         default:
@@ -1215,15 +1246,17 @@ const getDeviceType = (features) => {
 const getDeviceTypeByBleName = (name) => {
     if (!name)
         return hdShared.EDeviceType.Unknown;
-    if (name.startsWith('BixinKey'))
+    if (/^BixinKey/i.test(name))
         return hdShared.EDeviceType.Classic;
-    if (name.startsWith('K'))
+    if (/^K/i.test(name))
         return hdShared.EDeviceType.Classic;
-    if (name.startsWith('T'))
+    if (/^T/i.test(name))
         return hdShared.EDeviceType.Touch;
-    if (name.startsWith('Touch'))
+    if (/^Touch/i.test(name))
         return hdShared.EDeviceType.Touch;
-    if (name.startsWith('Pro'))
+    if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name))
+        return hdShared.EDeviceType.Pro2;
+    if (/\bPro\b/i.test(name) || /^Pro/i.test(name))
         return hdShared.EDeviceType.Pro;
     return hdShared.EDeviceType.Unknown;
 };
@@ -1456,7 +1489,7 @@ const validatePath = (path, length = 0, base = false) => {
     return base ? valid.splice(0, 3) : valid;
 };
 
-var nested$1 = {
+var nested$2 = {
 	AlephiumGetAddress: {
 		fields: {
 			address_n: {
@@ -13068,6 +13101,102 @@ var nested$1 = {
 			}
 		}
 	},
+	TonSignData: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			type: {
+				rule: "required",
+				type: "TonSignDataType",
+				id: 2
+			},
+			payload: {
+				rule: "required",
+				type: "bytes",
+				id: 3
+			},
+			schema: {
+				type: "string",
+				id: 4
+			},
+			appdomain: {
+				rule: "required",
+				type: "string",
+				id: 5
+			},
+			timestamp: {
+				rule: "required",
+				type: "uint64",
+				id: 6
+			},
+			from_address: {
+				type: "string",
+				id: 7
+			},
+			wallet_version: {
+				type: "TonWalletVersion",
+				id: 8,
+				options: {
+					"default": "V4R2"
+				}
+			},
+			wallet_id: {
+				type: "uint32",
+				id: 9,
+				options: {
+					"default": 698983191
+				}
+			},
+			workchain: {
+				type: "TonWorkChain",
+				id: 10,
+				options: {
+					"default": "BASECHAIN"
+				}
+			},
+			is_bounceable: {
+				type: "bool",
+				id: 11,
+				options: {
+					"default": false
+				}
+			},
+			is_testnet_only: {
+				type: "bool",
+				id: 12,
+				options: {
+					"default": false
+				}
+			}
+		},
+		nested: {
+			TonSignDataType: {
+				values: {
+					TEXT: 0,
+					BINARY: 1,
+					CELL: 2
+				}
+			}
+		}
+	},
+	TonSignedData: {
+		fields: {
+			signature: {
+				type: "bytes",
+				id: 1
+			},
+			digest: {
+				type: "bytes",
+				id: 2
+			}
+		}
+	},
 	TronGetAddress: {
 		fields: {
 			address_n: {
@@ -14003,6 +14132,8 @@ var nested$1 = {
 			MessageType_TonSignProof: 11905,
 			MessageType_TonSignedProof: 11906,
 			MessageType_TonTxAck: 11907,
+			MessageType_TonSignData: 11908,
+			MessageType_TonSignedData: 11909,
 			MessageType_ScdoGetAddress: 12001,
 			MessageType_ScdoAddress: 12002,
 			MessageType_ScdoSignTx: 12003,
@@ -14802,10 +14933,10 @@ var nested$1 = {
 	}
 };
 var MessagesJSON = {
-	nested: nested$1
+	nested: nested$2
 };
 
-var nested = {
+var nested$1 = {
 	AlgorandGetAddress: {
 		fields: {
 			address_n: {
@@ -25181,6 +25312,747 @@ var nested = {
 	}
 };
 var MessagesLegacyV1JSON = {
+	nested: nested$1
+};
+
+var nested = {
+	GetProtoVersion: {
+		fields: {
+		}
+	},
+	ProtoVersion: {
+		fields: {
+			proto_version: {
+				rule: "required",
+				type: "uint32",
+				id: 1
+			}
+		}
+	},
+	Ping: {
+		fields: {
+			message: {
+				type: "string",
+				id: 1,
+				options: {
+					"default": ""
+				}
+			}
+		}
+	},
+	Success: {
+		fields: {
+			message: {
+				type: "string",
+				id: 1,
+				options: {
+					"default": ""
+				}
+			}
+		}
+	},
+	Failure: {
+		fields: {
+			code: {
+				type: "FailureType",
+				id: 1
+			},
+			message: {
+				type: "string",
+				id: 2
+			}
+		},
+		nested: {
+			FailureType: {
+				values: {
+					Failure_UnexpectedMessage: 1,
+					Failure_ButtonExpected: 2,
+					Failure_DataError: 3,
+					Failure_ActionCancelled: 4,
+					Failure_PinExpected: 5,
+					Failure_PinCancelled: 6,
+					Failure_PinInvalid: 7,
+					Failure_InvalidSignature: 8,
+					Failure_ProcessError: 9,
+					Failure_NotEnoughFunds: 10,
+					Failure_NotInitialized: 11,
+					Failure_PinMismatch: 12,
+					Failure_WipeCodeMismatch: 13,
+					Failure_InvalidSession: 14,
+					Failure_FirmwareError: 99
+				}
+			}
+		}
+	},
+	DevRebootType: {
+		values: {
+			Normal: 0,
+			Boardloader: 1,
+			Bootloader: 2
+		}
+	},
+	DevReboot: {
+		fields: {
+			reboot_type: {
+				rule: "required",
+				type: "DevRebootType",
+				id: 1
+			}
+		}
+	},
+	DeviceType: {
+		values: {
+			CLASSIC1: 0,
+			CLASSIC1S: 1,
+			MINI: 2,
+			TOUCH: 3,
+			PRO: 5,
+			CLASSIC1S_PURE: 6
+		}
+	},
+	DevSeType: {
+		values: {
+			THD89: 0,
+			SE608A: 1
+		}
+	},
+	DevSEState: {
+		values: {
+			BOOT: 0,
+			APP_FACTORY: 51,
+			APP: 85
+		}
+	},
+	DevFirmwareImageInfo: {
+		fields: {
+			version: {
+				type: "string",
+				id: 10
+			},
+			build_id: {
+				type: "string",
+				id: 20
+			},
+			hash: {
+				type: "bytes",
+				id: 30
+			}
+		}
+	},
+	DevHardwareInfo: {
+		fields: {
+			device_type: {
+				type: "DeviceType",
+				id: 10
+			},
+			serial_no: {
+				type: "string",
+				id: 11
+			},
+			hardware_version: {
+				type: "string",
+				id: 100
+			},
+			hardware_version_raw_adc: {
+				type: "uint32",
+				id: 101
+			}
+		}
+	},
+	DevMainMcuInfo: {
+		fields: {
+			board: {
+				type: "DevFirmwareImageInfo",
+				id: 10
+			},
+			boot: {
+				type: "DevFirmwareImageInfo",
+				id: 20
+			},
+			app: {
+				type: "DevFirmwareImageInfo",
+				id: 30
+			}
+		}
+	},
+	DevBluetoothInfo: {
+		fields: {
+			boot: {
+				type: "DevFirmwareImageInfo",
+				id: 20
+			},
+			app: {
+				type: "DevFirmwareImageInfo",
+				id: 30
+			},
+			adv_name: {
+				type: "string",
+				id: 100
+			},
+			mac: {
+				type: "bytes",
+				id: 110
+			}
+		}
+	},
+	DevSEInfo: {
+		fields: {
+			boot: {
+				type: "DevFirmwareImageInfo",
+				id: 20
+			},
+			app: {
+				type: "DevFirmwareImageInfo",
+				id: 30
+			},
+			type: {
+				type: "DevSeType",
+				id: 100
+			},
+			state: {
+				type: "DevSEState",
+				id: 110
+			}
+		}
+	},
+	DevInfoTargets: {
+		fields: {
+			hw: {
+				type: "bool",
+				id: 100
+			},
+			fw: {
+				type: "bool",
+				id: 200
+			},
+			bt: {
+				type: "bool",
+				id: 300
+			},
+			se1: {
+				type: "bool",
+				id: 400
+			},
+			se2: {
+				type: "bool",
+				id: 410
+			},
+			se3: {
+				type: "bool",
+				id: 420
+			},
+			se4: {
+				type: "bool",
+				id: 430
+			},
+			status: {
+				type: "bool",
+				id: 10000
+			}
+		}
+	},
+	DevInfoTypes: {
+		fields: {
+			version: {
+				type: "bool",
+				id: 10
+			},
+			build_id: {
+				type: "bool",
+				id: 20
+			},
+			hash: {
+				type: "bool",
+				id: 30
+			},
+			specific: {
+				type: "bool",
+				id: 40
+			}
+		}
+	},
+	DevStatus: {
+		fields: {
+			language: {
+				type: "string",
+				id: 100
+			},
+			bt_enable: {
+				type: "bool",
+				id: 101
+			},
+			init_states: {
+				type: "bool",
+				id: 102
+			},
+			backup_required: {
+				type: "bool",
+				id: 200
+			},
+			passphrase_protection: {
+				type: "bool",
+				id: 201
+			},
+			label: {
+				type: "string",
+				id: 300
+			}
+		}
+	},
+	DevGetDeviceInfo: {
+		fields: {
+			targets: {
+				type: "DevInfoTargets",
+				id: 1
+			},
+			types: {
+				type: "DevInfoTypes",
+				id: 2
+			}
+		}
+	},
+	DeviceInfo: {
+		fields: {
+			protocol_version: {
+				rule: "required",
+				type: "uint32",
+				id: 1
+			},
+			hw: {
+				type: "DevHardwareInfo",
+				id: 100
+			},
+			fw: {
+				type: "DevMainMcuInfo",
+				id: 200
+			},
+			bt: {
+				type: "DevBluetoothInfo",
+				id: 300
+			},
+			se1: {
+				type: "DevSEInfo",
+				id: 400
+			},
+			se2: {
+				type: "DevSEInfo",
+				id: 410
+			},
+			se3: {
+				type: "DevSEInfo",
+				id: 420
+			},
+			se4: {
+				type: "DevSEInfo",
+				id: 430
+			},
+			status: {
+				type: "DevStatus",
+				id: 10000
+			}
+		}
+	},
+	DevGetOnboardingStatus: {
+		fields: {
+		}
+	},
+	DevOnboardingStatus: {
+		fields: {
+			page_index: {
+				type: "uint32",
+				id: 1
+			},
+			page_count: {
+				type: "uint32",
+				id: 2
+			},
+			page_name: {
+				type: "string",
+				id: 3
+			}
+		}
+	},
+	DevFirmwareTargetType: {
+		values: {
+			TARGET_MAIN_APP: 0,
+			TARGET_MAIN_BOOT: 1,
+			TARGET_BT: 2,
+			TARGET_SE1: 3,
+			TARGET_SE2: 4,
+			TARGET_SE3: 5,
+			TARGET_SE4: 6,
+			TARGET_RESOURCE: 10
+		}
+	},
+	DevFirmwareTarget: {
+		fields: {
+			target_id: {
+				rule: "required",
+				type: "DevFirmwareTargetType",
+				id: 1
+			},
+			path: {
+				rule: "required",
+				type: "string",
+				id: 2
+			}
+		}
+	},
+	DevFirmwareUpdate: {
+		fields: {
+			targets: {
+				rule: "repeated",
+				type: "DevFirmwareTarget",
+				id: 1
+			}
+		}
+	},
+	DevFirmwareInstallProgress: {
+		fields: {
+			target_id: {
+				rule: "required",
+				type: "DevFirmwareTargetType",
+				id: 1
+			},
+			progress: {
+				rule: "required",
+				type: "uint32",
+				id: 2
+			},
+			stage: {
+				type: "string",
+				id: 3
+			}
+		}
+	},
+	DevFirmwareUpdateStatusEntry: {
+		fields: {
+			target_id: {
+				rule: "required",
+				type: "DevFirmwareTargetType",
+				id: 1
+			},
+			status: {
+				rule: "required",
+				type: "uint32",
+				id: 2
+			}
+		}
+	},
+	DevGetFirmwareUpdateStatus: {
+		fields: {
+		}
+	},
+	DevFirmwareUpdateStatus: {
+		fields: {
+			targets: {
+				rule: "repeated",
+				type: "DevFirmwareUpdateStatusEntry",
+				id: 1
+			}
+		}
+	},
+	FactoryDeviceInfoSettings: {
+		fields: {
+			serial_no: {
+				type: "string",
+				id: 1
+			},
+			cpu_info: {
+				type: "string",
+				id: 2
+			},
+			pre_firmware: {
+				type: "string",
+				id: 3
+			}
+		}
+	},
+	FactoryGetDeviceInfo: {
+		fields: {
+		}
+	},
+	FactoryDeviceInfo: {
+		fields: {
+			serial_no: {
+				type: "string",
+				id: 1
+			},
+			spi_flash_info: {
+				type: "string",
+				id: 2
+			},
+			se_info: {
+				type: "string",
+				id: 3
+			},
+			nft_voucher: {
+				type: "bytes",
+				id: 4
+			},
+			cpu_info: {
+				type: "string",
+				id: 5
+			},
+			pre_firmware: {
+				type: "string",
+				id: 6
+			}
+		}
+	},
+	FilesystemFixPermission: {
+		fields: {
+		}
+	},
+	FilesystemPathInfo: {
+		fields: {
+			exist: {
+				rule: "required",
+				type: "bool",
+				id: 1
+			},
+			size: {
+				rule: "required",
+				type: "uint64",
+				id: 2
+			},
+			year: {
+				rule: "required",
+				type: "uint32",
+				id: 3
+			},
+			month: {
+				rule: "required",
+				type: "uint32",
+				id: 4
+			},
+			day: {
+				rule: "required",
+				type: "uint32",
+				id: 5
+			},
+			hour: {
+				rule: "required",
+				type: "uint32",
+				id: 6
+			},
+			minute: {
+				rule: "required",
+				type: "uint32",
+				id: 7
+			},
+			second: {
+				rule: "required",
+				type: "uint32",
+				id: 8
+			},
+			readonly: {
+				rule: "required",
+				type: "bool",
+				id: 9
+			},
+			hidden: {
+				rule: "required",
+				type: "bool",
+				id: 10
+			},
+			system: {
+				rule: "required",
+				type: "bool",
+				id: 11
+			},
+			archive: {
+				rule: "required",
+				type: "bool",
+				id: 12
+			},
+			directory: {
+				rule: "required",
+				type: "bool",
+				id: 13
+			}
+		}
+	},
+	FilesystemPathInfoQuery: {
+		fields: {
+			path: {
+				rule: "required",
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	FilesystemFile: {
+		fields: {
+			path: {
+				rule: "required",
+				type: "string",
+				id: 1
+			},
+			offset: {
+				rule: "required",
+				type: "uint32",
+				id: 2
+			},
+			total_size: {
+				rule: "required",
+				type: "uint32",
+				id: 3
+			},
+			data: {
+				type: "bytes",
+				id: 4
+			},
+			data_hash: {
+				type: "uint32",
+				id: 5
+			},
+			processed_byte: {
+				type: "uint32",
+				id: 6
+			}
+		}
+	},
+	FilesystemFileRead: {
+		fields: {
+			file: {
+				rule: "required",
+				type: "FilesystemFile",
+				id: 1
+			},
+			chunk_len: {
+				type: "uint32",
+				id: 2
+			},
+			ui_percentage: {
+				type: "uint32",
+				id: 3
+			}
+		}
+	},
+	FilesystemFileWrite: {
+		fields: {
+			file: {
+				rule: "required",
+				type: "FilesystemFile",
+				id: 1
+			},
+			overwrite: {
+				rule: "required",
+				type: "bool",
+				id: 2
+			},
+			append: {
+				rule: "required",
+				type: "bool",
+				id: 3
+			},
+			ui_percentage: {
+				type: "uint32",
+				id: 4
+			}
+		}
+	},
+	FilesystemFileDelete: {
+		fields: {
+			path: {
+				rule: "required",
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	FilesystemDir: {
+		fields: {
+			path: {
+				rule: "required",
+				type: "string",
+				id: 1
+			},
+			child_dirs: {
+				type: "string",
+				id: 2
+			},
+			child_files: {
+				type: "string",
+				id: 3
+			}
+		}
+	},
+	FilesystemDirList: {
+		fields: {
+			path: {
+				rule: "required",
+				type: "string",
+				id: 1
+			},
+			depth: {
+				type: "uint32",
+				id: 2,
+				options: {
+					"default": 0
+				}
+			}
+		}
+	},
+	FilesystemDirMake: {
+		fields: {
+			path: {
+				rule: "required",
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	FilesystemDirRemove: {
+		fields: {
+			path: {
+				rule: "required",
+				type: "string",
+				id: 1
+			}
+		}
+	},
+	FilesystemFormat: {
+		fields: {
+		}
+	},
+	MessageType: {
+		values: {
+			MessageType_FactoryDeviceInfoSettings: 60000,
+			MessageType_FactoryGetDeviceInfo: 60001,
+			MessageType_FactoryDeviceInfo: 60002,
+			MessageType_GetProtoVersion: 60200,
+			MessageType_ProtoVersion: 60201,
+			MessageType_StartSession: 60205,
+			MessageType_Ping: 60206,
+			MessageType_Success: 60207,
+			MessageType_Failure: 60208,
+			MessageType_DevReboot: 60400,
+			MessageType_DevGetDeviceInfo: 60600,
+			MessageType_DeviceInfo: 60601,
+			MessageType_DevGetOnboardingStatus: 60602,
+			MessageType_DevOnboardingStatus: 60603,
+			MessageType_FilesystemFixPermission: 60800,
+			MessageType_FilesystemPathInfo: 60801,
+			MessageType_FilesystemPathInfoQuery: 60802,
+			MessageType_FilesystemFile: 60803,
+			MessageType_FilesystemFileRead: 60804,
+			MessageType_FilesystemFileWrite: 60805,
+			MessageType_FilesystemFileDelete: 60806,
+			MessageType_FilesystemDir: 60807,
+			MessageType_FilesystemDirList: 60808,
+			MessageType_FilesystemDirMake: 60809,
+			MessageType_FilesystemDirRemove: 60810,
+			MessageType_FilesystemFormat: 60811,
+			MessageType_DevFirmwareUpdate: 61000,
+			MessageType_DevFirmwareInstallProgress: 61001,
+			MessageType_DevGetFirmwareUpdateStatus: 61002,
+			MessageType_DevFirmwareUpdateStatus: 61003
+		}
+	}
+};
+var MessagesPro2JSON = {
 	nested: nested
 };
 
@@ -25209,7 +26081,7 @@ const findLatestRelease = (releases) => {
 };
 
 var _a$1;
-const Log$e = getLogger(exports.LoggerNames.Core);
+const Log$f = getLogger(exports.LoggerNames.Core);
 const FIRMWARE_FIELDS = [
     'firmware',
     'firmware-v2',
@@ -25271,37 +26143,37 @@ class DataManager {
             let data = null;
             let fetchMethod = 'none';
             if (settings.configFetcher) {
-                Log$e.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
+                Log$f.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
                 try {
                     data = yield settings.configFetcher(urlWithCache);
                     if (data) {
                         fetchMethod = 'configFetcher';
-                        Log$e.log('[DataConfig] ConfigFetcher success');
+                        Log$f.log('[DataConfig] ConfigFetcher success');
                     }
                     else {
-                        Log$e.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
+                        Log$f.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
                     }
                 }
                 catch (e) {
-                    Log$e.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
+                    Log$f.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
                 }
             }
             if (!data) {
-                Log$e.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+                Log$f.debug('[DataConfig] Trying axios (SDK default fetcher)...');
                 try {
                     const response = yield axios__default["default"].get(urlWithCache, {
                         timeout: 7000,
                     });
                     data = response.data;
                     fetchMethod = 'axios';
-                    Log$e.log('[DataConfig] Axios fetch success');
+                    Log$f.log('[DataConfig] Axios fetch success');
                 }
                 catch (e) {
-                    Log$e.warn('[DataConfig] Axios fetch error:', e);
+                    Log$f.warn('[DataConfig] Axios fetch error:', e);
                 }
             }
             if (data) {
-                Log$e.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
+                Log$f.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
                 this.deviceMap = {
                     [hdShared.EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
                     [hdShared.EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
@@ -25315,7 +26187,7 @@ class DataManager {
                 };
             }
             else {
-                Log$e.warn('[DataConfig] All fetch methods failed, using built-in default config');
+                Log$f.warn('[DataConfig] All fetch methods failed, using built-in default config');
             }
         });
     }
@@ -25378,6 +26250,7 @@ DataManager.assets = null;
 DataManager.messages = {
     latest: MessagesJSON,
     v1: MessagesLegacyV1JSON,
+    protocolV2: MessagesPro2JSON,
 };
 DataManager.lastCheckTimestamp = 0;
 DataManager.getFirmwareStatus = (features, firmwareType) => {
@@ -26583,7 +27456,7 @@ const LogBlockEvent = new Set([
     UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
 
-const Log$d = getLogger(exports.LoggerNames.DevicePool);
+const Log$e = getLogger(exports.LoggerNames.DevicePool);
 const getDiff = (current, descriptors) => {
     const connected = descriptors.filter(d => current.find(x => x.path === d.path) === undefined);
     const disconnected = current.filter(d => descriptors.find(x => x.path === d.path) === undefined);
@@ -26641,7 +27514,7 @@ class DevicePool extends events.exports {
                         yield this._checkDevicePool(initOptions);
                         return { devices, deviceList };
                     }
-                    Log$d.debug('found device in cache, but path is different: ', connectId);
+                    Log$e.debug('found device in cache, but path is different: ', connectId);
                 }
             }
             try {
@@ -26684,7 +27557,7 @@ class DevicePool extends events.exports {
             if (!device) {
                 device = Device.fromDescriptor(descriptor);
                 device.deviceConnector = this.connector;
-                yield device.connect();
+                yield device.connect(initOptions === null || initOptions === void 0 ? void 0 : initOptions.connectProtocol);
                 yield device.initialize(initOptions);
                 yield device.release();
             }
@@ -26702,7 +27575,7 @@ class DevicePool extends events.exports {
             for (let i = this.connectedPool.length - 1; i >= 0; i--) {
                 const descriptor = this.connectedPool[i];
                 const device = yield this._createDevice(descriptor, initOptions);
-                Log$d.debug('emit DEVICE.CONNECT: ', device === null || device === void 0 ? void 0 : device.features);
+                Log$e.debug('emit DEVICE.CONNECT: ', device === null || device === void 0 ? void 0 : device.features);
                 this.emitter.emit(DEVICE.CONNECT, device);
                 this.connectedPool.splice(i, 1);
             }
@@ -26722,9 +27595,9 @@ class DevicePool extends events.exports {
         const diff = getDiff(this.current || [], upcoming);
         this.upcoming = upcoming;
         this.current = this.upcoming;
-        Log$d.debug('device pool -> current: ', this.current);
-        Log$d.debug('device pool -> upcomming: ', this.upcoming);
-        Log$d.debug('DeviceCache.reportDeviceChange diff: ', diff);
+        Log$e.debug('device pool -> current: ', this.current);
+        Log$e.debug('device pool -> upcomming: ', this.upcoming);
+        Log$e.debug('DeviceCache.reportDeviceChange diff: ', diff);
         if (!diff.didUpdate) {
             return;
         }
@@ -26734,7 +27607,7 @@ class DevicePool extends events.exports {
                 this._addConnectedDeviceToPool(d);
                 return;
             }
-            Log$d.debug('emit DEVICE.CONNECT: ', device.features);
+            Log$e.debug('emit DEVICE.CONNECT: ', device.features);
             this.emitter.emit(DEVICE.CONNECT, device);
         });
         diff.disconnected.forEach(d => {
@@ -26744,7 +27617,7 @@ class DevicePool extends events.exports {
                 this._addDisconnectedDeviceToPool(d);
                 return;
             }
-            Log$d.debug('emit DEVICE.DISCONNECT: ', device.features);
+            Log$e.debug('emit DEVICE.DISCONNECT: ', device.features);
             this.emitter.emit(DEVICE.DISCONNECT, device);
         });
     }
@@ -26780,7 +27653,7 @@ class DevicePool extends events.exports {
         this.disconnectPool = [];
         this.devicesCache = {};
         this.emitter.removeAllListeners();
-        Log$d.debug('DevicePool state has been reset');
+        Log$e.debug('DevicePool state has been reset');
     }
 }
 DevicePool.current = null;
@@ -26790,16 +27663,17 @@ DevicePool.disconnectPool = [];
 DevicePool.devicesCache = {};
 DevicePool.emitter = new events.exports();
 
-const Log$c = getLogger(exports.LoggerNames.Transport);
+const Log$d = getLogger(exports.LoggerNames.Transport);
 const BleLogger = getLogger(exports.LoggerNames.HdBleTransport);
 const HttpLogger = getLogger(exports.LoggerNames.HdTransportHttp);
 const LowLevelLogger = getLogger(exports.LoggerNames.HdTransportLowLevel);
 const NodeUsbLogger = getLogger(exports.LoggerNames.HdTransportNodeUsb);
 const WebBleLogger = getLogger(exports.LoggerNames.HdWebBleTransport);
 const WebUsbLogger = getLogger(exports.LoggerNames.HdTransportWebUsb);
+const REACT_NATIVE_BLE_SCAN_TIMEOUT_MS = 8000;
 class TransportManager {
     static load() {
-        Log$c.debug('transport manager load');
+        Log$d.debug('transport manager load');
         this.defaultMessages = DataManager.getProtobufMessages();
         this.currentMessages = this.defaultMessages;
         this.messageVersion = 'latest';
@@ -26808,14 +27682,14 @@ class TransportManager {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const env = DataManager.getSettings('env');
-                Log$c.debug('Initializing transports', env);
+                Log$d.debug('Initializing transports', env);
                 if (env === 'react-native') {
                     if (!this.reactNativeInit) {
                         yield this.transport.init(BleLogger, DevicePool.emitter);
                         this.reactNativeInit = true;
                     }
                     else {
-                        Log$c.debug('React Native Do Not Initializing transports');
+                        Log$d.debug('React Native Do Not Initializing transports');
                     }
                 }
                 else if (env === 'node-usb') {
@@ -26836,12 +27710,15 @@ class TransportManager {
                 else {
                     yield this.transport.init(HttpLogger);
                 }
-                Log$c.debug('Configuring transports');
+                Log$d.debug('Configuring transports');
                 yield this.transport.configure(JSON.stringify(this.defaultMessages));
-                Log$c.debug('Configuring transports done');
+                this.currentMessages = this.defaultMessages;
+                this.messageVersion = 'latest';
+                yield this.configureProtocolV2Messages();
+                Log$d.debug('Configuring transports done');
             }
             catch (error) {
-                Log$c.debug('Initializing transports error: ', error);
+                Log$d.debug('Initializing transports error: ', error);
                 if (error.code === 'ECONNABORTED') {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
                 }
@@ -26850,12 +27727,14 @@ class TransportManager {
     }
     static reconfigure(features) {
         return __awaiter(this, void 0, void 0, function* () {
-            Log$c.debug(`Begin reconfiguring transports`);
+            if (!features) {
+                return;
+            }
             const { messageVersion, messages } = getSupportMessageVersion(features);
             if (this.currentMessages === messages || !messages) {
                 return;
             }
-            Log$c.debug(`Reconfiguring transports version:${messageVersion}`);
+            Log$d.debug(`Reconfiguring transports version:${messageVersion}`);
             try {
                 yield this.transport.configure(JSON.stringify(messages));
                 this.currentMessages = messages;
@@ -26869,20 +27748,32 @@ class TransportManager {
     static setTransport(TransportConstructor, plugin) {
         const env = DataManager.getSettings('env');
         if (env === 'react-native') {
-            this.transport = new TransportConstructor({ scanTimeout: 3000 });
+            this.transport = new TransportConstructor({
+                scanTimeout: REACT_NATIVE_BLE_SCAN_TIMEOUT_MS,
+            });
         }
         else {
             this.transport = new TransportConstructor();
         }
         if (plugin) {
             this.plugin = plugin;
-            Log$c.debug('set transport plugin: ', this.plugin);
+            Log$d.debug('set transport plugin: ', this.plugin);
         }
-        Log$c.debug('set transport: ', this.transport.name, this.transport.version, this.transport.configured);
+        Log$d.debug('set transport: ', this.transport.name, this.transport.version, this.transport.configured);
     }
     static getTransport() {
         return this.transport;
     }
+    static configureProtocolV2Messages() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const protocolV2Messages = DataManager.getProtobufMessages('protocolV2');
+            const { configureProtocolV2 } = this.transport;
+            if (protocolV2Messages && typeof configureProtocolV2 === 'function') {
+                yield configureProtocolV2.call(this.transport, JSON.stringify(protocolV2Messages));
+                Log$d.debug('Protocol V2 messages configured');
+            }
+        });
+    }
     static getDefaultMessages() {
         return this.defaultMessages;
     }
@@ -26897,6 +27788,88 @@ TransportManager.reactNativeInit = false;
 TransportManager.messageVersion = 'latest';
 TransportManager.plugin = null;
 
+const MAX_DEBUG_ARRAY_ITEMS = 20;
+const MAX_DEBUG_OBJECT_KEYS = 40;
+const MAX_DEBUG_STRING_LENGTH = 512;
+const MAX_DEBUG_DEPTH = 4;
+const HIGH_VOLUME_DEBUG_CALLS = new Set([
+    'FilesystemFileWrite',
+    'FileWrite',
+    'EmmcFileWrite',
+    'FirmwareUpload',
+    'ResourceAck',
+]);
+function shouldReduceDebugForCall(type) {
+    return HIGH_VOLUME_DEBUG_CALLS.has(type);
+}
+function getBinaryByteLength(value) {
+    if (value instanceof ArrayBuffer) {
+        return value.byteLength;
+    }
+    if (ArrayBuffer.isView(value)) {
+        return value.byteLength;
+    }
+    if (typeof Blob !== 'undefined' && value instanceof Blob) {
+        return value.size;
+    }
+    return undefined;
+}
+function summarizeRedactedData(value) {
+    const byteLength = getBinaryByteLength(value);
+    if (byteLength !== undefined) {
+        return `[redacted data: ${byteLength} bytes]`;
+    }
+    if (typeof value === 'string') {
+        return `[redacted data: string length=${value.length}]`;
+    }
+    if (Array.isArray(value)) {
+        return `[redacted data: array length=${value.length}]`;
+    }
+    if (value && typeof value === 'object') {
+        return `[redacted data: object keys=${Object.keys(value).length}]`;
+    }
+    return `[redacted data: ${typeof value}]`;
+}
+function sanitizeDebugPayload(value, key = '', depth = 0) {
+    if (key === 'data' && value !== null && value !== undefined) {
+        return summarizeRedactedData(value);
+    }
+    const byteLength = getBinaryByteLength(value);
+    if (byteLength !== undefined) {
+        return `[binary: ${byteLength} bytes]`;
+    }
+    if (typeof value === 'string') {
+        return value.length > MAX_DEBUG_STRING_LENGTH
+            ? `${value.slice(0, MAX_DEBUG_STRING_LENGTH)}... (len=${value.length})`
+            : value;
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    if (depth >= MAX_DEBUG_DEPTH) {
+        return Array.isArray(value)
+            ? `[array length=${value.length}]`
+            : `[object keys=${Object.keys(value).length}]`;
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, MAX_DEBUG_ARRAY_ITEMS)
+            .map(item => sanitizeDebugPayload(item, key, depth + 1));
+        if (value.length > MAX_DEBUG_ARRAY_ITEMS) {
+            items.push(`... (${value.length - MAX_DEBUG_ARRAY_ITEMS} more)`);
+        }
+        return items;
+    }
+    const entries = Object.entries(value).slice(0, MAX_DEBUG_OBJECT_KEYS);
+    const sanitized = {};
+    entries.forEach(([entryKey, entryValue]) => {
+        sanitized[entryKey] = sanitizeDebugPayload(entryValue, entryKey, depth + 1);
+    });
+    if (Object.keys(value).length > MAX_DEBUG_OBJECT_KEYS) {
+        sanitized.__truncated__ = `${Object.keys(value).length - MAX_DEBUG_OBJECT_KEYS} more keys`;
+    }
+    return sanitized;
+}
 const assertType = (res, resType) => {
     const splitResTypes = Array.isArray(resType) ? resType : resType.split('|');
     if (!splitResTypes.includes(res.type)) {
@@ -26966,7 +27939,7 @@ const cancelDeviceWithInitialize = (device) => {
         },
     }));
 };
-const Log$b = getLogger(exports.LoggerNames.DeviceCommands);
+const Log$c = getLogger(exports.LoggerNames.DeviceCommands);
 const LogCore = getLogger(exports.LoggerNames.Core);
 class DeviceCommands {
     constructor(device, mainId) {
@@ -26975,7 +27948,7 @@ class DeviceCommands {
         this.transport = TransportManager.getTransport();
         this.disposed = false;
         this.instanceId = generateInstanceId('DeviceCommands', device.sdkInstanceId);
-        Log$b.debug(`[DeviceCommands] Created: ${this.instanceId}, device: ${this.device.instanceId}`);
+        Log$c.debug(`[DeviceCommands] Created: ${this.instanceId}, device: ${this.device.instanceId}`);
     }
     dispose(_cancelRequest) {
         var _a, _b;
@@ -27040,18 +28013,21 @@ class DeviceCommands {
             }
         });
     }
-    call(type, msg = {}) {
+    call(type, msg, options) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            Log$b.debug('[DeviceCommands] [call] Sending', type);
+            const shouldReduceDebug = shouldReduceDebugForCall(type);
+            if (!shouldReduceDebug) {
+                Log$c.debug('[DeviceCommands] [call] Sending', type);
+            }
             try {
-                const promise = this.transport.call(this.mainId, type, msg);
+                const promise = this.transport.call(this.mainId, type, msg !== null && msg !== void 0 ? msg : {}, options);
                 this.callPromise = promise;
                 const res = yield promise;
                 if (res.type === 'Failure') {
                     LogCore.debug('[DeviceCommands] [call] Received', res.type, res.message);
                 }
-                else {
+                else if (!shouldReduceDebug) {
                     LogCore.debug('[DeviceCommands] [call] Received', res.type);
                 }
                 return res;
@@ -27077,7 +28053,7 @@ class DeviceCommands {
                     }
                 }
                 if (responseData) {
-                    Log$b.debug('error response', responseData);
+                    Log$c.debug('error response', responseData);
                 }
                 if (responseError === 'device disconnected during action') {
                     return { type: 'BridgeDeviceDisconnected', message: { error: responseError } };
@@ -27094,7 +28070,7 @@ class DeviceCommands {
             }
         });
     }
-    typedCall(type, resType, msg) {
+    typedCall(type, resType, msg, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.disposed) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'typedCall: DeviceCommands already disposed');
@@ -27106,21 +28082,32 @@ class DeviceCommands {
                     'PassphraseAck',
                     'Cancel',
                     'BixinPinInputOnDevice',
+                    'FilesystemFileWrite',
+                    'FileWrite',
+                    'EmmcFileWrite',
+                    'FirmwareUpload',
+                    'ResourceAck',
                 ];
                 if (!skipTypes.includes(type) && msg) {
-                    Log$b.debug('[DeviceCommands] [typedCall] Sending payload', type, msg);
+                    Log$c.debug('[DeviceCommands] [typedCall] Sending payload', type, sanitizeDebugPayload(msg));
                 }
             }
             catch (e) {
             }
-            const response = yield this._commonCall(type, msg);
+            const response = yield this._commonCall(type, msg, options);
             try {
                 assertType(response, resType);
             }
             catch (error) {
-                Log$b.debug('DeviceCommands typedcall error: ', error);
+                Log$c.debug('DeviceCommands typedcall error: ', error);
                 if (error instanceof hdShared.HardwareError) {
                     if (error.errorCode === hdShared.HardwareErrorCode.ResponseUnexpectTypeError) {
+                        Log$c.debug('[DeviceCommands] [typedCall] Unexpected response type', {
+                            request: type,
+                            expected: resType,
+                            received: response.type,
+                            response: sanitizeDebugPayload(response.message),
+                        });
                         if (error.message.indexOf('BridgeNetworkError') > -1) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNetworkError);
                         }
@@ -27130,7 +28117,7 @@ class DeviceCommands {
                         if (error.message.indexOf('BridgeDeviceDisconnected') > -1) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeDeviceDisconnected);
                         }
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ResponseUnexpectTypeError);
+                        throw error;
                     }
                 }
                 else {
@@ -27140,19 +28127,21 @@ class DeviceCommands {
             return response;
         });
     }
-    _commonCall(type, msg) {
+    _commonCall(type, msg, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const resp = yield this.call(type, msg);
-            return this._filterCommonTypes(resp, type);
+            const resp = yield this.call(type, msg, options);
+            return this._filterCommonTypes(resp, type, options);
         });
     }
-    _filterCommonTypes(res, callType) {
+    _filterCommonTypes(res, callType, options) {
         try {
-            if (DataManager.getSettings('env') === 'react-native') {
-                Log$b.debug('_filterCommonTypes: ', JSON.stringify(res));
+            if (shouldReduceDebugForCall(callType)) {
+            }
+            else if (DataManager.getSettings('env') === 'react-native') {
+                Log$c.debug('_filterCommonTypes: ', JSON.stringify(sanitizeDebugPayload(res)));
             }
             else {
-                Log$b.debug('_filterCommonTypes: ', res);
+                Log$c.debug('_filterCommonTypes: ', sanitizeDebugPayload(res));
             }
         }
         catch (error) {
@@ -27173,6 +28162,9 @@ class DeviceCommands {
             if (code === 'Failure_PinCancelled') {
                 error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinCancelled);
             }
+            if (code === 'Failure_PinMismatch') {
+                error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.PinMismatch, message);
+            }
             if (code === 'Failure_DataError') {
                 if (message === 'Please confirm the BlindSign enabled') {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlindSignDisabled);
@@ -27229,18 +28221,18 @@ class DeviceCommands {
             else {
                 this.device.emit(DEVICE.BUTTON, this.device, res.message);
             }
-            return this._commonCall('ButtonAck', {});
+            return this._commonCall('ButtonAck', {}, options);
         }
         if (res.type === 'EntropyRequest') ;
         if (res.type === 'PinMatrixRequest') {
             return this._promptPin(res.message.type).then(pin => {
                 if (pin === '@@ONEKEY_INPUT_PIN_IN_DEVICE') {
                     this.device.setCancelableAction(() => this.cancelDeviceOnOneKeyDevice());
-                    return this._commonCall('BixinPinInputOnDevice').finally(() => {
+                    return this._commonCall('BixinPinInputOnDevice', {}, options).finally(() => {
                         this.device.clearCancelableAction();
                     });
                 }
-                return this._commonCall('PinMatrixAck', { pin });
+                return this._commonCall('PinMatrixAck', { pin }, options);
             }, error => Promise.reject(error));
         }
         if (res.type === 'PassphraseRequest') {
@@ -27250,11 +28242,11 @@ class DeviceCommands {
             }).then(response => {
                 const { passphrase, passphraseOnDevice, attachPinOnDevice } = response;
                 if (attachPinOnDevice && existsAttachPinUser) {
-                    return this._commonCall('PassphraseAck', { on_device_attach_pin: true });
+                    return this._commonCall('PassphraseAck', { on_device_attach_pin: true }, options);
                 }
                 return !passphraseOnDevice
-                    ? this._commonCall('PassphraseAck', { passphrase })
-                    : this._commonCall('PassphraseAck', { on_device: true });
+                    ? this._commonCall('PassphraseAck', { passphrase }, options)
+                    : this._commonCall('PassphraseAck', { on_device: true }, options);
             });
         }
         if (res.type === 'Deprecated_PassphraseStateRequest') ;
@@ -27278,7 +28270,7 @@ class DeviceCommands {
                 reject(error);
             });
             const listenerCount = this.device.listenerCount(DEVICE.PIN);
-            Log$b.debug(`[${this.instanceId}] _promptPin called`, {
+            Log$c.debug(`[${this.instanceId}] _promptPin called`, {
                 responseID: this.currentResponseID,
                 deviceInstanceId: this.device.instanceId,
                 listenerCount,
@@ -27345,12 +28337,178 @@ class DeviceCommands {
     }
 }
 
+const PROTOCOL_V2_DEVICE_INFO_REQUEST = {
+    targets: {
+        hw: true,
+        fw: true,
+        bt: true,
+        se1: true,
+        se2: true,
+        se3: true,
+        se4: true,
+        status: true,
+    },
+    types: {
+        version: true,
+        build_id: true,
+        hash: true,
+        specific: true,
+    },
+};
+function parseVersion(version) {
+    if (!version)
+        return [0, 0, 0];
+    const [major = 0, minor = 0, patch = 0] = version.split('.').map(part => Number(part) || 0);
+    return [major, minor, patch];
+}
+function bytesToHex$1(value) {
+    if (!value)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    if (value instanceof Uint8Array) {
+        return Array.from(value)
+            .map(byte => byte.toString(16).padStart(2, '0'))
+            .join('');
+    }
+    if (Array.isArray(value)) {
+        return value.map(byte => Number(byte).toString(16).padStart(2, '0')).join('');
+    }
+    return undefined;
+}
+function getDescriptorId(descriptor) {
+    return descriptor.path || descriptor.id || '';
+}
+function getImageVersion(image) {
+    return (image === null || image === void 0 ? void 0 : image.version) || undefined;
+}
+function getImageBuildId(image) {
+    return (image === null || image === void 0 ? void 0 : image.build_id) || undefined;
+}
+function getImageHash(image) {
+    return bytesToHex$1(image === null || image === void 0 ? void 0 : image.hash);
+}
+function getSeState(se) {
+    switch (se === null || se === void 0 ? void 0 : se.state) {
+        case 0:
+            return 'BOOT';
+        case 51:
+            return 'APP_FACTORY';
+        case 85:
+            return 'APP';
+        default:
+            return null;
+    }
+}
+function createBaseFeatures(descriptor) {
+    const descriptorId = getDescriptorId(descriptor);
+    return {
+        vendor: 'onekey.so',
+        major_version: 0,
+        minor_version: 0,
+        patch_version: 0,
+        bootloader_mode: false,
+        device_id: descriptorId,
+        pin_protection: null,
+        passphrase_protection: false,
+        language: null,
+        label: null,
+        initialized: false,
+        revision: null,
+        bootloader_hash: null,
+        imported: null,
+        unlocked: false,
+        firmware_present: false,
+        needs_backup: null,
+        flags: null,
+        model: 'pro2',
+        fw_major: 0,
+        fw_minor: 0,
+        fw_patch: 0,
+        fw_vendor: null,
+        unfinished_backup: null,
+        no_backup: null,
+        recovery_mode: null,
+        capabilities: [],
+        backup_type: null,
+        sd_card_present: null,
+        sd_protection: null,
+        wipe_code_protection: null,
+        session_id: null,
+        passphrase_always_on_device: null,
+        safety_checks: null,
+        auto_lock_delay_ms: null,
+        display_rotation: null,
+        experimental_features: null,
+        onekey_device_type: hdShared.EDeviceType.Pro2,
+        onekey_serial_no: descriptorId,
+        serial_no: descriptorId,
+    };
+}
+function normalizeProtocolV2Features(descriptor, deviceInfo) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
+    const features = createBaseFeatures(descriptor);
+    if (!deviceInfo)
+        return features;
+    const serialNo = ((_a = deviceInfo.hw) === null || _a === void 0 ? void 0 : _a.serial_no) || features.onekey_serial_no || getDescriptorId(descriptor);
+    const firmwareVersion = getImageVersion((_b = deviceInfo.fw) === null || _b === void 0 ? void 0 : _b.app);
+    const [fwMajor, fwMinor, fwPatch] = parseVersion(firmwareVersion);
+    return Object.assign(Object.assign({}, features), { major_version: fwMajor, minor_version: fwMinor, patch_version: fwPatch, fw_major: fwMajor, fw_minor: fwMinor, fw_patch: fwPatch, device_id: serialNo, serial_no: serialNo, onekey_serial_no: serialNo, label: (_d = (_c = deviceInfo.status) === null || _c === void 0 ? void 0 : _c.label) !== null && _d !== void 0 ? _d : features.label, language: (_f = (_e = deviceInfo.status) === null || _e === void 0 ? void 0 : _e.language) !== null && _f !== void 0 ? _f : features.language, initialized: (_h = (_g = deviceInfo.status) === null || _g === void 0 ? void 0 : _g.init_states) !== null && _h !== void 0 ? _h : features.initialized, passphrase_protection: (_k = (_j = deviceInfo.status) === null || _j === void 0 ? void 0 : _j.passphrase_protection) !== null && _k !== void 0 ? _k : features.passphrase_protection, needs_backup: (_m = (_l = deviceInfo.status) === null || _l === void 0 ? void 0 : _l.backup_required) !== null && _m !== void 0 ? _m : features.needs_backup, ble_enable: (_o = deviceInfo.status) === null || _o === void 0 ? void 0 : _o.bt_enable, onekey_ble_name: (_p = deviceInfo.bt) === null || _p === void 0 ? void 0 : _p.adv_name, ble_name: (_q = deviceInfo.bt) === null || _q === void 0 ? void 0 : _q.adv_name, onekey_firmware_version: firmwareVersion, onekey_firmware_build_id: getImageBuildId((_r = deviceInfo.fw) === null || _r === void 0 ? void 0 : _r.app), onekey_firmware_hash: getImageHash((_s = deviceInfo.fw) === null || _s === void 0 ? void 0 : _s.app), onekey_boot_version: getImageVersion((_t = deviceInfo.fw) === null || _t === void 0 ? void 0 : _t.boot), bootloader_version: getImageVersion((_u = deviceInfo.fw) === null || _u === void 0 ? void 0 : _u.boot), onekey_boot_build_id: getImageBuildId((_v = deviceInfo.fw) === null || _v === void 0 ? void 0 : _v.boot), onekey_boot_hash: getImageHash((_w = deviceInfo.fw) === null || _w === void 0 ? void 0 : _w.boot), onekey_board_version: getImageVersion((_x = deviceInfo.fw) === null || _x === void 0 ? void 0 : _x.board), onekey_board_hash: getImageHash((_y = deviceInfo.fw) === null || _y === void 0 ? void 0 : _y.board), onekey_ble_version: getImageVersion((_z = deviceInfo.bt) === null || _z === void 0 ? void 0 : _z.app), ble_ver: getImageVersion((_0 = deviceInfo.bt) === null || _0 === void 0 ? void 0 : _0.app), onekey_ble_build_id: getImageBuildId((_1 = deviceInfo.bt) === null || _1 === void 0 ? void 0 : _1.app), onekey_ble_hash: getImageHash((_2 = deviceInfo.bt) === null || _2 === void 0 ? void 0 : _2.app), onekey_se01_version: getImageVersion((_3 = deviceInfo.se1) === null || _3 === void 0 ? void 0 : _3.app), onekey_se01_hash: getImageHash((_4 = deviceInfo.se1) === null || _4 === void 0 ? void 0 : _4.app), onekey_se01_build_id: getImageBuildId((_5 = deviceInfo.se1) === null || _5 === void 0 ? void 0 : _5.app), onekey_se01_state: getSeState(deviceInfo.se1), onekey_se02_version: getImageVersion((_6 = deviceInfo.se2) === null || _6 === void 0 ? void 0 : _6.app), onekey_se02_state: getSeState(deviceInfo.se2), onekey_se03_version: getImageVersion((_7 = deviceInfo.se3) === null || _7 === void 0 ? void 0 : _7.app), onekey_se03_state: getSeState(deviceInfo.se3), onekey_se04_version: getImageVersion((_8 = deviceInfo.se4) === null || _8 === void 0 ? void 0 : _8.app), onekey_se04_state: getSeState(deviceInfo.se4) });
+}
+function getProtocolV2Features({ commands, descriptor, onDeviceInfoError, timeoutMs, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const callOptions = timeoutMs ? { timeoutMs } : undefined;
+        if (callOptions) {
+            yield commands.typedCall('Ping', 'Success', { message: 'init' }, callOptions);
+        }
+        else {
+            yield commands.typedCall('Ping', 'Success', { message: 'init' });
+        }
+        try {
+            const { message } = callOptions
+                ? yield commands.typedCall('DevGetDeviceInfo', 'DeviceInfo', PROTOCOL_V2_DEVICE_INFO_REQUEST, callOptions)
+                : yield commands.typedCall('DevGetDeviceInfo', 'DeviceInfo', PROTOCOL_V2_DEVICE_INFO_REQUEST);
+            return normalizeProtocolV2Features(descriptor, message);
+        }
+        catch (error) {
+            onDeviceInfoError === null || onDeviceInfoError === void 0 ? void 0 : onDeviceInfoError(error);
+            throw error;
+        }
+    });
+}
+
+const ProtocolV2FirmwareTargetType = {
+    TARGET_MAIN_APP: 0,
+    TARGET_MAIN_BOOT: 1,
+    TARGET_BT: 2,
+    TARGET_SE1: 3,
+    TARGET_SE2: 4,
+    TARGET_SE3: 5,
+    TARGET_SE4: 6,
+    TARGET_RESOURCE: 10,
+};
+function protocolV2FileNameToTargetId(fileName) {
+    if (fileName.includes('ble'))
+        return ProtocolV2FirmwareTargetType.TARGET_BT;
+    if (fileName.includes('bootloader'))
+        return ProtocolV2FirmwareTargetType.TARGET_MAIN_BOOT;
+    if (fileName.includes('se1'))
+        return ProtocolV2FirmwareTargetType.TARGET_SE1;
+    if (fileName.includes('se2'))
+        return ProtocolV2FirmwareTargetType.TARGET_SE2;
+    if (fileName.includes('se3'))
+        return ProtocolV2FirmwareTargetType.TARGET_SE3;
+    if (fileName.includes('se4'))
+        return ProtocolV2FirmwareTargetType.TARGET_SE4;
+    return ProtocolV2FirmwareTargetType.TARGET_MAIN_APP;
+}
+
 const parseRunOptions = (options) => {
     if (!options)
         options = {};
     return options;
 };
-const Log$a = getLogger(exports.LoggerNames.Device);
+const Log$b = getLogger(exports.LoggerNames.Device);
 const deviceSessionCache = {};
 function preloadSessionCache(deviceId, passphraseState, sessionId) {
     const key = `${deviceId}@${passphraseState}`;
@@ -27374,7 +28532,7 @@ class Device extends events.exports {
         this.sdkInstanceId = sdkInstanceId;
         this.instanceId = generateInstanceId('Device', this.sdkInstanceId);
         this.createdAt = Date.now();
-        Log$a.debug(`[Device] Created: ${this.instanceId}${this.sdkInstanceId ? ` for SDK: ${this.sdkInstanceId}` : ''}`);
+        Log$b.debug(`[Device] Created: ${this.instanceId}${this.sdkInstanceId ? ` for SDK: ${this.sdkInstanceId}` : ''}`);
     }
     static fromDescriptor(originalDescriptor, sdkInstanceId) {
         const descriptor = Object.assign({}, originalDescriptor);
@@ -27408,12 +28566,12 @@ class Device extends events.exports {
             unavailableCapabilities: this.unavailableCapabilities,
         };
     }
-    connect() {
+    connect(connectProtocol) {
         const env = DataManager.getSettings('env');
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
             if (DataManager.isBleConnect(env)) {
                 try {
-                    yield this.acquire();
+                    yield this.acquire(connectProtocol);
                     resolve(true);
                 }
                 catch (error) {
@@ -27423,7 +28581,7 @@ class Device extends events.exports {
             }
             if (!this.mainId || (!this.isUsedHere() && this.originalDescriptor)) {
                 try {
-                    yield this.acquire();
+                    yield this.acquire(connectProtocol);
                     resolve(true);
                 }
                 catch (error) {
@@ -27438,27 +28596,32 @@ class Device extends events.exports {
             resolve(false);
         }));
     }
-    acquire() {
-        var _a, _b, _c, _d;
+    acquire(connectProtocol) {
+        var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
             const env = DataManager.getSettings('env');
             const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
+            const expectedProtocol = connectProtocol !== null && connectProtocol !== void 0 ? connectProtocol : this.originalDescriptor.protocolType;
             try {
                 if (DataManager.isBleConnect(env)) {
-                    const res = yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.originalDescriptor.id));
+                    const res = yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.originalDescriptor.id, undefined, true, expectedProtocol));
                     this.mainId = (_b = res.uuid) !== null && _b !== void 0 ? _b : '';
-                    Log$a.debug('Expected uuid:', this.mainId);
+                    Log$b.debug('Expected uuid:', this.mainId);
                 }
                 else {
-                    this.mainId = yield ((_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.acquire(this.originalDescriptor.path, this.originalDescriptor.session));
-                    Log$a.debug('Expected session id:', this.mainId);
+                    this.mainId = yield ((_c = this.deviceConnector) === null || _c === void 0 ? void 0 : _c.acquire(this.originalDescriptor.path, this.originalDescriptor.session, undefined, expectedProtocol));
+                    Log$b.debug('Expected session id:', this.mainId);
                 }
                 this.deviceAcquired = true;
                 this.updateDescriptor({ [mainIdKey]: this.mainId });
+                const detectedProtocol = (_e = (_d = TransportManager.transport) === null || _d === void 0 ? void 0 : _d.getProtocolType) === null || _e === void 0 ? void 0 : _e.call(_d, DataManager.isBleConnect(env) ? this.originalDescriptor.id : this.originalDescriptor.path);
+                if (detectedProtocol) {
+                    this.originalDescriptor.protocolType = detectedProtocol;
+                }
                 if (this.commands) {
                     yield this.commands.dispose(false);
                 }
-                this.commands = new DeviceCommands(this, (_d = this.mainId) !== null && _d !== void 0 ? _d : '');
+                this.commands = new DeviceCommands(this, (_f = this.mainId) !== null && _f !== void 0 ? _f : '');
             }
             catch (error) {
                 if (this.runPromise) {
@@ -27479,11 +28642,11 @@ class Device extends events.exports {
                 (this.mainId && DataManager.isBleConnect(env))) {
                 if (this.pendingCallbackPromise) {
                     try {
-                        Log$a.debug('Waiting for callback tasks to complete before releasing device (in release method)');
+                        Log$b.debug('Waiting for callback tasks to complete before releasing device (in release method)');
                         yield this.pendingCallbackPromise.promise;
                     }
                     catch (error) {
-                        Log$a.error('Error waiting for callback tasks in release method:', error);
+                        Log$b.error('Error waiting for callback tasks in release method:', error);
                     }
                 }
                 if (this.commands) {
@@ -27502,7 +28665,7 @@ class Device extends events.exports {
                     this.updateDescriptor({ session: null });
                 }
                 catch (err) {
-                    Log$a.error('[Device] release error: ', err);
+                    Log$b.error('[Device] release error: ', err);
                 }
                 finally {
                     this.needReloadDevice = true;
@@ -27522,8 +28685,8 @@ class Device extends events.exports {
     }
     getInternalState(_deviceId) {
         var _a, _b;
-        Log$a.debug('getInternalState session cache: ', deviceSessionCache);
-        Log$a.debug('getInternalState session param: ', `device_id: ${_deviceId}`, `features.device_id: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id}`, `passphraseState: ${this.passphraseState}`);
+        Log$b.debug('getInternalState session cache: ', deviceSessionCache);
+        Log$b.debug('getInternalState session param: ', `device_id: ${_deviceId}`, `features.device_id: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id}`, `passphraseState: ${this.passphraseState}`);
         const deviceId = _deviceId || ((_b = this.features) === null || _b === void 0 ? void 0 : _b.device_id);
         if (!deviceId)
             return undefined;
@@ -27533,7 +28696,7 @@ class Device extends events.exports {
         return deviceSessionCache[usePassKey];
     }
     updateInternalState(enablePassphrase, passphraseState, deviceId, sessionId = null, featuresSessionId = null) {
-        Log$a.debug('updateInternalState session param: ', `device_id: ${deviceId}`, `enablePassphrase: ${enablePassphrase}`, `passphraseState: ${passphraseState}`, `sessionId: ${sessionId}`, `featuresSessionId: ${featuresSessionId}`);
+        Log$b.debug('updateInternalState session param: ', `device_id: ${deviceId}`, `enablePassphrase: ${enablePassphrase}`, `passphraseState: ${passphraseState}`, `sessionId: ${sessionId}`, `featuresSessionId: ${featuresSessionId}`);
         if (enablePassphrase) {
             if (sessionId) {
                 deviceSessionCache[this.generateStateKey(deviceId, passphraseState)] = sessionId;
@@ -27546,11 +28709,11 @@ class Device extends events.exports {
         if (deviceSessionCache[oldKey]) {
             delete deviceSessionCache[oldKey];
         }
-        Log$a.debug('updateInternalState session cache: ', deviceSessionCache);
+        Log$b.debug('updateInternalState session cache: ', deviceSessionCache);
     }
     setInternalState(state, initSession) {
         var _a, _b;
-        Log$a.debug('setInternalState session param: ', `state: ${state}`, `initSession: ${initSession}`, `device_id: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id}`, `passphraseState: ${this.passphraseState}`);
+        Log$b.debug('setInternalState session param: ', `state: ${state}`, `initSession: ${initSession}`, `device_id: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id}`, `passphraseState: ${this.passphraseState}`);
         if (!this.features)
             return;
         if (!this.passphraseState && !initSession)
@@ -27562,11 +28725,11 @@ class Device extends events.exports {
         if (state) {
             deviceSessionCache[key] = state;
         }
-        Log$a.debug('setInternalState done session cache: ', deviceSessionCache);
+        Log$b.debug('setInternalState done session cache: ', deviceSessionCache);
     }
     clearInternalState(_deviceId) {
         var _a;
-        Log$a.debug('clearInternalState param: ', _deviceId);
+        Log$b.debug('clearInternalState param: ', _deviceId);
         const deviceId = _deviceId || ((_a = this.features) === null || _a === void 0 ? void 0 : _a.device_id);
         if (!deviceId)
             return;
@@ -27579,6 +28742,10 @@ class Device extends events.exports {
     }
     initialize(options) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.originalDescriptor.protocolType === 'V2') {
+                yield this._initializeProtocolV2();
+                return;
+            }
             this.passphraseState = options === null || options === void 0 ? void 0 : options.passphraseState;
             if (options === null || options === void 0 ? void 0 : options.initSession) {
                 this.clearInternalState(options === null || options === void 0 ? void 0 : options.deviceId);
@@ -27593,7 +28760,7 @@ class Device extends events.exports {
             }
             payload.passphrase_state = options === null || options === void 0 ? void 0 : options.passphraseState;
             payload.is_contains_attach = true;
-            Log$a.debug('Initialize device begin:', {
+            Log$b.debug('Initialize device begin:', {
                 deviceId: options === null || options === void 0 ? void 0 : options.deviceId,
                 passphraseState: options === null || options === void 0 ? void 0 : options.passphraseState,
                 initSession: options === null || options === void 0 ? void 0 : options.initSession,
@@ -27608,12 +28775,40 @@ class Device extends events.exports {
                         }, 25 * 1000);
                     }),
                 ]);
-                Log$a.debug('Initialize device end: ', message);
+                Log$b.debug('Initialize device end: ', message);
                 this._updateFeatures(message, options === null || options === void 0 ? void 0 : options.initSession);
                 yield TransportManager.reconfigure(this.features);
             }
             catch (error) {
-                Log$a.error('Initialization failed:', error);
+                Log$b.error('Initialization failed:', error);
+                throw error;
+            }
+        });
+    }
+    _initializeProtocolV2() {
+        return __awaiter(this, void 0, void 0, function* () {
+            Log$b.debug('Initialize device via Protocol V2 feature adapter');
+            try {
+                const features = yield Promise.race([
+                    getProtocolV2Features({
+                        commands: this.commands,
+                        descriptor: this.originalDescriptor,
+                        onDeviceInfoError: error => {
+                            Log$b.debug('Protocol V2 DevGetDeviceInfo failed:', error);
+                        },
+                        timeoutMs: 10 * 1000,
+                    }),
+                    new Promise((_, reject) => {
+                        setTimeout(() => {
+                            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed));
+                        }, 10 * 1000);
+                    }),
+                ]);
+                Log$b.debug('Protocol V2 normalized features:', features);
+                this._updateFeatures(features);
+            }
+            catch (error) {
+                Log$b.error('Protocol V2 initialization failed:', error);
                 throw error;
             }
         });
@@ -27664,7 +28859,7 @@ class Device extends events.exports {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.runPromise) {
                 yield this.interruptionFromOutside();
-                Log$a.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
+                Log$b.debug('[Device] run error:', 'Device is running, but will cancel previous operate');
             }
             options = parseRunOptions(options);
             this.runPromise = hdShared.createDeferred(this._runInner.bind(this, fn, options));
@@ -27678,7 +28873,7 @@ class Device extends events.exports {
                 const env = DataManager.getSettings('env');
                 if (env !== 'react-native') {
                     try {
-                        yield this.acquire();
+                        yield this.acquire(options.connectProtocol);
                     }
                     catch (error) {
                         this.runPromise = null;
@@ -27720,7 +28915,7 @@ class Device extends events.exports {
                             yield ((_a = this.deviceConnector) === null || _a === void 0 ? void 0 : _a.disconnect(this.mainId));
                         }
                         yield this.release();
-                        Log$a.debug(`error code ${e.errorCode} release device, mainId: ${this.mainId}`);
+                        Log$b.debug(`error code ${e.errorCode} release device, mainId: ${this.mainId}`);
                     }
                     this.runPromise = null;
                     return;
@@ -27730,7 +28925,7 @@ class Device extends events.exports {
                 options.keepSession === false) {
                 this.keepSession = false;
                 yield this.release();
-                Log$a.debug('release device, mainId: ', this.mainId);
+                Log$b.debug('release device, mainId: ', this.mainId);
             }
             if (this.runPromise) {
                 this.runPromise.resolve();
@@ -27763,7 +28958,7 @@ class Device extends events.exports {
     setCancelableAction(callback) {
         this.cancelableAction = (e) => callback(e)
             .catch(e2 => {
-            Log$a.debug('cancelableAction error', e2);
+            Log$b.debug('cancelableAction error', e2);
         })
             .finally(() => {
             this.clearCancelableAction();
@@ -27918,7 +29113,7 @@ class Device extends events.exports {
             }
             const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphrase;
             const useErrorAttachPin = unlockedAttachPin && passphraseState && passphraseState !== newPassphraseState;
-            Log$a.debug('Check passphrase state safety: ', {
+            Log$b.debug('Check passphrase state safety: ', {
                 passphraseState,
                 newPassphraseState,
                 unlockedAttachPin,
@@ -28018,7 +29213,7 @@ const getBootloaderReleaseInfo = ({ features, willUpdateFirmwareVersion, firmwar
     };
 };
 
-const Log$9 = getLogger(exports.LoggerNames.Method);
+const Log$a = getLogger(exports.LoggerNames.Method);
 class BaseMethod {
     constructor(message) {
         this.shouldEnsureConnected = true;
@@ -28048,7 +29243,7 @@ class BaseMethod {
     setContext(context) {
         this.sdkInstanceId = context.sdkInstanceId;
         this.instanceId = generateInstanceId('Method', this.sdkInstanceId);
-        Log$9.debug(`[BaseMethod] Created: ${this.instanceId}, method: ${this.name}, SDK: ${this.sdkInstanceId}`);
+        Log$a.debug(`[BaseMethod] Created: ${this.instanceId}, method: ${this.name}, SDK: ${this.sdkInstanceId}`);
     }
     setDevice(device) {
         var _a, _b;
@@ -28068,7 +29263,7 @@ class BaseMethod {
         if (device.commands) {
             device.commands.currentResponseID = this.responseID;
         }
-        Log$9.debug(`[${this.instanceId}] setDevice: ${device.instanceId}, commands: ${(_b = device.commands) === null || _b === void 0 ? void 0 : _b.instanceId}`);
+        Log$a.debug(`[${this.instanceId}] setDevice: ${device.instanceId}, commands: ${(_b = device.commands) === null || _b === void 0 ? void 0 : _b.instanceId}`);
     }
     checkFirmwareRelease() {
         if (!this.device || !this.device.features)
@@ -28121,7 +29316,7 @@ class BaseMethod {
                 checkFlag = true;
             }
             if (checkFlag && ((_c = this.device.features) === null || _c === void 0 ? void 0 : _c.safety_checks) === 'Strict') {
-                Log$9.debug('will change safety_checks level');
+                Log$a.debug('will change safety_checks level');
                 yield this.device.commands.typedCall('ApplySettings', 'Success', {
                     safety_checks: 'PromptTemporarily',
                 });
@@ -28159,7 +29354,7 @@ class SearchDevices extends BaseMethod {
         this.skipForceUpdateCheck = true;
     }
     run() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             yield TransportManager.configure();
             const deviceDiff = yield ((_a = this.connector) === null || _a === void 0 ? void 0 : _a.enumerate());
@@ -28172,12 +29367,15 @@ class SearchDevices extends BaseMethod {
                     const lowerId = (_c = device.id) === null || _c === void 0 ? void 0 : _c.toLowerCase();
                     if (!seenIds.has(lowerId)) {
                         seenIds.add(lowerId);
-                        devices.push(Object.assign(Object.assign({}, device), { connectId: device.id, deviceType: getDeviceTypeByBleName((_d = device.name) !== null && _d !== void 0 ? _d : '') }));
+                        const bleName = (_e = (_d = device.name) !== null && _d !== void 0 ? _d : device.localName) !== null && _e !== void 0 ? _e : '';
+                        devices.push(Object.assign(Object.assign({}, device), { connectId: device.id, name: bleName || device.name, deviceType: getDeviceTypeByBleName(bleName) }));
                     }
                 }
                 return devices;
             }
-            const { deviceList } = yield DevicePool.getDevices(devicesDescriptor);
+            const { deviceList } = yield DevicePool.getDevices(devicesDescriptor, undefined, {
+                connectProtocol: this.payload.connectProtocol,
+            });
             return deviceList.map(device => device.toMessageObject());
         });
     }
@@ -28202,6 +29400,70 @@ class GetFeatures extends BaseMethod {
     }
 }
 
+const ONEKEY_FEATURE_KEYS = [
+    'onekey_device_type',
+    'onekey_board_version',
+    'onekey_boot_version',
+    'onekey_firmware_version',
+    'onekey_board_hash',
+    'onekey_boot_hash',
+    'onekey_firmware_hash',
+    'onekey_board_build_id',
+    'onekey_boot_build_id',
+    'onekey_firmware_build_id',
+    'onekey_serial_no',
+    'onekey_ble_name',
+    'onekey_ble_version',
+    'onekey_ble_build_id',
+    'onekey_ble_hash',
+    'onekey_se_type',
+    'onekey_se01_state',
+    'onekey_se02_state',
+    'onekey_se03_state',
+    'onekey_se04_state',
+    'onekey_se01_version',
+    'onekey_se02_version',
+    'onekey_se03_version',
+    'onekey_se04_version',
+    'onekey_se01_hash',
+    'onekey_se02_hash',
+    'onekey_se03_hash',
+    'onekey_se04_hash',
+    'onekey_se01_build_id',
+    'onekey_se02_build_id',
+    'onekey_se03_build_id',
+    'onekey_se04_build_id',
+    'onekey_se01_boot_version',
+    'onekey_se02_boot_version',
+    'onekey_se03_boot_version',
+    'onekey_se04_boot_version',
+    'onekey_se01_boot_hash',
+    'onekey_se02_boot_hash',
+    'onekey_se03_boot_hash',
+    'onekey_se04_boot_hash',
+    'onekey_se01_boot_build_id',
+    'onekey_se02_boot_build_id',
+    'onekey_se03_boot_build_id',
+    'onekey_se04_boot_build_id',
+];
+function normalizeOnekeyFirmwareVersion(message) {
+    if (message.onekey_firmware_version && !semver__default["default"].valid(message.onekey_firmware_version)) {
+        message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+    }
+}
+function pickOnekeyFeatures(features) {
+    const message = {};
+    if (!features)
+        return message;
+    for (const key of ONEKEY_FEATURE_KEYS) {
+        const value = features[key];
+        if (value !== undefined && value !== null) {
+            message[key] = value;
+        }
+    }
+    normalizeOnekeyFirmwareVersion(message);
+    return message;
+}
 class GetOnekeyFeatures extends BaseMethod {
     init() {
         this.allowDeviceMode = [
@@ -28213,11 +29475,13 @@ class GetOnekeyFeatures extends BaseMethod {
         this.skipForceUpdateCheck = true;
     }
     run() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { message } = yield this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
-            if (!!message.onekey_firmware_version && !semver__default["default"].valid(message.onekey_firmware_version)) {
-                message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+            if (((_a = this.device.originalDescriptor) === null || _a === void 0 ? void 0 : _a.protocolType) === 'V2') {
+                return Promise.resolve(pickOnekeyFeatures(this.device.features));
             }
+            const { message } = yield this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
+            normalizeOnekeyFirmwareVersion(message);
             return Promise.resolve(message);
         });
     }
@@ -28762,7 +30026,14 @@ class DeviceRebootToBootloader extends BaseMethod {
         };
     }
     run() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.device.originalDescriptor) === null || _a === void 0 ? void 0 : _a.protocolType) === 'V2') {
+                const res = yield this.device.commands.typedCall('DevReboot', 'Success', {
+                    reboot_type: hdTransport.DevRebootType.Bootloader,
+                });
+                return Promise.resolve(res.message);
+            }
             const res = yield this.device.commands.typedCall('RebootToBootloader', 'Success');
             return Promise.resolve(res.message);
         });
@@ -28785,7 +30056,14 @@ class DeviceRebootToBoardloader extends BaseMethod {
         };
     }
     run() {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.device.originalDescriptor) === null || _a === void 0 ? void 0 : _a.protocolType) === 'V2') {
+                const res = yield this.device.commands.typedCall('DevReboot', 'Success', {
+                    reboot_type: hdTransport.DevRebootType.Boardloader,
+                });
+                return Promise.resolve(res.message);
+            }
             const res = yield this.device.commands.typedCall('BixinOutMessageSE', 'Success');
             return Promise.resolve(res.message);
         });
@@ -29225,10 +30503,10 @@ const getInfo = ({ features, updateType, targetVersion, firmwareType }) => {
 };
 
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
-const SESSION_ERROR$1 = 'session not found';
+const SESSION_ERROR$2 = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM$1 = 'Firmware install confirmed';
-const Log$8 = getLogger(exports.LoggerNames.Method);
-const isDeviceDisconnectedError$1 = (error) => {
+const Log$9 = getLogger(exports.LoggerNames.Method);
+const isDeviceDisconnectedError$2 = (error) => {
     const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
     return (message.includes('device was disconnected') ||
         message.includes('transferIn') ||
@@ -29276,13 +30554,13 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, r
             const newFeatures = yield typedCall('GetFeatures', 'Features', {});
             const deviceBootloaderVersion = getDeviceBootloaderVersion(newFeatures.message).join('.');
             const supportUpgradeFileHeader = semver__default["default"].gte(deviceBootloaderVersion, '2.1.0');
-            Log$8.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
+            Log$9.debug('supportUpgradeFileHeader:', supportUpgradeFileHeader);
             if (supportUpgradeFileHeader) {
                 const HEADER_SIZE = 1024;
                 if (payload.byteLength < HEADER_SIZE) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`);
                 }
-                Log$8.debug('Uploading firmware header:', {
+                Log$9.debug('Uploading firmware header:', {
                     size: HEADER_SIZE,
                     totalSize: payload.byteLength,
                 });
@@ -29294,18 +30572,18 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, r
                     });
                     const isUnknownMessage = (_b = (_a = headerRes.message) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.includes('Failure_UnknownMessage');
                     if (headerRes.type !== 'Success' && !isUnknownMessage) {
-                        Log$8.error('Firmware header upload failed:', headerRes);
+                        Log$9.error('Firmware header upload failed:', headerRes);
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'failed to upload firmware header');
                     }
                 }
                 catch (error) {
-                    Log$8.error('Firmware header upload failed:', error);
+                    Log$9.error('Firmware header upload failed:', error);
                     const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
                     if (!message.includes('Failure_UnknownMessage')) {
                         throw error;
                     }
                 }
-                Log$8.debug('Firmware header uploaded successfully');
+                Log$9.debug('Firmware header uploaded successfully');
             }
         }
         const eraseCommand = isFirmware ? 'FirmwareErase' : 'FirmwareErase_ex';
@@ -29322,8 +30600,8 @@ const uploadFirmware = (updateType, typedCall, postMessage, device, { payload, r
             });
         }
         catch (error) {
-            if (isDeviceDisconnectedError$1(error)) {
-                Log$8.log('Rebooting device');
+            if (isDeviceDisconnectedError$2(error)) {
+                Log$9.log('Rebooting device');
                 updateResponse = {
                     type: 'Success',
                     message: { message: FIRMWARE_UPDATE_CONFIRM$1 },
@@ -29408,8 +30686,8 @@ const newTouchUpdateProcess = (updateType, postMessage, device, { payload }, reb
         });
     }
     catch (error) {
-        if (isDeviceDisconnectedError$1(error)) {
-            Log$8.log('Rebooting device');
+        if (isDeviceDisconnectedError$2(error)) {
+            Log$9.log('Rebooting device');
             response = {
                 type: 'Success',
                 message: { message: FIRMWARE_UPDATE_CONFIRM$1 },
@@ -29440,7 +30718,7 @@ const newTouchUpdateProcess = (updateType, postMessage, device, { payload }, reb
                         ]);
                     }
                     catch (e) {
-                        Log$8.log('catch Bluetooth error when device is restarting: ', e);
+                        Log$9.log('catch Bluetooth error when device is restarting: ', e);
                     }
                 }
                 else {
@@ -29461,7 +30739,7 @@ const newTouchUpdateProcess = (updateType, postMessage, device, { payload }, reb
             }
             catch (error) {
                 console.error('Device reconnect failed: ', error);
-                Log$8.error('Device reconnect failed:', error);
+                Log$9.error('Device reconnect failed:', error);
                 yield wait(1000);
             }
         }
@@ -29486,8 +30764,8 @@ const emmcFileWriteWithRetry = (device, filePath, chunkLength, offset, chunk, ov
         });
         if (writeRes.type !== 'EmmcFile') {
             if (writeRes.type === 'CallMethodError') {
-                if (((_s = writeRes.message.error) !== null && _s !== void 0 ? _s : '').indexOf(SESSION_ERROR$1) > -1) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR$1);
+                if (((_s = writeRes.message.error) !== null && _s !== void 0 ? _s : '').indexOf(SESSION_ERROR$2) > -1) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR$2);
                 }
             }
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
@@ -29501,7 +30779,7 @@ const emmcFileWriteWithRetry = (device, filePath, chunkLength, offset, chunk, ov
             return result;
         }
         catch (error) {
-            Log$8.error(`emmcWrite error: `, error);
+            Log$9.error(`emmcWrite error: `, error);
             retryCount--;
             if (retryCount === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
@@ -29512,8 +30790,8 @@ const emmcFileWriteWithRetry = (device, filePath, chunkLength, offset, chunk, ov
                 yield ((_h = device.deviceConnector) === null || _h === void 0 ? void 0 : _h.acquire(device.originalDescriptor.id, null, true));
                 yield device.initialize();
             }
-            else if (((_j = error === null || error === void 0 ? void 0 : error.message) === null || _j === void 0 ? void 0 : _j.indexOf(SESSION_ERROR$1)) > -1 ||
-                ((_l = (_k = error === null || error === void 0 ? void 0 : error.response) === null || _k === void 0 ? void 0 : _k.data) === null || _l === void 0 ? void 0 : _l.indexOf(SESSION_ERROR$1)) > -1) {
+            else if (((_j = error === null || error === void 0 ? void 0 : error.message) === null || _j === void 0 ? void 0 : _j.indexOf(SESSION_ERROR$2)) > -1 ||
+                ((_l = (_k = error === null || error === void 0 ? void 0 : error.response) === null || _k === void 0 ? void 0 : _k.data) === null || _l === void 0 ? void 0 : _l.indexOf(SESSION_ERROR$2)) > -1) {
                 const deviceDiff = yield ((_m = device.deviceConnector) === null || _m === void 0 ? void 0 : _m.enumerate());
                 const devicesDescriptor = (_o = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _o !== void 0 ? _o : [];
                 const { deviceList } = yield DevicePool.getDevices(devicesDescriptor, undefined);
@@ -29643,10 +30921,10 @@ class DeviceFullyUploadResource extends BaseMethod {
     }
 }
 
-const Log$7 = getLogger(exports.LoggerNames.Method);
-const SESSION_ERROR = 'session not found';
+const Log$8 = getLogger(exports.LoggerNames.Method);
+const SESSION_ERROR$1 = 'session not found';
 const FIRMWARE_UPDATE_CONFIRM = 'Firmware install confirmed';
-const isDeviceDisconnectedError = (error) => {
+const isDeviceDisconnectedError$1 = (error) => {
     const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
     return (message.includes('device was disconnected') ||
         message.includes('transferIn') ||
@@ -29669,12 +30947,9 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 type,
             }));
         };
-        this.postProgressMessage = (progress, progressType) => {
-            this.postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-                device: this.device.toMessageObject(),
-                progress,
-                progressType,
-            }));
+        this.postProgressMessage = (progress, progressType, metadata = {}) => {
+            this.postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, Object.assign({ device: this.device.toMessageObject(), progress,
+                progressType }, metadata)));
         };
     }
     init() { }
@@ -29722,7 +30997,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
         this.checkPromise = hdShared.createDeferred();
         const env = DataManager.getSettings('env');
         const isBleReconnect = connectId && DataManager.isBleConnect(env);
-        Log$7.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+        Log$8.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
         let isFirstCheck = true;
         let checkCount = 0;
         let timeoutTimer;
@@ -29731,10 +31006,10 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
         const intervalTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _c, _d, _e, _f;
             checkCount += 1;
-            Log$7.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+            Log$8.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
             if (isTouchOrProDevice && isFirstCheck) {
                 isFirstCheck = false;
-                Log$7.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] wait 3000ms');
+                Log$8.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] wait 3000ms');
                 yield wait(3000);
             }
             if (checkCount > 4 &&
@@ -29750,7 +31025,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$7.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ', e);
+                    Log$8.log('FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ', e);
                     (_c = this.checkPromise) === null || _c === void 0 ? void 0 : _c.reject(e);
                 }
                 return;
@@ -29765,7 +31040,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$7.log('catch Bluetooth error when device is restarting: ', e);
+                    Log$8.log('catch Bluetooth error when device is restarting: ', e);
                 }
             }
             else {
@@ -29845,8 +31120,8 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 });
             }
             catch (error) {
-                if (isDeviceDisconnectedError(error)) {
-                    Log$7.log('Rebooting device');
+                if (isDeviceDisconnectedError$1(error)) {
+                    Log$8.log('Rebooting device');
                     updateResponse = {
                         type: 'Success',
                         message: { message: FIRMWARE_UPDATE_CONFIRM },
@@ -29870,7 +31145,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
             });
         });
     }
-    emmcCommonUpdateProcess({ payload, filePath, processedSize, totalSize, }) {
+    emmcCommonUpdateProcess({ payload, filePath, processedSize, totalSize, transferStartTime = Date.now(), }) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!filePath.startsWith('0:')) {
                 throw new Error('filePath must start with 0:');
@@ -29880,7 +31155,6 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
             const chunkSize = 1024 * perPackageSize;
             const totalChunks = Math.ceil(payload.byteLength / chunkSize);
             let offset = 0;
-            let currentFileProcessed = 0;
             for (let i = 0; i < totalChunks; i++) {
                 const chunkStart = i * chunkSize;
                 const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
@@ -29889,7 +31163,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 const overwrite = i === 0;
                 let progress;
                 if (totalSize !== undefined && processedSize !== undefined) {
-                    currentFileProcessed = processedSize + chunkEnd;
+                    const currentFileProcessed = processedSize + chunkEnd;
                     progress = Math.min(Math.ceil((currentFileProcessed / totalSize) * 100), 99);
                 }
                 else {
@@ -29897,7 +31171,15 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 }
                 const writeRes = yield this.emmcFileWriteWithRetry(filePath, chunkLength, offset, chunk, overwrite, progress);
                 offset += writeRes.message.processed_byte;
-                this.postProgressMessage(progress, 'transferData');
+                const elapsedMs = Date.now() - transferStartTime;
+                const transferredBytes = totalSize !== undefined && processedSize !== undefined ? processedSize + offset : offset;
+                const totalBytes = totalSize !== null && totalSize !== void 0 ? totalSize : payload.byteLength;
+                this.postProgressMessage(progress, 'transferData', {
+                    transferredBytes,
+                    totalBytes,
+                    rateBytesPerSecond: elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
+                    elapsedMs,
+                });
             }
             return totalSize !== undefined ? (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + payload.byteLength : 0;
         });
@@ -29921,8 +31203,8 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 });
                 if (writeRes.type !== 'EmmcFile') {
                     if (writeRes.type === 'CallMethodError') {
-                        if (((_k = writeRes.message.error) !== null && _k !== void 0 ? _k : '').indexOf(SESSION_ERROR) > -1) {
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR);
+                        if (((_k = writeRes.message.error) !== null && _k !== void 0 ? _k : '').indexOf(SESSION_ERROR$1) > -1) {
+                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR$1);
                         }
                     }
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
@@ -29936,7 +31218,7 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                     return result;
                 }
                 catch (error) {
-                    Log$7.error(`emmcWrite error: `, error);
+                    Log$8.error(`emmcWrite error: `, error);
                     retryCount--;
                     if (retryCount === 0) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
@@ -29947,8 +31229,8 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                         yield ((_a = this.device.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.device.originalDescriptor.id, null, true));
                         yield this.device.initialize();
                     }
-                    else if (((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.indexOf(SESSION_ERROR)) > -1 ||
-                        ((_d = (_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.indexOf(SESSION_ERROR)) > -1) {
+                    else if (((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.indexOf(SESSION_ERROR$1)) > -1 ||
+                        ((_d = (_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.indexOf(SESSION_ERROR$1)) > -1) {
                         const deviceDiff = yield ((_e = this.device.deviceConnector) === null || _e === void 0 ? void 0 : _e.enumerate());
                         const devicesDescriptor = (_f = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _f !== void 0 ? _f : [];
                         const { deviceList } = yield DevicePool.getDevices(devicesDescriptor, undefined);
@@ -30115,7 +31397,7 @@ class GetNextU2FCounter extends BaseMethod {
     }
 }
 
-const Log$6 = getLogger(exports.LoggerNames.Method);
+const Log$7 = getLogger(exports.LoggerNames.Method);
 class FirmwareUpdate extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -30153,7 +31435,7 @@ class FirmwareUpdate extends BaseMethod {
         this.checkPromise = hdShared.createDeferred();
         const env = DataManager.getSettings('env');
         const isBleReconnect = connectId && DataManager.isBleConnect(env);
-        Log$6.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+        Log$7.log('FirmwareUpdate [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
         const intervalTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f, _g, _h;
             if (isBleReconnect) {
@@ -30166,7 +31448,7 @@ class FirmwareUpdate extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$6.log('catch Bluetooth error when device is restarting: ', e);
+                    Log$7.log('catch Bluetooth error when device is restarting: ', e);
                 }
             }
             else {
@@ -30220,7 +31502,7 @@ class FirmwareUpdate extends BaseMethod {
                     if (e instanceof hdShared.HardwareError) {
                         return Promise.reject(e);
                     }
-                    Log$6.log('auto go to bootloader mode failed: ', e);
+                    Log$7.log('auto go to bootloader mode failed: ', e);
                     return Promise.reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateAutoEnterBootFailure));
                 }
             }
@@ -30257,7 +31539,7 @@ class FirmwareUpdate extends BaseMethod {
     }
 }
 
-const Log$5 = getLogger(exports.LoggerNames.Method);
+const Log$6 = getLogger(exports.LoggerNames.Method);
 class FirmwareUpdateV2 extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -30320,7 +31602,7 @@ class FirmwareUpdateV2 extends BaseMethod {
         this.checkPromise = hdShared.createDeferred();
         const env = DataManager.getSettings('env');
         const isBleReconnect = connectId && DataManager.isBleConnect(env);
-        Log$5.log('FirmwareUpdateV2 [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
+        Log$6.log('FirmwareUpdateV2 [checkDeviceToBootloader] isBleReconnect: ', isBleReconnect);
         let isFirstCheck = true;
         let checkCount = 0;
         let timeoutTimer;
@@ -30329,10 +31611,10 @@ class FirmwareUpdateV2 extends BaseMethod {
         const intervalTimer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
             var _c, _d, _e, _f;
             checkCount += 1;
-            Log$5.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
+            Log$6.log('FirmwareUpdateV2 [checkDeviceToBootloader] isFirstCheck: ', isFirstCheck);
             if (isTouchOrProDevice && isFirstCheck) {
                 isFirstCheck = false;
-                Log$5.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
+                Log$6.log('FirmwareUpdateV2 [checkDeviceToBootloader] wait 3000ms');
                 yield wait(3000);
             }
             if (checkCount > 4 &&
@@ -30350,7 +31632,7 @@ class FirmwareUpdateV2 extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$5.log('FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ', e);
+                    Log$6.log('FirmwareUpdateV2 [checkDeviceToBootloader] promptDeviceInBootloaderForWebDevice failed: ', e);
                     (_c = this.checkPromise) === null || _c === void 0 ? void 0 : _c.reject(e);
                 }
                 return;
@@ -30365,7 +31647,7 @@ class FirmwareUpdateV2 extends BaseMethod {
                     }
                 }
                 catch (e) {
-                    Log$5.log('catch Bluetooth error when device is restarting: ', e);
+                    Log$6.log('catch Bluetooth error when device is restarting: ', e);
                 }
             }
             else {
@@ -30529,7 +31811,7 @@ class FirmwareUpdateV2 extends BaseMethod {
     }
 }
 
-const Log$4 = getLogger(exports.LoggerNames.Method);
+const Log$5 = getLogger(exports.LoggerNames.Method);
 const MIN_UPDATE_V3_BOOTLOADER_VERSION = '2.8.0';
 class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
     constructor() {
@@ -30569,6 +31851,16 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
         };
     }
     run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.device.originalDescriptor) === null || _a === void 0 ? void 0 : _a.protocolType) === 'V2') {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware update must use firmwareUpdateV4');
+            }
+            Log$5.debug('FirmwareUpdateV3 strategy: Protocol V1');
+            return this.runProtocolV1();
+        });
+    }
+    runProtocolV1() {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const { device } = this;
@@ -30635,7 +31927,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                 const resource = (yield getSysResourceBinary(resourceUrl)).binary;
                 return resource;
             }
-            Log$4.warn('No resource url found');
+            Log$5.warn('No resource url found');
             return null;
         });
     }
@@ -30720,6 +32012,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                 totalSize += bootloaderBinary.byteLength;
             }
             this.postTipMessage(exports.FirmwareUpdateTipMessage.StartTransferData);
+            const transferStartTime = Date.now();
             if (resourceBinary) {
                 const file = yield JSZip__default["default"].loadAsync(resourceBinary);
                 const files = Object.entries(file.files);
@@ -30732,6 +32025,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                             filePath: `0:res/${name}`,
                             processedSize,
                             totalSize,
+                            transferStartTime,
                         });
                     }
                 }
@@ -30742,6 +32036,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                     filePath: `0:boot/bootloader.bin`,
                     processedSize,
                     totalSize,
+                    transferStartTime,
                 });
             }
             yield this.createUpdatesFolderIfNotExists(`0:updates/`);
@@ -30752,17 +32047,16 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                         filePath: `0:updates/${fwbinary.fileName}`,
                         processedSize,
                         totalSize,
+                        transferStartTime,
                     });
                 }
             }
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.ConfirmOnDevice);
-                yield this.startEmmcFirmwareUpdate({
-                    path: '0:updates',
-                });
+                yield this.startEmmcFirmwareUpdate({ path: '0:updates' });
             }
             catch (error) {
-                Log$4.error('triggerFirmwareUpdateEmmc error: ', error);
+                Log$5.error('triggerFirmwareUpdateEmmc error: ', error);
                 if (error === null || error === void 0 ? void 0 : error.errorCode) {
                     const unexpectedError = [
                         hdShared.HardwareErrorCode.ActionCancelled,
@@ -30823,7 +32117,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                     yield hdShared.wait(1000);
                 }
                 catch (error) {
-                    Log$4.log('getFeatures error', error);
+                    Log$5.log('getFeatures error', error);
                     let shouldReconnect = true;
                     const progress = this.extractUpdateModeProgress(error);
                     if (progress !== null) {
@@ -30921,7 +32215,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                             return;
                         }
                         catch (e) {
-                            Log$4.log('catch Bluetooth error when device is restarting: ', e);
+                            Log$5.log('catch Bluetooth error when device is restarting: ', e);
                         }
                     }
                     else {
@@ -30936,7 +32230,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                                     yield this._promptDeviceForSwitchFirmwareWebDevice();
                                 }
                                 catch (e) {
-                                    Log$4.log('WebUSB re-authorization failed: ', e);
+                                    Log$5.log('WebUSB re-authorization failed: ', e);
                                 }
                                 webUsbCheckCount = 0;
                             }
@@ -30957,7 +32251,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
                 }
                 catch (error) {
                     console.error('Device reconnect failed: ', error);
-                    Log$4.error('Device reconnect failed:', error);
+                    Log$5.error('Device reconnect failed:', error);
                     yield hdShared.wait(1000);
                 }
             }
@@ -30966,6 +32260,712 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
     }
 }
 
+const DEV_REBOOT_TYPES = {
+    Normal: hdTransport.DevRebootType.Normal,
+    normal: hdTransport.DevRebootType.Normal,
+    Boardloader: hdTransport.DevRebootType.Boardloader,
+    boardloader: hdTransport.DevRebootType.Boardloader,
+    Bootloader: hdTransport.DevRebootType.Bootloader,
+    bootloader: hdTransport.DevRebootType.Bootloader,
+};
+const PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS = {
+    intermediateTypes: ['DevFirmwareInstallProgress'],
+};
+const PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES = ['Success', 'DevFirmwareUpdateStatus'];
+function normalizeRebootType(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string') {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric))
+            return numeric;
+        if (value in DEV_REBOOT_TYPES)
+            return DEV_REBOOT_TYPES[value];
+    }
+    return hdTransport.DevRebootType.Normal;
+}
+function normalizeTargetId(value) {
+    if (typeof value === 'number')
+        return value;
+    const numeric = Number(value);
+    if (Number.isFinite(numeric))
+        return numeric;
+    return 0;
+}
+function normalizeFirmwareTargets(params) {
+    var _a, _b, _c;
+    const targets = (_a = params.targets) !== null && _a !== void 0 ? _a : (params.path
+        ? [
+            {
+                target_id: (_c = (_b = params.target_id) !== null && _b !== void 0 ? _b : params.targetId) !== null && _c !== void 0 ? _c : 0,
+                path: params.path,
+            },
+        ]
+        : []);
+    return targets.map(target => ({
+        target_id: normalizeTargetId('target_id' in target ? target.target_id : target.targetId),
+        path: target.path,
+    }));
+}
+function buildTargets(params) {
+    if (params.targets)
+        return params.targets;
+    const targets = {
+        hw: params.targetHw,
+        fw: params.targetFw,
+        bt: params.targetBt,
+        se1: params.targetSe1,
+        se2: params.targetSe2,
+        se3: params.targetSe3,
+        se4: params.targetSe4,
+        status: params.targetStatus,
+    };
+    return Object.values(targets).some(value => value !== undefined) ? targets : undefined;
+}
+function buildTypes(params) {
+    if (params.types)
+        return params.types;
+    const types = {
+        version: params.includeVersion,
+        build_id: params.includeBuildId,
+        hash: params.includeHash,
+        specific: params.includeSpecific,
+    };
+    return Object.values(types).some(value => value !== undefined) ? types : undefined;
+}
+
+const Log$4 = getLogger(exports.LoggerNames.Method);
+const SESSION_ERROR = 'session not found';
+const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT = 5 * 1000;
+const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
+const PROTOCOL_V2_TARGET_STATUS_FINISHED = 0;
+const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
+const PROTOCOL_V2_TARGET_STATUS_FAILED = 2;
+const PROTOCOL_V2_CONNECT_PROTOCOL = 'V2';
+const PROTOCOL_V2_FIRMWARE_STAGING_VOLUME = 'vol1:';
+const PROTOCOL_V2_MIN_FILE_CHUNK_SIZE = 64;
+const getUnknownErrorText = (error) => {
+    if (!error) {
+        return '';
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    const parts = [];
+    if (error instanceof Error) {
+        parts.push(error.name, error.message);
+    }
+    if (typeof error === 'object') {
+        const record = error;
+        for (const field of ['name', 'message', 'reason', 'code', 'errorCode', 'nativeErrorCode']) {
+            const value = record[field];
+            if (value !== undefined && value !== null) {
+                parts.push(String(value));
+            }
+        }
+    }
+    const stringified = String(error);
+    if (stringified && stringified !== '[object Object]') {
+        parts.push(stringified);
+    }
+    return parts.filter(Boolean).join(' ');
+};
+const isDeviceDisconnectedError = (error) => {
+    const message = getUnknownErrorText(error).toLowerCase();
+    const compactMessage = message.replace(/\s+/g, '');
+    return (message.includes('device was disconnected') ||
+        message.includes('device disconnected') ||
+        message.includes('device disconnect') ||
+        message.includes('was disconnected') ||
+        message.includes('bledevicedisconnected') ||
+        message.includes('bleconnectederror') ||
+        message.includes('connected error is always runtime error') ||
+        message.includes('connection has timed out unexpectedly') ||
+        message.includes('connection error has occured') ||
+        message.includes('connection error has occurred') ||
+        message.includes('transferIn') ||
+        message.includes('transferin') ||
+        message.includes('usbdevice') ||
+        message.includes('multiplatformbleadapter') ||
+        message.includes('multipalformebleadapter') ||
+        compactMessage.includes('rxerrorerror6') ||
+        message.includes('rxerror error 6'));
+};
+const isProtocolV2ReconnectProbeError = (error) => {
+    const message = getUnknownErrorText(error).toLowerCase();
+    return ((message.includes('device protocol mismatch') && message.includes('expected v2')) ||
+        message.includes('did not respond to expected protocol'));
+};
+const isProtocolV2PollingTransientError = (error) => {
+    const message = getUnknownErrorText(error).toLowerCase();
+    return (isDeviceDisconnectedError(error) ||
+        isProtocolV2ReconnectProbeError(error) ||
+        (message.includes('response timeout') && message.includes('devgetfirmwareupdatestatus')) ||
+        message.includes('device not found') ||
+        message.includes('transportnotfound'));
+};
+class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
+    init() {
+        this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
+        this.requireDeviceMode = [];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+        const { payload } = this;
+        validateParams(payload, [
+            { name: 'bleVersion', type: 'array' },
+            { name: 'bleBinary', type: 'buffer' },
+            { name: 'chunkSize', type: 'number' },
+            { name: 'firmwareVersion', type: 'array' },
+            { name: 'firmwareBinary', type: 'buffer' },
+            { name: 'resourceBinary', type: 'buffer' },
+            { name: 'forcedUpdateRes', type: 'boolean' },
+            { name: 'bootloaderVersion', type: 'array' },
+            { name: 'bootloaderBinary', type: 'buffer' },
+            { name: 'firmwareType', type: 'string' },
+            { name: 'platform', type: 'string' },
+        ]);
+        this.params = {
+            bleBinary: payload.bleBinary,
+            chunkSize: payload.chunkSize,
+            firmwareBinary: payload.firmwareBinary,
+            forcedUpdateRes: payload.forcedUpdateRes,
+            bleVersion: payload.bleVersion,
+            bootloaderVersion: payload.bootloaderVersion,
+            bootloaderBinary: payload.bootloaderBinary,
+            firmwareVersion: payload.firmwareVersion,
+            resourceBinary: payload.resourceBinary,
+            firmwareType: payload.firmwareType,
+            platform: payload.platform,
+        };
+    }
+    getProtocolV2FirmwareChunkSize() {
+        var _a, _b;
+        const payloadChunkSize = Number((_a = this.params) === null || _a === void 0 ? void 0 : _a.chunkSize);
+        const env = DataManager.getSettings('env');
+        const maxChunkSize = ((_b = this.params) === null || _b === void 0 ? void 0 : _b.platform) === 'native' || (env && DataManager.isBleConnect(env))
+            ? hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE
+            : hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+        if (!Number.isFinite(payloadChunkSize) || payloadChunkSize <= 0) {
+            return maxChunkSize;
+        }
+        return Math.min(Math.max(Math.floor(payloadChunkSize), PROTOCOL_V2_MIN_FILE_CHUNK_SIZE), maxChunkSize);
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (((_a = this.device.originalDescriptor) === null || _a === void 0 ? void 0 : _a.protocolType) !== 'V2') {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'firmwareUpdateV4 requires a Protocol V2 device');
+            }
+            Log$4.debug('FirmwareUpdateV4 strategy: Protocol V2');
+            return this.runProtocolV2();
+        });
+    }
+    runProtocolV2() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { device } = this;
+            const { features } = device;
+            if (!features) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device features not available');
+            }
+            const deviceFirmwareType = getFirmwareType(features);
+            const firmwareType = (_a = this.params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
+            let resourceBinary = null;
+            let fwBinaryMap = [];
+            let bootloaderBinary = null;
+            try {
+                this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
+                resourceBinary = yield this.prepareResourceBinary(firmwareType);
+                fwBinaryMap = yield this.prepareFirmwareAndBleBinary(firmwareType);
+                bootloaderBinary = yield this.prepareBootloaderBinary(firmwareType);
+                this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
+            }
+            catch (err) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_b = err.message) !== null && _b !== void 0 ? _b : err);
+            }
+            if (!resourceBinary && !bootloaderBinary && fwBinaryMap.length === 0) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
+            }
+            yield this.executeProtocolV2Update({
+                resourceBinary,
+                fwBinaryMap,
+                bootloaderBinary,
+            });
+            yield this.exitProtocolV2BootloaderToNormal();
+            const versions = yield this.waitForProtocolV2FinalFeatures();
+            this.postTipMessage(exports.FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
+            DevicePool.resetState();
+            return versions;
+        });
+    }
+    prepareResourceBinary(firmwareType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.params.resourceBinary) {
+                return this.params.resourceBinary;
+            }
+            const { features } = this.device;
+            if (!features)
+                return null;
+            const resourceUrl = DataManager.getSysResourcesLatestRelease({
+                features,
+                forcedUpdateRes: this.params.forcedUpdateRes,
+                firmwareType,
+            });
+            if (resourceUrl) {
+                const resource = (yield getSysResourceBinary(resourceUrl)).binary;
+                return resource;
+            }
+            Log$4.warn('No resource url found');
+            return null;
+        });
+    }
+    prepareBootloaderBinary(firmwareType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.params.bootloaderBinary) {
+                return this.params.bootloaderBinary;
+            }
+            const { features } = this.device;
+            if (!features)
+                return null;
+            if (this.params.bootloaderVersion) {
+                const bootResourceUrl = DataManager.getBootloaderResource(features, firmwareType);
+                if (bootResourceUrl) {
+                    const bootBinary = (yield getSysResourceBinary(bootResourceUrl)).binary;
+                    return bootBinary;
+                }
+            }
+            return null;
+        });
+    }
+    prepareFirmwareAndBleBinary(firmwareType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fwBinaryMap = [];
+            if (this.params.firmwareBinary) {
+                fwBinaryMap.push({
+                    fileName: 'firmware.bin',
+                    binary: this.params.firmwareBinary,
+                });
+            }
+            else if (this.params.firmwareVersion) {
+                const { features } = this.device;
+                if (features) {
+                    const firmwareBinary = (yield getBinary({
+                        features,
+                        version: this.params.firmwareVersion,
+                        updateType: 'firmware',
+                        isUpdateBootloader: false,
+                        firmwareType,
+                    })).binary;
+                    fwBinaryMap.push({
+                        fileName: 'firmware.bin',
+                        binary: firmwareBinary,
+                    });
+                }
+            }
+            if (this.params.bleBinary) {
+                fwBinaryMap.push({
+                    fileName: 'ble-firmware.bin',
+                    binary: this.params.bleBinary,
+                });
+            }
+            else if (this.params.bleVersion) {
+                const { features } = this.device;
+                if (features) {
+                    const bleBinary = yield getBinary({
+                        features,
+                        version: this.params.bleVersion,
+                        updateType: 'ble',
+                        firmwareType,
+                    });
+                    fwBinaryMap.push({
+                        fileName: 'ble-firmware.bin',
+                        binary: bleBinary.binary,
+                    });
+                }
+            }
+            return fwBinaryMap;
+        });
+    }
+    executeProtocolV2Update({ resourceBinary, fwBinaryMap, bootloaderBinary, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let totalSize = 0;
+            let processedSize = 0;
+            if (resourceBinary)
+                totalSize += resourceBinary.byteLength;
+            for (const fwbinary of fwBinaryMap)
+                totalSize += fwbinary.binary.byteLength;
+            if (bootloaderBinary)
+                totalSize += bootloaderBinary.byteLength;
+            this.postTipMessage(exports.FirmwareUpdateTipMessage.StartTransferData);
+            const transferStartTime = Date.now();
+            const targets = [];
+            if (resourceBinary) {
+                const resourcePath = `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}res/`;
+                yield this.protocolV2CreateFolder(resourcePath);
+                const file = yield JSZip__default["default"].loadAsync(resourceBinary);
+                const files = Object.entries(file.files);
+                for (const [fileName, entry] of files) {
+                    const name = fileName.split('/').pop();
+                    if (!entry.dir && fileName.indexOf('__MACOSX') === -1 && name) {
+                        const data = yield entry.async('arraybuffer');
+                        processedSize = yield this.protocolV2CommonUpdateProcess({
+                            payload: data,
+                            filePath: `${resourcePath}${name}`,
+                            processedSize,
+                            totalSize,
+                            transferStartTime,
+                        });
+                    }
+                }
+                targets.push({
+                    target_id: ProtocolV2FirmwareTargetType.TARGET_RESOURCE,
+                    path: resourcePath,
+                });
+            }
+            if (bootloaderBinary) {
+                const bootloaderPath = `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}bootloader.bin`;
+                processedSize = yield this.protocolV2CommonUpdateProcess({
+                    payload: bootloaderBinary,
+                    filePath: bootloaderPath,
+                    processedSize,
+                    totalSize,
+                    transferStartTime,
+                });
+                targets.push({
+                    target_id: ProtocolV2FirmwareTargetType.TARGET_MAIN_BOOT,
+                    path: bootloaderPath,
+                });
+            }
+            for (const fwbinary of fwBinaryMap) {
+                const firmwarePath = `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${fwbinary.fileName}`;
+                processedSize = yield this.protocolV2CommonUpdateProcess({
+                    payload: fwbinary.binary,
+                    filePath: firmwarePath,
+                    processedSize,
+                    totalSize,
+                    transferStartTime,
+                });
+                targets.push({
+                    target_id: protocolV2FileNameToTargetId(fwbinary.fileName),
+                    path: firmwarePath,
+                });
+            }
+            this.postTipMessage(exports.FirmwareUpdateTipMessage.ConfirmOnDevice);
+            const startResponse = yield this.protocolV2StartFirmwareUpdate({ targets });
+            yield this.waitForProtocolV2FirmwareUpdateComplete(targets, startResponse);
+        });
+    }
+    queryProtocolV2FirmwareUpdateStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            return typedCall('DevGetFirmwareUpdateStatus', 'DevFirmwareUpdateStatus', {}, {
+                timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+            });
+        });
+    }
+    pingProtocolV2Device() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            yield typedCall('Ping', 'Success', { message: 'firmware-update' }, {
+                timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+            });
+        });
+    }
+    assertProtocolV2TargetStatus(statusTargets, expectedTargetIds) {
+        const failedTarget = statusTargets.find(target => expectedTargetIds.has(target.target_id) &&
+            target.status === PROTOCOL_V2_TARGET_STATUS_FAILED);
+        if (failedTarget) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareError, `Protocol V2 firmware target ${failedTarget.target_id} failed`);
+        }
+        const completedTargets = statusTargets.filter(target => expectedTargetIds.has(target.target_id) &&
+            target.status === PROTOCOL_V2_TARGET_STATUS_FINISHED);
+        if (completedTargets.length === expectedTargetIds.size && expectedTargetIds.size > 0) {
+            return true;
+        }
+        const inProgressTarget = statusTargets.find(target => expectedTargetIds.has(target.target_id) &&
+            target.status === PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS);
+        if (inProgressTarget) {
+            this.postProgressMessage(99, 'installingFirmware');
+        }
+        return false;
+    }
+    waitForProtocolV2FirmwareUpdateComplete(targets, startResponse) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const expectedTargetIds = new Set(targets.map(target => target.target_id));
+            if ((startResponse === null || startResponse === void 0 ? void 0 : startResponse.type) === 'Success') {
+                return;
+            }
+            if ((startResponse === null || startResponse === void 0 ? void 0 : startResponse.type) === 'DevFirmwareUpdateStatus') {
+                const statusTargets = ((_a = startResponse.message.targets) !== null && _a !== void 0 ? _a : []);
+                if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
+                    return;
+                }
+            }
+            const startTime = Date.now();
+            let lastError;
+            while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
+                try {
+                    const statusRes = yield this.queryProtocolV2FirmwareUpdateStatus();
+                    const statusTargets = ((_b = statusRes.message.targets) !== null && _b !== void 0 ? _b : []);
+                    if (this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds)) {
+                        return;
+                    }
+                }
+                catch (error) {
+                    lastError = error;
+                    if (error instanceof hdShared.HardwareError && error.errorCode === hdShared.HardwareErrorCode.FirmwareError) {
+                        throw error;
+                    }
+                    Log$4.log('Protocol V2 firmware install status polling failed: ', error);
+                    if (isProtocolV2PollingTransientError(error)) {
+                        try {
+                            yield this.reconnectProtocolV2Device();
+                        }
+                        catch (reconnectError) {
+                            lastError = reconnectError;
+                            Log$4.log('Protocol V2 firmware install reconnect/status polling failed: ', reconnectError);
+                        }
+                        try {
+                            yield this.pingProtocolV2Device();
+                            Log$4.log('Protocol V2 firmware status unavailable, Ping is ready');
+                            return;
+                        }
+                        catch (pingError) {
+                            lastError = pingError;
+                            Log$4.log('Protocol V2 firmware install Ping polling failed: ', pingError);
+                        }
+                    }
+                }
+                yield hdShared.wait(1000);
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 firmware update status timeout: ${this.normalizeErrorMessage(lastError)}`);
+        });
+    }
+    exitProtocolV2BootloaderToNormal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.postTipMessage(exports.FirmwareUpdateTipMessage.SwitchFirmwareReconnectDevice);
+            yield this.protocolV2Reboot(hdTransport.DevRebootType.Normal);
+        });
+    }
+    waitForProtocolV2FinalFeatures() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.waitForProtocolV2ReconnectAndFeatures(PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT);
+            this.device._updateFeatures(features);
+            const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
+            const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
+            const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
+            if (firmwareVersion === '0.0.0') {
+                Log$4.warn('Protocol V2 firmware update finished but app firmware version is still 0.0.0. This is allowed for Pro2 debug BLE-only update flows.');
+            }
+            return {
+                bootloaderVersion,
+                bleVersion,
+                firmwareVersion,
+            };
+        });
+    }
+    waitForProtocolV2ReconnectAndFeatures(timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            let lastError;
+            while (Date.now() - startTime < timeout) {
+                try {
+                    yield this.reconnectProtocolV2Device();
+                    const features = yield getProtocolV2Features({
+                        commands: this.device.getCommands(),
+                        descriptor: this.device.originalDescriptor,
+                        onDeviceInfoError: error => {
+                            Log$4.debug('Protocol V2 post-update DevGetDeviceInfo failed:', error);
+                        },
+                        timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+                    });
+                    return features;
+                }
+                catch (error) {
+                    lastError = error;
+                    Log$4.log('Protocol V2 normal mode not ready, polling Ping/DevGetDeviceInfo: ', error);
+                    yield hdShared.wait(1000);
+                }
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Protocol V2 final features not ready within ${timeout / 1000}s: ${this.normalizeErrorMessage(lastError)}`);
+        });
+    }
+    reconnectProtocolV2Device() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isBleReconnect()) {
+                yield this.acquireProtocolV2BleDevice();
+                return;
+            }
+            const deviceDiff = yield ((_a = this.device.deviceConnector) === null || _a === void 0 ? void 0 : _a.enumerate());
+            const devicesDescriptor = (_b = deviceDiff === null || deviceDiff === void 0 ? void 0 : deviceDiff.descriptors) !== null && _b !== void 0 ? _b : [];
+            const { deviceList } = yield DevicePool.getDevices(devicesDescriptor, this.connectId);
+            if (deviceList.length !== 1) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound);
+            }
+            this.device.updateFromCache(deviceList[0]);
+            yield this.device.acquire();
+            this.device.commands.disposed = false;
+            this.device.getCommands().mainId = (_c = this.device.mainId) !== null && _c !== void 0 ? _c : '';
+        });
+    }
+    protocolV2CreateFolder(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            yield typedCall('FilesystemDirMake', 'Success', { path });
+        });
+    }
+    protocolV2CommonUpdateProcess({ payload, filePath, processedSize, totalSize, transferStartTime = Date.now(), }) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const chunkSize = this.getProtocolV2FirmwareChunkSize();
+            let offset = 0;
+            const getUploadProgress = (fileOffset) => {
+                if (totalSize !== undefined && processedSize !== undefined) {
+                    return Math.min(Math.ceil(((processedSize + fileOffset) / totalSize) * 100), 99);
+                }
+                return Math.min(Math.ceil((fileOffset / payload.byteLength) * 100), 99);
+            };
+            while (offset < payload.byteLength) {
+                const chunkEnd = Math.min(offset + chunkSize, payload.byteLength);
+                const chunkLength = chunkEnd - offset;
+                const chunk = payload.slice(offset, chunkEnd);
+                const overwrite = offset === 0;
+                const progress = getUploadProgress(chunkEnd);
+                const writeRes = yield this.fileWriteWithRetry(filePath, payload.byteLength, offset, chunk, overwrite, progress);
+                const nextOffset = (_a = writeRes.message.processed_byte) !== null && _a !== void 0 ? _a : offset + chunkLength;
+                if (nextOffset <= offset || nextOffset > payload.byteLength) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `invalid processed_byte ${nextOffset} for offset ${offset}`);
+                }
+                offset = nextOffset;
+                const elapsedMs = Date.now() - transferStartTime;
+                const transferredBytes = totalSize !== undefined && processedSize !== undefined
+                    ? Math.min(processedSize + offset, totalSize)
+                    : offset;
+                const totalBytes = totalSize !== null && totalSize !== void 0 ? totalSize : payload.byteLength;
+                this.postProgressMessage(getUploadProgress(offset), 'transferData', {
+                    transferredBytes,
+                    totalBytes,
+                    rateBytesPerSecond: elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
+                    elapsedMs,
+                });
+            }
+            return totalSize !== undefined ? (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + payload.byteLength : 0;
+        });
+    }
+    fileWriteWithRetry(filePath, totalFileSize, offset, chunk, overwrite, progress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const writeFunc = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+                const writeRes = yield typedCall('FilesystemFileWrite', 'FilesystemFile', {
+                    file: {
+                        path: filePath,
+                        offset,
+                        total_size: totalFileSize,
+                        data: chunk,
+                    },
+                    overwrite,
+                    append: false,
+                    ui_percentage: progress !== null && progress !== void 0 ? progress : undefined,
+                });
+                if (writeRes.type !== 'FilesystemFile') {
+                    if (writeRes.type === 'CallMethodError') {
+                        if (((_a = writeRes.message.error) !== null && _a !== void 0 ? _a : '').indexOf(SESSION_ERROR) > -1) {
+                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, SESSION_ERROR);
+                        }
+                    }
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+                }
+                return writeRes;
+            });
+            let retryCount = 10;
+            while (retryCount > 0) {
+                try {
+                    const result = yield writeFunc();
+                    return result;
+                }
+                catch (error) {
+                    Log$4.error(`fileWrite error: `, error);
+                    retryCount--;
+                    if (retryCount === 0) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+                    }
+                    const env = DataManager.getSettings('env');
+                    if (DataManager.isBleConnect(env)) {
+                        yield hdShared.wait(3000);
+                        yield this.acquireProtocolV2BleDevice();
+                        yield this.device.initialize();
+                    }
+                    yield hdShared.wait(2000);
+                }
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+        });
+    }
+    acquireProtocolV2BleDevice() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.device.deviceConnector) === null || _a === void 0 ? void 0 : _a.acquire(this.device.originalDescriptor.id, null, true, PROTOCOL_V2_CONNECT_PROTOCOL));
+        });
+    }
+    protocolV2StartFirmwareUpdate({ targets, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            let response;
+            try {
+                response = yield typedCall('DevFirmwareUpdate', PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES, {
+                    targets,
+                }, {
+                    intermediateTypes: ['DevFirmwareInstallProgress'],
+                    onIntermediateResponse: (response) => {
+                        var _a;
+                        const progress = Number((_a = response.message) === null || _a === void 0 ? void 0 : _a.progress);
+                        if (Number.isFinite(progress)) {
+                            this.postProgressMessage(Math.min(progress, 99), 'installingFirmware');
+                        }
+                    },
+                });
+            }
+            catch (error) {
+                if (isDeviceDisconnectedError(error)) {
+                    Log$4.log('Rebooting device');
+                }
+                else {
+                    throw error;
+                }
+            }
+            this.postTipMessage(exports.FirmwareUpdateTipMessage.FirmwareUpdating);
+            return response;
+        });
+    }
+    protocolV2Reboot(rebootType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            try {
+                const res = yield typedCall('DevReboot', 'Success', {
+                    reboot_type: rebootType,
+                });
+                return res.message;
+            }
+            catch (error) {
+                if (isDeviceDisconnectedError(error) || isProtocolV2ReconnectProbeError(error)) {
+                    return { message: 'Device rebooted successfully' };
+                }
+                throw error;
+            }
+        });
+    }
+    normalizeErrorMessage(error) {
+        if (!error) {
+            return '';
+        }
+        return getUnknownErrorText(error);
+    }
+}
+
 const Log$3 = getLogger(exports.LoggerNames.Method);
 class PromptWebDeviceAccess extends BaseMethod {
     init() {
@@ -31023,6 +33023,538 @@ class PromptWebDeviceAccess extends BaseMethod {
     }
 }
 
+class GetProtoVersion extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = undefined;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('GetProtoVersion', 'ProtoVersion', {});
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class Ping extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = { message: this.payload.message };
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('Ping', 'Success', {
+                message: (_a = this.params.message) !== null && _a !== void 0 ? _a : '',
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DevReboot extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = {
+            rebootType: this.payload.rebootType,
+            reboot_type: this.payload.reboot_type,
+        };
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('DevReboot', 'Success', {
+                reboot_type: normalizeRebootType((_a = this.params.reboot_type) !== null && _a !== void 0 ? _a : this.params.rebootType),
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DevGetDeviceInfo extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = {
+            targets: this.payload.targets,
+            types: this.payload.types,
+            targetHw: this.payload.targetHw,
+            targetFw: this.payload.targetFw,
+            targetBt: this.payload.targetBt,
+            targetSe1: this.payload.targetSe1,
+            targetSe2: this.payload.targetSe2,
+            targetSe3: this.payload.targetSe3,
+            targetSe4: this.payload.targetSe4,
+            targetStatus: this.payload.targetStatus,
+            includeVersion: this.payload.includeVersion,
+            includeBuildId: this.payload.includeBuildId,
+            includeHash: this.payload.includeHash,
+            includeSpecific: this.payload.includeSpecific,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('DevGetDeviceInfo', 'DeviceInfo', {
+                targets: buildTargets(this.params),
+                types: buildTypes(this.params),
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DevGetOnboardingStatus extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = undefined;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('DevGetOnboardingStatus', 'DevOnboardingStatus', {});
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DevFirmwareUpdate extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = {
+            targets: this.payload.targets,
+            targetId: this.payload.targetId,
+            target_id: this.payload.target_id,
+            path: this.payload.path,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('DevFirmwareUpdate', PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES, {
+                targets: normalizeFirmwareTargets(this.params),
+            }, PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS);
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DevGetFirmwareUpdateStatus extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = undefined;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('DevGetFirmwareUpdateStatus', 'DevFirmwareUpdateStatus', {});
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class FactoryDeviceInfoSettings extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = {
+            serial_no: this.payload.serial_no,
+            serialNo: this.payload.serialNo,
+            cpu_info: this.payload.cpu_info,
+            cpuInfo: this.payload.cpuInfo,
+            pre_firmware: this.payload.pre_firmware,
+            preFirmware: this.payload.preFirmware,
+        };
+    }
+    run() {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('FactoryDeviceInfoSettings', 'Success', {
+                serial_no: (_a = this.params.serial_no) !== null && _a !== void 0 ? _a : this.params.serialNo,
+                cpu_info: (_b = this.params.cpu_info) !== null && _b !== void 0 ? _b : this.params.cpuInfo,
+                pre_firmware: (_c = this.params.pre_firmware) !== null && _c !== void 0 ? _c : this.params.preFirmware,
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class FactoryGetDeviceInfo extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = undefined;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('FactoryGetDeviceInfo', 'FactoryDeviceInfo', {});
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class FilesystemFixPermission extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = undefined;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('FilesystemFixPermission', 'Success', {});
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class FilesystemFormat extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = undefined;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('FilesystemFormat', 'Success', {});
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+const MIN_FILE_READ_CHUNK_SIZE = 64;
+function getProtocolV2FileReadChunkLimit() {
+    const env = DataManager.getSettings('env');
+    if (env && DataManager.isBleConnect(env)) {
+        return hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+    }
+    return hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+function normalizeChunkSize$1(value, maxChunkSize) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return maxChunkSize;
+    return Math.min(Math.max(Math.floor(numeric), MIN_FILE_READ_CHUNK_SIZE), maxChunkSize);
+}
+function toFiniteNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string') {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : undefined;
+    }
+    if (value && typeof value === 'object') {
+        const longLike = value;
+        if (typeof longLike.toNumber === 'function') {
+            const numeric = longLike.toNumber();
+            return Number.isFinite(numeric) ? numeric : undefined;
+        }
+    }
+    return undefined;
+}
+function toUint8Array(value) {
+    if (value instanceof Uint8Array)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (typeof value === 'string') {
+        const hex = stripHexPrefix(value);
+        if (!hex)
+            return new Uint8Array(0);
+        if (!isHexString(hex) || hex.length % 2 !== 0)
+            return new Uint8Array(0);
+        return hexToBytes(hex);
+    }
+    return new Uint8Array(0);
+}
+class FileRead extends BaseMethod {
+    init() {
+        var _a, _b;
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = {
+            path: this.payload.path,
+            offset: (_a = this.payload.offset) !== null && _a !== void 0 ? _a : 0,
+            totalSize: (_b = this.payload.totalSize) !== null && _b !== void 0 ? _b : 0,
+            chunkLen: this.payload.chunkLen,
+            uiPercentage: this.payload.uiPercentage,
+        };
+    }
+    run() {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            const startOffset = (_a = this.params.offset) !== null && _a !== void 0 ? _a : 0;
+            const requestedLength = Number(this.params.totalSize);
+            const chunkSize = normalizeChunkSize$1(this.params.chunkLen, getProtocolV2FileReadChunkLimit());
+            let totalLength = Number.isFinite(requestedLength) && requestedLength > 0 ? requestedLength : 0;
+            if (totalLength === 0) {
+                const pathInfoRes = yield this.device.commands.typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
+                    path: this.params.path,
+                });
+                const fileSize = toFiniteNumber((_b = pathInfoRes.message) === null || _b === void 0 ? void 0 : _b.size);
+                if (!((_c = pathInfoRes.message) === null || _c === void 0 ? void 0 : _c.exist) || ((_d = pathInfoRes.message) === null || _d === void 0 ? void 0 : _d.directory)) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileRead path is not a file: ${this.params.path}`);
+                }
+                if (fileSize === undefined || fileSize < startOffset) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileRead invalid offset ${startOffset} for ${this.params.path}`);
+                }
+                totalLength = fileSize - startOffset;
+            }
+            const chunks = [];
+            let read = 0;
+            let lastMessage;
+            while (read < totalLength) {
+                const readLen = Math.min(chunkSize, totalLength - read);
+                const offset = startOffset + read;
+                const progress = (_e = this.params.uiPercentage) !== null && _e !== void 0 ? _e : Math.min(Math.ceil(((read + readLen) / Math.max(totalLength, 1)) * 100), 99);
+                const res = yield this.device.commands.typedCall('FilesystemFileRead', 'FilesystemFile', {
+                    file: {
+                        path: this.params.path,
+                        offset,
+                        total_size: 0,
+                    },
+                    chunk_len: readLen,
+                    ui_percentage: progress,
+                });
+                const data = toUint8Array((_f = res.message) === null || _f === void 0 ? void 0 : _f.data);
+                lastMessage = res.message;
+                if (data.byteLength === 0) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileRead received empty data at offset ${offset}`);
+                }
+                chunks.push(data);
+                read += data.byteLength;
+            }
+            const combined = new Uint8Array(read);
+            let cursor = 0;
+            chunks.forEach(chunk => {
+                combined.set(chunk, cursor);
+                cursor += chunk.byteLength;
+            });
+            return Promise.resolve(Object.assign(Object.assign({}, lastMessage), { path: this.params.path, offset: startOffset, total_size: totalLength, data: combined, chunks: chunks.length }));
+        });
+    }
+}
+
+const MIN_FILE_CHUNK_SIZE = 64;
+function getProtocolV2FileChunkLimit() {
+    const env = DataManager.getSettings('env');
+    if (env && DataManager.isBleConnect(env)) {
+        return hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+    }
+    return hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
+}
+function dataToUint8Array(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof data === 'string') {
+            return new TextEncoder().encode(data);
+        }
+        if (data instanceof ArrayBuffer) {
+            return new Uint8Array(data);
+        }
+        if (ArrayBuffer.isView(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        if (typeof Blob !== 'undefined' && data instanceof Blob) {
+            return new Uint8Array(yield data.arrayBuffer());
+        }
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Unsupported FilesystemFileWrite data');
+    });
+}
+function normalizeChunkSize(value, maxChunkSize) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return maxChunkSize;
+    return Math.min(Math.max(Math.floor(numeric), MIN_FILE_CHUNK_SIZE), maxChunkSize);
+}
+function getConfirmedProgress(processedByte, totalSize, written, dataLength) {
+    if (Number.isFinite(processedByte) && Number.isFinite(totalSize) && totalSize > 0) {
+        if (processedByte >= totalSize)
+            return 100;
+        return Math.min(Math.max(Math.floor((processedByte / totalSize) * 100), 0), 99);
+    }
+    if (dataLength > 0) {
+        if (written >= dataLength)
+            return 100;
+        return Math.min(Math.max(Math.floor((written / dataLength) * 100), 0), 99);
+    }
+    return 100;
+}
+class FileWrite extends BaseMethod {
+    init() {
+        var _a, _b, _c, _d;
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        const offset = (_a = this.payload.offset) !== null && _a !== void 0 ? _a : 0;
+        this.params = {
+            path: this.payload.path,
+            offset,
+            totalSize: (_b = this.payload.totalSize) !== null && _b !== void 0 ? _b : 0,
+            data: this.payload.data,
+            chunkSize: this.payload.chunkSize,
+            chunkLen: this.payload.chunkLen,
+            overwrite: (_c = this.payload.overwrite) !== null && _c !== void 0 ? _c : offset === 0,
+            append: (_d = this.payload.append) !== null && _d !== void 0 ? _d : false,
+            uiPercentage: this.payload.uiPercentage,
+        };
+    }
+    run() {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield dataToUint8Array(this.params.data);
+            const dataLength = data.byteLength;
+            const offsetValue = Number((_a = this.params.offset) !== null && _a !== void 0 ? _a : 0);
+            const startOffset = Number.isFinite(offsetValue) && offsetValue > 0 ? offsetValue : 0;
+            const payloadTotalSize = Number(this.params.totalSize);
+            const totalSize = Number.isFinite(payloadTotalSize) && payloadTotalSize > 0
+                ? payloadTotalSize
+                : startOffset + dataLength;
+            if (totalSize < startOffset + dataLength) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite totalSize ${totalSize} is smaller than offset + data length ${startOffset + dataLength}`);
+            }
+            const chunkSize = normalizeChunkSize((_b = this.params.chunkSize) !== null && _b !== void 0 ? _b : this.params.chunkLen, getProtocolV2FileChunkLimit());
+            const overwrite = (_c = this.params.overwrite) !== null && _c !== void 0 ? _c : false;
+            const append = (_d = this.params.append) !== null && _d !== void 0 ? _d : false;
+            let written = 0;
+            let chunkIndex = 0;
+            let lastMessage;
+            const startTime = Date.now();
+            while (written < dataLength) {
+                const chunkEnd = Math.min(written + chunkSize, dataLength);
+                const chunk = data.slice(written, chunkEnd);
+                const offset = startOffset + written;
+                const isFirstChunk = chunkIndex === 0;
+                const progress = (_e = this.params.uiPercentage) !== null && _e !== void 0 ? _e : Math.min(Math.ceil(((written + chunk.byteLength) / dataLength) * 100), 99);
+                const res = yield this.device.commands.typedCall('FilesystemFileWrite', 'FilesystemFile', {
+                    file: {
+                        path: this.params.path,
+                        offset,
+                        total_size: totalSize,
+                        data: chunk,
+                    },
+                    overwrite: isFirstChunk ? overwrite : false,
+                    append,
+                    ui_percentage: progress,
+                });
+                lastMessage = res.message;
+                const processedByte = Number((_f = res.message) === null || _f === void 0 ? void 0 : _f.processed_byte);
+                if (Number.isFinite(processedByte) && processedByte > offset) {
+                    written = processedByte - startOffset;
+                }
+                else {
+                    written += chunk.byteLength;
+                }
+                if (written > dataLength) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `FilesystemFileWrite invalid processed_byte ${processedByte}`);
+                }
+                const confirmedProcessedByte = Number.isFinite(processedByte) && processedByte > offset
+                    ? processedByte
+                    : startOffset + written;
+                if (typeof this.postMessage === 'function') {
+                    const elapsedMs = Date.now() - startTime;
+                    const transferredBytes = Math.min(written, dataLength);
+                    this.postMessage(createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
+                        progress: getConfirmedProgress(confirmedProcessedByte, totalSize, written, dataLength),
+                        transferredBytes,
+                        totalBytes: dataLength,
+                        rateBytesPerSecond: elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
+                        elapsedMs,
+                    }));
+                }
+                chunkIndex += 1;
+            }
+            return Promise.resolve(Object.assign(Object.assign({}, lastMessage), { path: this.params.path, offset: startOffset, total_size: totalSize, processed_byte: startOffset + written, chunks: chunkIndex }));
+        });
+    }
+}
+
+class FileDelete extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        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('FilesystemFileDelete', 'Success', {
+                path: this.params.path,
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DirList extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        this.useDevicePassphraseState = false;
+        this.params = {
+            path: this.payload.path,
+            depth: this.payload.depth,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('FilesystemDirList', 'FilesystemDir', {
+                path: this.params.path,
+                depth: this.params.depth,
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DirMake extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        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('FilesystemDirMake', 'Success', {
+                path: this.params.path,
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class DirRemove extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        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('FilesystemDirRemove', 'Success', {
+                path: this.params.path,
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
+class PathInfo extends BaseMethod {
+    init() {
+        this.skipForceUpdateCheck = true;
+        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('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
+                path: this.params.path,
+            });
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
 class CipherKeyValue extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -39176,6 +41708,50 @@ class TonSignProof extends BaseMethod {
     }
 }
 
+class TonSignData extends BaseMethod {
+    init() {
+        this.strictCheckDeviceSupport = false;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
+        validateParams(this.payload, [
+            { name: 'path', required: true },
+            { name: 'type', type: 'number', required: true },
+            { name: 'payload', type: 'hexString', required: true },
+            { name: 'schema', type: 'string' },
+            { name: 'appdomain', type: 'string', required: true },
+            { name: 'timestamp', required: true },
+            { name: 'fromAddress', type: 'string' },
+            { name: 'walletVersion' },
+            { name: 'walletId', type: 'number' },
+            { name: 'workchain' },
+            { name: 'isBounceable', type: 'boolean' },
+            { name: 'isTestnetOnly', type: 'boolean' },
+        ]);
+        const { path } = this.payload;
+        const addressN = validatePath(path, 3);
+        this.params = {
+            address_n: addressN,
+            type: this.payload.type,
+            payload: formatAnyHex(this.payload.payload),
+            schema: this.payload.schema,
+            appdomain: this.payload.appdomain,
+            timestamp: this.payload.timestamp,
+            from_address: this.payload.fromAddress,
+            wallet_version: this.payload.walletVersion,
+            wallet_id: this.payload.walletId,
+            workchain: this.payload.workchain,
+            is_bounceable: this.payload.isBounceable,
+            is_testnet_only: this.payload.isTestnetOnly,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.device.commands.typedCall('TonSignData', 'TonSignedData', Object.assign({}, this.params));
+            return Promise.resolve(res.message);
+        });
+    }
+}
+
 class ScdoGetAddress extends BaseMethod {
     constructor() {
         super(...arguments);
@@ -39913,7 +42489,33 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     firmwareUpdate: FirmwareUpdate,
     firmwareUpdateV2: FirmwareUpdateV2,
     firmwareUpdateV3: FirmwareUpdateV3,
+    firmwareUpdateV4: FirmwareUpdateV4,
     promptWebDeviceAccess: PromptWebDeviceAccess,
+    getProtoVersion: GetProtoVersion,
+    ping: Ping,
+    devReboot: DevReboot,
+    devGetDeviceInfo: DevGetDeviceInfo,
+    devGetOnboardingStatus: DevGetOnboardingStatus,
+    devFirmwareUpdate: DevFirmwareUpdate,
+    devGetFirmwareUpdateStatus: DevGetFirmwareUpdateStatus,
+    factoryDeviceInfoSettings: FactoryDeviceInfoSettings,
+    factoryGetDeviceInfo: FactoryGetDeviceInfo,
+    filesystemFixPermission: FilesystemFixPermission,
+    filesystemFormat: FilesystemFormat,
+    fileRead: FileRead,
+    fileWrite: FileWrite,
+    fileDelete: FileDelete,
+    dirList: DirList,
+    dirMake: DirMake,
+    dirRemove: DirRemove,
+    pathInfo: PathInfo,
+    filesystemFileRead: FileRead,
+    filesystemFileWrite: FileWrite,
+    filesystemFileDelete: FileDelete,
+    filesystemDirList: DirList,
+    filesystemDirMake: DirMake,
+    filesystemDirRemove: DirRemove,
+    filesystemPathInfoQuery: PathInfo,
     cipherKeyValue: CipherKeyValue,
     allNetworkGetAddress: AllNetworkGetAddress,
     allNetworkGetAddressByLoop: AllNetworkGetAddressByLoop,
@@ -39993,6 +42595,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     tonGetAddress: TonGetAddress,
     tonSignMessage: TonSignMessage,
     tonSignProof: TonSignProof,
+    tonSignData: TonSignData,
     scdoGetAddress: ScdoGetAddress,
     scdoSignTransaction: ScdoSignTransaction,
     scdoSignMessage: ScdoSignMessage,
@@ -40084,17 +42687,31 @@ class DeviceConnector {
     stop() {
         this.listening = false;
     }
-    acquire(path, session, forceCleanRunPromise) {
+    acquire(path, session, forceCleanRunPromise, connectProtocol) {
         return __awaiter(this, void 0, void 0, function* () {
-            Log$2.debug('acquire', path, session);
+            Log$2.debug('acquire', path, session, connectProtocol);
             const env = DataManager.getSettings('env');
             try {
                 let res;
                 if (DataManager.isBleConnect(env)) {
-                    res = yield this.transport.acquire({ uuid: path, forceCleanRunPromise });
+                    res = yield this.transport.acquire({
+                        uuid: path,
+                        forceCleanRunPromise,
+                        expectedProtocol: connectProtocol,
+                    });
                 }
                 else {
-                    res = yield this.transport.acquire({ path, previous: session !== null && session !== void 0 ? session : null });
+                    res = yield this.transport.acquire({
+                        path,
+                        previous: session !== null && session !== void 0 ? session : null,
+                        expectedProtocol: connectProtocol,
+                    });
+                }
+                if (connectProtocol) {
+                    const detectedProtocol = this.transport.getProtocolType(path);
+                    if (detectedProtocol !== connectProtocol) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${connectProtocol}, detected ${detectedProtocol}`);
+                    }
                 }
                 return res;
             }
@@ -40281,6 +42898,7 @@ const parseInitOptions = (method) => ({
     passphraseState: method === null || method === void 0 ? void 0 : method.payload.passphraseState,
     deviceId: method === null || method === void 0 ? void 0 : method.payload.deviceId,
     deriveCardano: method && hasDeriveCardano(method),
+    connectProtocol: method === null || method === void 0 ? void 0 : method.payload.connectProtocol,
 });
 let _core;
 let _deviceList;
@@ -40652,6 +43270,7 @@ function initDevice(method) {
     }
     else if (allDevices.length > 1) {
         throw hdShared.ERRORS.TypedError([
+            'firmwareUpdateV4',
             'firmwareUpdateV3',
             'firmwareUpdateV2',
             'checkFirmwareRelease',
@@ -40690,18 +43309,28 @@ function initDeviceForBle(method) {
     return device;
 }
 let bleTimeoutRetry = 0;
+function isRetryableBleProtocolV2ProbeError(method, error) {
+    const message = error instanceof Error ? error.message : String(error !== null && error !== void 0 ? error : '');
+    return (method.payload.connectProtocol === 'V2' &&
+        message.includes('Device protocol mismatch') &&
+        message.includes('expected V2') &&
+        message.includes('did not respond to expected protocol'));
+}
 function connectDeviceForBle(method, device) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            yield device.acquire();
+            yield device.acquire(method.payload.connectProtocol);
             if ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.onlyConnectBleDevice) {
                 return;
             }
             yield device.initialize(parseInitOptions(method));
         }
         catch (err) {
-            if (err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError && bleTimeoutRetry <= 5) {
+            if ((err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError ||
+                err.errorCode === hdShared.HardwareErrorCode.BleConnectedError ||
+                isRetryableBleProtocolV2ProbeError(method, err)) &&
+                bleTimeoutRetry <= 5) {
                 bleTimeoutRetry += 1;
                 Log.debug(`Bletooth connect timeout and will retry, retry count: ${bleTimeoutRetry}`);
                 yield wait(3000);
@@ -41180,6 +43809,10 @@ Object.defineProperty(exports, 'PROTO', {
     enumerable: true,
     get: function () { return hdTransport.Messages; }
 });
+Object.defineProperty(exports, 'TonSignDataType', {
+    enumerable: true,
+    get: function () { return hdTransport.TonSignDataType; }
+});
 exports.CORE_EVENT = CORE_EVENT;
 exports.Core = Core;
 exports.DEFAULT_PRIORITY = DEFAULT_PRIORITY;