@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/data/firmwareInfo.d.ts

@@ -1,14 +1,8 @@
-import { ConditionalRelease, DeviceModelInternal, FirmwareRelease, FirmwareReleaseConfig, FirmwareType, IntermediaryReleaseConfig, VersionArray } from '@trezor/device-utils';
-import { Features } from '../types/device';
-import { FirmwareReleaseConfigInfo, FirmwareUpdateSource } from '../types/firmware';
-interface RemoteBaseInfo {
-    BASE_URL: string;
-    MIDDLE_PATH: string;
-}
-type OnlineFirmwareBaseUrl = RemoteBaseInfo & {
-    env: FirmwareUpdateSource;
-};
-export declare const getOnlineFirmwareBaseUrl: () => OnlineFirmwareBaseUrl;
+import type { Features } from '@trezor/connect-common/lib/types/device';
+import type { FirmwareReleaseConfigInfo } from '@trezor/connect-common/lib/types/firmware';
+import type { ConditionalRelease, FirmwareRelease, FirmwareReleaseConfig, IntermediaryReleaseConfig } from '@trezor/device-utils';
+import { DeviceModelInternal, FirmwareType } from '@trezor/device-utils';
+import type { VersionArray } from '@trezor/utils/lib/versionUtils';
 export declare const getBundledRelease: (deviceModel: DeviceModelInternal, firmwareType: FirmwareType) => FirmwareRelease | undefined;
 export declare const getOnlineReleaseByVersion: (deviceModel: DeviceModelInternal, firmwareVersion: VersionArray, firmwareType: FirmwareType) => Promise<FirmwareRelease | undefined>;
 export declare const getReleaseConfig: (features: Features, firmwareType: FirmwareType) => ConditionalRelease | undefined;
