@onekeyfe/hd-core 1.2.0-alpha.22 → 1.2.0-alpha.23

package/dist/index.js

@@ -6,9 +6,9 @@ var hdShared = require('@onekeyfe/hd-shared');
 var utils = require('@noble/hashes/utils');
 var sha256 = require('@noble/hashes/sha256');
 var semver = require('semver');
-var lodash = require('lodash');
 var hdTransport = require('@onekeyfe/hd-transport');
 var axios = require('axios');
+var lodash = require('lodash');
 var ByteBuffer = require('bytebuffer');
 var BigNumber = require('bignumber.js');
 var blake2s = require('@noble/hashes/blake2s');
@@ -437,19 +437,9 @@ const getDeviceUUID = getDeviceSerialNo;
 const getDeviceLabel = (features) => {
     if (!features)
         return null;
-    const deviceType = getDeviceType(features);
-    if (deviceType == null)
-        return null;
-    if ('label' in features && typeof features.label === 'string' && !lodash.isEmpty(features.label)) {
-        return features.label;
-    }
-    const bleName = getDeviceBleName(features);
-    if (!lodash.isEmpty(bleName))
-        return bleName;
-    if (deviceType === hdShared.EDeviceType.ClassicPure) {
-        return 'OneKey Classic 1S';
-    }
-    return `OneKey ${deviceType.charAt(0).toUpperCase() + deviceType.slice(1)}`;
+    return 'label' in features && typeof features.label === 'string' && features.label.length > 0
+        ? features.label
+        : null;
 };
 const getMethodVersionRange = (features, getVersionRange) => {
     const deviceType = getDeviceType(features);
@@ -1079,6 +1069,13 @@ const validateFirmwareUpdatePreparedPlan = (value) => {
     }
     return preparedPlan;
 };
+const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({ preparedPlan: value, deviceIdentity, }) => {
+    const preparedPlan = validateFirmwareUpdatePreparedPlan(value);
+    if (!deviceIdentity || preparedPlan.deviceIdentity !== deviceIdentity) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
+    }
+    return preparedPlan;
+};
 const sameArtifactReference = (first, second) => first.artifactRef === second.artifactRef &&
     first.size === second.size &&
     first.sha256.toLowerCase() === second.sha256.toLowerCase();
@@ -27183,9 +27180,10 @@ var nested = {
 			MessageType_DeviceStatus: 60603,
 			MessageType_DevGetOnboardingStatus: 60604,
 			MessageType_DevOnboardingStatus: 60605,
+			MessageType_DeviceSessionGet: 60606,
 			MessageType_DeviceSession: 60607,
 			MessageType_DeviceSessionAskPin: 60608,
-			MessageType_DeviceSessionOpen: 60609,
+			MessageType_DeviceSessionAskPassphrase: 60609,
 			MessageType_FilesystemPermissionFix: 60800,
 			MessageType_FilesystemPathInfo: 60801,
 			MessageType_FilesystemPathInfoQuery: 60802,
@@ -27219,10 +27217,6 @@ var nested = {
 			[
 				309,
 				312
-			],
-			[
-				60606,
-				60606
 			]
 		]
 	},
@@ -39199,90 +39193,42 @@ var nested = {
 			DeviceSessionError_Busy: 5
 		}
 	},
