@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/types/idevice.d.mts

@@ -0,0 +1,109 @@
+import type { Device, DeviceBusyStatus, DeviceButtonRequestPayload, DeviceFirmwareStatus, DeviceState, DeviceThpCredentialsChangedPayload, DeviceThpPairingPayload, DeviceThpPairingStatus, DeviceUniquePath, DeviceVersionChanged, Features, FirmwareHashCheckResult, KnownDevice, UiResponsePassphrase, UiResponsePin, UiResponseThpPairingTag, UiResponseWord, UnavailableCapabilities } from '@trezor/connect-common';
+import type { FirmwareReleaseConfigInfo } from '@trezor/connect-common/libESM/types/firmware';
+import type { FirmwareRelease, FirmwareType } from '@trezor/device-utils';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { DecodedTrezorPushNotification, TransportProtocol, thp as protocolThp } from '@trezor/protocol';
+import type { Descriptor, Transport } from '@trezor/transport';
+import type { TypedEmitter, VersionArray } from '@trezor/utils';
+import type { TypedCallProvider } from './typed-call-provider';
+import type { DeviceCommands } from '../device/DeviceCommands';
+export interface DeviceLifecycleEvents {
+    'device-connect': void;
+    'device-connect_unacquired': void;
+    'device-changed': void;
+    'device-disconnect': void;
+    'device-trezor_push_notification': DecodedTrezorPushNotification;
+}
+export type PromptResult<T> = {
+    success: true;
+    payload: T;
+} | {
+    success: false;
+    error: Error;
+};
+export interface DeviceEvents {
+    pin: {
+        type: PROTO.PinMatrixRequestType | undefined;
+        callback: (response: PromptResult<UiResponsePin['payload']>) => void;
+    };
+    word: {
+        type: PROTO.WordRequestType;
+        callback: (response: PromptResult<UiResponseWord['payload']>) => void;
+    };
+    passphrase: {
+        callback: (response: PromptResult<UiResponsePassphrase['payload']>) => void;
+    };
+    passphrase_on_device: void;
+    button: {
+        device: IDevice;
+        payload: DeviceButtonRequestPayload;
+    };
+    'device-firmware_version_changed': DeviceVersionChanged['payload'];
+    'device-trezor_push_notification': {
+        device: Device;
+        payload: DecodedTrezorPushNotification;
+    };
+    thp_pairing: {
+        payload: DeviceThpPairingPayload;
+        callback: (response: PromptResult<UiResponseThpPairingTag['payload']>) => void;
+    };
+    'device-thp_credentials_changed': DeviceThpCredentialsChangedPayload;
+    'device-thp_pairing_status_changed': DeviceThpPairingStatus;
+}
+export type RunOptions = {
+    skipFinalReload?: boolean;
+    keepSession?: boolean;
+    useCardanoDerivation?: boolean;
+    skipFirmwareChecks?: boolean;
+    skipLanguageChecks?: boolean;
+};
+export interface IDevice {
+    readonly transport: Transport;
+    readonly descriptor: Pick<Descriptor, 'apiType' | 'id' | 'type' | 'path' | 'model'>;
+    readonly protocol: TransportProtocol;
+    readonly transportPath: Descriptor['path'];
+    readonly lifecycle: TypedEmitter<DeviceLifecycleEvents>;
+    readonly possibleT1: boolean;
+    readonly firmwareStatus: DeviceFirmwareStatus;
+    readonly currentRelease: FirmwareRelease | undefined;
+    readonly firmwareReleaseConfigInfo: FirmwareReleaseConfigInfo | undefined;
+    readonly features: Features;
+    readonly unavailableCapabilities: Readonly<UnavailableCapabilities>;
+    readonly firmwareType: FirmwareType | undefined;
+    readonly currentRun: Promise<void> | undefined;
+    acquire(): ReturnType<Transport['acquire']>;
+    release(): ReturnType<Transport['release']> | undefined;
+    run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
+    interrupt(reason: Error): Promise<void>;
+    reset(): void;
+    setBusy(value?: DeviceBusyStatus): void;
+    setupThp(): void;
+    handshake(): Promise<boolean>;
+    setInstance(instance?: number): void;
+    getThpState(): protocolThp.ThpState | undefined;
+    getUniquePath(): DeviceUniquePath;
+    getInstance(): number;
+    getState(): DeviceState | undefined;
+    setState(state?: Partial<DeviceState>): void;
+    getVersion(): VersionArray | undefined;
+    getBusy(): DeviceBusyStatus | undefined;
+    getAuthenticityChecks(): KnownDevice['authenticityChecks'];
+    setAuthenticityChecks(firmwareHash: FirmwareHashCheckResult | null): void;
+    getCurrentSession(): TypedCallProvider;
+    getCommands(): ReturnType<typeof DeviceCommands>;
+    startPiggybackAck(): void;
+    stopPiggybackAck(): Promise<void>;
+    isUnacquired(): boolean;
+    isBootloader(): boolean;
+    isInitialized(): boolean;
+    isSeedless(): boolean;
+    isUsed(): boolean;
+    isUsedHere(): boolean;
+    isUsedElsewhere(): boolean;
+    atLeast(versions: string[] | string): boolean;
+    hasUnexpectedMode(allow: string[]): string | null;
+    toMessageObject(): Device;
+    emit: TypedEmitter<DeviceEvents>['emit'];
+    prompt<T extends 'pin' | 'passphrase' | 'word' | 'thp_pairing'>(type: T, args: Omit<DeviceEvents[T], 'callback'>): Promise<Parameters<DeviceEvents[T]['callback']>[0]>;
+    getFeatures(): Promise<void>;
+}

