@onekeyfe/hd-core 1.2.0-alpha.7 → 1.2.0-alpha.9

package/dist/index.js

@@ -119,6 +119,7 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, updateSettings, swi
 };
 const createCoreApi = (call) => ({
     getLogs: () => call({ method: 'getLogs' }),
+    clearSessionCache: params => call(Object.assign(Object.assign({}, params), { method: 'clearSessionCache' })),
     searchDevices: params => call(Object.assign(Object.assign({}, params), { method: 'searchDevices' })),
     getFeatures: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'getFeatures' })),
     getDeviceInfo: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'getDeviceInfo' })),
@@ -142,6 +143,8 @@ const createCoreApi = (call) => ({
     ping: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'ping' })),
     deviceReboot: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceReboot' })),
     deviceInfoGet: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceInfoGet' })),
+    deviceStatusGet: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceStatusGet' })),
+    deviceSessionGet: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceSessionGet' })),
     deviceFirmwareUpdate: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceFirmwareUpdate' })),
     deviceGetFirmwareUpdateStatus: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceGetFirmwareUpdateStatus' })),
     deviceFactoryInfoSet: (connectId, params) => call(Object.assign(Object.assign({}, params), { connectId, method: 'deviceFactoryInfoSet' })),
@@ -9277,6 +9280,14 @@ var nested$2 = {
 			passphrase_state: {
 				type: "string",
 				id: 1
+			},
+			_only_main_pin: {
+				type: "bool",
+				id: 2
+			},
+			allow_create_attach_pin: {
+				type: "bool",
+				id: 3
 			}
 		}
 	},
