@onekeyfe/hd-core 1.2.0-alpha.79 → 1.2.0-alpha.80

package/dist/index.js

@@ -1287,12 +1287,22 @@ function parseProtocolV2Resources(value) {
     if (!source || typeof source !== 'object') {
         throw new Error('Invalid Pro2 resources config: source is required');
     }
-    const { manifestUrl } = source;
-    if (typeof manifestUrl !== 'string' || !manifestUrl.startsWith('https://')) {
-        throw new Error('Invalid Pro2 resources config: source.manifestUrl must use HTTPS');
+    const { archiveUrl, archiveSha256, archiveSize } = source;
+    if (typeof archiveUrl !== 'string' || !archiveUrl.startsWith('https://')) {
+        throw new Error('Invalid Pro2 resources config: source.archiveUrl must use HTTPS');
+    }
+    if (typeof archiveSha256 !== 'string' || !/^[0-9a-fA-F]{64}$/.test(archiveSha256)) {
+        throw new Error('Invalid Pro2 resources config: source.archiveSha256 must be a SHA-256 digest');
+    }
+    if (!Number.isSafeInteger(archiveSize) || archiveSize <= 0) {
+        throw new Error('Invalid Pro2 resources config: source.archiveSize must be a positive integer');
     }
     return {
-        source: { manifestUrl },
+        source: {
+            archiveUrl,
+            archiveSha256: archiveSha256.toLowerCase(),
+            archiveSize: archiveSize,
+        },
     };
 }
 const PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS = [
@@ -1418,20 +1428,7 @@ function parseProtocolV2ResourceManifest(value) {
     };
 }
 function selectProtocolV2ResourceManifestFiles({ manifest, targetsToUpdate, }) {
-    const targets = new Set(targetsToUpdate);
-    return manifest.files.filter(file => {
-        if (file.device_path.startsWith('vol0:/bundles/')) {
-            return targets.has('resource');
-        }
-        return targets.has('boot_resources');
-    });
-}
-function resolveProtocolV2ResourceManifestFileUrl({ manifestUrl, archivePath, }) {
-    const url = new URL(assertManifestRelativePath(archivePath, 'archive_path'), manifestUrl);
-    if (url.protocol !== 'https:') {
-        throw new Error('Invalid Pro2 resource manifest file URL');
-    }
-    return url.toString();
+    return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
 }
 function prepareProtocolV2ResourceFiles({ manifest: value, files, targetsToUpdate, }) {
     const manifest = parseProtocolV2ResourceManifest(value);
@@ -47303,76 +47300,93 @@ class ClearSessionCache extends BaseMethod {
     }
 }
 
-class CheckFirmwareRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [
-            ...this.allowDeviceMode,
-            UI_REQUEST.NOT_INITIALIZE,
-            UI_REQUEST.BOOTLOADER,
-        ];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        var _a;
-        const payload = this.payload;
-        if (this.device.features) {
-            const deviceFirmwareType = this.device.getCurrentFirmwareType();
-            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
-            const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
-            return Promise.resolve(releaseInfo);
+const PROTOCOL_V2_MAIN_FIRMWARE_TARGETS = [
+    'APPLICATION_P1',
+    'APPLICATION_P2',
+    'SE01',
+    'SE02',
+    'SE03',
+    'SE04',
+];
+const PROTOCOL_V2_BLE_TARGETS = [
+    'COPROCESSOR',
+];
+const PROTOCOL_V2_BOOTLOADER_TARGETS = [
+    'BOOTLOADER',
+];
+function loadProtocolV2FirmwareReleaseContext({ device, firmwareType: firmwareTypeParam, checkFirmwareHash = false, methodName, }) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const state = yield device.getDeviceState({
+            refreshSections: checkFirmwareHash
+                ? ['identity', 'versions', 'verification']
+                : ['identity', 'versions'],
+        });
+        if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportMethod, `${methodName} requires a Pro2 or Neo device for Protocol V2`);
         }