package/libESM/types/idevice.mjs

@@ -0,0 +1 @@
+export {};

package/libESM/types/typed-call-provider.d.mts

@@ -0,0 +1,29 @@
+import type { MessagesSchema as Messages } from '@trezor/protobuf';
+import type { MessageResponse } from '@trezor/transport';
+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/libESM/types/typed-call-provider.mjs

@@ -0,0 +1 @@
+export {};

package/libESM/types/workflow.d.mts

@@ -0,0 +1,16 @@
+import type { CoreEventMessage } from '@trezor/connect-common';
+import type { IDevice } from './idevice';
+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/libESM/types/workflow.mjs

@@ -0,0 +1 @@
+export {};

package/libESM/utils/accountUtils.d.mts

@@ -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/libESM/utils/accountUtils.mjs

@@ -0,0 +1,83 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { fromHardened, toHardened } from "./pathUtils.mjs";
+import { getCoinName } from "../data/coinInfo.mjs";
+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 [toHardened(options.purpose), toHardened(options.coinType), toHardened(index)];
+  }
+  if (coinInfo.shortcut === 'ADA' || coinInfo.shortcut === 'tADA') {
+    return [toHardened(1852), toHardened(options.coinType), toHardened(index)];
+  }
+  if (coinInfo.type === 'ethereum') {
+    return [toHardened(options.purpose), toHardened(options.coinType), toHardened(0), 0, index];
+  }
+  if (coinInfo.shortcut === 'tXRP') {
+    return [toHardened(options.purpose), toHardened(144), toHardened(index), 0, 0];
+  }
+  return [toHardened(options.purpose), toHardened(options.coinType), toHardened(index), 0, 0];
+};
+export const getAccountLabel = (path, coinInfo) => {
+  if (coinInfo.type === 'bitcoin') {
+    const accountType = fromHardened(path[0]);
+    const account = fromHardened(path[2]);
+    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 account = fromHardened(path[4]);
+  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 p1 = fromHardened(path[0]);
+  let account = path.length >= 3 ? fromHardened(path[2]) : -1;
+  let realAccountId = account + 1;
+  let prefix = 'Export public key';
+  let accountType = '';
+  if (p1 === 45342) {
+    const p2 = fromHardened(path[1]);
+    account = fromHardened(path[3]);
+    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/libESM/utils/addressUtils.d.mts

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

package/libESM/utils/addressUtils.mjs

@@ -0,0 +1,24 @@
+import { address as BitcoinJSAddress } from "@trezor/utxo-lib";
+const isValidBase58Address = (address, network) => {
+  try {
+    const decoded = BitcoinJSAddress.fromBase58Check(address, network);
+    if (decoded.version !== network.pubKeyHash && decoded.version !== network.scriptHash) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  return true;
+};
+const isValidBech32Address = (address, network) => {
+  try {
+    const decoded = BitcoinJSAddress.fromBech32(address);
+    if (decoded.prefix !== network.bech32) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  return true;
+};
+export const isValidAddress = (address, coinInfo) => isValidBase58Address(address, coinInfo.network) || isValidBech32Address(address, coinInfo.network);

package/libESM/utils/assetUtils.d.mts

@@ -0,0 +1,13 @@
+import type { DeviceModelInternal, FirmwareRelease } from '@trezor/device-utils';
+import { FirmwareType } from '@trezor/device-utils';
+import type { VersionArray } from '@trezor/utils/libESM/versionUtils';
+import type { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
+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: any;
+export declare const tryLocalAssetRequire: (url: string) => unknown;
+export declare const httpRequest: <T extends HttpRequestType>(url: string, type?: T, options?: HttpRequestOptions) => Promise<HttpRequestReturnType<T>>;

package/libESM/utils/assetUtils.mjs

@@ -0,0 +1,56 @@
+import fetch from "cross-fetch";
+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/libESM/utils/assets.browser.d.mts

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

package/libESM/utils/assets.browser.mjs

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

package/libESM/utils/assets.d.mts

@@ -0,0 +1,2 @@
+import type { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
+export declare function httpRequest<T extends HttpRequestType>(url: string, type: T, options?: HttpRequestOptions): Promise<HttpRequestReturnType<T>>;

package/libESM/utils/assets.mjs

@@ -0,0 +1,13 @@
+import fetch from "cross-fetch";
+import { promises as fs } from "fs";
+import { httpRequest as browserHttpRequest, tryLocalAssetRequire } from "./assetUtils.mjs";
+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/libESM/utils/assets.native.d.mts

@@ -0,0 +1,2 @@
+import type { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
+export declare function httpRequest<T extends HttpRequestType>(url: string, type: T, options?: HttpRequestOptions): Promise<HttpRequestReturnType<T>>;

package/libESM/utils/assets.native.mjs

@@ -0,0 +1,23 @@
+import { HttpRequestError, tryLocalAssetRequire } from "./assetUtils.mjs";
+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/libESM/utils/assetsTypes.d.mts

@@ -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/libESM/utils/assetsTypes.mjs

@@ -0,0 +1 @@
+export {};

package/libESM/utils/buildOutputDescriptor.d.mts

@@ -0,0 +1,12 @@
+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/libESM/utils/buildOutputDescriptor.mjs

@@ -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/libESM/utils/deviceFeaturesUtils.d.mts

@@ -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/libESM/utils/deviceFeaturesUtils.mjs

@@ -0,0 +1,109 @@
+import { DeviceModelInternal, getFirmwareOrBootloaderVersionArray } from "@trezor/device-utils";
+import { isArrayMember, versionUtils } from "@trezor/utils";
+import { config } from "../data/config.mjs";
+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_Binance', '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) {
+    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 === 'BNB' && info.type === 'misc') {
+      return !capabilities.includes('Capability_Binance');
+    }
+    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);
+    }
+  });
+  config.supportedFirmware.forEach(s => {
+    if (!s.capabilities) 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/libESM/utils/ethereumUtils.d.mts

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

package/libESM/utils/ethereumUtils.mjs

@@ -0,0 +1,7 @@
+export const getNetworkLabel = (label, network) => {
+  if (network) {
+    const name = network.name.toLowerCase().includes('testnet') ? 'Testnet' : network.name;
+    return label.replace('#NETWORK', name);
+  }
+  return label.replace('#NETWORK', '');
+};

package/libESM/utils/firmwareReleaseConfigUtils.d.mts

@@ -0,0 +1,19 @@
+import type { FirmwareChannel } from '@trezor/connect-common/libESM/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: any;
+    isRemote: boolean;
+}>;
+export declare const getOnlyLocalFirmwareReleaseConfig: () => {
+    config: FirmwareReleaseConfig;
+    isRemote: false;
+};
+export {};