@@ -25394,8 +25405,6 @@ var nested = {
 			MessageType_FirmwareHash: 89,
 			MessageType_UnlockPath: 93,
 			MessageType_UnlockedPathRequest: 94,
-			MessageType_UnLockDevice: 10030,
-			MessageType_UnLockDeviceResponse: 10031,
 			MessageType_SetU2FCounter: 63,
 			MessageType_GetNextU2FCounter: 80,
 			MessageType_NextU2FCounter: 81,
@@ -25484,6 +25493,7 @@ var nested = {
 			MessageType_EthereumGnosisSafeTxAck: 20118,
 			MessageType_EthereumGnosisSafeTxRequest: 20119,
 			MessageType_EthereumSignTxEIP7702OneKey: 20120,
+			MessageType_EthereumSignTypedDataQR: 20121,
 			MessageType_NEMGetAddress: 67,
 			MessageType_NEMAddress: 68,
 			MessageType_NEMSignTx: 69,
@@ -25741,6 +25751,8 @@ var nested = {
 			MessageType_UiviewConfirmTxRequest: 30202,
 			MessageType_UiviewConfirmSignMessageRequest: 30203,
 			MessageType_UiviewResponse: 30204,
+			MessageType_UnLockDevice: 10030,
+			MessageType_UnLockDeviceResponse: 10031,
 			MessageType_DeviceFactoryInfoSet: 60000,
 			MessageType_DeviceFactoryInfoGet: 60001,
 			MessageType_DeviceFactoryInfo: 60002,
@@ -25765,6 +25777,12 @@ var nested = {
 			MessageType_Wallpaper: 60432,
 			MessageType_DeviceInfoGet: 60600,
 			MessageType_DeviceInfo: 60601,
+			MessageType_DeviceStatusGet: 60602,
+			MessageType_DeviceStatus: 60603,
+			MessageType_DevGetOnboardingStatus: 60604,
+			MessageType_DevOnboardingStatus: 60605,
+			MessageType_DeviceSessionGet: 60606,
+			MessageType_DeviceSession: 60607,
 			MessageType_FilesystemPermissionFix: 60800,
 			MessageType_FilesystemPathInfo: 60801,
 			MessageType_FilesystemPathInfoQuery: 60802,
@@ -25779,7 +25797,8 @@ var nested = {
 			MessageType_FilesystemFormat: 60811,
 			MessageType_DeviceFirmwareUpdateRequest: 61000,
 			MessageType_DeviceFirmwareUpdateStatusGet: 61001,
-			MessageType_DeviceFirmwareUpdateStatus: 61002
+			MessageType_DeviceFirmwareUpdateStatus: 61002,
+			MessageType_PortfolioUpdate: 61200
 		},
 		reserved: [
 			[
@@ -30700,6 +30719,37 @@ var nested = {
 			}
 		}
 	},
+	EthereumSignTypedDataQR: {
+		fields: {
+			address_n: {
+				rule: "repeated",
+				type: "uint32",
+				id: 1,
+				options: {
+					packed: false
+				}
+			},
+			json_data: {
+				type: "bytes",
+				id: 2
+			},
+			chain_id: {
+				type: "uint64",
+				id: 3
+			},
+			metamask_v4_compat: {
+				type: "bool",
+				id: 4,
+				options: {
+					"default": true
+				}
+			},
+			request_id: {
+				type: "bytes",
+				id: 5
+			}
+		}
+	},
 	EthereumGetPublicKeyOneKey: {
 		fields: {
 			address_n: {
@@ -36450,6 +36500,26 @@ var nested = {
 			}
 		}
 	},
+	ViewRawData: {
+		fields: {
+			initial_data: {
+				rule: "required",
+				type: "string",
+				id: 1
+			},
+			placeholder: {
+				rule: "required",
+				type: "uint32",
+				id: 2
+			}
+		}
+	},
+	ViewSignLayout: {
+		values: {
+			LayoutDefault: 0,
+			LayoutSafeTxCreate: 1
+		}
+	},
 	ViewSignPage: {
 		fields: {
 			title: {
@@ -36469,6 +36539,24 @@ var nested = {
 			tip: {
 				type: "ViewTip",
 				id: 4
+			},
+			raw_data: {
+				type: "ViewRawData",
+				id: 5
+			},
+			slide_to_confirm: {
+				type: "bool",
+				id: 6,
+				options: {
+					"default": true
+				}
+			},
+			layout: {
+				type: "ViewSignLayout",
+				id: 7,
+				options: {
+					"default": "LayoutDefault"
+				}
 			}
 		}
 	},
@@ -37227,6 +37315,48 @@ var nested = {
 			}
 		}
 	},
+	DeviceStatusGet: {
+		fields: {
+		}
+	},
+	DevOnboardingStage: {
+		values: {
+			DEV_ONBOARDING_STAGE_UNKNOWN: 0,
+			DEV_ONBOARDING_STAGE_SAFETY_CHECK: 1,
+			DEV_ONBOARDING_STAGE_PERSONALIZATION: 2,
+			DEV_ONBOARDING_STAGE_SELECT_SETUP_METHOD: 3,
+			DEV_ONBOARDING_STAGE_NEW_DEVICE: 4,
+			DEV_ONBOARDING_STAGE_SELECT_RESTORE_METHOD: 5,
+			DEV_ONBOARDING_STAGE_RESTORE_MNEMONIC: 6,
+			DEV_ONBOARDING_STAGE_RESTORE_SEEDCARD: 7,
+			DEV_ONBOARDING_STAGE_WALLET_READY: 8,
+			DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP_PROMPT: 9,
+			DEV_ONBOARDING_STAGE_SELECT_SEEDCARD_BACKUP_METHOD: 10,
+			DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP: 11,
+			DEV_ONBOARDING_STAGE_DONE: 12
+		}
+	},
+	DevGetOnboardingStatus: {
+		fields: {
+		}
+	},
+	DevOnboardingStatus: {
+		fields: {
+			stage: {
+				rule: "required",
+				type: "DevOnboardingStage",
+				id: 1
+			},
+			status_code: {
+				type: "uint32",
+				id: 2
+			},
+			detail_code: {
+				type: "uint32",
+				id: 3
+			}
+		}
+	},
 	FilesystemPermissionFix: {
 		fields: {
 		}
@@ -37441,6 +37571,20 @@ var nested = {
 		}
 	},
 	FilesystemFormat: {
+		fields: {
+			data: {
+				rule: "required",
+				type: "bool",
+				id: 1
+			},
+			user: {
+				rule: "required",
+				type: "bool",
+				id: 2
+			}
+		}
+	},
+	PortfolioUpdate: {
 		fields: {
 		}
 	},
@@ -38595,6 +38739,68 @@ const PROTOBUF_MESSAGE_CONFIG = {
     ],
 };
 
+const getErrorText = (error) => {
+    if (error instanceof Error)
+        return `${error.name} ${error.message}`;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object') {
+        const record = error;
+        return [record.code, record.errorCode, record.message, record.reason]
+            .filter(value => value !== undefined && value !== null)
+            .join(' ');
+    }
+    return String(error !== null && error !== void 0 ? error : '');
+};
+const isProtocolV2InvalidSessionError = (error) => getErrorText(error).toLowerCase().includes('failure_invalidsession');
+function requestProtocolV2DeviceStatus(device) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { message } = yield device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
+        return message;
+    });
+}
+function refreshProtocolV2DeviceStatus(device) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const status = yield requestProtocolV2DeviceStatus(device);
+        return device.updateProtocolV2Status(status);
+    });
+}
+function getProtocolV2WalletSession(device, options) {
+    var _a, _b, _c, _d, _e;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (((_a = device.features) === null || _a === void 0 ? void 0 : _a.unlocked) === false) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device is locked');
+        }
+        if (options === null || options === void 0 ? void 0 : options.initSession) {
+            device.clearInternalState();
+        }
+        const cachedSessionId = typeof device.getInternalState === 'function' ? device.getInternalState() : undefined;
+        try {
+            const { message } = yield device.commands.typedCall('DeviceSessionGet', 'DeviceSession', cachedSessionId ? { session_id: cachedSessionId } : {});
+            if ((options === null || options === void 0 ? void 0 : options.expectedPassphraseState) &&
+                options.expectedPassphraseState !== message.btc_test_address) {
+                device.clearInternalState();
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckPassphraseStateError);
+            }
+            if (message.btc_test_address && device.getCurrentPassphraseProtection() !== true) {
+                yield refreshProtocolV2DeviceStatus(device);
+            }
+            device.updateInternalState(((_b = device.getCurrentPassphraseProtection()) !== null && _b !== void 0 ? _b : false) || Boolean(message.btc_test_address), message.btc_test_address, device.getCurrentDeviceId(), message.session_id, (options === null || options === void 0 ? void 0 : options.initSession) ? null : (_c = device.features) === null || _c === void 0 ? void 0 : _c.sessionId);
+            return {
+                passphraseState: message.btc_test_address,
+                newSession: message.session_id,
+                unlockedAttachPin: (_e = (_d = device.features) === null || _d === void 0 ? void 0 : _d.unlockedAttachPin) !== null && _e !== void 0 ? _e : undefined,
+            };
+        }
+        catch (error) {
+            if (isProtocolV2InvalidSessionError(error)) {
+                device.clearInternalState();
+            }
+            throw error;
+        }
+    });
+}
+
 const getSupportProtocolV1MessageSchema = (features) => {
     var _a;
     if (!features)
@@ -38635,6 +38841,19 @@ const supportInputPinOnSoftware = (features) => {
 };
 const getPassphraseStateWithRefreshDeviceInfo = (device, options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c;
+    if (device.isProtocolV2()) {
+        if (!device.features) {
+            return {
+                passphraseState: undefined,
+                newSession: undefined,
+                unlockedAttachPin: undefined,
+            };
+        }
+        return getProtocolV2WalletSession(device, {
+            initSession: options === null || options === void 0 ? void 0 : options.initSession,
+            expectedPassphraseState: options === null || options === void 0 ? void 0 : options.expectPassphraseState,
+        });
+    }
     const { features } = device;
     const locked = (features === null || features === void 0 ? void 0 : features.unlocked) === false;
     const deviceType = device.getCurrentDeviceType();
@@ -38660,31 +38879,20 @@ const getPassphraseStateWithRefreshDeviceInfo = (device, options) => __awaiter(v
 });
 const supportProSeriesAttachPinPassphrase = (deviceType, firmwareVersion) => deviceType === hdShared.EDeviceType.Pro && semver__default["default"].gte(firmwareVersion, '4.15.0');
 const getPassphraseState = (device, options) => __awaiter(void 0, void 0, void 0, function* () {
-    var _d, _e;
+    var _d;
     const { features, commands } = device;
     if (!features)
         return { passphraseState: undefined, newSession: undefined, unlockedAttachPin: undefined };
     const firmwareVersion = (_d = device.getCurrentFirmwareVersionString()) !== null && _d !== void 0 ? _d : '0.0.0';
     const deviceType = device.getCurrentDeviceType();
     if (device.isProtocolV2()) {
-        const payload = {};
-        const cachedSessionId = typeof device.getInternalState === 'function' ? device.getInternalState() : undefined;
-        if (cachedSessionId) {
-            payload.session_id = cachedSessionId;
-        }
-        const { message, type } = yield commands.typedCall('DeviceSessionGet', 'DeviceSession', payload);
-        if (type === 'CallMethodError') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Get the passphrase state error');
-        }
-        return {
-            passphraseState: message.btc_test_address,
-            newSession: message.session_id,
-            unlockedAttachPin: (_e = features.unlockedAttachPin) !== null && _e !== void 0 ? _e : undefined,
-        };
+        return getProtocolV2WalletSession(device, {
+            initSession: options === null || options === void 0 ? void 0 : options.initSession,
+            expectedPassphraseState: options === null || options === void 0 ? void 0 : options.expectPassphraseState,
+        });
     }
     const supportAttachPinCapability = existCapability(features, hdTransport.Enum_Capability.Capability_AttachToPin);
-    const supportGetPassphraseState = supportAttachPinCapability ||
-        supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
+    const supportGetPassphraseState = supportAttachPinCapability || supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
     if (supportGetPassphraseState) {
         const payload = (options === null || options === void 0 ? void 0 : options.onlyMainPin)
             ? { _only_main_pin: true }
@@ -40504,6 +40712,85 @@ class DeviceCommands {
     }
 }
 
+class DeviceWalletSessionStore {
+    constructor() {
+        this.walletSessions = new Map();
+        this.pendingSessions = new Map();
+    }
+    get(deviceKey, passphraseState) {
+        var _a;
+        if (!deviceKey || !passphraseState)
+            return undefined;
+        return (_a = this.walletSessions.get(deviceKey)) === null || _a === void 0 ? void 0 : _a.get(passphraseState);
+    }
+    set(deviceKey, passphraseState, sessionId) {
+        if (!deviceKey || !passphraseState || !sessionId)
+            return;
+        let deviceSessions = this.walletSessions.get(deviceKey);
+        if (!deviceSessions) {
+            deviceSessions = new Map();
+            this.walletSessions.set(deviceKey, deviceSessions);
+        }
+        deviceSessions.set(passphraseState, sessionId);
+    }
+    setPending(deviceKey, sessionId) {
+        if (!deviceKey || !sessionId)
+            return;
+        this.pendingSessions.set(deviceKey, sessionId);
+    }
+    getPending(deviceKey) {
+        if (!deviceKey)
+            return undefined;
+        return this.pendingSessions.get(deviceKey);
+    }
+    delete(deviceKey, passphraseState) {
+        if (!deviceKey || !passphraseState)
+            return;
+        const deviceSessions = this.walletSessions.get(deviceKey);
+        if (!deviceSessions)
+            return;
+        deviceSessions.delete(passphraseState);
+        if (deviceSessions.size === 0) {
+            this.walletSessions.delete(deviceKey);
+        }
+    }
+    deletePending(deviceKey) {
+        if (!deviceKey)
+            return;
+        this.pendingSessions.delete(deviceKey);
+    }
+    deleteDevice(deviceKey) {
+        if (!deviceKey)
+            return;
+        this.walletSessions.delete(deviceKey);
+        this.pendingSessions.delete(deviceKey);
+    }
+    migrateDeviceKey(from, to) {
+        var _a;
+        if (!from || !to || from === to)
+            return;
+        const sourceSessions = this.walletSessions.get(from);
+        if (sourceSessions) {
+            const targetSessions = (_a = this.walletSessions.get(to)) !== null && _a !== void 0 ? _a : new Map();
+            this.walletSessions.set(to, targetSessions);
+            sourceSessions.forEach((sessionId, passphraseState) => {
+                targetSessions.set(passphraseState, sessionId);
+            });
+            this.walletSessions.delete(from);
+        }
+        const pendingSession = this.pendingSessions.get(from);
+        if (pendingSession) {
+            this.pendingSessions.set(to, pendingSession);
+            this.pendingSessions.delete(from);
+        }
+    }
+    clear() {
+        this.walletSessions.clear();
+        this.pendingSessions.clear();
+    }
+}
+const deviceWalletSessionStore = new DeviceWalletSessionStore();
+
 const isProtocolV2BootloaderDeviceInfo = (deviceInfo) => !!deviceInfo && deviceInfo.status == null;
 const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
     targets: {
@@ -41076,10 +41363,8 @@ const parseRunOptions = (options) => {
     return options;
 };
 const Log$c = getLogger(exports.LoggerNames.Device);
-const deviceSessionCache = {};
 function preloadSessionCache(deviceId, passphraseState, sessionId) {
-    const key = `${deviceId}@${passphraseState}`;
-    deviceSessionCache[key] = sessionId;
+    deviceWalletSessionStore.set(deviceId, passphraseState, sessionId);
 }
 class Device extends events.exports {
     constructor(descriptor, sdkInstanceId) {
@@ -41116,7 +41401,7 @@ class Device extends events.exports {
         const serialNo = this.getCurrentSerialNo();
         const connectId = this.getConnectId();
         const deviceId = this.getCurrentDeviceId() || null;
-        const features = this.features;
+        const { features } = this;
         return {
             connectId: DataManager.isBleConnect(env) ? this.mainId || null : connectId,
             uuid: serialNo,
@@ -41406,12 +41691,6 @@ class Device extends events.exports {
             support: Boolean(firmwareVersion && semver__default["default"].gte(firmwareVersion, '3.4.0')),
         };
     }
-    generateStateKey(deviceId, passphraseState) {
-        if (passphraseState) {
-            return `${deviceId}@${passphraseState}`;
-        }
-        return deviceId;
-    }
     getSessionCacheDeviceKey(_deviceId) {
         const deviceId = _deviceId || this.getCurrentDeviceId();
         if (deviceId)
@@ -41423,60 +41702,48 @@ class Device extends events.exports {
     }
     getInternalState(_deviceId) {
         var _a;
-        Log$c.debug('getInternalState session cache: ', deviceSessionCache);
         Log$c.debug('getInternalState session param: ', `device_id: ${_deviceId}`, `features.deviceId: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.deviceId}`, `passphraseState: ${this.passphraseState}`);
         const deviceId = this.getSessionCacheDeviceKey(_deviceId);
         if (!deviceId)
             return undefined;
         if (!this.passphraseState)
             return undefined;
-        const usePassKey = this.generateStateKey(deviceId, this.passphraseState);
-        return deviceSessionCache[usePassKey];
+        return deviceWalletSessionStore.get(deviceId, this.passphraseState);
     }
     updateInternalState(enablePassphrase, passphraseState, deviceId, sessionId = null, featuresSessionId = null) {
-        Log$c.debug('updateInternalState session param: ', `device_id: ${deviceId}`, `enablePassphrase: ${enablePassphrase}`, `passphraseState: ${passphraseState}`, `sessionId: ${sessionId}`, `featuresSessionId: ${featuresSessionId}`);
+        Log$c.debug('updateInternalState session param: ', `device_id: ${deviceId}`, `enablePassphrase: ${enablePassphrase}`, `passphraseState: ${passphraseState}`, `hasSessionId: ${Boolean(sessionId)}`, `hasFeaturesSessionId: ${Boolean(featuresSessionId)}`);
         const cacheDeviceKey = this.getSessionCacheDeviceKey(deviceId);
         if (!cacheDeviceKey)
             return;
         if (enablePassphrase) {
-            if (sessionId) {
-                deviceSessionCache[this.generateStateKey(cacheDeviceKey, passphraseState)] = sessionId;
-            }
-            else if (featuresSessionId) {
-                deviceSessionCache[this.generateStateKey(cacheDeviceKey, passphraseState)] =
-                    featuresSessionId;
-            }
+            const walletSessionId = sessionId || featuresSessionId || deviceWalletSessionStore.getPending(cacheDeviceKey);
+            deviceWalletSessionStore.set(cacheDeviceKey, passphraseState, walletSessionId !== null && walletSessionId !== void 0 ? walletSessionId : undefined);
         }
-        const oldKey = `${cacheDeviceKey}`;
-        if (deviceSessionCache[oldKey]) {
-            delete deviceSessionCache[oldKey];
-        }
-        Log$c.debug('updateInternalState session cache: ', deviceSessionCache);
+        deviceWalletSessionStore.deletePending(cacheDeviceKey);
     }
     setInternalState(state, initSession) {
         var _a;
-        Log$c.debug('setInternalState session param: ', `state: ${state}`, `initSession: ${initSession}`, `deviceId: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.deviceId}`, `passphraseState: ${this.passphraseState}`);
+        Log$c.debug('setInternalState session param: ', `hasState: ${Boolean(state)}`, `initSession: ${initSession}`, `deviceId: ${(_a = this.features) === null || _a === void 0 ? void 0 : _a.deviceId}`, `passphraseState: ${this.passphraseState}`);
         if (!this.passphraseState && !initSession)
             return;
         const deviceId = this.getSessionCacheDeviceKey();
         if (!deviceId)
             return;
-        const key = this.generateStateKey(deviceId, this.passphraseState);
-        if (state) {
-            deviceSessionCache[key] = state;
+        if (this.passphraseState) {
+            deviceWalletSessionStore.set(deviceId, this.passphraseState, state);
+        }
+        else if (initSession) {
+            deviceWalletSessionStore.setPending(deviceId, state);
         }
-        Log$c.debug('setInternalState done session cache: ', deviceSessionCache);
     }
     clearInternalState(_deviceId) {
         Log$c.debug('clearInternalState param: ', _deviceId);
         const deviceId = this.getSessionCacheDeviceKey(_deviceId);
         if (!deviceId)
             return;
-        const key = `${deviceId}`;
-        delete deviceSessionCache[key];
+        deviceWalletSessionStore.deletePending(deviceId);
         if (this.passphraseState) {
-            const usePassKey = this.generateStateKey(deviceId, this.passphraseState);
-            delete deviceSessionCache[usePassKey];
+            deviceWalletSessionStore.delete(deviceId, this.passphraseState);
         }
     }
     initialize(options) {
@@ -41578,28 +41845,44 @@ class Device extends events.exports {
     }
     _updateFeatures(protoFeatures, initSession) {
         var _a, _b;
+        const previousCacheDeviceKey = this.getSessionCacheDeviceKey();
         let feat = 'protocol' in protoFeatures
             ? protoFeatures
             : buildProtocolV1FeaturesPayload(protoFeatures, this.features);
         if (((_a = this.features) === null || _a === void 0 ? void 0 : _a.sessionId) && !feat.sessionId) {
             feat.sessionId = this.features.sessionId;
         }
-        if (this.getCurrentDeviceId() && feat.sessionId) {
-            this.setInternalState(feat.sessionId, initSession);
-        }
         feat.unlocked = (_b = feat.unlocked) !== null && _b !== void 0 ? _b : true;
         feat = fixFeaturesFirmwareVersion(feat);
         this.features = feat;
+        const nextCacheDeviceKey = this.getSessionCacheDeviceKey();
+        if (previousCacheDeviceKey && nextCacheDeviceKey) {
+            deviceWalletSessionStore.migrateDeviceKey(previousCacheDeviceKey, nextCacheDeviceKey);
+        }
+        if (feat.deviceId && feat.sessionId) {
+            this.setInternalState(feat.sessionId, initSession);
+        }
         this.featuresNeedsReload = false;
         this.emit(DEVICE.FEATURES, this, feat);
     }
     updateProtocolV2Features(deviceInfo) {
+        const previousCacheDeviceKey = this.getSessionCacheDeviceKey();
         const features = fixFeaturesFirmwareVersion(buildProtocolV2FeaturesPayload(deviceInfo, this.features));
         this.features = features;
+        const nextCacheDeviceKey = this.getSessionCacheDeviceKey();
+        if (previousCacheDeviceKey && nextCacheDeviceKey) {
+            deviceWalletSessionStore.migrateDeviceKey(previousCacheDeviceKey, nextCacheDeviceKey);
+        }
         this.featuresNeedsReload = false;
         this.emit(DEVICE.FEATURES, this, features);
         return features;
     }
+    updateProtocolV2Status(status) {
+        var _a, _b, _c, _d, _e;
+        const previousDeviceInfo = (_b = (_a = this.features) === null || _a === void 0 ? void 0 : _a.raw) === null || _b === void 0 ? void 0 : _b.protocolV2DeviceInfo;
+        const previousStatus = previousDeviceInfo === null || previousDeviceInfo === void 0 ? void 0 : previousDeviceInfo.status;
+        return this.updateProtocolV2Features(Object.assign(Object.assign({}, (previousDeviceInfo !== null && previousDeviceInfo !== void 0 ? previousDeviceInfo : {})), { protocol_version: (_e = (_c = previousDeviceInfo === null || previousDeviceInfo === void 0 ? void 0 : previousDeviceInfo.protocol_version) !== null && _c !== void 0 ? _c : (_d = this.features) === null || _d === void 0 ? void 0 : _d.protocolVersion) !== null && _e !== void 0 ? _e : 2, status: Object.assign(Object.assign({}, previousStatus), status) }));
+    }
     updateDescriptor(descriptor, forceUpdate = false) {
         var _a;
         const env = DataManager.getSettings('env');
@@ -41837,13 +42120,27 @@ class Device extends events.exports {
         };
     }
     unlockDevice() {
-        var _a;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            const firmwareVersion = (_a = this.getCurrentFirmwareVersionString()) !== null && _a !== void 0 ? _a : '0.0.0';
+            if (this.isProtocolV2()) {
+                try {
+                    yield this.commands.typedCall('UnLockDevice', 'UnLockDeviceResponse');
+                }
+                catch (error) {
+                    const errorText = error instanceof Error
+                        ? `${error.name} ${error.message}`
+                        : String((_b = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error) !== null && _b !== void 0 ? _b : '');
+                    if (errorText.includes('Failure_UnexpectedMessage')) {
+                        throw hdShared.createDeviceNotSupportMethodError('deviceUnlock', this.getCurrentFirmwareType());
+                    }
+                    throw error;
+                }
+                return refreshProtocolV2DeviceStatus(this);
+            }
+            const firmwareVersion = (_c = this.getCurrentFirmwareVersionString()) !== null && _c !== void 0 ? _c : '0.0.0';
             const versionRange = this.getCurrentMethodVersionRange(type => this.supportUnlockVersionRange()[type]);
             const supportAttachPinCapability = existCapability(this.features, hdTransport.Enum_Capability.Capability_AttachToPin);
-            const supportUnlock = this.isProtocolV2() ||
-                supportAttachPinCapability ||
+            const supportUnlock = supportAttachPinCapability ||
                 (versionRange &&
                     semver__default["default"].valid(firmwareVersion) &&
                     semver__default["default"].gte(firmwareVersion, versionRange.min));
@@ -41860,9 +42157,6 @@ class Device extends events.exports {
                 const features = yield this.getFeatures();
                 return Promise.resolve(features);
             }
-            if (this.isProtocolV2()) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'unlock device error: device firmware does not support UnLockDevice');
-            }
             const { type } = yield this.commands.typedCall('GetAddress', 'Address', {
                 address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
                 coin_name: 'Testnet',
@@ -42572,6 +42866,31 @@ class GetLogs extends BaseMethod {
     }
 }
 
+class ClearSessionCache extends BaseMethod {
+    init() {
+        this.useDevice = false;
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+        this.params = {
+            deviceId: this.payload.deviceId,
+            passphraseState: this.payload.passphraseState,
+        };
+    }
+    run() {
+        const { deviceId, passphraseState } = this.params;
+        if (!deviceId) {
+            deviceWalletSessionStore.clear();
+        }
+        else if (!passphraseState) {
+            deviceWalletSessionStore.deleteDevice(deviceId);
+        }
+        else {
+            deviceWalletSessionStore.delete(deviceId, passphraseState);
+        }
+        return Promise.resolve({ cleared: true });
+    }
+}
+
 class CheckFirmwareRelease extends BaseMethod {
     init() {
         this.allowDeviceMode = [
@@ -45448,21 +45767,29 @@ function normalizeRebootType(value) {
     }
     return hdTransport.DeviceRebootType.Normal;
 }
-const VALID_FIRMWARE_TARGET_IDS = new Set(Object.values(ProtocolV2FirmwareTargetType).filter(value => typeof value === 'number'));
-const FIRMWARE_TARGET_ID_BY_NAME = new Map(Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) => VALID_FIRMWARE_TARGET_IDS.has(value)
-    ? [[key, value]]
-    : []));
+const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set([
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P2,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_COPROCESSOR,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE01,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE02,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03,
+    ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
+]);
+const FIRMWARE_TARGET_ID_BY_NAME = new Map(Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) => INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value]] : []));
 function normalizeTargetId(value, name) {
     if (value === undefined || value === null) {
         throw invalidParameter(`Missing required parameter: ${name}`);
     }
     const named = typeof value === 'string' ? FIRMWARE_TARGET_ID_BY_NAME.get(value) : undefined;
     const numeric = named !== null && named !== void 0 ? named : (typeof value === 'number' ? value : Number(value));
-    if (Number.isSafeInteger(numeric) && VALID_FIRMWARE_TARGET_IDS.has(numeric)) {
+    if (Number.isSafeInteger(numeric) && INSTALLABLE_FIRMWARE_TARGET_IDS.has(numeric)) {
         return numeric;
     }
-    throw invalidParameter(`Parameter [${name}] must be a valid firmware target id (one of ${[
-        ...VALID_FIRMWARE_TARGET_IDS,
+    throw invalidParameter(`Parameter [${name}] must be an installable firmware target id (one of ${[
+        ...INSTALLABLE_FIRMWARE_TARGET_IDS,
     ].join(', ')}).`);
 }
 function normalizeFirmwareTargets(params) {
@@ -45495,19 +45822,20 @@ 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_START_UPDATE_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_START_UPDATE_TIMEOUT = 3 * 60 * 1000;
 const PROTOCOL_V2_INSTALL_TIMEOUT = 5 * 60 * 1000;
 const PROTOCOL_V2_TARGET_STATUS_PENDING = 0;
 const PROTOCOL_V2_TARGET_STATUS_IN_PROGRESS = 1;
 const PROTOCOL_V2_TARGET_STATUS_FINISHED = 2;
 const PROTOCOL_V2_TARGET_STATUS_FAILED_MIN = 3;
 const PROTOCOL_V2_CONNECT_PROTOCOL = 'V2';
-const PROTOCOL_V2_FIRMWARE_STAGING_VOLUME = 'vol1:';
+const PROTOCOL_V2_FIRMWARE_STAGING_VOLUME = 'vol0:/';
 const PROTOCOL_V2_MIN_FILE_CHUNK_SIZE = 64;
 const PROTOCOL_V2_CONNECT_RETRY_COUNT = 10;
 const PROTOCOL_V2_CONNECT_POLL_INTERVAL = 500;
 const PROTOCOL_V2_CONNECT_SINGLE_TIMEOUT = 75 * 1000;
 const PROTOCOL_V2_DEVICE_INFO_READY_TIMEOUT = 60 * 1000;
+const PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT = 3;
 const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
 const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
 const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
@@ -45569,11 +45897,6 @@ const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS = {
         targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04,
         kind: 'firmware',
     },
-    CRATE: {
-        fileName: 'resource.bin',
-        targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-        kind: 'resource',
-    },
 };
 const PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE = 'FW_MGMT_TARGET_ROMLOADER is not accepted by the current Pro2 bootloader update request. Flash romloader with the loader-specific flow instead of firmwareUpdateV4.';
 const PROTOCOL_V2_TARGET_ID_BY_DECODED_NAME = new Map(Object.entries(ProtocolV2FirmwareTargetType).map(([key, value]) => [key, value]));
@@ -45741,7 +46064,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         }
         validateParams(payload, [
             { name: 'chunkSize', type: 'number' },
-            { name: 'resourceBinaries', type: 'array', allowEmpty: true },
             { name: 'forcedUpdateRes', type: 'boolean' },
             { name: 'bootloaderBinary', type: 'buffer' },
             { name: 'romloaderBinary', type: 'buffer' },
@@ -45754,6 +46076,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             { name: 'se04Binary', type: 'buffer' },
             { name: 'firmwareType', type: 'string' },
             { name: 'platform', type: 'string' },
+            { name: 'resourceBundleFiles', type: 'array', allowEmpty: true },
         ]);
         this.params = {
             chunkSize: payload.chunkSize,
@@ -45767,7 +46090,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             se02Binary: payload.se02Binary,
             se03Binary: payload.se03Binary,
             se04Binary: payload.se04Binary,
-            resourceBinaries: payload.resourceBinaries,
+            resourceBundleFiles: payload.resourceBundleFiles,
             firmwareType: payload.firmwareType,
             platform: payload.platform,
         };
@@ -45799,18 +46122,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const deviceFeatures = yield this.getProtocolV2DeviceFeatures();
             const deviceFirmwareType = getFirmwareType(deviceFeatures);
             const firmwareType = (_a = this.params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
-            let resourceBinaryMap = [];
             let fwBinaryMap = [];
             let bootloaderBinary = null;
             let installItems;
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
-                resourceBinaryMap = yield this.prepareResourceBinaries(firmwareType, deviceFeatures);
                 fwBinaryMap = this.collectExplicitTargetBinaries();
                 bootloaderBinary = this.prepareBootloaderBinary();
                 if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
                     const remoteBinaries = yield this.prepareRemoteProtocolV2Binaries(firmwareType, deviceFeatures);
-                    resourceBinaryMap = remoteBinaries.resourceBinaryMap;
                     bootloaderBinary = remoteBinaries.bootloaderBinary;
                     fwBinaryMap = remoteBinaries.fwBinaryMap;
                     installItems = remoteBinaries.installItems;
@@ -45820,13 +46140,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             catch (err) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_b = err.message) !== null && _b !== void 0 ? _b : err);
             }
-            if (resourceBinaryMap.length === 0 && !bootloaderBinary && fwBinaryMap.length === 0) {
+            const resourceBundles = this.prepareProtocolV2ResourceBundles(firmwareType, deviceFeatures);
+            if (!bootloaderBinary && fwBinaryMap.length === 0 && !(resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
             }
             yield this.enterProtocolV2BootloaderMode();
-            yield this.executeProtocolV2Update(Object.assign({ resourceBinaryMap,
-                fwBinaryMap,
-                bootloaderBinary }, (installItems ? { installItems } : undefined)));
+            yield this.executeProtocolV2Update(Object.assign(Object.assign({ fwBinaryMap,
+                bootloaderBinary }, (installItems ? { installItems } : undefined)), ((resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) ? { resourceBundles } : undefined)));
             yield this.exitProtocolV2BootloaderToNormal();
             const versions = yield this.waitForProtocolV2FinalFeatures();
             this.postTipMessage(exports.FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
@@ -45847,52 +46167,18 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device features not available');
         });
     }
-    prepareResourceBinaries(firmwareType, features) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((_a = this.params.resourceBinaries) === null || _a === void 0 ? void 0 : _a.length) {
-                this.params.resourceBinaries.forEach((binary, index) => {
-                    if (!(binary instanceof ArrayBuffer)) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Parameter [resourceBinaries.${index}] is of type invalid and should be [buffer].`);
-                    }
-                });
-                return this.params.resourceBinaries.map((binary, index) => ({
-                    fileName: `resource-${index + 1}.bin`,
-                    binary,
-                    targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-                }));
-            }
-            const resourceUrl = DataManager.getSysResourcesLatestRelease({
-                features,
-                forcedUpdateRes: this.params.forcedUpdateRes,
-                firmwareType,
-            });
-            if (resourceUrl) {
-                const resource = (yield getSysResourceBinary(resourceUrl)).binary;
-                return [
-                    {
-                        fileName: 'resource.bin',
-                        binary: resource,
-                        targetId: ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_CRATE,
-                    },
-                ];
-            }
-            Log$4.warn('No resource url found');
-            return [];
-        });
-    }
     prepareBootloaderBinary() {
         var _a;
         return (_a = this.params.bootloaderBinary) !== null && _a !== void 0 ? _a : null;
     }
     hasExplicitProtocolV2Payload(fwBinaryMap) {
         var _a;
-        return (!!((_a = this.params.resourceBinaries) === null || _a === void 0 ? void 0 : _a.length) ||
+        return (!!((_a = this.params.resourceBundleFiles) === null || _a === void 0 ? void 0 : _a.length) ||
             !!this.params.bootloaderBinary ||
             fwBinaryMap.length > 0);
     }
-    buildProtocolV2InstallItems({ resourceBinaryMap, bootloaderBinary, fwBinaryMap, }) {
-        const installItems = resourceBinaryMap.map(resource => (Object.assign(Object.assign({}, resource), { kind: 'resource' })));
+    buildProtocolV2InstallItems({ bootloaderBinary, fwBinaryMap, }) {
+        const installItems = [];
         if (bootloaderBinary) {
             installItems.push({
                 fileName: 'bootloader.bin',
@@ -46024,75 +46310,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return parseProtocolV2OkppHeader(headerBytes);
         });
     }
-    isProtocolV2ResourcePackageMatched(pkg, manifestVersion) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const header = yield this.readProtocolV2DeviceFileHeader(pkg.path);
-                if (!header)
-                    return false;
-                const expectedType = (_a = pkg.type) !== null && _a !== void 0 ? _a : 'RESC';
-                const expectedVersion = (_b = pkg.version) !== null && _b !== void 0 ? _b : manifestVersion;
-                if (header.type !== expectedType)
-                    return false;
-                if (expectedVersion && compareProtocolV2Versions(header.version, expectedVersion) !== 0) {
-                    return false;
-                }
-                const expectedPayloadHash = normalizeProtocolV2Hex(pkg.payloadHash);
-                if (expectedPayloadHash && header.payloadHash !== expectedPayloadHash)
-                    return false;
-                const expectedHeaderHash = normalizeProtocolV2Hex(pkg.headerHash);
-                if (expectedHeaderHash && header.headerHash !== expectedHeaderHash)
-                    return false;
-                return true;
-            }
-            catch (error) {
-                Log$4.log(`Protocol V2 resource package check failed for ${pkg.path}: `, error);
-                return false;
-            }
-        });
-    }
-    isProtocolV2ResourceManifestSatisfied(manifest) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!((_a = manifest === null || manifest === void 0 ? void 0 : manifest.packages) === null || _a === void 0 ? void 0 : _a.length))
-                return false;
-            for (const pkg of manifest.packages) {
-                if (!(yield this.isProtocolV2ResourcePackageMatched(pkg, manifest.version))) {
-                    return false;
-                }
-            }
-            return true;
-        });
-    }
-    getProtocolV2ResourceManifest(release, component) {
-        var _a;
-        return (_a = component.resourceManifest) !== null && _a !== void 0 ? _a : release.resourceManifest;
-    }
-    getProtocolV2ResourceComponentFileName(key) {
-        const safeKey = key.replace(/[^a-z0-9_-]/gi, '_') || 'resource';
-        return `resource-${safeKey}.bin`;
-    }
     shouldInstallRemoteProtocolV2Component(release, key, component, target, features) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (target.kind === 'resource') {
-                if (this.params.forcedUpdateRes ||
-                    features.bootloaderMode ||
-                    features.mode === 'bootloader') {
-                    return true;
-                }
-                const resourceMatched = yield this.isProtocolV2ResourceManifestSatisfied(this.getProtocolV2ResourceManifest(release, component));
-                if (resourceMatched) {
-                    Log$4.log(`[FirmwareUpdateV4] skip Protocol V2 resource component ${key}; manifest matched`);
-                }
-                return !resourceMatched;
-            }
-            const versionSatisfied = this.isProtocolV2ComponentVersionSatisfied(release, component, target, features);
-            if (versionSatisfied) {
-                Log$4.log(`[FirmwareUpdateV4] skip Protocol V2 component ${key}; version is up to date`);
-            }
-            return !versionSatisfied;
-        });
+        const versionSatisfied = this.isProtocolV2ComponentVersionSatisfied(release, component, target, features);
+        if (versionSatisfied) {
+            Log$4.log(`[FirmwareUpdateV4] skip Protocol V2 component ${key}; version is up to date`);
+        }
+        return !versionSatisfied;
     }
     downloadRemoteProtocolV2Component(key, component) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -46107,13 +46330,11 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     prepareRemoteProtocolV2Binaries(firmwareType, features) {
         return __awaiter(this, void 0, void 0, function* () {
             const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-            const resourceBinaryMap = [];
             let bootloaderBinary = null;
             const fwBinaryMap = [];
             const installItems = [];
             if (!release) {
                 return {
-                    resourceBinaryMap,
                     bootloaderBinary,
                     fwBinaryMap,
                     installItems,
@@ -46122,19 +46343,10 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const entries = this.getRemoteComponentEntries(release);
             for (const [key, component] of entries) {
                 const target = this.getRemoteComponentTarget(key, component);
-                const shouldInstall = yield this.shouldInstallRemoteProtocolV2Component(release, key, component, target, features);
+                const shouldInstall = this.shouldInstallRemoteProtocolV2Component(release, key, component, target, features);
                 if (shouldInstall) {
                     const remoteBinary = yield this.downloadRemoteProtocolV2Component(key, component);
-                    if (remoteBinary.kind === 'resource') {
-                        const binaryEntry = {
-                            fileName: this.getProtocolV2ResourceComponentFileName(key),
-                            binary: remoteBinary.binary,
-                            targetId: remoteBinary.targetId,
-                        };
-                        resourceBinaryMap.push(binaryEntry);
-                        installItems.push(Object.assign(Object.assign({}, binaryEntry), { kind: remoteBinary.kind }));
-                    }
-                    else if (remoteBinary.kind === 'bootloader') {
+                    if (remoteBinary.kind === 'bootloader') {
                         bootloaderBinary = remoteBinary.binary;
                         installItems.push({
                             fileName: remoteBinary.fileName,
@@ -46155,13 +46367,117 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 }
             }
             return {
-                resourceBinaryMap,
                 bootloaderBinary,
                 fwBinaryMap,
                 installItems,
             };
         });
     }
+    prepareProtocolV2ResourceBundles(firmwareType, features) {
+        var _a, _b;
+        if ((_a = this.params.resourceBundleFiles) === null || _a === void 0 ? void 0 : _a.length) {
+            return this.params.resourceBundleFiles.map(file => {
+                var _a;
+                return ({
+                    name: (_a = file.devicePath.split('/').pop()) !== null && _a !== void 0 ? _a : file.devicePath,
+                    binary: file.binary,
+                    devicePath: file.devicePath,
+                });
+            });
+        }
+        const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+        if (!((_b = release === null || release === void 0 ? void 0 : release.resourceBundles) === null || _b === void 0 ? void 0 : _b.length))
+            return undefined;
+        return release.resourceBundles.map(bundle => ({
+            name: bundle.name,
+            binary: new ArrayBuffer(0),
+            devicePath: bundle.devicePath,
+            url: bundle.url,
+            version: bundle.version,
+            payloadHash: bundle.payloadHash,
+            headerHash: bundle.headerHash,
+        }));
+    }
+    syncProtocolV2ResourceBundles(bundles, firmwareSize) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transferStartTime = Date.now();
+            const transferTransport = this.getProtocolV2FirmwareTransferTransport();
+            const isManualMode = bundles.every(b => b.binary.byteLength > 0);
+            let bundlesToSync = bundles;
+            if (!isManualMode) {
+                const filtered = [];
+                for (const bundle of bundles) {
+                    if (bundle.binary.byteLength === 0 && bundle.url) {
+                        Log$4.log(`[FirmwareUpdateV4] downloading RESC bundle ${bundle.name} from ${bundle.url}`);
+                        const { binary } = yield getSysResourceBinary(bundle.url);
+                        bundle.binary = binary;
+                    }
+                    const upToDate = yield this.isProtocolV2ResourceBundleUpToDate(bundle);
+                    if (upToDate) {
+                        Log$4.log(`[FirmwareUpdateV4] skip RESC bundle ${bundle.name}; already up to date`);
+                    }
+                    else {
+                        filtered.push(bundle);
+                    }
+                }
+                bundlesToSync = filtered;
+            }
+            if (bundlesToSync.length === 0) {
+                Log$4.log('[FirmwareUpdateV4] all RESC bundles up to date, nothing to sync');
+                return { processedSize: 0, totalSize: firmwareSize };
+            }
+            let totalSize = 0;
+            for (const b of bundlesToSync)
+                totalSize += b.binary.byteLength;
+            const transferTotalSize = totalSize + firmwareSize;
+            let processedSize = 0;
+            for (const bundle of bundlesToSync) {
+                Log$4.log(`[FirmwareUpdateV4] syncing RESC bundle ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`);
+                processedSize = yield this.protocolV2CommonUpdateProcess({
+                    payload: bundle.binary,
+                    filePath: bundle.devicePath,
+                    processedSize,
+                    totalSize: transferTotalSize,
+                });
+            }
+            const elapsedMs = Date.now() - transferStartTime;
+            Log$4.log(`[FirmwareUpdateV4] RESC bundle sync finished transport=${transferTransport} bytes=${totalSize} elapsed=${(elapsedMs / 1000).toFixed(2)}s speed=${formatProtocolV2TransferSpeed(totalSize, elapsedMs)} KB/s`);
+            return { processedSize, totalSize: transferTotalSize };
+        });
+    }
+    isProtocolV2ResourceBundleUpToDate(bundle) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.params.forcedUpdateRes)
+                return false;
+            if (!bundle.version && !bundle.payloadHash)
+                return false;
+            try {
+                const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath);
+                if (!header)
+                    return false;
+                if (bundle.version) {
+                    const cmp = compareProtocolV2Versions(header.version, bundle.version);
+                    if (cmp === undefined || cmp !== 0)
+                        return false;
+                }
+                if (bundle.payloadHash) {
+                    const expected = normalizeProtocolV2Hex(bundle.payloadHash);
+                    if (expected && header.payloadHash !== expected)
+                        return false;
+                }
+                if (bundle.headerHash) {
+                    const expected = normalizeProtocolV2Hex(bundle.headerHash);
+                    if (expected && header.headerHash !== expected)
+                        return false;
+                }
+                return true;
+            }
+            catch (error) {
+                Log$4.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
+                return false;
+            }
+        });
+    }
     isProtocolV2BootloaderMode() {
         var _a;
         if (typeof this.device.isBootloader === 'function') {
@@ -46236,19 +46552,31 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         push(this.params.se04Binary, 'se04.bin', ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04);
         return entries;
     }
-    executeProtocolV2Update({ resourceBinaryMap, fwBinaryMap, bootloaderBinary, installItems, }) {
+    executeProtocolV2Update({ fwBinaryMap, bootloaderBinary, installItems, resourceBundles, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const orderedInstallItems = installItems !== null && installItems !== void 0 ? installItems : this.buildProtocolV2InstallItems({
-                resourceBinaryMap: resourceBinaryMap !== null && resourceBinaryMap !== void 0 ? resourceBinaryMap : [],
                 bootloaderBinary: bootloaderBinary !== null && bootloaderBinary !== void 0 ? bootloaderBinary : null,
                 fwBinaryMap: fwBinaryMap !== null && fwBinaryMap !== void 0 ? fwBinaryMap : [],
             });
-            let totalSize = 0;
-            let processedSize = 0;
-            let transferredSize = 0;
+            let firmwareSize = 0;
             for (const item of orderedInstallItems)
-                totalSize += item.binary.byteLength;
+                firmwareSize += item.binary.byteLength;
             this.postTipMessage(exports.FirmwareUpdateTipMessage.StartTransferData);
+            let processedSize = 0;
+            let totalSize = firmwareSize;
+            if (resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) {
+                const resourceTransfer = yield this.syncProtocolV2ResourceBundles(resourceBundles, firmwareSize);
+                processedSize = resourceTransfer.processedSize;
+                totalSize = resourceTransfer.totalSize;
+            }
+            if (orderedInstallItems.length === 0) {
+                Log$4.log('[FirmwareUpdateV4] no firmware targets to install (RESC bundles only)');
+                if (totalSize > 0) {
+                    this.postProgressMessage(100, 'transferData');
+                }
+                return;
+            }
+            let transferredSize = processedSize;
             const transferStartTime = Date.now();
             const transferTransport = this.getProtocolV2FirmwareTransferTransport();
             const chunkSize = this.getProtocolV2FirmwareChunkSize();
@@ -46269,6 +46597,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         onTransferredBytes,
                     });
                     transferredSize = processedSize;
+                    yield this.verifyProtocolV2StagedFile(filePath, item.binary.byteLength);
                     stagedInstallTargets.push(Object.assign(Object.assign({}, item), { path: filePath }));
                 }
                 if (totalSize > 0) {
@@ -46283,39 +46612,29 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 throw error;
             }
             this.postTipMessage(exports.FirmwareUpdateTipMessage.ConfirmOnDevice);
-            const firmwareTargets = [];
-            const flushFirmwareTargets = () => __awaiter(this, void 0, void 0, function* () {
-                if (firmwareTargets.length === 0)
-                    return;
-                const targets = firmwareTargets.splice(0, firmwareTargets.length);
-                Log$4.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest targets=${JSON.stringify(targets)}`);
-                const startResponse = yield this.protocolV2StartFirmwareUpdate({ targets });
-                yield this.waitForProtocolV2FirmwareUpdateComplete(targets, startResponse);
-            });
-            for (const item of stagedInstallTargets) {
-                const target = {
-                    target_id: item.targetId,
-                    path: item.path,
-                };
-                if (item.kind === 'resource') {
-                    yield flushFirmwareTargets();
-                    const resourceTargets = [target];
-                    Log$4.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest resources=${JSON.stringify(resourceTargets)}`);
-                    const startResponse = yield this.protocolV2StartFirmwareUpdate({
-                        targets: resourceTargets,
-                    });
-                    yield this.waitForProtocolV2FirmwareUpdateComplete(resourceTargets, startResponse);
-                }
-                else {
-                    firmwareTargets.push(target);
-                }
-            }
-            yield flushFirmwareTargets();
+            const allTargets = stagedInstallTargets.map(item => ({
+                target_id: item.targetId,
+                path: item.path,
+            }));
+            Log$4.log(`[FirmwareUpdateV4] DeviceFirmwareUpdateRequest targets=${JSON.stringify(allTargets)}`);
+            const startResponse = yield this.protocolV2StartFirmwareUpdate({ targets: allTargets });
+            yield this.waitForProtocolV2FirmwareUpdateComplete(allTargets, startResponse);
         });
     }
     getProtocolV2InstallItemStagingPath(item) {
         return `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${item.fileName}`;
     }