-        return Promise.resolve(null);
-    }
+        const { features } = device;
+        if (!features) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${methodName} requires initialized device features`);
+        }
+        const firmwareType = (_a = firmwareTypeParam !== null && firmwareTypeParam !== void 0 ? firmwareTypeParam : state.identity.firmwareType) !== null && _a !== void 0 ? _a : hdShared.EFirmwareType.Universal;
+        return {
+            state: state,
+            features,
+            firmwareType,
+            release: DataManager.getFirmwareLatestRelease(features, firmwareType),
+        };
+    });
 }
-
-class CheckBLEFirmwareRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [
-            ...this.allowDeviceMode,
-            UI_REQUEST.NOT_INITIALIZE,
-            UI_REQUEST.BOOTLOADER,
-        ];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
+function summarizeProtocolV2FirmwareRelease(plan, componentTargets) {
+    var _a;
+    const targetSet = new Set(componentTargets);
+    const components = plan.components.filter(component => targetSet.has(component.componentTarget));
+    const targetsToUpdate = Array.from(new Set(components.flatMap(component => component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : [])));
+    const hasUpgrade = targetsToUpdate.length > 0;
+    const required = !!((_a = plan.release) === null || _a === void 0 ? void 0 : _a.required) && hasUpgrade;
+    let status = 'valid';
+    if (!plan.release || components.length === 0) {
+        status = 'unavailable';
     }
-    run() {
-        if (this.device.features) {
-            const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
-            return Promise.resolve(releaseInfo);
-        }
-        return Promise.resolve(null);
+    else if (required) {
+        status = 'required';
+    }
+    else if (hasUpgrade) {
+        status = 'outdated';
+    }
+    else if (components.some(component => component.status === 'unknown')) {
+        status = 'unknown';
     }
+    else if (components.every(component => component.status === 'unsupported')) {
+        status = 'unavailable';
+    }
+    return Object.assign(Object.assign({}, plan), { status,
+        hasUpgrade,
+        required,
+        components,
+        targetsToUpdate });
 }
-
-class CheckBridgeStatus extends BaseMethod {
-    init() {
-        this.useDevice = false;
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
+function toProtocolV2FirmwareReleaseInfo({ plan, state, release, }) {
+    return {
+        shouldUpdate: plan.hasUpgrade,
+        status: plan.status === 'unavailable' ? 'unknown' : plan.status,
+        changelog: plan.release ? [plan.release.changelog] : [],
+        release,
+        bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
+    };
+}
+function getProtocolV2ComponentReleaseInfo(plan, componentTarget) {
+    var _a;
+    const componentRelease = plan.components.find(component => component.componentTarget === componentTarget);
+    if (!componentRelease || !plan.release) {
+        return undefined;
     }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                axios__default["default"]
-                    .request({
-                    url: 'http://localhost:21320',
-                    method: 'POST',
-                    withCredentials: false,
-                    timeout: 3000,
-                })
-                    .then(() => resolve(true))
-                    .catch(e => {
-                    if (e.code === 'ECONNABORTED') {
-                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError));
-                    }
-                    else {
-                        resolve(false);
-                    }
-                });
-            });
-        });
+    const component = (_a = plan.release.components) === null || _a === void 0 ? void 0 : _a[componentRelease.configKey];
+    if (!component) {
+        return undefined;
     }
+    return Object.assign(Object.assign({}, component), { protocol: 'V2', configKey: componentRelease.configKey, componentTarget, required: plan.release.required, changelog: plan.release.changelog });
 }
 
 const REQUIRED_BRIDGE_VERSION = '2.2.0';
@@ -47429,56 +47443,6 @@ function getBridgeReleaseInfo({ deviceType, currentFirmwareVersion, willUpdateFi
     });
 }
 
-class CheckBridgeRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device.features) {
-                return null;
-            }
-            const { willUpdateFirmwareVersion } = this.payload;
-            const { features } = this.device;
-            const deviceType = getDeviceType(features);
-            const currentFirmwareVersion = getDeviceFirmwareVersion(features).join('.');
-            return getBridgeReleaseInfo({
-                deviceType,
-                currentFirmwareVersion,
-                willUpdateFirmwareVersion,
-            });
-        });
-    }
-}
-
-class CheckBootloaderRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device.features) {
-                return null;
-            }
-            const { features } = this.device;
-            const payload = this.payload;
-            const deviceFirmwareType = this.device.getCurrentFirmwareType();
-            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
-            const releaseInfo = getBootloaderReleaseInfo({
-                features,
-                willUpdateFirmwareVersion: payload.willUpdateFirmwareVersion,
-                firmwareType,
-            });
-            return Promise.resolve(releaseInfo);
-        });
-    }
-}
-
 const UPDATE_TARGET_BY_COMPONENT_TARGET = {
     BOOTLOADER: 'boot',
     APPLICATION_P1: 'app_v1',
@@ -47724,24 +47688,15 @@ class CheckAllFirmwareRelease extends BaseMethod {
         });
     }
     runProtocolV2() {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
                 .payload;
-            const state = yield this.device.getDeviceState({
-                refreshSections: checkFirmwareHash
-                    ? ['identity', 'versions', 'verification']
-                    : ['identity', 'versions'],
+            const { state, features, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
+                device: this.device,
+                firmwareType: firmwareTypeParam,
+                checkFirmwareHash,
+                methodName: 'checkAllFirmwareRelease',
             });
-            if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportMethod, 'checkAllFirmwareRelease requires a Pro2 or Neo device for Protocol V2');
-            }
-            const { features } = this.device;
-            if (!features) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'checkAllFirmwareRelease requires initialized device features');
-            }
-            const firmwareType = (_a = firmwareTypeParam !== null && firmwareTypeParam !== void 0 ? firmwareTypeParam : state.identity.firmwareType) !== null && _a !== void 0 ? _a : hdShared.EFirmwareType.Universal;
-            const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
             const plan = buildProtocolV2FirmwareRelease({
                 currentVersions: state.versions,
                 currentVerification: checkFirmwareHash ? state.verification : undefined,
@@ -47753,21 +47708,211 @@ class CheckAllFirmwareRelease extends BaseMethod {
             const resourceDeviceType = state.identity.deviceType === 'neo' ? hdShared.EDeviceType.Neo : hdShared.EDeviceType.Pro2;
             const resourceSource = DataManager.getProtocolV2ResourceSource(resourceDeviceType);
             const resourceStatus = 'unknown';
-            const targetsToUpdate = [...plan.targetsToUpdate];
-            const firmwareStatus = plan.status === 'unavailable' ? 'unknown' : plan.status;
-            const emptyRelease = 'none';
-            return Object.assign(Object.assign({ firmware: {
-                    status: firmwareStatus,
-                    changelog: release ? [release.changelog] : [],
-                    release: release !== null && release !== void 0 ? release : emptyRelease,
-                    bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
-                }, ble: {
-                    status: 'valid',
-                    release: emptyRelease,
-                }, bootloader: {
-                    status: 'valid',
-                    release: emptyRelease,
-                }, features, protocol: 'V2', deviceType: state.identity.deviceType }, plan), { resourceStatus, resourceManifestUrl: resourceSource === null || resourceSource === void 0 ? void 0 : resourceSource.manifestUrl, hasUpgrade: plan.hasUpgrade, targetsToUpdate });
+            const resourcePreparationRequired = !!resourceSource;
+            const targetsToUpdate = Array.from(new Set([
+                ...plan.targetsToUpdate,
+                ...(resourcePreparationRequired ? ['resource'] : []),
+            ]));
+            const firmwarePlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_MAIN_FIRMWARE_TARGETS);
+            const blePlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BLE_TARGETS);
+            const bootloaderPlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BOOTLOADER_TARGETS);
+            const status = resourcePreparationRequired && (plan.status === 'valid' || plan.status === 'unavailable')
+                ? 'unknown'
+                : plan.status;
+            return Object.assign(Object.assign({ firmware: toProtocolV2FirmwareReleaseInfo({ plan: firmwarePlan, state, release }), ble: toProtocolV2FirmwareReleaseInfo({
+                    plan: blePlan,
+                    state,
+                    release: getProtocolV2ComponentReleaseInfo(plan, 'COPROCESSOR'),
+                }), bootloader: toProtocolV2FirmwareReleaseInfo({
+                    plan: bootloaderPlan,
+                    state,
+                    release: getProtocolV2ComponentReleaseInfo(plan, 'BOOTLOADER'),
+                }), features, protocol: 'V2', deviceType: state.identity.deviceType }, plan), { status,
+                resourceStatus, resourceArchive: resourceSource, resourcePreparationRequired, hasUpgrade: plan.hasUpgrade || resourcePreparationRequired, targetsToUpdate });
+        });
+    }
+}
+
+class CheckFirmwareRelease extends BaseMethod {
+    getSupportedProtocols() {
+        return ['V1', 'V2'];
+    }
+    init() {
+        this.allowDeviceMode = [
+            ...this.allowDeviceMode,
+            UI_REQUEST.NOT_INITIALIZE,
+            UI_REQUEST.BOOTLOADER,
+        ];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = this.payload;
+            if (this.device.isProtocolV2()) {
+                const { state, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
+                    device: this.device,
+                    firmwareType: payload.firmwareType,
+                    methodName: 'checkFirmwareRelease',
+                });
+                const plan = summarizeProtocolV2FirmwareRelease(buildProtocolV2FirmwareRelease({
+                    currentVersions: state.versions,
+                    firmwareType,
+                    release,
+                    deviceType: state.identity.deviceType,
+                }), PROTOCOL_V2_MAIN_FIRMWARE_TARGETS);
+                return toProtocolV2FirmwareReleaseInfo({ plan, state, release });
+            }
+            if (this.device.features) {
+                const deviceFirmwareType = this.device.getCurrentFirmwareType();
+                const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
+                const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
+                return releaseInfo;
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'checkFirmwareRelease requires initialized device features');
+        });
+    }
+}
+
+class CheckBLEFirmwareRelease extends BaseMethod {
+    getSupportedProtocols() {
+        return ['V1', 'V2'];
+    }
+    init() {
+        this.allowDeviceMode = [
+            ...this.allowDeviceMode,
+            UI_REQUEST.NOT_INITIALIZE,
+            UI_REQUEST.BOOTLOADER,
+        ];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.device.isProtocolV2()) {
+                const { state, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
+                    device: this.device,
+                    methodName: 'checkBLEFirmwareRelease',
+                });
+                const plan = summarizeProtocolV2FirmwareRelease(buildProtocolV2FirmwareRelease({
+                    currentVersions: state.versions,
+                    firmwareType,
+                    release,
+                    deviceType: state.identity.deviceType,
+                }), PROTOCOL_V2_BLE_TARGETS);
+                return toProtocolV2FirmwareReleaseInfo({
+                    plan,
+                    state,
+                    release: getProtocolV2ComponentReleaseInfo(plan, 'COPROCESSOR'),
+                });
+            }
+            if (this.device.features) {
+                const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+                return releaseInfo;
+            }
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'checkBLEFirmwareRelease requires initialized device features');
+        });
+    }
+}
+
+class CheckBridgeStatus extends BaseMethod {
+    init() {
+        this.useDevice = false;
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                axios__default["default"]
+                    .request({
+                    url: 'http://localhost:21320',
+                    method: 'POST',
+                    withCredentials: false,
+                    timeout: 3000,
+                })
+                    .then(() => resolve(true))
+                    .catch(e => {
+                    if (e.code === 'ECONNABORTED') {
+                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError));
+                    }
+                    else {
+                        resolve(false);
+                    }
+                });
+            });
+        });
+    }
+}
+
+class CheckBridgeRelease extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device.features) {
+                return null;
+            }
+            const { willUpdateFirmwareVersion } = this.payload;
+            const { features } = this.device;
+            const deviceType = getDeviceType(features);
+            const currentFirmwareVersion = getDeviceFirmwareVersion(features).join('.');
+            return getBridgeReleaseInfo({
+                deviceType,
+                currentFirmwareVersion,
+                willUpdateFirmwareVersion,
+            });
+        });
+    }
+}
+
+class CheckBootloaderRelease extends BaseMethod {
+    getSupportedProtocols() {
+        return ['V1', 'V2'];
+    }
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device.features) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'checkBootloaderRelease requires initialized device features');
+            }
+            const { features } = this.device;
+            const payload = this.payload;
+            if (this.device.isProtocolV2()) {
+                const { state, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
+                    device: this.device,
+                    firmwareType: payload.firmwareType,
+                    methodName: 'checkBootloaderRelease',
+                });
+                const plan = summarizeProtocolV2FirmwareRelease(buildProtocolV2FirmwareRelease({
+                    currentVersions: state.versions,
+                    firmwareType,
+                    release,
+                    deviceType: state.identity.deviceType,
+                }), PROTOCOL_V2_BOOTLOADER_TARGETS);
+                return toProtocolV2FirmwareReleaseInfo({
+                    plan,
+                    state,
+                    release: getProtocolV2ComponentReleaseInfo(plan, 'BOOTLOADER'),
+                });
+            }
+            const deviceFirmwareType = this.device.getCurrentFirmwareType();
+            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
+            const releaseInfo = getBootloaderReleaseInfo({
+                features,
+                willUpdateFirmwareVersion: payload.willUpdateFirmwareVersion,
+                firmwareType,
+            });
+            return Promise.resolve(releaseInfo);
         });
     }
 }
@@ -51391,7 +51536,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     runProtocolV2() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.captureProtocolV2PhysicalIdentity();
             const deviceFeatures = yield this.getProtocolV2DeviceFeatures();
@@ -51408,9 +51553,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
             }
             const hasExplicitResourceFiles = !!((_c = this.params.resourceFiles) === null || _c === void 0 ? void 0 : _c.length);
-            const wantsStableResources = !!((_d = this.params.targetsToUpdate) === null || _d === void 0 ? void 0 : _d.includes('resource'));
-            const wantsBootResources = !!((_e = this.params.targetsToUpdate) === null || _e === void 0 ? void 0 : _e.includes('boot_resources'));
-            const needsPreparedResources = !hasExplicitResourceFiles && (wantsStableResources || wantsBootResources);
+            const wantsResources = !!((_d = this.params.targetsToUpdate) === null || _d === void 0 ? void 0 : _d.includes('resource'));
+            const needsPreparedResources = !hasExplicitResourceFiles && wantsResources;
             let fwBinaryMap = [];
             let bootloaderBinary = null;
             let installItems;
@@ -51448,7 +51592,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 if (typeof err === 'object' &&
                     err !== null &&
                     'params' in err &&
-                    ((_f = err.params) === null || _f === void 0 ? void 0 : _f.firmwareUpdateCode) === 'FirmwareArtifactsNotPrepared') {
+                    ((_e = err.params) === null || _e === void 0 ? void 0 : _e.firmwareUpdateCode) === 'FirmwareArtifactsNotPrepared') {
                     throw err;
                 }
                 if (err instanceof hdShared.HardwareError && err.errorCode === hdShared.HardwareErrorCode.NetworkError) {
@@ -51572,7 +51716,19 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
                 const installSources = yield this.prepareProtocolV2InstallSources(firmwareType, features);
-                const resourceSources = yield this.prepareProtocolV2ResourceSources(firmwareType, features);
+                const explicitResourceBundles = this.prepareExplicitProtocolV2ResourceFiles();
+                const resourceSources = (explicitResourceBundles === null || explicitResourceBundles === void 0 ? void 0 : explicitResourceBundles.length)
+                    ? yield Promise.all(explicitResourceBundles.map((bundle) => __awaiter(this, void 0, void 0, function* () {
+                        return ({
+                            name: bundle.name,
+                            source: yield this.openProtocolV2MemorySource(bundle.binary),
+                            devicePath: bundle.devicePath,
+                            version: bundle.version,
+                            payloadHash: bundle.payloadHash,
+                            headerHash: bundle.headerHash,
+                        });
+                    })))
+                    : yield this.prepareProtocolV2ResourceSources(firmwareType, features);
                 if (installSources.length === 0 && resourceSources.length === 0) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
                 }
@@ -51888,11 +52044,14 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 })) {
                 throw new Error(`resourceFiles[${index}] SHA-256 mismatch`);
             }
-            return {
-                name: (_a = devicePath.split('/').pop()) !== null && _a !== void 0 ? _a : devicePath,
-                binary: file.binary,
-                devicePath,
-            };
+            const header = parseProtocolV2OkppHeader(toProtocolV2Bytes(file.binary));
+            return Object.assign({ name: (_a = devicePath.split('/').pop()) !== null && _a !== void 0 ? _a : devicePath, binary: file.binary, devicePath }, (header
+                ? {
+                    version: header.version,
+                    payloadHash: header.payloadHash,
+                    headerHash: header.headerHash,
+                }
+                : {}));
         });
         if (new Set(prepared.map(file => file.devicePath)).size !== prepared.length) {
             throw new Error('resourceFiles contain duplicate devicePath values');
@@ -51955,7 +52114,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             if ((_a = this.params) === null || _a === void 0 ? void 0 : _a.forcedUpdateRes)
                 return false;
-            if (!bundle.version && !bundle.payloadHash)
+            if (!bundle.payloadHash || !bundle.headerHash)
                 return false;
             try {
                 const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath);
@@ -51966,16 +52125,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     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;
-                }
+                const expectedPayloadHash = normalizeProtocolV2Hex(bundle.payloadHash);
+                const expectedHeaderHash = normalizeProtocolV2Hex(bundle.headerHash);
+                if (!expectedPayloadHash || header.payloadHash !== expectedPayloadHash)
+                    return false;
+                if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash)
+                    return false;
                 return true;
             }
             catch (error) {
@@ -52179,6 +52334,9 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         name: bundle.name,
                         source: yield this.openProtocolV2MemorySource(bundle.binary),
                         devicePath: bundle.devicePath,
+                        version: bundle.version,
+                        payloadHash: bundle.payloadHash,
+                        headerHash: bundle.headerHash,
                     });
                 })));
                 return yield this.executeProtocolV2Phases({
@@ -64936,7 +65094,6 @@ exports.preloadSessionCache = preloadSessionCache;
 exports.prepareProtocolV2ResourceFiles = prepareProtocolV2ResourceFiles;
 exports.projectDeviceStateFeatures = projectFeatures;
 exports.registerFirmwareUpdateHostBinding = registerFirmwareUpdateHostBinding;
-exports.resolveProtocolV2ResourceManifestFileUrl = resolveProtocolV2ResourceManifestFileUrl;
 exports.safeThrowError = safeThrowError;
 exports.selectProtocolV2ResourceManifestFiles = selectProtocolV2ResourceManifestFiles;
 exports.setLoggerPostMessage = setLoggerPostMessage;

package/dist/protocols/protocol-v2/resources.d.ts

@@ -9,10 +9,6 @@ export declare function selectProtocolV2ResourceManifestFiles({ manifest, target
     manifest: IProtocolV2ResourceManifest;
     targetsToUpdate: readonly FirmwareUpdateV4Target[];
 }): IProtocolV2ResourceManifestFile[];
-export declare function resolveProtocolV2ResourceManifestFileUrl({ manifestUrl, archivePath, }: {
-    manifestUrl: string;
-    archivePath: string;
-}): string;
 export declare function prepareProtocolV2ResourceFiles({ manifest: value, files, targetsToUpdate, }: {
     manifest: unknown;
     files: Array<{

package/dist/protocols/protocol-v2/resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/resources.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,2BAA2B,EAC3B,+BAA+B,EAC/B,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E,eAAO,MAAM,sCAAsC,iDACH,CAAC;AACjD,eAAO,MAAM,8CAA8C,QAAsD,CAAC;AAClH,eAAO,MAAM,mCAAmC,mCAAmC,CAAC;AAkBpF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,GAAG,SAAS,CAgBzF;AA0FD,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,2BAA2B,CAmD3F;AAED,wBAAgB,qCAAqC,CAAC,EACpD,QAAQ,EACR,eAAe,GAChB,EAAE;IACD,QAAQ,EAAE,2BAA2B,CAAC;IACtC,eAAe,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACpD,GAAG,+BAA+B,EAAE,CAQpC;AAED,wBAAgB,wCAAwC,CAAC,EACvD,WAAW,EACX,WAAW,GACZ,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,MAAM,CAMT;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,QAAQ,EAAE,KAAK,EACf,KAAK,EACL,eAAe,GAChB,EAAE;IACD,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;IAC3D,eAAe,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACpD,GAAG,KAAK,CAAC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAsBrF;AAOD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC3C,OAAO,CAGT"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/resources.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,2BAA2B,EAC3B,+BAA+B,EAC/B,oBAAoB,EACrB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAE7E,eAAO,MAAM,sCAAsC,iDACH,CAAC;AACjD,eAAO,MAAM,8CAA8C,QAAsD,CAAC;AAClH,eAAO,MAAM,mCAAmC,mCAAmC,CAAC;AAkBpF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,oBAAoB,GAAG,SAAS,CA8BzF;AA0FD,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,OAAO,GAAG,2BAA2B,CAmD3F;AAED,wBAAgB,qCAAqC,CAAC,EACpD,QAAQ,EACR,eAAe,GAChB,EAAE;IACD,QAAQ,EAAE,2BAA2B,CAAC;IACtC,eAAe,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACpD,GAAG,+BAA+B,EAAE,CAEpC;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,QAAQ,EAAE,KAAK,EACf,KAAK,EACL,eAAe,GAChB,EAAE;IACD,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;IAC3D,eAAe,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACpD,GAAG,KAAK,CAAC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAsBrF;AAOD,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC3C,OAAO,CAGT"}