@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/lib/types/typed-call-provider.d.ts

@@ -0,0 +1,29 @@
+import type { MessagesSchema as Messages } from '@trezor/protobuf';
+import type { MessageResponse } from '@trezor/transport-common';
+type AbortableOptions = {
+  timeout?: number;
+  signal?: AbortSignal;
+};
+type CallResult = {
+  success: true;
+  payload: MessageResponse;
+} | {
+  success: false;
+  error: Error;
+};
+type SendResult = {
+  success: true;
+  payload: undefined;
+} | {
+  success: false;
+  error: Error;
+};
+export interface TypedCallProvider {
+  typedCall: Messages.TypedCall;
+  isDisposed: () => boolean;
+  cancelCall: () => Promise<CallResult>;
+  call: (name: string, data: Record<string, unknown>, options?: AbortableOptions) => Promise<CallResult>;
+  send: (name: string, data: Record<string, unknown>, options?: AbortableOptions) => Promise<SendResult>;
+  receive: (options?: AbortableOptions) => Promise<CallResult>;
+}
+export {};

package/lib/types/workflow.d.ts

@@ -0,0 +1,16 @@
+import type { CoreEventMessage } from '@trezor/connect-common';
+import type { IDevice } from "./idevice.js";
+export interface WorkflowMethod {
+  preauthorized?: boolean;
+  useCardanoDerivation: boolean;
+}
+export type WorkflowContext = {
+  device: IDevice;
+  method: WorkflowMethod;
+  signal: AbortSignal;
+  sendCoreMessage: (message: CoreEventMessage) => void;
+};
+export type TpnWorkflowContext = {
+  device: IDevice;
+  message: number[];
+};

package/lib/utils/accountUtils.d.ts

@@ -0,0 +1,10 @@
+import type { BitcoinNetworkInfo, CoinInfo } from '@trezor/connect-common';
+type Bip44Options = {
+  purpose?: number;
+  coinType?: number;
+};
+export declare const getAccountAddressN: (coinInfo: CoinInfo, accountIndex: number, bip44?: Bip44Options) => number[];
+export declare const getAccountLabel: (path: number[], coinInfo: CoinInfo) => string;
+export declare const getPublicKeyLabel: (path: number[], coinInfo?: BitcoinNetworkInfo) => string;
+export declare const isUtxoBased: (coinInfo: CoinInfo) => boolean;
+export {};

package/lib/utils/accountUtils.js