+    verifyProtocolV2StagedFile(path, expectedSize) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            const response = yield typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', { path });
+            const actualSize = toProtocolV2FiniteNumber((_a = response.message) === null || _a === void 0 ? void 0 : _a.size);
+            if (!((_b = response.message) === null || _b === void 0 ? void 0 : _b.exist) || ((_c = response.message) === null || _c === void 0 ? void 0 : _c.directory) || actualSize !== expectedSize) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `staged file verification failed: path=${path} exist=${!!((_d = response.message) === null || _d === void 0 ? void 0 : _d.exist)} expected=${expectedSize} actual=${actualSize !== null && actualSize !== void 0 ? actualSize : 'unknown'}`);
+            }
+        });
+    }
     queryProtocolV2FirmwareUpdateStatus() {
         return __awaiter(this, void 0, void 0, function* () {
             const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
@@ -46520,7 +46839,26 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             yield this.device.initialize();
         });
     }
-    protocolV2CommonUpdateProcess({ payload, filePath, processedSize, totalSize, onTransferredBytes, }) {
+    protocolV2CommonUpdateProcess(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let lastError;
+            for (let attempt = 1; attempt <= PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT; attempt += 1) {
+                try {
+                    return yield this.protocolV2WriteWholeFile(params);
+                }
+                catch (error) {
+                    lastError = error;
+                    Log$4.error(`Protocol V2 file transfer failed path=${params.filePath} attempt=${attempt}/${PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT}; restarting from offset 0`, error);
+                    if (attempt === PROTOCOL_V2_FILE_TRANSFER_RETRY_COUNT) {
+                        break;
+                    }
+                    yield this.recoverProtocolV2FileTransfer();
+                }
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, `transfer data error: ${getProtocolV2UnknownErrorText(lastError)}`);
+        });
+    }
+    protocolV2WriteWholeFile({ payload, filePath, processedSize, totalSize, onTransferredBytes, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const chunkSize = this.getProtocolV2FirmwareChunkSize();
             let offset = 0;
@@ -46536,7 +46874,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 const chunk = payload.slice(offset, chunkEnd);
                 const overwrite = offset === 0;
                 const progress = getProtocolV2DeviceTransferProgress((processedSize !== null && processedSize !== void 0 ? processedSize : 0) + offset, (processedSize !== null && processedSize !== void 0 ? processedSize : 0) + chunkEnd, totalSize !== null && totalSize !== void 0 ? totalSize : payload.byteLength);
-                const writeRes = yield this.fileWriteWithRetry(filePath, payload.byteLength, offset, chunk, overwrite, progress);
+                const writeRes = yield this.fileWriteChunk(filePath, payload.byteLength, offset, chunk, overwrite, progress);
                 const processedByte = Number(writeRes.message.processed_byte);
                 const nextOffset = Number.isFinite(processedByte) && processedByte > offset
                     ? processedByte
@@ -46562,54 +46900,41 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         }
         return env !== null && env !== void 0 ? env : 'unknown';
     }