-	DeviceSessionResume: {
+	DeviceSessionGet: {
 		fields: {
 			session_id: {
-				rule: "required",
 				type: "bytes",
 				id: 1
 			}
 		}
 	},
-	DeviceSessionHostPassphrase: {
-		fields: {
-			passphrase: {
-				rule: "required",
-				type: "string",
-				id: 1
-			}
-		}
-	},
-	DeviceSessionPassphraseOnDevice: {
-		fields: {
-		}
-	},
-	DeviceSessionAttachPinOnDevice: {
-		fields: {
-		}
-	},
-	DeviceSessionSelect: {
-		oneofs: {
-			access: {
-				oneof: [
-					"host_passphrase",
-					"passphrase_on_device",
-					"attach_pin_on_device"
-				]
-			}
-		},
+	DeviceSession: {
 		fields: {
-			host_passphrase: {
-				type: "DeviceSessionHostPassphrase",
+			session_id: {
+				type: "bytes",
 				id: 1
 			},
-			passphrase_on_device: {
-				type: "DeviceSessionPassphraseOnDevice",
+			btc_test_address: {
+				type: "string",
 				id: 2
-			},
-			attach_pin_on_device: {
-				type: "DeviceSessionAttachPinOnDevice",
-				id: 3
 			}
 		}
 	},
-	DeviceSessionOpen: {
-		oneofs: {
-			mode: {
-				oneof: [
-					"resume",
-					"select"
-				]
-			}
-		},
-		fields: {
-			resume: {
-				type: "DeviceSessionResume",
-				id: 1
-			},
-			select: {
-				type: "DeviceSessionSelect",
-				id: 2
-			}
+	DeviceSessionPinType: {
+		values: {
+			Any: 1,
+			Main: 2,
+			AttachToPin: 3
 		}
 	},
-	DeviceSession: {
+	DeviceSessionAskPin: {
 		fields: {
-			session_id: {
-				type: "bytes",
+			type: {
+				type: "DeviceSessionPinType",
 				id: 1
-			},
-			btc_test_address: {
-				type: "string",
-				id: 2
 			}
 		}
 	},
-	DeviceSessionAskPin: {
+	DeviceSessionAskPassphrase: {
 		fields: {
 		}
 	},
@@ -40973,15 +40919,6 @@ const LogBlockEvent = new Set([
     UI_RESPONSE.RECEIVE_PIN,
     UI_RESPONSE.RECEIVE_PASSPHRASE,
 ]);
-const LogBlockMethod = new Set([
-    'evmSignTypedData',
-    'openWalletSession',
-    'DeviceSessionOpen',
-    'deviceUploadWallpaper',
-    'uploadPortfolio',
-    'fileWrite',
-    'fileRead',
-]);
 function getLogBlockLabel(message) {
     if (!message || typeof message !== 'object')
         return undefined;
@@ -40990,10 +40927,7 @@ function getLogBlockLabel(message) {
         return type;
     }
     const methodName = method !== null && method !== void 0 ? method : payload === null || payload === void 0 ? void 0 : payload.method;
-    if (methodName && LogBlockMethod.has(methodName)) {
-        return methodName;
-    }
-    return undefined;
+    return methodName;
 }
 
 function assertCompleteDeviceSession(message) {
@@ -41001,7 +40935,7 @@ function assertCompleteDeviceSession(message) {
         !message.session_id ||
         typeof message.btc_test_address !== 'string' ||
         !message.btc_test_address) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'DeviceSessionOpen returned an incomplete DeviceSession response.');
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'DeviceSessionGet returned an incomplete DeviceSession response.');
     }
 }
 
@@ -41017,16 +40951,31 @@ const negotiateEventlessWalletSession = (device) => __awaiter(void 0, void 0, vo
         eventless_wallet_session: true,
     });
 });
-const openDeviceSession = (device, request) => __awaiter(void 0, void 0, void 0, function* () {
+const getDeviceSession = (device, request) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        return yield device.commands.typedCall('DeviceSessionOpen', 'DeviceSession', request);
+        return yield device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
     }
     catch (error) {
         if (!isDeviceLockedError(error)) {
             throw error;
         }
-        yield device.unlockDevice();
-        return device.commands.typedCall('DeviceSessionOpen', 'DeviceSession', request);
+        yield device.unlockDevice(hdTransport.DeviceSessionPinType.Main);
+        return device.commands.typedCall('DeviceSessionGet', 'DeviceSession', request);
+    }
+});
+const askDevicePassphrase = (device) => __awaiter(void 0, void 0, void 0, function* () {
+    const request = () => device.commands.typedCall('DeviceSessionAskPassphrase', 'Success', {}, {
+        timeoutMs: 120000,
+    });
+    try {
+        return yield request();
+    }
+    catch (error) {
+        if (!isDeviceLockedError(error)) {
+            throw error;
+        }
+        yield device.unlockDevice(hdTransport.DeviceSessionPinType.Main);
+        return request();
     }
 });
 const selectDeviceSession = (device) => __awaiter(void 0, void 0, void 0, function* () {
@@ -41036,10 +40985,10 @@ const selectDeviceSession = (device) => __awaiter(void 0, void 0, void 0, functi
         source: 'wallet-session-coordinator',
         reason: 'open-wallet',
     };
-    const response = yield device.commands.promptPassphrase(Object.assign({ existsAttachPinUser }, metadata), { cancelDeviceOnReject: false });
-    const hostPassphrase = typeof response.passphrase === 'string' ? response.passphrase.normalize('NFKD') : undefined;
+    const response = yield device.commands.promptPassphrase(Object.assign({ existsAttachPinUser, deviceOnly: true }, metadata), { cancelDeviceOnReject: false });
+    const hasHostPassphrase = typeof response.passphrase === 'string' && response.passphrase.length > 0;
     const selections = [
-        !!hostPassphrase,
+        hasHostPassphrase,
         response.passphraseOnDevice === true,
         response.attachPinOnDevice === true,
     ].filter(Boolean).length;
@@ -41051,21 +41000,19 @@ const selectDeviceSession = (device) => __awaiter(void 0, void 0, void 0, functi
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Attach PIN wallet selection is unavailable on this device.');
         }
         device.emit(DEVICE.ATTACH_PIN_ON_DEVICE, device, metadata);
-        return openDeviceSession(device, { select: { attach_pin_on_device: {} } });
-    }
-    if (response.passphraseOnDevice) {
-        device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
-        return openDeviceSession(device, { select: { passphrase_on_device: {} } });
+        yield device.unlockDevice(hdTransport.DeviceSessionPinType.AttachToPin);
+        return getDeviceSession(device, {});
     }
-    return openDeviceSession(device, {
-        select: { host_passphrase: { passphrase: hostPassphrase } },
-    });
+    device.emit(DEVICE.PASSPHRASE_ON_DEVICE, device, metadata);
+    yield askDevicePassphrase(device);
+    return getDeviceSession(device, {});
 });
 function getProtocolV2WalletSession(device, options) {
     var _a, _b, _c, _d, _e, _f;
     return __awaiter(this, void 0, void 0, function* () {
         if (options === null || options === void 0 ? void 0 : options.initSession) {
             device.clearInternalState();
+            device.passphraseState = undefined;
         }
         yield negotiateEventlessWalletSession(device);
         if (options === null || options === void 0 ? void 0 : options.onlyMainPin) {
@@ -41075,7 +41022,7 @@ function getProtocolV2WalletSession(device, options) {
             ? undefined
             : (_a = options === null || options === void 0 ? void 0 : options.expectedPassphraseState) !== null && _a !== void 0 ? _a : device.passphraseState;
         if (((_b = device.features) === null || _b === void 0 ? void 0 : _b.unlocked) === false) {
-            yield device.unlockDevice();
+            yield device.unlockDevice(hdTransport.DeviceSessionPinType.Main);
         }
         if ((options === null || options === void 0 ? void 0 : options.onlyMainPin) || device.getCurrentPassphraseProtection() === false) {
             return {
@@ -41090,7 +41037,7 @@ function getProtocolV2WalletSession(device, options) {
         let resumed = false;
         if (cachedSessionId && expectedPassphraseState) {
             try {
-                response = yield openDeviceSession(device, { resume: { session_id: cachedSessionId } });
+                response = yield getDeviceSession(device, { session_id: cachedSessionId });
                 resumed = true;
             }
             catch (error) {
@@ -42516,10 +42463,6 @@ TransportManager.reactNativeInit = false;
 TransportManager.protocolV1MessageSchema = 'v1CurrentSchema';
 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([
     'FilesystemFileRead',
     'FilesystemFileWrite',
@@ -42530,84 +42473,14 @@ const HIGH_VOLUME_DEBUG_CALLS = new Set([
     'FirmwareUpload',
     'ResourceAck',
 ]);
-const SENSITIVE_DEBUG_CALLS = new Set(['DeviceSessionOpen']);
+const DEVICE_SESSION_CALLS = new Set([
+    'DeviceSessionGet',
+    'DeviceSessionAskPin',
+    'DeviceSessionAskPassphrase',
+]);
 function shouldReduceDebugForCall(type) {
     return HIGH_VOLUME_DEBUG_CALLS.has(type);
 }
-function shouldBlockDebugForCall(type) {
-    return SENSITIVE_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);
-    }
-    if (key && /passphrase/i.test(key)) {
-        return '[redacted passphrase]';
-    }
-    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 stripInteractiveAckTimeout = (options) => {
     if (!options)
         return options;
@@ -42778,16 +42651,16 @@ class DeviceCommands {
                 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 if (!shouldReduceDebug) {
+                if (!shouldReduceDebug) {
                     LogCore.debug('[DeviceCommands] [call] Received', res.type);
                 }
                 return res;
             }
             catch (error) {
-                LogCore.debug('[DeviceCommands] [call] Received error', error);
+                LogCore.debug('[DeviceCommands] [call] Received error', {
+                    request: type,
+                    errorCode: error === null || error === void 0 ? void 0 : error.errorCode,
+                });
                 if (error.errorCode === hdShared.HardwareErrorCode.BleDeviceBondError) {
                     return {
                         type: 'BleDeviceBondError',
@@ -42806,9 +42679,6 @@ class DeviceCommands {
                     catch (error) {
                     }
                 }
-                if (responseData) {
-                    Log$f.debug('error response', responseData);
-                }
                 if (responseError === 'device disconnected during action') {
                     return { type: 'BridgeDeviceDisconnected', message: { error: responseError } };
                 }
@@ -42830,29 +42700,6 @@ class DeviceCommands {
             if (this.disposed) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'typedCall: DeviceCommands already disposed');
             }
-            try {
-                const skipTypes = [
-                    'ButtonAck',
-                    'PinMatrixAck',
-                    'PassphraseAck',
-                    'Cancel',
-                    'DeviceSessionOpen',
-                    'BixinPinInputOnDevice',
-                    'FilesystemFileRead',
-                    'FilesystemFileWrite',
-                    'FileRead',
-                    'FileWrite',
-                    'EmmcFileRead',
-                    'EmmcFileWrite',
-                    'FirmwareUpload',
-                    'ResourceAck',
-                ];
-                if (!skipTypes.includes(type) && !shouldBlockDebugForCall(type) && msg) {
-                    Log$f.debug('[DeviceCommands] [typedCall] Sending payload', type, sanitizeDebugPayload(msg));
-                }
-            }
-            catch (e) {
-            }
             const expectedTypes = Array.isArray(resType) ? resType : resType.split('|');
             const response = yield this._commonCall(type, msg, Object.assign(Object.assign({}, options), { expectedTypes: (_a = options === null || options === void 0 ? void 0 : options.expectedTypes) !== null && _a !== void 0 ? _a : expectedTypes }));
             try {
@@ -42862,14 +42709,11 @@ class DeviceCommands {
                 Log$f.debug('DeviceCommands typedcall error: ', error);
                 if (error instanceof hdShared.HardwareError) {
                     if (error.errorCode === hdShared.HardwareErrorCode.ResponseUnexpectTypeError) {
-                        if (!shouldBlockDebugForCall(type)) {
-                            Log$f.debug('[DeviceCommands] [typedCall] Unexpected response type', {
-                                request: type,
-                                expected: resType,
-                                received: response.type,
-                                response: sanitizeDebugPayload(response.message),
-                            });
-                        }
+                        Log$f.debug('[DeviceCommands] [typedCall] Unexpected response type', {
+                            request: type,
+                            expected: resType,
+                            received: response.type,
+                        });
                         if (error.message.indexOf('BridgeNetworkError') > -1) {
                             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNetworkError);
                         }
@@ -42898,13 +42742,11 @@ class DeviceCommands {
     _filterCommonTypes(res, callType, options) {
         var _a;
         try {
-            if (shouldReduceDebugForCall(callType) || shouldBlockDebugForCall(callType)) {
-            }
-            else if (DataManager.getSettings('env') === 'react-native') {
-                Log$f.debug('_filterCommonTypes: ', JSON.stringify(sanitizeDebugPayload(res)));
-            }
-            else {
-                Log$f.debug('_filterCommonTypes: ', sanitizeDebugPayload(res));
+            if (!shouldReduceDebugForCall(callType)) {
+                Log$f.debug('_filterCommonTypes: ', {
+                    request: callType,
+                    response: res.type,
+                });
             }
         }
         catch (error) {
@@ -42950,7 +42792,7 @@ class DeviceCommands {
                 const isLegacyProtocolV2ActionCancelledFailure = this.device.isProtocolV2() &&
                     /^(?:cancelled on device|confirm dismissed)$/i.test(normalizedMessage);
                 const isLegacyProtocolV2LockedFailure = this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
-                if (callType === 'DeviceSessionOpen' &&
+                if (DEVICE_SESSION_CALLS.has(callType) &&
                     subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_InvalidSession) {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.WalletSessionInvalid, message, {
                         failureCode: code,
@@ -42958,7 +42800,7 @@ class DeviceCommands {
                         firmwareMessage: message,
                     });
                 }
-                else if (callType === 'DeviceSessionOpen' &&
+                else if (DEVICE_SESSION_CALLS.has(callType) &&
                     subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_UserCancelled) {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.ActionCancelled, message, {
                         failureCode: code,
@@ -42966,7 +42808,7 @@ class DeviceCommands {
                         firmwareMessage: message,
                     });
                 }
-                else if (callType === 'DeviceSessionOpen' &&
+                else if (DEVICE_SESSION_CALLS.has(callType) &&
                     subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_AttachPinUnavailable) {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckUnlockTypeError, message, {
                         failureCode: code,
@@ -42974,7 +42816,7 @@ class DeviceCommands {
                         firmwareMessage: message,
                     });
                 }
-                else if (callType === 'DeviceSessionOpen' &&
+                else if (DEVICE_SESSION_CALLS.has(callType) &&
                     subcode === hdTransport.DeviceSessionErrorCode.DeviceSessionError_PassphraseDisabled) {
                     error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotOpenedPassphrase, message, {
                         failureCode: code,
@@ -43979,8 +43821,8 @@ class Device extends events.exports {
             deviceId,
             path: (_a = this.originalDescriptor) === null || _a === void 0 ? void 0 : _a.path,
             bleName,
-            name: bleName || label || `OneKey ${deviceType === null || deviceType === void 0 ? void 0 : deviceType.toUpperCase()}`,
-            label: label || 'OneKey',
+            name: label || bleName || `OneKey ${deviceType === null || deviceType === void 0 ? void 0 : deviceType.toUpperCase()}`,
+            label: label !== null && label !== void 0 ? label : '',
             mode: this.getMode(),
             features,
             state,
@@ -44578,6 +44420,20 @@ class Device extends events.exports {
         this.protocolV2StateNeedsReload = true;
         this.clearPreInitialized();
     }
+    invalidateAfterWipe() {
+        const deviceId = this.getCurrentDeviceId();
+        if (deviceId) {
+            deviceWalletSessionStore.deleteDevice(deviceId);
+        }
+        if (this.isProtocolV2() && this.originalDescriptor.path !== deviceId) {
+            deviceWalletSessionStore.deleteDevice(this.originalDescriptor.path);
+            this.protocolV2StateNeedsReload = true;
+        }
+        this.passphraseState = undefined;
+        this.stateStore = new DeviceStateStore();
+        this.clearPreInitialized();
+        this.needReloadDevice = true;
+    }
     markProtocolV2Reboot(rebootType) {
         if (!this.isProtocolV2())
             return;
@@ -44873,12 +44729,12 @@ class Device extends events.exports {
             },
         };
     }
-    unlockDevice() {
+    unlockDevice(pinType = hdTransport.DeviceSessionPinType.Main) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.isProtocolV2()) {
                 try {
-                    yield this.commands.typedCall('DeviceSessionAskPin', 'Success', undefined, {
+                    yield this.commands.typedCall('DeviceSessionAskPin', 'Success', { type: pinType }, {
                         timeoutMs: 120000,
                     });
                 }
@@ -45564,13 +45420,16 @@ class GetPassphraseState extends BaseMethod {
     }
     run() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.device.isProtocolV2()) {
-                throw hdShared.createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-            }
             if (!this.device.features) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceInitializeFailed);
             }
-            const { passphraseState } = yield getPassphraseStateWithRefreshDeviceInfo(this.device);
+            const isProtocolV2 = this.device.isProtocolV2();
+            const { passphraseState } = yield getPassphraseStateWithRefreshDeviceInfo(this.device, isProtocolV2
+                ? {
+                    onlyMainPin: this.payload.useEmptyPassphrase === true,
+                    initSession: this.payload.initSession === true,
+                }
+                : undefined);
             const passphraseProtection = this.device.getCurrentPassphraseProtection();
             return Promise.resolve(passphraseProtection === true ? passphraseState : undefined);
         });
@@ -46215,14 +46074,20 @@ class CheckAllFirmwareRelease extends BaseMethod {
                 firmwareType,
             });
             const bleFirmwareReleaseInfo = getBleFirmwareReleaseInfo(features);
-            const firmwareUpdatePlan = buildFirmwareUpdatePlan({
-                features,
-                firmwareType,
-                platform: platform !== null && platform !== void 0 ? platform : 'web',
-                firmware: firmwareRelease,
-                ble: bleFirmwareReleaseInfo,
-                bootloader: bootloaderRelease,
-            });
+            let firmwareUpdatePlan;
+            try {
+                firmwareUpdatePlan = buildFirmwareUpdatePlan({
+                    features,
+                    firmwareType,
+                    platform: platform !== null && platform !== void 0 ? platform : 'web',
+                    firmware: firmwareRelease,
+                    ble: bleFirmwareReleaseInfo,
+                    bootloader: bootloaderRelease,
+                });
+            }
+            catch (_c) {
+                firmwareUpdatePlan = undefined;
+            }
             return {
                 firmware: firmwareRelease,
                 bootloader: bootloaderRelease,
@@ -46543,7 +46408,6 @@ class DeviceReset extends BaseMethod {
 }
 
 const LOCK_FREE_DEVICE_SETTINGS = new Set([
-    'label',
     'language',
     'brightness',
     'haptic_feedback',
@@ -47010,9 +46874,11 @@ class DeviceWipe extends BaseMethod {
                 const res = yield this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
                     page: hdTransport.DeviceSettingsPage.DeviceReset,
                 });
+                this.device.invalidateAfterWipe();
                 return Promise.resolve(res.message);
             }
             const res = yield this.device.commands.typedCall('WipeDevice', 'Success');
+            this.device.invalidateAfterWipe();
             return Promise.resolve(res.message);
         });
     }
@@ -48074,6 +47940,10 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
                 : undefined;
             const executionParams = Object.assign(Object.assign({}, payload), { artifactReader: (_a = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _a !== void 0 ? _a : payload.artifactReader });
             if (payload.artifact) {
+                assertFirmwareUpdatePreparedPlanDeviceIdentity({
+                    preparedPlan: payload.preparedPlan,
+                    deviceIdentity: getDeviceUUID(features) || undefined,
+                });
                 assertFirmwareUpdatePreparedPlanBinding({
                     preparedPlan: payload.preparedPlan,
                     executor: 'v2',
@@ -48617,6 +48487,12 @@ class FirmwareUpdateV2 extends BaseMethod {
             if (device.isProtocolV2()) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware update must use firmwareUpdateV4');
             }
+            if (params.preparedPlan) {
+                assertFirmwareUpdatePreparedPlanDeviceIdentity({
+                    preparedPlan: params.preparedPlan,
+                    deviceIdentity: getDeviceUUID(features) || undefined,
+                });
+            }
             const deviceFirmwareType = device.getCurrentFirmwareType();
             const firmwareType = (_a = params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
             this.checkVersionForCopyTouchResource(features, firmwareType);
@@ -48901,6 +48777,12 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             if (!features) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Device features not available');
             }
+            if (this.params.preparedPlan) {
+                assertFirmwareUpdatePreparedPlanDeviceIdentity({
+                    preparedPlan: this.params.preparedPlan,
+                    deviceIdentity: getDeviceUUID(features) || undefined,
+                });
+            }
             const deviceFirmwareType = device.getCurrentFirmwareType();
             const firmwareType = (_b = this.params.firmwareType) !== null && _b !== void 0 ? _b : deviceFirmwareType;
             this.isSwitchFirmware = firmwareType !== deviceFirmwareType;
@@ -49700,7 +49582,7 @@ const parseProtocolV2OkppHeader = (bytes) => {
 };
 const assertProtocolV2ReconnectIdentity = (expectedSerialNumber, actualSerialNumber) => {
     if (!expectedSerialNumber || !actualSerialNumber) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, 'Protocol V2 reconnect physical identity unavailable');
+        return;
     }
     if (actualSerialNumber !== expectedSerialNumber) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Protocol V2 reconnect physical identity mismatch: expected ${expectedSerialNumber}, received ${actualSerialNumber}`);
@@ -49759,14 +49641,10 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
             : undefined;
         if (hostBinding) {
-            if (!payload.expectedDeviceId) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Protocol V2 prepared update requires the expected device identity');
-            }
             assertFirmwareUpdatePreparedPlanBinding({
                 preparedPlan: payload.preparedPlan,
                 executor: 'v4',
                 platform: payload.platform,
-                deviceIdentity: payload.expectedDeviceId,
                 scopeTargets: [
                     'boot',
                     'app_v1',
@@ -49972,10 +49850,11 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         artifactName: descriptor.name,
                     });
                 }
+                const devicePath = validateProtocolV2FilesystemPath(descriptor.devicePath, 'resourceBundles[].devicePath');
                 sources.push({
                     name: descriptor.name,
                     source: yield this.openProtocolV2PreparedSource(artifact),
-                    devicePath: descriptor.devicePath,
+                    devicePath,
                     version: descriptor.version,
                     payloadHash: descriptor.payloadHash,
                     headerHash: descriptor.headerHash,
@@ -50064,9 +49943,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 ? visibleVersions[target]
                 : `${Math.floor(statusVersion / 0x10000) % 0x100}.${Math.floor(statusVersion / 0x100) % 0x100}.${statusVersion % 0x100}`;
             if (!observedVersion) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 target ${target} has no observable final version`);
+                Log$5.warn(`Protocol V2 target ${target} has no observable final version; skipping version comparison`);
             }
-            if (observedVersion !== expectedVersion) {
+            else if (observedVersion !== expectedVersion) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareVerificationFailed, `Protocol V2 target ${target} reached ${observedVersion}, expected ${expectedVersion}`);
             }
         }
@@ -50129,10 +50008,19 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     captureProtocolV2PhysicalIdentity() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const deviceInfo = yield this.requestProtocolV2PhysicalIdentity();
             const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
-            assertProtocolV2ReconnectIdentity(serialNumber, serialNumber);
+            if ((_a = this.params) === null || _a === void 0 ? void 0 : _a.preparedPlan) {
+                assertFirmwareUpdatePreparedPlanDeviceIdentity({
+                    preparedPlan: this.params.preparedPlan,
+                    deviceIdentity: serialNumber,
+                });
+            }
+            else {
+                assertProtocolV2ReconnectIdentity((_b = this.params) === null || _b === void 0 ? void 0 : _b.expectedDeviceId, serialNumber);
+            }
             this.protocolV2ExpectedSerialNumber = serialNumber;
         });
     }
@@ -62236,6 +62124,7 @@ const onDevicePassphraseHandler = (...[device, requestPayload, callback]) => __a
         device: device.toMessageObject(),
         passphraseState: device.passphraseState,
         existsAttachPinUser: requestPayload.existsAttachPinUser,
+        deviceOnly: requestPayload.deviceOnly,
         source: requestPayload.source,
         reason: requestPayload.reason,
         expectedPassphraseState: requestPayload.expectedPassphraseState,