@@ -0,0 +1,90 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { fromHardenedPathPart, toHardenedPathPart } from "@trezor/crypto-utils";
+import { getCoinName } from "../data/coinInfo.js";
+export const getAccountAddressN = (coinInfo, accountIndex, bip44) => {
+  if (!coinInfo) {
+    throw ERRORS.TypedError('Method_UnknownCoin');
+  }
+  const index = typeof accountIndex === 'number' ? accountIndex : 0;
+  const options = {
+    purpose: 44,
+    coinType: coinInfo.slip44,
+    ...bip44
+  };
+  if (coinInfo.type === 'bitcoin') {
+    return [toHardenedPathPart(options.purpose), toHardenedPathPart(options.coinType), toHardenedPathPart(index)];
+  }
+  if (coinInfo.shortcut === 'ADA' || coinInfo.shortcut === 'tADA') {
+    return [toHardenedPathPart(1852), toHardenedPathPart(options.coinType), toHardenedPathPart(index)];
+  }
+  if (coinInfo.type === 'ethereum') {
+    return [toHardenedPathPart(options.purpose), toHardenedPathPart(options.coinType), toHardenedPathPart(0), 0, index];
+  }
+  if (coinInfo.shortcut === 'tXRP') {
+    return [toHardenedPathPart(options.purpose), toHardenedPathPart(144), toHardenedPathPart(index), 0, 0];
+  }
+  return [toHardenedPathPart(options.purpose), toHardenedPathPart(options.coinType), toHardenedPathPart(index), 0, 0];
+};
+export const getAccountLabel = (path, coinInfo) => {
+  if (coinInfo.type === 'bitcoin') {
+    const path0 = path[0];
+    const path2 = path[2];
+    const accountType = fromHardenedPathPart(path0);
+    const account = fromHardenedPathPart(path2);
+    let prefix = '';
+    if (accountType === 48) {
+      prefix = 'multisig';
+    } else if (accountType === 49 && coinInfo.segwit) {
+      prefix = 'segwit';
+    } else if (accountType === 44 && coinInfo.segwit) {
+      prefix = 'legacy';
+    }
+    return `${prefix} account #${account + 1}`;
+  }
+  const path4 = path[4];
+  const account = fromHardenedPathPart(path4);
+  return `account #${account + 1}`;
+};
+export const getPublicKeyLabel = (path, coinInfo) => {
+  let hasSegwit = false;
+  let coinLabel = 'Unknown coin';
+  if (coinInfo) {
+    coinLabel = coinInfo.label;
+    hasSegwit = coinInfo.segwit;
+  } else {
+    coinLabel = getCoinName(path);
+  }
+  const pubKeyPath0 = path[0];
+  const p1 = fromHardenedPathPart(pubKeyPath0);
+  const pubKeyPath2 = path[2];
+  let account = path.length >= 3 ? fromHardenedPathPart(pubKeyPath2) : -1;
+  let realAccountId = account + 1;
+  let prefix = 'Export public key';
+  let accountType = '';
+  if (p1 === 45342) {
+    const pubKeyPath1 = path[1];
+    const p2 = fromHardenedPathPart(pubKeyPath1);
+    const pubKeyPath3 = path[3];
+    account = fromHardenedPathPart(pubKeyPath3);
+    realAccountId = account + 1;
+    prefix = 'Export Copay ID of';
+    if (p2 === 48) {
+      accountType = 'multisig';
+    } else if (p2 === 44) {
+      accountType = 'legacy';
+    }
+  } else if (p1 === 48) {
+    accountType = `${coinLabel} multisig`;
+  } else if (p1 === 44 && hasSegwit) {
+    accountType = `${coinLabel} legacy`;
+  } else if (p1 === 84 && hasSegwit) {
+    accountType = `${coinLabel} native segwit`;
+  } else {
+    accountType = coinLabel;
+  }
+  if (realAccountId > 0) {
+    return `${prefix} of ${accountType} account #${realAccountId}`;
+  }
+  return prefix;
+};
+export const isUtxoBased = coinInfo => coinInfo.type === 'bitcoin' || coinInfo.shortcut === 'ADA' || coinInfo.shortcut === 'tADA';

package/lib/utils/addressUtils.d.ts

@@ -0,0 +1,2 @@
+import type { BitcoinNetworkInfo } from '@trezor/connect-common';
+export declare const isValidAddress: (address: string, coinInfo: BitcoinNetworkInfo) => boolean;

package/lib/utils/assetUtils.d.ts

