@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/utils/assets.js

@@ -1,22 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.httpRequest = httpRequest;
-const tslib_1 = require("tslib");
-const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
-const fs_1 = require("fs");
-const assetUtils_1 = require("./assetUtils");
-const assets_browser_1 = require("./assets-browser");
+import fetch from "cross-fetch";
+import { promises as fs } from "fs";
+import { httpRequest as browserHttpRequest, tryLocalAssetRequire } from "./assetUtils.js";
 if (global && typeof global.fetch !== 'function') {
-  global.fetch = cross_fetch_1.default;
+  global.fetch = fetch;
 }
-function httpRequest(url, type, options) {
-  const asset = options?.skipLocalForceDownload ? null : (0, assetUtils_1.tryLocalAssetRequire)(url);
+export function httpRequest(url, type, options) {
+  const asset = options?.skipLocalForceDownload ? null : tryLocalAssetRequire(url);
   if (!asset) {
-    return /^https?/.test(url) ? (0, assets_browser_1.httpRequest)(url, type, options) : fs_1.promises.readFile(url);
+    return /^https?/.test(url) ? browserHttpRequest(url, type, options) : fs.readFile(url);
   }
   return asset;
-}
-//# sourceMappingURL=assets.js.map
+}

package/lib/utils/assets.native.d.ts