@@ -16,38 +10,46 @@ export declare const getReleaseByVersion: (features: Features, firmwareVersion:
 export declare const createLocalFirmwareConfig: (baseConfig: FirmwareReleaseConfig) => any;
 export declare const createRemoteFirmwareConfig: (config: FirmwareReleaseConfig) => Promise<any>;
 export declare const initializeFirmwareConfig: (config: FirmwareReleaseConfig, isRemote: boolean) => Promise<{
-    releases: any;
-    intermediaries: Record<DeviceModelInternal, IntermediaryReleaseConfig[]>;
+  releases: any;
+  intermediaries: Record<DeviceModelInternal, IntermediaryReleaseConfig[]>;
 }>;
 export declare const getLanguage: (languageBinPath: string) => Promise<ArrayBuffer | Buffer<ArrayBufferLike>>;
-export type CurrentVersion = {
-    bootloaderVersion: VersionArray | null;
-    firmwareVersion: VersionArray | null;
-};
-export declare const getCurrentVersion: (features: Features) => CurrentVersion;
+export type { CurrentVersion } from '@trezor/connect-common/lib/types/firmware';
 interface GetReleaseInfoParams {
-    features: Features;
-    release: FirmwareRelease;
-    conditions: ConditionalRelease['conditions'];
-    intermediary: IntermediaryReleaseConfig | undefined;
-    firmwareType: FirmwareType;
-    isBitcoinOnlyAvailable: boolean;
-    releasesOfDevice: FirmwareRelease[];
+  features: Features;
+  release: FirmwareRelease;
+  conditions: ConditionalRelease['conditions'];
+  intermediary: IntermediaryReleaseConfig | undefined;
+  firmwareType: FirmwareType;
+  isBitcoinOnlyAvailable: boolean;
+  releasesOfDevice: FirmwareRelease[];
 }
-export declare const getReleaseInfo: ({ features, release, conditions, intermediary, firmwareType, isBitcoinOnlyAvailable, releasesOfDevice, }: GetReleaseInfoParams) => FirmwareReleaseConfigInfo;
+export declare const getReleaseInfo: ({
+  features,
+  release,
+  conditions,
+  intermediary,
+  firmwareType,
+  isBitcoinOnlyAvailable,
+  releasesOfDevice
+}: GetReleaseInfoParams) => FirmwareReleaseConfigInfo;
 export declare const getFirmwareReleaseConfigInfo: (features: Features, firmwareType: FirmwareType) => FirmwareReleaseConfigInfo | undefined;
-export declare const getFirmwareStatus: (features: Features, firmwareType: FirmwareType) => "valid" | "outdated" | "required" | "unknown" | "custom" | "none";
+export declare const getFirmwareStatus: (features: Features, firmwareType: FirmwareType) => "custom" | "valid" | "outdated" | "required" | "unknown" | "none";
 type GetFirmwareLocationParam = {
-    firmwareVersion: VersionArray;
-    remotePath: string;
-    deviceModel: DeviceModelInternal;
-    firmwareType: FirmwareType;
-    intermediaryVersion?: number;
+  firmwareVersion: VersionArray;
+  remotePath: string;
+  deviceModel: DeviceModelInternal;
+  firmwareType: FirmwareType;
+  intermediaryVersion?: number;
 };
 type FirmwareLocationPathParams = {
-    baseUrl: string;
-    path: string;
+  baseUrl: string;
+  path: string;
 };
-export declare const getFirmwareLocation: ({ firmwareVersion, remotePath, deviceModel, firmwareType, intermediaryVersion, }: GetFirmwareLocationParam) => FirmwareLocationPathParams;
-export {};
-//# sourceMappingURL=firmwareInfo.d.ts.map
+export declare const getFirmwareLocation: ({
+  firmwareVersion,
+  remotePath,
+  deviceModel,
+  firmwareType,
+  intermediaryVersion
+}: GetFirmwareLocationParam) => FirmwareLocationPathParams;

package/lib/data/firmwareInfo.js

@@ -1,63 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getFirmwareLocation = exports.getFirmwareStatus = exports.getFirmwareReleaseConfigInfo = exports.getReleaseInfo = exports.getCurrentVersion = exports.getLanguage = exports.initializeFirmwareConfig = exports.createRemoteFirmwareConfig = exports.createLocalFirmwareConfig = exports.getReleaseByVersion = exports.getReleaseConfig = exports.getOnlineReleaseByVersion = exports.getBundledRelease = exports.getOnlineFirmwareBaseUrl = void 0;
-const device_utils_1 = require("@trezor/device-utils");
-const utils_1 = require("@trezor/utils");
-const DataManager_1 = require("./DataManager");
-const assetUtils_1 = require("../utils/assetUtils");
-const assets_1 = require("../utils/assets");
-const firmwareUtils_1 = require("../utils/firmwareUtils");
-const RELEASES_URL_REMOTE_BASE = {
-  BASE_URL: 'https://data.trezor.io',
-  MIDDLE_PATH: 'firmware'
-};
-const UNSIGNED_URL_REMOTE_BASE = {
-  BASE_URL: 'https://data.trezor.io',
-  MIDDLE_PATH: 'dev/firmware/releases/unsigned'
-};
-const UNSIGNED_STABLE_URL_REMOTE_BASE = {
-  BASE_URL: 'https://data.trezor.io',
-  MIDDLE_PATH: 'dev/firmware/releases/unsigned-stable'
-};
-const SIGNED_URL_REMOTE_BASE = {
-  BASE_URL: 'https://suite.corp.sldev.cz',
-  MIDDLE_PATH: 'firmware/signed'
-};
-const SIGNED_LOCALHOST = {
-  BASE_URL: 'http://localhost:3000',
-  MIDDLE_PATH: 'firmware/signed'
-};
-const UNSIGNED_LOCALHOST = {
-  BASE_URL: 'http://localhost:3000',
-  MIDDLE_PATH: 'firmware/unsigned'
-};
-const FIRMWARE_REMOTE_BASE_URLS = {
-  production: RELEASES_URL_REMOTE_BASE,
-  'test-unsigned': UNSIGNED_URL_REMOTE_BASE,
-  'test-unsigned-stable': UNSIGNED_STABLE_URL_REMOTE_BASE,
-  'test-signed': SIGNED_URL_REMOTE_BASE,
-  'localhost-unsigned': UNSIGNED_LOCALHOST,
-  'localhost-signed': SIGNED_LOCALHOST
-};
-const getOnlineFirmwareBaseUrl = () => {
-  const firmwareUpdateSource = DataManager_1.DataManager.getSettings('firmwareUpdateSource');
-  if (!firmwareUpdateSource) {
-    return {
-      ...FIRMWARE_REMOTE_BASE_URLS['production'],
-      env: 'production'
-    };
-  }
-  return {
-    ...FIRMWARE_REMOTE_BASE_URLS[firmwareUpdateSource],
-    env: firmwareUpdateSource
-  };
-};
-exports.getOnlineFirmwareBaseUrl = getOnlineFirmwareBaseUrl;
+import { DeviceModelInternal, FirmwareType, getBootloaderVersionArray, getFirmwareOrBootloaderVersionArray, getFirmwareVersionArray } from "@trezor/device-utils";
+import { getIntegerInRangeFromString, isNotNull, removeTrailingSlashes, versionUtils } from "@trezor/utils";
+import * as firmwareReleaseStore from "./firmwareReleaseStore.js";
+import * as localFirmwareStore from "./localFirmwareStore.js";
+import * as settingsStore from "./settingsStore.js";
+import { getReleaseAsset, getReleasesAssetByDeviceModelAndFirmwareType } from "../utils/assetUtils.js";
+import { httpRequest } from "../utils/assets.js";
+import { getOnlineFirmwareBaseUrl } from "../utils/firmwareReleaseConfigUtils.js";
+import { buildIntermediaryFirmwareFileName, buildLocalFirmwareFileName, buildLocalReleaseName, findBestCompatibleRelease, isFirmwareCacheUsedForSelectedSource, isProductionFirmwareChannel, isStrictFeatures } from "../utils/firmwareUtils.js";
 const getBundledFirmwareVersion = (deviceModel, firmwareType) => {
-  const localFirmwareReleaseConfig = DataManager_1.DataManager.getLocalFirmwareReleaseConfig();
+  const localFirmwareReleaseConfig = firmwareReleaseStore.getLocal();
   const modelReleases = localFirmwareReleaseConfig.releases[deviceModel];
   const bundledRelease = modelReleases?.[firmwareType];
   if (!bundledRelease) {
@@ -69,52 +20,50 @@ const getBundledFirmwareVersion = (deviceModel, firmwareType) => {
   }
   return bundledVersion[0];
 };
-const getBundledRelease = (deviceModel, firmwareType) => {
+export const getBundledRelease = (deviceModel, firmwareType) => {
   const version = getBundledFirmwareVersion(deviceModel, firmwareType);
   if (!version) {
     return;
   }
-  const versionArray = utils_1.versionUtils.tryParse(version);
+  const versionArray = versionUtils.tryParse(version);
   if (!versionArray) {
     throw new Error('There was error parsing bundled release.');
   }
-  return (0, assetUtils_1.getReleaseAsset)(deviceModel, versionArray, firmwareType);
+  return getReleaseAsset(deviceModel, versionArray, firmwareType);
 };
-exports.getBundledRelease = getBundledRelease;
 const getOnlineReleaseByPath = async releasePath => {
-  const onlineFirmwareBaseUrl = (0, exports.getOnlineFirmwareBaseUrl)();
+  const onlineFirmwareBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
   const url = `${onlineFirmwareBaseUrl.BASE_URL}/${releasePath}`;
-  const response = await (0, assets_1.httpRequest)(url, 'json', {
+  const response = await httpRequest(url, 'json', {
     signal: AbortSignal.timeout(10000),
     skipLocalForceDownload: true
   });
   return response;
 };
 const getOnlineReleasePath = (deviceModel, firmwareVersion, firmwareType) => {
-  const onlineFirmwareBaseUrl = (0, exports.getOnlineFirmwareBaseUrl)();
-  const firmwareTypeFileString = firmwareType === device_utils_1.FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
+  const onlineFirmwareBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
+  const firmwareTypeFileString = firmwareType === FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
   const relaseJsonFilename = `${deviceModel.toLowerCase()}-${firmwareVersion.join('.')}-${firmwareTypeFileString}.json`;
   const origin = `${onlineFirmwareBaseUrl.MIDDLE_PATH}/${deviceModel.toLowerCase()}/${firmwareTypeFileString}`;
   const releasePath = `${origin}/${relaseJsonFilename}`;
   return releasePath;
 };
-const getOnlineReleaseByVersion = async (deviceModel, firmwareVersion, firmwareType) => {
+export const getOnlineReleaseByVersion = async (deviceModel, firmwareVersion, firmwareType) => {
   const releasePath = getOnlineReleasePath(deviceModel, firmwareVersion, firmwareType);
   const onlineRelease = await getOnlineReleaseByPath(releasePath);
-  if (!onlineRelease || !utils_1.versionUtils.isEqual(onlineRelease.version, firmwareVersion)) {
+  if (!onlineRelease || !versionUtils.isEqual(onlineRelease.version, firmwareVersion)) {
     return;
   }
   return onlineRelease;
 };
-exports.getOnlineReleaseByVersion = getOnlineReleaseByVersion;
-const getReleaseConfig = (features, firmwareType) => {
+export const getReleaseConfig = (features, firmwareType) => {
   const {
     internal_model
   } = features;
-  if (internal_model === device_utils_1.DeviceModelInternal.UNKNOWN) {
+  if (internal_model === DeviceModelInternal.UNKNOWN) {
     return undefined;
   }
-  const firmwareReleaseConfig = DataManager_1.DataManager.getFirmwareReleaseConfig();
+  const firmwareReleaseConfig = firmwareReleaseStore.getReleases();
   if (!firmwareReleaseConfig) {
     throw new Error('Firmware release config not loaded.');
   }
@@ -124,9 +73,9 @@ const getReleaseConfig = (features, firmwareType) => {
   }
   return deviceMessageRelease[firmwareType];
 };
-exports.getReleaseConfig = getReleaseConfig;
-const getReleaseByVersion = async (features, firmwareVersion, firmwareType) => {
+export const getReleaseByVersion = async (features, firmwareVersion, firmwareType) => {
   const deviceModel = features.internal_model;
+  const firmwareChannel = settingsStore.get('firmwareChannel');
   const tryGetRelease = async getter => {
     try {
       return await getter();
@@ -134,58 +83,57 @@ const getReleaseByVersion = async (features, firmwareVersion, firmwareType) => {
       return;
     }
   };
-  const releaseFromConfig = (0, exports.getReleaseConfig)(features, firmwareType)?.release;
-  if (releaseFromConfig && utils_1.versionUtils.isEqual(firmwareVersion, releaseFromConfig.version)) {
+  const releaseFromConfig = getReleaseConfig(features, firmwareType)?.release;
+  if (releaseFromConfig && versionUtils.isEqual(firmwareVersion, releaseFromConfig.version)) {
     return releaseFromConfig;
   }
-  const releaseName = (0, firmwareUtils_1.buildLocalReleaseName)(firmwareType, deviceModel, firmwareVersion);
+  const releaseName = buildLocalReleaseName(firmwareType, deviceModel, firmwareVersion);
   const {
     firmwareDir,
     firmwareList
-  } = DataManager_1.DataManager.getLocalFirmwares();
-  if ((0, firmwareUtils_1.isFirmwareCacheUsedForSelectedSource)() && firmwareList.includes(releaseName)) {
+  } = localFirmwareStore.get();
+  if (isFirmwareCacheUsedForSelectedSource(firmwareChannel) && firmwareList.includes(releaseName)) {
     const localReleasePath = `${firmwareDir}${releaseName}`;
-    const localReleaseBuffer = await (0, assets_1.httpRequest)(localReleasePath, 'json');
+    const localReleaseBuffer = await httpRequest(localReleasePath, 'json');
     return JSON.parse(localReleaseBuffer.toString());
   }
-  const release = (await tryGetRelease(() => (0, assetUtils_1.getReleaseAsset)(deviceModel, firmwareVersion, firmwareType))) || (await tryGetRelease(() => (0, exports.getOnlineReleaseByVersion)(deviceModel, firmwareVersion, firmwareType)));
-  if (release && utils_1.versionUtils.isEqual(release.version, firmwareVersion)) {
+  const useBundledRelease = isProductionFirmwareChannel(firmwareChannel);
+  const release = (useBundledRelease ? await tryGetRelease(() => getReleaseAsset(deviceModel, firmwareVersion, firmwareType)) : undefined) || (await tryGetRelease(() => getOnlineReleaseByVersion(deviceModel, firmwareVersion, firmwareType)));
+  if (release && versionUtils.isEqual(release.version, firmwareVersion)) {
     return release;
   }
   return;
 };
-exports.getReleaseByVersion = getReleaseByVersion;
-const createLocalFirmwareConfig = baseConfig => {
+export const createLocalFirmwareConfig = baseConfig => {
   const releaseEntries = Object.entries(baseConfig.releases).map(([deviceModel, modelReleases]) => {
     const modelKey = deviceModel;
-    if (modelKey === device_utils_1.DeviceModelInternal.UNKNOWN) return null;
+    if (modelKey === DeviceModelInternal.UNKNOWN) return null;
     const {
       'bitcoin-only': bitcoinOnlyConfig,
       universal: universalConfig
     } = modelReleases ?? {};
     if (!bitcoinOnlyConfig?.releasePath || !universalConfig?.releasePath) return null;
-    const btcOnlyRelease = (0, exports.getBundledRelease)(modelKey, device_utils_1.FirmwareType.BitcoinOnly);
-    const universalRelease = (0, exports.getBundledRelease)(modelKey, device_utils_1.FirmwareType.Universal);
+    const btcOnlyRelease = getBundledRelease(modelKey, FirmwareType.BitcoinOnly);
+    const universalRelease = getBundledRelease(modelKey, FirmwareType.Universal);
     if (!btcOnlyRelease || !universalRelease) return null;
     const releases = {
-      [device_utils_1.FirmwareType.BitcoinOnly]: {
+      [FirmwareType.BitcoinOnly]: {
         ...bitcoinOnlyConfig,
         release: btcOnlyRelease
       },
-      [device_utils_1.FirmwareType.Universal]: {
+      [FirmwareType.Universal]: {
         ...universalConfig,
         release: universalRelease
       }
     };
     return [modelKey, releases];
-  }).filter(entry => entry !== null);
+  }).filter(isNotNull);
   return Object.fromEntries(releaseEntries);
 };
-exports.createLocalFirmwareConfig = createLocalFirmwareConfig;
-const createRemoteFirmwareConfig = async config => {
+export const createRemoteFirmwareConfig = async config => {
   const releaseEntryPromises = Object.entries(config.releases).map(async ([deviceModel, modelReleases]) => {
     const modelKey = deviceModel;
-    if (modelKey === device_utils_1.DeviceModelInternal.UNKNOWN) return null;
+    if (modelKey === DeviceModelInternal.UNKNOWN) return null;
     const {
       'bitcoin-only': bitcoinOnlyConfig,
       universal: universalConfig
@@ -194,70 +142,59 @@ const createRemoteFirmwareConfig = async config => {
     const [bitcoinOnlyRelease, universalRelease] = await Promise.all([getOnlineReleaseByPath(bitcoinOnlyConfig.releasePath), getOnlineReleaseByPath(universalConfig.releasePath)]);
     if (!universalRelease || !bitcoinOnlyRelease) return null;
     const releases = {
-      [device_utils_1.FirmwareType.BitcoinOnly]: {
+      [FirmwareType.BitcoinOnly]: {
         ...bitcoinOnlyConfig,
         release: bitcoinOnlyRelease
       },
-      [device_utils_1.FirmwareType.Universal]: {
+      [FirmwareType.Universal]: {
         ...universalConfig,
         release: universalRelease
       }
     };
     return [modelKey, releases];
   });
-  const validEntries = (await Promise.all(releaseEntryPromises)).filter(entry => entry !== null);
+  const validEntries = (await Promise.all(releaseEntryPromises)).filter(isNotNull);
   return Object.fromEntries(validEntries);
 };
-exports.createRemoteFirmwareConfig = createRemoteFirmwareConfig;
-const initializeFirmwareConfig = async (config, isRemote) => {
+export const initializeFirmwareConfig = async (config, isRemote) => {
   if (isRemote) {
     try {
-      const remoteReleases = await (0, exports.createRemoteFirmwareConfig)(config);
+      const remoteReleases = await createRemoteFirmwareConfig(config);
       return {
         releases: remoteReleases,
         intermediaries: config.intermediaries
       };
     } catch {}
   }
-  const localFirmwareReleaseConfig = DataManager_1.DataManager.getLocalFirmwareReleaseConfig();
-  const localReleases = (0, exports.createLocalFirmwareConfig)(localFirmwareReleaseConfig);
+  const localFirmwareReleaseConfig = firmwareReleaseStore.getLocal();
+  const localReleases = createLocalFirmwareConfig(localFirmwareReleaseConfig);
   return {
     releases: localReleases,
     intermediaries: localFirmwareReleaseConfig.intermediaries
   };
 };
-exports.initializeFirmwareConfig = initializeFirmwareConfig;
-const getLanguage = languageBinPath => {
-  const baseUrl = (0, exports.getOnlineFirmwareBaseUrl)();
+export const getLanguage = languageBinPath => {
+  const baseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
   const url = `${baseUrl.BASE_URL}/${languageBinPath}`;
-  return (0, assets_1.httpRequest)(url, 'binary');
+  return httpRequest(url, 'binary');
 };
-exports.getLanguage = getLanguage;
 const getCurrentVersion = features => {
-  if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
+  if (!isStrictFeatures(features)) {
     throw new Error('Features of unexpected shape provided.');
   }
-  const {
-    bootloader_mode,
-    major_version,
-    minor_version,
-    patch_version,
-    fw_major,
-    fw_minor,
-    fw_patch
-  } = features;
-  const fw_version = [fw_major, fw_minor, fw_patch];
-  const version = [major_version, minor_version, patch_version];
-  const bootloaderVersion = bootloader_mode ? version : null;
-  const fwVersion = bootloader_mode ? fw_version : version;
+  const bootloaderVersion = getBootloaderVersionArray({
+    features
+  });
+  const firmwareVersion = getFirmwareVersionArray({
+    features
+  });
   return {
     bootloaderVersion,
-    firmwareVersion: fwVersion.includes(null) ? null : fwVersion
+    firmwareVersion
   };
 };
-exports.getCurrentVersion = getCurrentVersion;
 const getIntermediaryMessageRelease = features => {
-  const config = DataManager_1.DataManager.getFirmwareIntermediaryReleaseConfig();
+  const config = firmwareReleaseStore.getIntermediary();
   if (!config) {
     throw new Error('Firmware release config not loaded.');
   }
@@ -268,27 +205,27 @@ const getIntermediaryMessageRelease = features => {
   const {
     bootloaderVersion,
     firmwareVersion
-  } = (0, exports.getCurrentVersion)(features);
+  } = getCurrentVersion(features);
   const currentVersion = features.bootloader_mode ? bootloaderVersion : firmwareVersion;
   const minVersionKey = features.bootloader_mode ? 'min_bootloader_version' : 'min_firmware_version';
   if (!currentVersion) {
     return undefined;
   }
-  return deviceIntermediaryReleases.find(release => utils_1.versionUtils.isNewer(release[minVersionKey], currentVersion));
+  return deviceIntermediaryReleases.find(release => versionUtils.isNewer(release[minVersionKey], currentVersion));
 };
 const getIsBitcoinOnlyAvailable = features => {
   const {
     internal_model
   } = features;
-  if (internal_model === device_utils_1.DeviceModelInternal.UNKNOWN) {
+  if (internal_model === DeviceModelInternal.UNKNOWN) {
     return false;
   }
-  const firmwareReleaseConfig = DataManager_1.DataManager.getFirmwareReleaseConfig();
+  const firmwareReleaseConfig = firmwareReleaseStore.getReleases();
   if (!firmwareReleaseConfig) {
     throw new Error('Firmware release config not loaded.');
   }
   const deviceMessageRelease = firmwareReleaseConfig[internal_model];
-  return !!deviceMessageRelease && !!deviceMessageRelease[device_utils_1.FirmwareType.BitcoinOnly];
+  return !!deviceMessageRelease && !!deviceMessageRelease[FirmwareType.BitcoinOnly];
 };
 const isValidConditionalRelease = release => !!(release.version && release.min_firmware_version && release.min_bootloader_version);
 const calculateShouldOfferRelease = (rolloutProbability, deviceId) => {
@@ -298,7 +235,7 @@ const calculateShouldOfferRelease = (rolloutProbability, deviceId) => {
   if (deviceId === null) {
     return rolloutProbability > 0;
   } else {
-    const deterministicValueToCompare = (0, utils_1.getIntegerInRangeFromString)(deviceId, 101);
+    const deterministicValueToCompare = getIntegerInRangeFromString(deviceId, 101);
     return deterministicValueToCompare < rolloutProbability;
   }
 };
@@ -308,17 +245,17 @@ const getChangelog = (releases, features) => {
       return null;
     }
     if (features.firmware_present && features.major_version === 2) {
-      return releases.filter(r => utils_1.versionUtils.isNewer(r.version, [features.fw_major, features.fw_minor, features.fw_patch]));
+      return releases.filter(r => versionUtils.isNewer(r.version, [features.fw_major, features.fw_minor, features.fw_patch]));
     }
     return releases;
   }
-  return releases.filter(r => utils_1.versionUtils.isNewer(r.version, [features.major_version, features.minor_version, features.patch_version]));
+  return releases.filter(r => versionUtils.isNewer(r.version, getFirmwareOrBootloaderVersionArray(features)));
 };
 const isRequired = changelog => {
-  if (!changelog || !changelog.length) return null;
+  if (!changelog?.length) return null;
   return changelog.some(item => item.required);
 };
-const getReleaseInfo = ({
+export const getReleaseInfo = ({
   features,
   release,
   conditions,
@@ -327,7 +264,7 @@ const getReleaseInfo = ({
   isBitcoinOnlyAvailable,
   releasesOfDevice
 }) => {
-  if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
+  if (!isStrictFeatures(features)) {
     throw new Error('Features of unexpected shape provided.');
   }
   if (!isValidConditionalRelease(release)) {
@@ -344,25 +281,25 @@ const getReleaseInfo = ({
     const {
       bootloaderVersion,
       firmwareVersion
-    } = (0, exports.getCurrentVersion)(features);
-    if (utils_1.versionUtils.isVersionArray(firmwareVersion)) {
-      isNewer = utils_1.versionUtils.isNewer(release.version, firmwareVersion);
-      requiresIntermediary = utils_1.versionUtils.isNewer(min_firmware_version, firmwareVersion);
-    } else if (utils_1.versionUtils.isVersionArray(bootloaderVersion)) {
-      isNewer = utils_1.versionUtils.isNewer(release.bootloader_version, bootloaderVersion);
-      requiresIntermediary = utils_1.versionUtils.isNewer(min_bootloader_version, bootloaderVersion);
+    } = getCurrentVersion(features);
+    if (versionUtils.isVersionArray(firmwareVersion)) {
+      isNewer = versionUtils.isNewer(release.version, firmwareVersion);
+      requiresIntermediary = versionUtils.isNewer(min_firmware_version, firmwareVersion);
+    } else if (versionUtils.isVersionArray(bootloaderVersion)) {
+      isNewer = versionUtils.isNewer(release.bootloader_version, bootloaderVersion);
+      requiresIntermediary = versionUtils.isNewer(min_bootloader_version, bootloaderVersion);
     } else {
       throw new Error('Version is not version array.');
     }
   } else {
     const {
       firmwareVersion
-    } = (0, exports.getCurrentVersion)(features);
-    if (!utils_1.versionUtils.isVersionArray(firmwareVersion)) {
+    } = getCurrentVersion(features);
+    if (!versionUtils.isVersionArray(firmwareVersion)) {
       throw new Error('Firmware version is not version array.');
     }
-    isNewer = utils_1.versionUtils.isNewer(release.version, firmwareVersion);
-    requiresIntermediary = utils_1.versionUtils.isNewer(min_firmware_version, firmwareVersion);
+    isNewer = versionUtils.isNewer(release.version, firmwareVersion);
+    requiresIntermediary = versionUtils.isNewer(min_firmware_version, firmwareVersion);
   }
   const {
     rollout_probability
@@ -385,9 +322,8 @@ const getReleaseInfo = ({
     translations: release.translations
   };
 };
-exports.getReleaseInfo = getReleaseInfo;
-const getFirmwareReleaseConfigInfo = (features, firmwareType) => {
-  const deviceMessageRelease = (0, exports.getReleaseConfig)(features, firmwareType);
+export const getFirmwareReleaseConfigInfo = (features, firmwareType) => {
+  const deviceMessageRelease = getReleaseConfig(features, firmwareType);
   if (!deviceMessageRelease?.release) {
     return;
   }
@@ -396,7 +332,7 @@ const getFirmwareReleaseConfigInfo = (features, firmwareType) => {
     conditions,
     firmware_type
   } = deviceMessageRelease;
-  const currentVersion = (0, exports.getCurrentVersion)(features);
+  const currentVersion = getCurrentVersion(features);
   const inBootloaderMode = features.bootloader_mode && !!currentVersion.bootloaderVersion;
   const versionContext = inBootloaderMode ? {
     version: currentVersion.bootloaderVersion,
@@ -405,18 +341,18 @@ const getFirmwareReleaseConfigInfo = (features, firmwareType) => {
     version: currentVersion.firmwareVersion,
     minVersionKey: 'min_firmware_version'
   };
-  const isCompatible = versionContext.version && utils_1.versionUtils.isNewerOrEqual(versionContext.version, release[versionContext.minVersionKey]);
-  const releasesOfDevice = (0, assetUtils_1.getReleasesAssetByDeviceModelAndFirmwareType)(features.internal_model, firmwareType);
+  const isCompatible = versionContext.version && versionUtils.isNewerOrEqual(versionContext.version, release[versionContext.minVersionKey]);
+  const releasesOfDevice = getReleasesAssetByDeviceModelAndFirmwareType(features.internal_model, firmwareType);
   let suitableRelease = release;
   if (!isCompatible) {
-    const alternativeRelease = (0, firmwareUtils_1.findBestCompatibleRelease)(releasesOfDevice, currentVersion, versionContext.minVersionKey);
+    const alternativeRelease = findBestCompatibleRelease(releasesOfDevice, currentVersion, versionContext.minVersionKey);
     if (alternativeRelease) {
       suitableRelease = alternativeRelease;
     }
   }
   const intermediary = getIntermediaryMessageRelease(features);
   const finalTargetRelease = intermediary ? release : suitableRelease;
-  return (0, exports.getReleaseInfo)({
+  return getReleaseInfo({
     isBitcoinOnlyAvailable: getIsBitcoinOnlyAvailable(features),
     features,
     release: finalTargetRelease,
@@ -426,31 +362,29 @@ const getFirmwareReleaseConfigInfo = (features, firmwareType) => {
     releasesOfDevice
   });
 };
-exports.getFirmwareReleaseConfigInfo = getFirmwareReleaseConfigInfo;
-const getFirmwareStatus = (features, firmwareType) => {
+export const getFirmwareStatus = (features, firmwareType) => {
   if (features.firmware_present === false) {
     return 'none';
   }
   if (features.major_version === 1 && features.bootloader_mode) {
     return 'unknown';
   }
-  const releaseInfo = (0, exports.getFirmwareReleaseConfigInfo)(features, firmwareType);
+  const releaseInfo = getFirmwareReleaseConfigInfo(features, firmwareType);
   if (!releaseInfo) return 'custom';
   if (releaseInfo.isRequired) return 'required';
   if (releaseInfo.isNewer) return 'outdated';
   return 'valid';
 };
-exports.getFirmwareStatus = getFirmwareStatus;
-const getFirmwareLocation = ({
+export const getFirmwareLocation = ({
   firmwareVersion,
   remotePath,
   deviceModel,
   firmwareType,
   intermediaryVersion
 }) => {
-  const firmwareName = intermediaryVersion ? (0, firmwareUtils_1.buildIntermediaryFirmwareFileName)(deviceModel, intermediaryVersion) : (0, firmwareUtils_1.buildLocalFirmwareFileName)(firmwareType, deviceModel, firmwareVersion);
+  const firmwareName = intermediaryVersion ? buildIntermediaryFirmwareFileName(deviceModel, intermediaryVersion) : buildLocalFirmwareFileName(firmwareType, deviceModel, firmwareVersion);
   const versionString = firmwareVersion.join('.');
-  const bundledBaseUrl = (0, utils_1.removeTrailingSlashes)(DataManager_1.DataManager.getSettings('binFilesBaseUrl'));
+  const bundledBaseUrl = removeTrailingSlashes(settingsStore.get('binFilesBaseUrl'));
   const isRealBundled = !bundledBaseUrl.includes('data.trezor.io');
   const bundledVersion = getBundledFirmwareVersion(deviceModel, firmwareType);
   const isIntermediary = bundledBaseUrl && intermediaryVersion;
@@ -464,18 +398,16 @@ const getFirmwareLocation = ({
   const {
     firmwareDir,
     firmwareList
-  } = DataManager_1.DataManager.getLocalFirmwares();
-  if ((0, firmwareUtils_1.isFirmwareCacheUsedForSelectedSource)() && firmwareList.includes(firmwareName)) {
+  } = localFirmwareStore.get();
+  if (isFirmwareCacheUsedForSelectedSource(settingsStore.get('firmwareChannel')) && firmwareList.includes(firmwareName)) {
     return {
       baseUrl: firmwareDir,
       path: firmwareName
     };
   }
-  const onlineBaseUrl = (0, exports.getOnlineFirmwareBaseUrl)();
+  const onlineBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
   return {
     baseUrl: onlineBaseUrl.BASE_URL,
     path: remotePath
   };
-};
-exports.getFirmwareLocation = getFirmwareLocation;
-//# sourceMappingURL=firmwareInfo.js.map
+};

package/lib/data/firmwareReleaseStore.d.ts

@@ -0,0 +1,10 @@
+import type { FirmwareChannel } from '@trezor/connect-common/lib/types/firmware';
+import type { ConditionalRelease, DeviceModelInternal, FirmwareReleaseConfig, FirmwareType, IntermediaryReleaseConfig, ReleasesConfig } from '@trezor/device-utils';
+export type InitializeFirmwareConfig = (config: FirmwareReleaseConfig, isRemote: boolean) => Promise<{
+  releases: ReleasesConfig;
+  intermediaries: Record<DeviceModelInternal, IntermediaryReleaseConfig[]>;
+}>;
+export declare const init: (firmwareChannel: FirmwareChannel | undefined, onlyLocal: boolean, initializeFirmwareConfig: InitializeFirmwareConfig) => Promise<void>;
+export declare const getLocal: () => FirmwareReleaseConfig;
+export declare const getReleases: () => Partial<Record<"T1B1" | "T2T1" | "T3T1" | "T2B1" | "T3B1" | "T3W1" | "UNKNOWN", Record<FirmwareType, ConditionalRelease>>> | undefined;
+export declare const getIntermediary: () => Record<"T1B1" | "T2T1" | "T3T1" | "T2B1" | "T3B1" | "T3W1" | "UNKNOWN", IntermediaryReleaseConfig[]> | undefined;

package/lib/data/firmwareReleaseStore.js

@@ -0,0 +1,16 @@
+import { getFirmwareReleaseConfig, getOnlyLocalFirmwareReleaseConfig } from "../utils/firmwareReleaseConfigUtils.js";
+const local = getOnlyLocalFirmwareReleaseConfig().config;
+let releases;
+let intermediary;
+export const init = async (firmwareChannel, onlyLocal, initializeFirmwareConfig) => {
+  const firmwareReleaseConfig = onlyLocal ? {
+    config: local,
+    isRemote: false
+  } : await getFirmwareReleaseConfig(firmwareChannel);
+  const result = await initializeFirmwareConfig(firmwareReleaseConfig.config, firmwareReleaseConfig.isRemote);
+  releases = result.releases;
+  intermediary = result.intermediaries;
+};
+export const getLocal = () => local;
+export const getReleases = () => releases;
+export const getIntermediary = () => intermediary;