@@ -0,0 +1,13 @@
+import type { DeviceModelInternal, FirmwareRelease, FirmwareReleaseConfig } from '@trezor/device-utils';
+import { FirmwareType } from '@trezor/device-utils';
+import type { VersionArray } from '@trezor/utils/lib/versionUtils';
+import type { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from "./assetsTypes.js";
+export declare class HttpRequestError extends Error {
+  response: Response;
+  constructor(response: Response);
+}
+export declare const getReleasesAssetByDeviceModelAndFirmwareType: (deviceModel: DeviceModelInternal, firmwareType: FirmwareType) => FirmwareRelease[];
+export declare const getReleaseAsset: (deviceModel: DeviceModelInternal, version: VersionArray, firmwareType: FirmwareType) => FirmwareRelease;
+export declare const firmwareReleaseConfigAssets: FirmwareReleaseConfig;
+export declare const tryLocalAssetRequire: (url: string) => unknown;
+export declare const httpRequest: <T extends HttpRequestType>(url: string, type?: T, options?: HttpRequestOptions) => Promise<HttpRequestReturnType<T>>;

package/lib/utils/assetUtils.js

@@ -0,0 +1,55 @@
+import { firmwareAssets } from "@trezor/connect-data";
+import connectDataCoinsEth from "@trezor/connect-data/files/coins-eth.json" with { type: "json" };
+import connectDataCoins from "@trezor/connect-data/files/coins.json" with { type: "json" };
+import firmwareReleaseConfigAssetsJson from "@trezor/connect-data/files/firmware/release/releases.v1.json" with { type: "json" };
+import { FirmwareType } from "@trezor/device-utils";
+import { versionUtils } from "@trezor/utils";
+export class HttpRequestError extends Error {
+  response;
+  constructor(response) {
+    const message = `${response.status} while fetching ${response.url}`;
+    super(message);
+    this.response = response;
+  }
+}
+export const getReleasesAssetByDeviceModelAndFirmwareType = (deviceModel, firmwareType) => {
+  const firmwareTypeInFileName = firmwareType === FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
+  const availableReleasesRecord = firmwareAssets?.[deviceModel.toLowerCase()]?.[firmwareTypeInFileName] ?? {};
+  return Object.values(availableReleasesRecord).sort((a, b) => versionUtils.isNewer(b.version, a.version) ? 1 : -1);
+};
+export const getReleaseAsset = (deviceModel, version, firmwareType) => {
+  const firmwareTypeInFileName = firmwareType === FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
+  const fileName = `${deviceModel.toLowerCase()}-${version.join('.')}-${firmwareTypeInFileName}`;
+  const deviceModelLower = deviceModel.toLowerCase();
+  const asset = firmwareAssets?.[deviceModelLower]?.[firmwareTypeInFileName]?.[fileName];
+  return asset;
+};
+export const firmwareReleaseConfigAssets = firmwareReleaseConfigAssetsJson;
+export const tryLocalAssetRequire = url => {
+  const fileUrl = url.split('?')[0];
+  switch (fileUrl) {
+    case './data/coins.json':
+      return connectDataCoins;
+    case './data/coins-eth.json':
+      return connectDataCoinsEth;
+  }
+  return null;
+};
+export const httpRequest = async (url, type = 'text', options) => {
+  const init = {
+    ...options,
+    credentials: 'same-origin'
+  };
+  const response = await fetch(url, init);
+  if (response.ok) {
+    if (type === 'json') {
+      const txt = await response.text();
+      return JSON.parse(txt);
+    }
+    if (type === 'binary') {
+      return response.arrayBuffer();
+    }
+    return response.text();
+  }
+  throw new HttpRequestError(response);
+};

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

@@ -0,0 +1 @@
+export { httpRequest } from "./assetUtils.js";

package/lib/utils/assets.browser.js

@@ -0,0 +1 @@
+export { httpRequest } from "./assetUtils.js";

package/lib/utils/assets.d.ts

@@ -0,0 +1,2 @@
+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.js

@@ -0,0 +1,13 @@
+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 = fetch;
+}
+export function httpRequest(url, type, options) {
+  const asset = options?.skipLocalForceDownload ? null : tryLocalAssetRequire(url);
+  if (!asset) {
+    return /^https?/.test(url) ? browserHttpRequest(url, type, options) : fs.readFile(url);
+  }
+  return asset;
+}

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,23 @@
+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 HttpRequestError(response);
+      }
+      if (type === 'binary') {
+        return response.arrayBuffer();
+      }
+      if (type === 'json') {
+        return response.json();
+      }
+      return response.text();
+    }).catch(error => {
+      throw error;
+    });
+  }
+  return asset;
+}

package/lib/utils/assetsTypes.d.ts

@@ -0,0 +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;
+}

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/deviceFeaturesUtils.d.ts

@@ -0,0 +1,7 @@
+import type { CoinInfo, Features } from '@trezor/connect-common';
+import { DeviceModelInternal } from '@trezor/device-utils';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+export declare const parseCapabilities: (features?: Features) => PROTO.Capability[];
+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;