@@ -1,3 +1,2 @@
-import { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
-export declare function httpRequest<T extends HttpRequestType>(url: string, type: T, options?: HttpRequestOptions): Promise<HttpRequestReturnType<T>>;
-//# sourceMappingURL=assets.native.d.ts.map
+import type { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from "./assetsTypes.js";
+export declare function httpRequest<T extends HttpRequestType>(url: string, type: T, options?: HttpRequestOptions): Promise<HttpRequestReturnType<T>>;

package/lib/utils/assets.native.js

@@ -1,18 +1,12 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.httpRequest = httpRequest;
-const assetUtils_1 = require("./assetUtils");
-function httpRequest(url, type, options) {
-  const asset = options?.skipLocalForceDownload ? null : (0, assetUtils_1.tryLocalAssetRequire)(url);
+import { HttpRequestError, tryLocalAssetRequire } from "./assetUtils.js";
+export function httpRequest(url, type, options) {
+  const asset = options?.skipLocalForceDownload ? null : tryLocalAssetRequire(url);
   if (!asset) {
     return fetch(url, {
       ...options
     }).then(response => {
       if (!response.ok) {
-        throw new assetUtils_1.HttpRequestError(response);
+        throw new HttpRequestError(response);
       }
       if (type === 'binary') {
         return response.arrayBuffer();
@@ -26,5 +20,4 @@ function httpRequest(url, type, options) {
     });
   }
   return asset;
-}
-//# sourceMappingURL=assets.native.js.map
+}

package/lib/utils/assetsTypes.d.ts

@@ -1,6 +1,5 @@
 export type HttpRequestType = 'text' | 'binary' | 'json';
 export type HttpRequestReturnType<T extends HttpRequestType> = T extends 'text' ? string : T extends 'binary' ? ArrayBuffer | Buffer : T extends 'json' ? Record<string, any> : never;
 export interface HttpRequestOptions extends RequestInit {
-    skipLocalForceDownload?: boolean;
-}
-//# sourceMappingURL=assetsTypes.d.ts.map
+  skipLocalForceDownload?: boolean;
+}

package/lib/utils/assetsTypes.js

@@ -1,6 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=assetsTypes.js.map
+export {};

package/lib/utils/buildOutputDescriptor.d.ts

@@ -0,0 +1,20 @@
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+type BuildOutputDescriptorBip380Params = {
+  coin?: string;
+  account: number;
+  purpose?: number;
+  scriptType?: PROTO.InternalInputScriptType;
+  xpub: string;
+  rootFingerprint?: number;
+  descriptor?: string;
+};
+export declare const buildOutputDescriptor: ({
+  coin,
+  account,
+  purpose,
+  scriptType,
+  xpub,
+  rootFingerprint,
+  descriptor
+}: BuildOutputDescriptorBip380Params) => string | undefined;
+export {};

package/lib/utils/buildOutputDescriptor.js

@@ -0,0 +1,67 @@
+import { addDescriptorChecksum } from "@trezor/utxo-lib";
+const PURPOSE_BIP44 = 44;
+const PURPOSE_BIP49 = 49;
+const PURPOSE_BIP84 = 84;
+const PURPOSE_BIP86 = 86;
+const PURPOSE_SLIP25 = 10025;
+const SCRIPT_TYPE_TO_PURPOSES = {
+  SPENDADDRESS: [PURPOSE_BIP44],
+  SPENDP2SHWITNESS: [PURPOSE_BIP49],
+  SPENDWITNESS: [PURPOSE_BIP84],
+  SPENDTAPROOT: [PURPOSE_BIP86, PURPOSE_SLIP25]
+};
+const PURPOSE_TO_SCRIPT_TYPE = {
+  [PURPOSE_BIP44]: 'SPENDADDRESS',
+  [PURPOSE_BIP49]: 'SPENDP2SHWITNESS',
+  [PURPOSE_BIP84]: 'SPENDWITNESS',
+  [PURPOSE_BIP86]: 'SPENDTAPROOT',
+  [PURPOSE_SLIP25]: 'SPENDTAPROOT'
+};
+export const buildOutputDescriptor = ({
+  coin,
+  account,
+  purpose,
+  scriptType,
+  xpub,
+  rootFingerprint,
+  descriptor
+}) => {
+  if (descriptor !== undefined) return descriptor;
+  if (purpose === undefined) {
+    scriptType ??= 'SPENDADDRESS';
+    purpose = SCRIPT_TYPE_TO_PURPOSES[scriptType]?.[0];
+    if (purpose === undefined) return undefined;
+  } else if (scriptType === undefined) {
+    scriptType = PURPOSE_TO_SCRIPT_TYPE[purpose];
+    if (!scriptType) return undefined;
+  } else if (!SCRIPT_TYPE_TO_PURPOSES[scriptType]?.includes(purpose)) {
+    return undefined;
+  }
+  const COIN_TYPE = {
+    Bitcoin: 0,
+    Testnet: 1,
+    Regtest: 1
+  };
+  const coinType = COIN_TYPE[coin ?? 'Bitcoin'];
+  if (coinType === undefined) {
+    return undefined;
+  }
+  let path = `m/${purpose}h/${coinType}h/${account}h`;
+  if (purpose === PURPOSE_SLIP25) {
+    if (scriptType === 'SPENDTAPROOT') {
+      path += '/1h';
+    } else {
+      return undefined;
+    }
+  }
+  const fmtMap = {
+    SPENDADDRESS: 'pkh({})',
+    SPENDP2SHWITNESS: 'sh(wpkh({}))',
+    SPENDWITNESS: 'wpkh({})',
+    SPENDTAPROOT: 'tr({})'
+  };
+  const fmt = fmtMap[scriptType];
+  const fingerprint = rootFingerprint ?? 0;
+  const inner = `[${fingerprint.toString(16).padStart(8, '0')}${path.slice(1)}]${xpub}/<0;1>/*`;
+  return addDescriptorChecksum(fmt.replace('{}', inner));
+};

package/lib/utils/deviceFeaturesUtils.d.ts

@@ -1,8 +1,7 @@
+import type { CoinInfo, Features } from '@trezor/connect-common';
 import { DeviceModelInternal } from '@trezor/device-utils';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { CoinInfo, Features, UnavailableCapabilities } from '../types';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
 export declare const parseCapabilities: (features?: Features) => PROTO.Capability[];
-export declare const getUnavailableCapabilities: (features: Features, coins: CoinInfo[]) => UnavailableCapabilities;
+export declare const getUnavailableCapabilities: (features: Features, coins: CoinInfo[]) => Partial<Record<import("@trezor/connect-common").FirmwareCapability | (string & {}), import("@trezor/connect-common").UnavailableCapability>>;
 export declare const parseRevision: (features: Features) => string | null;
-export declare const ensureInternalModelFeature: (model: Features["model"]) => DeviceModelInternal;
-//# sourceMappingURL=deviceFeaturesUtils.d.ts.map
+export declare const ensureInternalModelFeature: (model: Features["model"]) => DeviceModelInternal;

package/lib/utils/deviceFeaturesUtils.js

@@ -1,29 +1,23 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ensureInternalModelFeature = exports.parseRevision = exports.getUnavailableCapabilities = exports.parseCapabilities = void 0;
-const device_utils_1 = require("@trezor/device-utils");
-const utils_1 = require("@trezor/utils");
-const config_1 = require("../data/config");
-const DEFAULT_CAPABILITIES_T1 = ['Capability_Bitcoin', 'Capability_Bitcoin_like', 'Capability_Crypto', 'Capability_Ethereum', 'Capability_NEM', 'Capability_Stellar', 'Capability_U2F'];
-const DEFAULT_CAPABILITIES_TT = ['Capability_Bitcoin', 'Capability_Bitcoin_like', 'Capability_Binance', 'Capability_Cardano', 'Capability_Crypto', 'Capability_EOS', 'Capability_Ethereum', 'Capability_Monero', 'Capability_NEM', 'Capability_Ripple', 'Capability_Stellar', 'Capability_Tezos', 'Capability_U2F'];
-const parseCapabilities = features => {
+import { DeviceModelInternal, getFirmwareOrBootloaderVersionArray } from "@trezor/device-utils";
+import { isArrayMember, versionUtils } from "@trezor/utils";
+import { isDebugFirmware } from "./firmwareUtils.js";
+import { config } from "../data/config.js";
+const DEFAULT_CAPABILITIES_T1 = ['Capability_Bitcoin', 'Capability_Bitcoin_like', 'Capability_Crypto', 'Capability_Ethereum', 'Capability_Stellar', 'Capability_U2F'];
+const DEFAULT_CAPABILITIES_TT = ['Capability_Bitcoin', 'Capability_Bitcoin_like', 'Capability_Cardano', 'Capability_Crypto', 'Capability_Ethereum', 'Capability_Monero', 'Capability_Ripple', 'Capability_Solana', 'Capability_Stellar', 'Capability_Tezos', 'Capability_U2F'];
+export const parseCapabilities = features => {
   if (!features || features.firmware_present === false) return [];
-  if (!features.capabilities || !features.capabilities.length) {
+  if (!features.capabilities?.length) {
     return features.major_version === 1 ? DEFAULT_CAPABILITIES_T1 : DEFAULT_CAPABILITIES_TT;
   }
   return features.capabilities;
 };
-exports.parseCapabilities = parseCapabilities;
-const getUnavailableCapabilities = (features, coins) => {
+export const getUnavailableCapabilities = (features, coins) => {
   const {
     capabilities
   } = features;
   const list = {};
   if (!capabilities) return list;
-  const fw = [features.major_version, features.minor_version, features.patch_version].join('.');
+  const fw = getFirmwareOrBootloaderVersionArray(features).join('.');
   const key = features.internal_model;
   const supported = coins.filter(info => {
     if (!info.support || info.support[key] === false) {
@@ -47,15 +41,9 @@ const getUnavailableCapabilities = (features, coins) => {
     if (info.type === 'ethereum') {
       return !capabilities.includes('Capability_Ethereum');
     }
-    if (info.type === 'nem') {
-      return !capabilities.includes('Capability_NEM');
-    }
-    if (info.shortcut === 'TRX' && info.type === 'misc') {
+    if ((info.shortcut === 'TRX' || info.shortcut === 'tTRX') && info.type === 'misc') {
       return !capabilities.includes('Capability_Tron');
     }
-    if (info.shortcut === 'BNB' && info.type === 'misc') {
-      return !capabilities.includes('Capability_Binance');
-    }
     if (info.shortcut === 'ADA' || info.shortcut === 'tADA') {
       return !capabilities.includes('Capability_Cardano');
     }
@@ -68,29 +56,31 @@ const getUnavailableCapabilities = (features, coins) => {
     if (info.shortcut === 'SOL' || info.shortcut === 'DSOL') {
       return !capabilities.includes('Capability_Solana');
     }
-    return !(0, utils_1.isArrayMember)(`Capability_${info.name}`, capabilities);
+    return !isArrayMember(`Capability_${info.name}`, capabilities);
   });
   unavailable.forEach(info => {
     list[info.shortcut.toLowerCase()] = 'no-capability';
   });
   supported.filter(info => !unavailable.includes(info)).forEach(info => {
     const supportVersion = info.support[key];
-    if (typeof supportVersion === 'string' && utils_1.versionUtils.isNewer(supportVersion, fw)) {
+    if (typeof supportVersion === 'string' && versionUtils.isNewer(supportVersion, fw)) {
       list[info.shortcut.toLowerCase()] = 'update-required';
       unavailable.push(info);
     }
   });
-  config_1.config.supportedFirmware.forEach(s => {
+  const isDebug = isDebugFirmware(features);
+  config.supportedFirmware.forEach(s => {
     if (!s.capabilities) return;
+    if (s.firmwareType && s.firmwareType === 'debug' !== isDebug) return;
     const min = s.min ? s.min[key] : null;
     const max = s.max ? s.max[key] : null;
-    if (min && (min === '0' || utils_1.versionUtils.isNewer(min, fw))) {
+    if (min && (min === '0' || versionUtils.isNewer(min, fw))) {
       const value = min === '0' ? 'no-support' : 'update-required';
       s.capabilities.forEach(m => {
         list[m] = value;
       });
     }
-    if (max && !utils_1.versionUtils.isNewerOrEqual(max, fw)) {
+    if (max && !versionUtils.isNewerOrEqual(max, fw)) {
       s.capabilities.forEach(m => {
         list[m] = 'trezor-connect-outdated';
       });
@@ -98,8 +88,7 @@ const getUnavailableCapabilities = (features, coins) => {
   });
   return list;
 };
-exports.getUnavailableCapabilities = getUnavailableCapabilities;
-const parseRevision = features => {
+export const parseRevision = features => {
   const {
     revision
   } = features;
@@ -108,16 +97,13 @@ const parseRevision = features => {
   const revisionUtf8 = Buffer.from(revision, 'hex').toString('utf-8');
   return /^([a-f0-9])*$/gi.test(revisionUtf8) ? revisionUtf8 : revision;
 };
-exports.parseRevision = parseRevision;
-const ensureInternalModelFeature = model => {
+export const ensureInternalModelFeature = model => {
   switch (model.toUpperCase()) {
     case 'T':
-      return device_utils_1.DeviceModelInternal.T2T1;
+      return DeviceModelInternal.T2T1;
     case '1':
-      return device_utils_1.DeviceModelInternal.T1B1;
+      return DeviceModelInternal.T1B1;
     default:
-      return device_utils_1.DeviceModelInternal.UNKNOWN;
+      return DeviceModelInternal.UNKNOWN;
   }
-};
-exports.ensureInternalModelFeature = ensureInternalModelFeature;
-//# sourceMappingURL=deviceFeaturesUtils.js.map
+};

package/lib/utils/ethereumUtils.d.ts

@@ -1,4 +1,3 @@
 export declare const getNetworkLabel: (label: string, network?: {
-    name: string;
-}) => string;
-//# sourceMappingURL=ethereumUtils.d.ts.map
+  name: string;
+}) => string;

package/lib/utils/ethereumUtils.js

@@ -1,15 +1,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getNetworkLabel = void 0;
-const getNetworkLabel = (label, network) => {
+export const getNetworkLabel = (label, network) => {
   if (network) {
-    const name = network.name.toLowerCase().indexOf('testnet') >= 0 ? 'Testnet' : network.name;
+    const name = network.name.toLowerCase().includes('testnet') ? 'Testnet' : network.name;
     return label.replace('#NETWORK', name);
   }
   return label.replace('#NETWORK', '');
-};
-exports.getNetworkLabel = getNetworkLabel;
-//# sourceMappingURL=ethereumUtils.js.map
+};

package/lib/utils/firmwareReleaseConfigUtils.d.ts

@@ -1,10 +1,19 @@
-import { FirmwareReleaseConfig } from '@trezor/device-utils';
-export declare const getFirmwareReleaseConfig: () => Promise<{
-    config: any;
-    isRemote: boolean;
+import type { FirmwareChannel } from '@trezor/connect-common/lib/types/firmware';
+import type { FirmwareReleaseConfig } from '@trezor/device-utils';
+interface RemoteBaseInfo {
+  BASE_URL: string;
+  MIDDLE_PATH: string;
+}
+type OnlineFirmwareBaseUrl = RemoteBaseInfo & {
+  firmwareChannel: FirmwareChannel;
+};
+export declare const getOnlineFirmwareBaseUrl: (firmwareChannel?: FirmwareChannel) => OnlineFirmwareBaseUrl;
+export declare const getFirmwareReleaseConfig: (firmwareChannel?: FirmwareChannel) => Promise<{
+  config: FirmwareReleaseConfig;
+  isRemote: boolean;
 }>;
 export declare const getOnlyLocalFirmwareReleaseConfig: () => {
-    config: FirmwareReleaseConfig;
-    isRemote: false;
+  config: FirmwareReleaseConfig;
+  isRemote: false;
 };
-//# sourceMappingURL=firmwareReleaseConfigUtils.d.ts.map
+export {};

package/lib/utils/firmwareReleaseConfigUtils.js

@@ -1,26 +1,69 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getOnlyLocalFirmwareReleaseConfig = exports.getFirmwareReleaseConfig = void 0;
-const jws_1 = require("jws");
-const env_utils_1 = require("@trezor/env-utils");
-const assetUtils_1 = require("./assetUtils");
-const firmwareInfo_1 = require("../data/firmwareInfo");
+import { decode, verify } from "jws";
+import { getFirmwareReleaseJwsPublicKey } from "@trezor/connect-data";
+import { firmwareReleaseConfigAssets } from "./assetUtils.js";
+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,
+  'production-early-access': 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
+};
+export const getOnlineFirmwareBaseUrl = firmwareChannel => {
+  if (!firmwareChannel) {
+    return {
+      ...FIRMWARE_REMOTE_BASE_URLS['production'],
+      firmwareChannel: 'production'
+    };
+  }
+  return {
+    ...FIRMWARE_REMOTE_BASE_URLS[firmwareChannel],
+    firmwareChannel
+  };
+};
 const JWS_CONFIG = {
   SIGN_ALGORITHM: 'ES256',
   VERSION: 1,
   REMOTE_FILENAME: 'releases.v1.json',
   REQUEST_TIMEOUT_MS: 5000
 };
-const fetchRemoteJws = async () => {
+const CONFIG_PATH_BY_CHANNEL = {
+  production: 'config/',
+  'production-early-access': 'config-early-access/'
+};
+const fetchRemoteJws = async firmwareChannel => {
   const {
     BASE_URL,
     MIDDLE_PATH,
-    env
-  } = (0, firmwareInfo_1.getOnlineFirmwareBaseUrl)();
-  const path = `${MIDDLE_PATH}/${env === 'production' ? 'config/' : ''}${JWS_CONFIG.REMOTE_FILENAME}`;
+    firmwareChannel: resolvedChannel
+  } = getOnlineFirmwareBaseUrl(firmwareChannel);
+  const configPath = CONFIG_PATH_BY_CHANNEL[resolvedChannel] ?? '';
+  const path = `${MIDDLE_PATH}/${configPath}${JWS_CONFIG.REMOTE_FILENAME}`;
   const remoteReleasesUrl = new URL(path, BASE_URL);
   try {
     const controller = new AbortController();
@@ -38,15 +81,15 @@ const fetchRemoteJws = async () => {
     }
     return {
       jws: data.jws,
-      env
+      firmwareChannel: resolvedChannel
     };
   } catch (error) {
     throw new Error(`Failed to fetch remote JWS: ${error instanceof Error ? error.message : String(error)}`);
   }
 };
 const verifyAndDecodeJws = (jws, publicKey) => {
-  const decoded = (0, jws_1.decode)(jws);
-  if (!decoded || !decoded.payload || !decoded.header) {
+  const decoded = decode(jws);
+  if (!decoded?.payload || !decoded.header) {
     throw new Error('Invalid JWS structure.');
   }
   const parsedPayload = JSON.parse(decoded.payload);
@@ -56,21 +99,21 @@ const verifyAndDecodeJws = (jws, publicKey) => {
   if (parsedPayload.version !== JWS_CONFIG.VERSION) {
     throw new Error('Config version mismatch.');
   }
-  if (!(0, jws_1.verify)(jws, JWS_CONFIG.SIGN_ALGORITHM, publicKey)) {
+  if (!verify(jws, JWS_CONFIG.SIGN_ALGORITHM, publicKey)) {
     throw new Error('JWS signature is invalid.');
   }
   return parsedPayload;
 };
-const getFirmwareReleaseConfig = async () => {
+export const getFirmwareReleaseConfig = async firmwareChannel => {
   try {
     const {
       jws,
-      env
-    } = await fetchRemoteJws();
-    const useProductionKey = ['test-signed', 'production'].includes(env);
-    const publicKey = (0, env_utils_1.getFirmwareReleaseJwsPublicKey)(useProductionKey);
+      firmwareChannel: resolvedChannel
+    } = await fetchRemoteJws(firmwareChannel);
+    const useProductionKey = ['test-signed', 'production-early-access', 'production'].includes(resolvedChannel);
+    const publicKey = getFirmwareReleaseJwsPublicKey(useProductionKey);
     const remoteConfig = verifyAndDecodeJws(jws, publicKey);
-    if (remoteConfig.sequence > assetUtils_1.firmwareReleaseConfigAssets.sequence) {
+    if (remoteConfig.sequence > firmwareReleaseConfigAssets.sequence) {
       return {
         config: remoteConfig,
         isRemote: true
@@ -78,14 +121,11 @@ const getFirmwareReleaseConfig = async () => {
     }
   } catch {}
   return {
-    config: assetUtils_1.firmwareReleaseConfigAssets,
+    config: firmwareReleaseConfigAssets,
     isRemote: false
   };
 };
-exports.getFirmwareReleaseConfig = getFirmwareReleaseConfig;
-const getOnlyLocalFirmwareReleaseConfig = () => ({
-  config: assetUtils_1.firmwareReleaseConfigAssets,
+export const getOnlyLocalFirmwareReleaseConfig = () => ({
+  config: firmwareReleaseConfigAssets,
   isRemote: false
-});
-exports.getOnlyLocalFirmwareReleaseConfig = getOnlyLocalFirmwareReleaseConfig;
-//# sourceMappingURL=firmwareReleaseConfigUtils.js.map
+});

package/lib/utils/firmwareUtils.d.ts

@@ -1,7 +1,6 @@
-import { FirmwareType } from '@trezor/device-utils';
-import type { DeviceModelInternal, FirmwareRelease, VersionArray } from '@trezor/device-utils';
-import type { CurrentVersion } from '../data/firmwareInfo';
-import type { Features, StrictFeatures } from '../types/device';
+import type { CurrentVersion, Features, FirmwareChannel, StrictFeatures } from '@trezor/connect-common';
+import { type DeviceModelInternal, type FirmwareRelease, FirmwareType } from '@trezor/device-utils';
+import { type VersionArray } from '@trezor/utils';
 export declare const isStrictFeatures: (extFeatures: Features) => extFeatures is StrictFeatures;
 type VersionCheckProperty = 'min_firmware_version' | 'min_bootloader_version';
 export declare const findBestCompatibleRelease: (availableFirmwares: FirmwareRelease[], currentVesion: CurrentVersion, checkProperty: VersionCheckProperty) => FirmwareRelease | undefined;
@@ -9,7 +8,8 @@ export declare const buildLocalReleaseName: (firmwareType: FirmwareType, deviceM
 export declare const buildLocalFirmwareFileName: (firmwareType: FirmwareType, deviceModel: DeviceModelInternal, version: VersionArray) => string;
 export declare const buildIntermediaryFirmwareFileName: (internalModel: DeviceModelInternal, version: number) => string;
 export declare const getFirmwareMode: (features: Features) => "normal" | "bootloader" | "initialize" | "seedless";
+export declare const isDebugFirmware: (features: Features) => boolean;
 export declare const getFirmwareType: (features: Features) => FirmwareType;
-export declare const isFirmwareCacheUsedForSelectedSource: () => boolean;
-export {};
-//# sourceMappingURL=firmwareUtils.d.ts.map
+export declare const isProductionFirmwareChannel: (firmwareChannel?: FirmwareChannel) => firmwareChannel is "production" | "production-early-access" | undefined;
+export declare const isFirmwareCacheUsedForSelectedSource: (firmwareChannel?: FirmwareChannel) => firmwareChannel is "production" | "production-early-access" | undefined;
+export {};

package/lib/utils/firmwareUtils.js

@@ -1,15 +1,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isFirmwareCacheUsedForSelectedSource = exports.getFirmwareType = exports.getFirmwareMode = exports.buildIntermediaryFirmwareFileName = exports.buildLocalFirmwareFileName = exports.buildLocalReleaseName = exports.findBestCompatibleRelease = exports.isStrictFeatures = void 0;
-const device_utils_1 = require("@trezor/device-utils");
-const utils_1 = require("@trezor/utils");
-const DataManager_1 = require("../data/DataManager");
-const isStrictFeatures = extFeatures => [1, 2].includes(extFeatures.major_version) && (extFeatures.firmware_present === false || extFeatures.bootloader_mode == null || extFeatures.bootloader_mode === true);
-exports.isStrictFeatures = isStrictFeatures;
-const findBestCompatibleRelease = (availableFirmwares, currentVesion, checkProperty) => {
+import { FirmwareType } from "@trezor/device-utils";
+import { versionUtils } from "@trezor/utils";
+export const isStrictFeatures = extFeatures => [1, 2].includes(extFeatures.major_version) && (extFeatures.firmware_present === false || extFeatures.bootloader_mode == null || extFeatures.bootloader_mode === true);
+export const findBestCompatibleRelease = (availableFirmwares, currentVesion, checkProperty) => {
   if (!availableFirmwares || availableFirmwares.length === 0) {
     return;
   }
@@ -19,7 +11,7 @@ const findBestCompatibleRelease = (availableFirmwares, currentVesion, checkPrope
   if (checkProperty === 'min_bootloader_version' && currentBootloaderVersion) {
     versionToCompare = currentBootloaderVersion;
   } else if (checkProperty === 'min_bootloader_version' && currentFirmwareVersion) {
-    const currentRelease = availableFirmwares.find(fw => utils_1.versionUtils.isEqual(currentFirmwareVersion, fw.version));
+    const currentRelease = availableFirmwares.find(fw => versionUtils.isEqual(currentFirmwareVersion, fw.version));
     if (!currentRelease?.bootloader_version) {
       return;
     }
@@ -27,44 +19,39 @@ const findBestCompatibleRelease = (availableFirmwares, currentVesion, checkPrope
   if (!versionToCompare) {
     return;
   }
-  const sortedFirmwares = availableFirmwares.sort((a, b) => utils_1.versionUtils.isNewer(b.version, a.version) ? 1 : -1);
-  const compatibleFirmware = sortedFirmwares.find(fw => utils_1.versionUtils.isNewerOrEqual(versionToCompare, fw[checkProperty]));
+  const sortedFirmwares = availableFirmwares.sort((a, b) => versionUtils.isNewer(b.version, a.version) ? 1 : -1);
+  const compatibleFirmware = sortedFirmwares.find(fw => versionUtils.isNewerOrEqual(versionToCompare, fw[checkProperty]));
   return compatibleFirmware;
 };
-exports.findBestCompatibleRelease = findBestCompatibleRelease;
 const buildLocalFileBaseName = (firmwareType, deviceModel, version) => {
-  const firmwareSuffix = firmwareType === device_utils_1.FirmwareType.BitcoinOnly ? '-bitcoinonly' : '';
+  const firmwareSuffix = firmwareType === FirmwareType.BitcoinOnly ? '-bitcoinonly' : '';
   const model = deviceModel.toLowerCase();
   const versionString = version.join('.');
   return `trezor-${model}-${versionString}${firmwareSuffix}`;
 };
-const buildLocalReleaseName = (firmwareType, deviceModel, version) => `${buildLocalFileBaseName(firmwareType, deviceModel, version)}.json`;
-exports.buildLocalReleaseName = buildLocalReleaseName;
-const buildLocalFirmwareFileName = (firmwareType, deviceModel, version) => `${buildLocalFileBaseName(firmwareType, deviceModel, version)}.bin`;
-exports.buildLocalFirmwareFileName = buildLocalFirmwareFileName;
-const buildIntermediaryFirmwareFileName = (internalModel, version) => `trezor-${internalModel.toLowerCase()}-inter-v${version}.bin`;
-exports.buildIntermediaryFirmwareFileName = buildIntermediaryFirmwareFileName;
-const getFirmwareMode = features => {
+export const buildLocalReleaseName = (firmwareType, deviceModel, version) => `${buildLocalFileBaseName(firmwareType, deviceModel, version)}.json`;
+export const buildLocalFirmwareFileName = (firmwareType, deviceModel, version) => `${buildLocalFileBaseName(firmwareType, deviceModel, version)}.bin`;
+export const buildIntermediaryFirmwareFileName = (internalModel, version) => `trezor-${internalModel.toLowerCase()}-inter-v${version}.bin`;
+export const getFirmwareMode = features => {
   if (features.bootloader_mode) return 'bootloader';
   if (!features.initialized) return 'initialize';
   if (features.no_backup) return 'seedless';
   return 'normal';
 };
-exports.getFirmwareMode = getFirmwareMode;
-const getFirmwareType = features => {
-  let type = device_utils_1.FirmwareType.Universal;
+const PRODUCTION_FIRMWARE_VENDORS = new Set(['Trezor', 'Trezor Bitcoin-only']);
+export const isDebugFirmware = features => !PRODUCTION_FIRMWARE_VENDORS.has(features.fw_vendor ?? '');
+export const getFirmwareType = features => {
+  let type = FirmwareType.Universal;
   if (features.fw_vendor === 'Trezor Bitcoin-only') {
-    type = device_utils_1.FirmwareType.BitcoinOnly;
+    type = FirmwareType.BitcoinOnly;
   } else if (features.fw_vendor === 'Trezor') {
-    type = device_utils_1.FirmwareType.Universal;
-  } else if ((0, exports.getFirmwareMode)(features) !== 'bootloader') {
-    type = features.capabilities && features.capabilities.length > 0 && !features.capabilities.includes('Capability_Bitcoin_like') ? device_utils_1.FirmwareType.BitcoinOnly : device_utils_1.FirmwareType.Universal;
-  } else if ((0, exports.getFirmwareMode)(features) === 'bootloader' && features.unit_btconly) {
-    type = device_utils_1.FirmwareType.BitcoinOnly;
+    type = FirmwareType.Universal;
+  } else if (getFirmwareMode(features) !== 'bootloader') {
+    type = features.capabilities && features.capabilities.length > 0 && !features.capabilities.includes('Capability_Bitcoin_like') ? FirmwareType.BitcoinOnly : FirmwareType.Universal;
+  } else if (getFirmwareMode(features) === 'bootloader' && features.unit_btconly) {
+    type = FirmwareType.BitcoinOnly;
   }
   return type;
 };
-exports.getFirmwareType = getFirmwareType;
-const isFirmwareCacheUsedForSelectedSource = () => DataManager_1.DataManager.getSettings('firmwareUpdateSource') === 'production';
-exports.isFirmwareCacheUsedForSelectedSource = isFirmwareCacheUsedForSelectedSource;
-//# sourceMappingURL=firmwareUtils.js.map
+export const isProductionFirmwareChannel = firmwareChannel => firmwareChannel === undefined || firmwareChannel === 'production' || firmwareChannel === 'production-early-access';
+export const isFirmwareCacheUsedForSelectedSource = firmwareChannel => isProductionFirmwareChannel(firmwareChannel);