-    fileWriteWithRetry(filePath, totalFileSize, offset, chunk, overwrite, progress) {
+    fileWriteChunk(filePath, totalFileSize, offset, chunk, overwrite, progress) {
+        var _a;
         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;
+            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,
             });
-            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');
+            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);
                     }
-                    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');
             }
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'transfer data error');
+            return writeRes;
+        });
+    }
+    recoverProtocolV2FileTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const env = DataManager.getSettings('env');
+            if (DataManager.isBleConnect(env)) {
+                yield hdShared.wait(3000);
+                yield this.acquireProtocolV2BleDevice();
+                yield this.device.initialize();
+            }
+            yield hdShared.wait(2000);
         });
     }
     acquireProtocolV2BleDevice() {
@@ -46875,6 +47200,38 @@ class DeviceInfoGet extends BaseMethod {
     }
 }
 
+class DeviceStatusGet extends BaseMethod {
+    init() {
+        this.requireProtocolV2 = true;
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { message } = yield this.device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
+            return message;
+        });
+    }
+}
+
+class DeviceSessionGet extends BaseMethod {
+    init() {
+        this.requireProtocolV2 = true;
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+        this.params = {
+            sessionId: this.payload.sessionId,
+        };
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this.params.sessionId ? { session_id: this.params.sessionId } : {};
+            const { message } = yield this.device.commands.typedCall('DeviceSessionGet', 'DeviceSession', payload);
+            return message;
+        });
+    }
+}
+
 class DeviceFirmwareUpdate extends BaseMethod {
     init() {
         this.requireProtocolV2 = true;
@@ -47023,7 +47380,10 @@ class FilesystemFormat extends BaseMethod {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            const res = yield this.device.commands.typedCall('FilesystemFormat', 'Success', {});
+            const res = yield this.device.commands.typedCall('FilesystemFormat', 'Success', {
+                data: true,
+                user: true,
+            });
             return Promise.resolve(res.message);
         });
     }
@@ -47067,7 +47427,7 @@ 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_BLE_FILE_READ_CHUNK_SIZE;
     }
     return hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
 }
@@ -56617,6 +56977,7 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     getOnekeyFeatures: GetOnekeyFeatures,
     getPassphraseState: GetPassphraseState,
     getLogs: GetLogs,
+    clearSessionCache: ClearSessionCache,
     checkFirmwareRelease: CheckFirmwareRelease,
     checkBLEFirmwareRelease: CheckBLEFirmwareRelease,
     checkBridgeStatus: CheckBridgeStatus,
@@ -56653,6 +57014,8 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     ping: Ping,
     deviceReboot: DeviceReboot,
     deviceInfoGet: DeviceInfoGet,
+    deviceStatusGet: DeviceStatusGet,
+    deviceSessionGet: DeviceSessionGet,
     deviceFirmwareUpdate: DeviceFirmwareUpdate,
     deviceGetFirmwareUpdateStatus: DeviceGetFirmwareUpdateStatus,
     deviceFactoryInfoSet: DeviceFactoryInfoSet,