package/lib/utils/deviceFeaturesUtils.js

@@ -0,0 +1,109 @@
+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?.length) {
+    return features.major_version === 1 ? DEFAULT_CAPABILITIES_T1 : DEFAULT_CAPABILITIES_TT;
+  }
+  return features.capabilities;
+};
+export const getUnavailableCapabilities = (features, coins) => {
+  const {
+    capabilities
+  } = features;
+  const list = {};
+  if (!capabilities) return list;
+  const fw = getFirmwareOrBootloaderVersionArray(features).join('.');
+  const key = features.internal_model;
+  const supported = coins.filter(info => {
+    if (!info.support || info.support[key] === false) {
+      const shortcut = info.shortcut.toLowerCase();
+      const occurrences = coins.filter(coin => shortcut == coin.shortcut.toLowerCase());
+      const allUnsupported = occurrences.every(info2 => !info2.support || info2.support[key] === false);
+      if (allUnsupported) {
+        list[shortcut] = 'no-support';
+      }
+      return false;
+    }
+    return true;
+  });
+  const unavailable = supported.filter(info => {
+    if (info.type === 'bitcoin') {
+      if (info.name === 'Bitcoin' || info.name === 'Testnet' || info.name === 'Regtest') {
+        return !capabilities.includes('Capability_Bitcoin');
+      }
+      return !capabilities.includes('Capability_Bitcoin_like');
+    }
+    if (info.type === 'ethereum') {
+      return !capabilities.includes('Capability_Ethereum');
+    }
+    if ((info.shortcut === 'TRX' || info.shortcut === 'tTRX') && info.type === 'misc') {
+      return !capabilities.includes('Capability_Tron');
+    }
+    if (info.shortcut === 'ADA' || info.shortcut === 'tADA') {
+      return !capabilities.includes('Capability_Cardano');
+    }
+    if (info.shortcut === 'XRP' || info.shortcut === 'tXRP') {
+      return !capabilities.includes('Capability_Ripple');
+    }
+    if (info.shortcut === 'XLM' || info.shortcut === 'tXLM') {
+      return !capabilities.includes('Capability_Stellar');
+    }
+    if (info.shortcut === 'SOL' || info.shortcut === 'DSOL') {
+      return !capabilities.includes('Capability_Solana');
+    }
+    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' && versionUtils.isNewer(supportVersion, fw)) {
+      list[info.shortcut.toLowerCase()] = 'update-required';
+      unavailable.push(info);
+    }
+  });
+  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' || versionUtils.isNewer(min, fw))) {
+      const value = min === '0' ? 'no-support' : 'update-required';
+      s.capabilities.forEach(m => {
+        list[m] = value;
+      });
+    }
+    if (max && !versionUtils.isNewerOrEqual(max, fw)) {
+      s.capabilities.forEach(m => {
+        list[m] = 'trezor-connect-outdated';
+      });
+    }
+  });
+  return list;
+};
+export const parseRevision = features => {
+  const {
+    revision
+  } = features;
+  if (!revision) return null;
+  if (/^(?=.*[a-f])([a-f0-9]*)$/gi.test(revision)) return revision;
+  const revisionUtf8 = Buffer.from(revision, 'hex').toString('utf-8');
+  return /^([a-f0-9])*$/gi.test(revisionUtf8) ? revisionUtf8 : revision;
+};
+export const ensureInternalModelFeature = model => {
+  switch (model.toUpperCase()) {
+    case 'T':
+      return DeviceModelInternal.T2T1;
+    case '1':
+      return DeviceModelInternal.T1B1;
+    default:
+      return DeviceModelInternal.UNKNOWN;
+  }
+};

package/lib/utils/ethereumUtils.d.ts

@@ -0,0 +1,3 @@
+export declare const getNetworkLabel: (label: string, network?: {
+  name: string;
+}) => string;

package/lib/utils/firmwareReleaseConfigUtils.d.ts

@@ -0,0 +1,19 @@
+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;
+};
+export {};

package/lib/utils/firmwareReleaseConfigUtils.js

@@ -0,0 +1,131 @@
+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 CONFIG_PATH_BY_CHANNEL = {
+  production: 'config/',
+  'production-early-access': 'config-early-access/'
+};
+const fetchRemoteJws = async firmwareChannel => {
+  const {
+    BASE_URL,
+    MIDDLE_PATH,
+    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();
+    const timeoutId = setTimeout(() => controller.abort('Request timed out'), JWS_CONFIG.REQUEST_TIMEOUT_MS);
+    const response = await fetch(remoteReleasesUrl.toString(), {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+    if (typeof data.jws !== 'string') {
+      throw new Error('Invalid response format: "jws" property missing or not a string.');
+    }
+    return {
+      jws: data.jws,
+      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 = decode(jws);
+  if (!decoded?.payload || !decoded.header) {
+    throw new Error('Invalid JWS structure.');
+  }
+  const parsedPayload = JSON.parse(decoded.payload);
+  if (decoded.header.alg !== JWS_CONFIG.SIGN_ALGORITHM) {
+    throw new Error('Invalid JWS algorithm');
+  }
+  if (parsedPayload.version !== JWS_CONFIG.VERSION) {
+    throw new Error('Config version mismatch.');
+  }
+  if (!verify(jws, JWS_CONFIG.SIGN_ALGORITHM, publicKey)) {
+    throw new Error('JWS signature is invalid.');
+  }
+  return parsedPayload;
+};
+export const getFirmwareReleaseConfig = async firmwareChannel => {
+  try {
+    const {
+      jws,
+      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 > firmwareReleaseConfigAssets.sequence) {
+      return {
+        config: remoteConfig,
+        isRemote: true
+      };
+    }
+  } catch {}
+  return {
+    config: firmwareReleaseConfigAssets,
+    isRemote: false
+  };
+};
+export const getOnlyLocalFirmwareReleaseConfig = () => ({
+  config: firmwareReleaseConfigAssets,
+  isRemote: false
+});

package/lib/utils/firmwareUtils.d.ts

@@ -0,0 +1,15 @@
+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;
+export declare const buildLocalReleaseName: (firmwareType: FirmwareType, deviceModel: DeviceModelInternal, version: VersionArray) => string;
+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 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

@@ -0,0 +1,57 @@
+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;
+  }
+  const currentFirmwareVersion = currentVesion.firmwareVersion;
+  const currentBootloaderVersion = currentVesion.bootloaderVersion;
+  let versionToCompare = currentFirmwareVersion;
+  if (checkProperty === 'min_bootloader_version' && currentBootloaderVersion) {
+    versionToCompare = currentBootloaderVersion;
+  } else if (checkProperty === 'min_bootloader_version' && currentFirmwareVersion) {
+    const currentRelease = availableFirmwares.find(fw => versionUtils.isEqual(currentFirmwareVersion, fw.version));
+    if (!currentRelease?.bootloader_version) {
+      return;
+    }
+  }
+  if (!versionToCompare) {
+    return;
+  }
+  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;
+};
+const buildLocalFileBaseName = (firmwareType, deviceModel, version) => {
+  const firmwareSuffix = firmwareType === FirmwareType.BitcoinOnly ? '-bitcoinonly' : '';
+  const model = deviceModel.toLowerCase();
+  const versionString = version.join('.');
+  return `trezor-${model}-${versionString}${firmwareSuffix}`;
+};
+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';
+};
+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 = FirmwareType.BitcoinOnly;
+  } else if (features.fw_vendor === 'Trezor') {
+    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;
+};
+export const isProductionFirmwareChannel = firmwareChannel => firmwareChannel === undefined || firmwareChannel === 'production' || firmwareChannel === 'production-early-access';
+export const isFirmwareCacheUsedForSelectedSource = firmwareChannel => isProductionFirmwareChannel(firmwareChannel);