@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/utils/firmwareReleaseConfigUtils.mjs

@@ -0,0 +1,131 @@
+import { decode, verify } from "jws";
+import { getFirmwareReleaseJwsPublicKey } from "@trezor/connect-data";
+import { firmwareReleaseConfigAssets } from "./assetUtils.mjs";
+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 || !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/libESM/utils/firmwareUtils.d.mts

@@ -0,0 +1,13 @@
+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 getFirmwareType: (features: Features) => FirmwareType;
+export declare const isFirmwareCacheUsedForSelectedSource: (firmwareChannel?: FirmwareChannel) => firmwareChannel is "production";
+export {};

package/libESM/utils/firmwareUtils.mjs

@@ -0,0 +1,54 @@
+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';
+};
+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 isFirmwareCacheUsedForSelectedSource = firmwareChannel => firmwareChannel === 'production';

package/libESM/utils/formatUtils.d.mts

@@ -0,0 +1,15 @@
+import type { CoinInfo } from '@trezor/connect-common';
+export declare const formatAmount: (n: string, coinInfo: CoinInfo) => string;
+export declare const hasHexPrefix: (str: string) => boolean;
+export declare const stripHexPrefix: (str: string) => string;
+export declare const addHexPrefix: (str: string) => `0x${string}`;
+export declare const isHexString: (value: string) => false | RegExpMatchArray | null;
+export declare const messageToBuffer: (message: string) => Buffer<ArrayBuffer>;
+export declare const messageToHex: (message: string) => string;
+export declare const hexToText: (hex: string) => string;
+export declare const deepTransform: <V>(transform: (str: string) => V) => <T>(value: T) => DeepTransformed<T, V>;
+type DeepTransformed<T, V> = T extends string ? V : T extends (infer U)[] ? DeepTransformed<U, V>[] : T extends object ? {
+    [K in keyof T]: DeepTransformed<T[K], V>;
+} : T;
+export declare const sanitizeString: (value?: string) => string | undefined;
+export {};

package/libESM/utils/formatUtils.mjs

@@ -0,0 +1,45 @@
+import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
+export const formatAmount = (n, coinInfo) => `${new BigNumber(n).div(10 ** coinInfo.decimals).toString(10)} ${coinInfo.shortcut}`;
+export const hasHexPrefix = str => str.slice(0, 2).toLowerCase() === '0x';
+export const stripHexPrefix = str => hasHexPrefix(str) ? str.slice(2) : str;
+export const addHexPrefix = str => str !== undefined && !hasHexPrefix(str) ? `0x${str}` : str;
+export const isHexString = value => typeof value === 'string' && value.match(/^(0x|0X)?[0-9A-Fa-f]*$/);
+export const messageToBuffer = message => {
+  if (isHexString(message)) {
+    let clean = stripHexPrefix(message);
+    if (clean.length % 2 !== 0) {
+      clean = `0${clean}`;
+    }
+    return Buffer.from(clean, 'hex');
+  } else {
+    return Buffer.from(message, 'utf8');
+  }
+};
+export const messageToHex = message => messageToBuffer(message).toString('hex');
+export const hexToText = hex => {
+  const text = messageToBuffer(hex).toString('utf8');
+  return /[\uFFFD]/.test(text) ? hex : text;
+};
+export const deepTransform = transform => {
+  const recursion = value => {
+    if (typeof value === 'string') {
+      return transform(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map(recursion);
+    }
+    if (value && typeof value === 'object') {
+      return Object.entries(value).reduce((obj, [k, v]) => ({
+        ...obj,
+        [k]: recursion(v)
+      }), {});
+    }
+    return value;
+  };
+  return recursion;
+};
+export const sanitizeString = value => {
+  if (typeof value === 'string') {
+    return value.replace(/[\u2018\u2019]/g, "'");
+  }
+};

package/libESM/utils/hdnodeUtils.d.mts

@@ -0,0 +1,6 @@
+import type { PROTO } from '@trezor/connect-common';
+import type { Network } from '@trezor/utxo-lib';
+export declare const convertXpub: (xpub: string, originalNetwork?: Network, requestedNetwork?: Network) => string;
+export declare function xpubDerive<PK extends PROTO.PublicKey | PROTO.EthereumPublicKey>(xpub: PK, childXPub: PK, suffix: number, network?: Network, _requestedNetwork?: Network): PK;
+export declare const xpubToHDNodeType: (xpub: string, network: Network) => PROTO.HDNodeType;
+export declare const convertMultisigPubKey: <T extends PROTO.TxInputType | PROTO.TxOutputType>(network: Network, utxo: T) => T;

package/libESM/utils/hdnodeUtils.mjs

@@ -0,0 +1,62 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { bip32 } from "@trezor/utxo-lib";
+const pubNode2bjsNode = (node, network) => {
+  const chainCode = Buffer.from(node.chain_code, 'hex');
+  const publicKey = Buffer.from(node.public_key, 'hex');
+  const res = bip32.fromPublicKey(publicKey, chainCode, network);
+  res.__DEPTH = node.depth;
+  res.__INDEX = node.child_num;
+  res.__PARENT_FINGERPRINT = node.fingerprint;
+  return res;
+};
+export const convertXpub = (xpub, originalNetwork, requestedNetwork) => {
+  const node = bip32.fromBase58(xpub, originalNetwork);
+  if (requestedNetwork) {
+    node.network = requestedNetwork;
+  }
+  return node.toBase58();
+};
+const pubKey2bjsNode = (key, network) => {
+  const keyNode = key.node;
+  const bjsNode = pubNode2bjsNode(keyNode, network);
+  const bjsXpub = bjsNode.toBase58();
+  const keyXpub = convertXpub(key.xpub, network);
+  if (bjsXpub !== keyXpub) {
+    throw ERRORS.TypedError('Runtime', `pubKey2bjsNode: Invalid public key transmission detected. Key: ${bjsXpub}, Received: ${keyXpub}`);
+  }
+  return bjsNode;
+};
+const checkDerivation = (parBjsNode, childBjsNode, suffix) => {
+  const derivedChildBjsNode = parBjsNode.derive(suffix);
+  const derivedXpub = derivedChildBjsNode.toBase58();
+  const compXpub = childBjsNode.toBase58();
+  if (derivedXpub !== compXpub) {
+    throw ERRORS.TypedError('Runtime', `checkDerivation: Invalid child cross-check public key. Derived: ${derivedXpub}, Received: ${compXpub}`);
+  }
+};
+export function xpubDerive(xpub, childXPub, suffix, network, _requestedNetwork) {
+  const resNode = pubKey2bjsNode(xpub, network);
+  const childNode = pubKey2bjsNode(childXPub, network);
+  checkDerivation(resNode, childNode, suffix);
+  return xpub;
+}
+export const xpubToHDNodeType = (xpub, network) => {
+  const hd = bip32.fromBase58(xpub, network);
+  return {
+    depth: hd.depth,
+    child_num: hd.index,
+    fingerprint: hd.parentFingerprint,
+    public_key: hd.publicKey.toString('hex'),
+    chain_code: hd.chainCode.toString('hex')
+  };
+};
+export const convertMultisigPubKey = (network, utxo) => {
+  if ('multisig' in utxo && utxo.multisig?.pubkeys) {
+    utxo.multisig.pubkeys.forEach(pk => {
+      if (typeof pk.node === 'string') {
+        pk.node = xpubToHDNodeType(pk.node, network);
+      }
+    });
+  }
+  return utxo;
+};

package/libESM/utils/pathUtils.d.mts

@@ -0,0 +1,17 @@
+import type { PROTO } from '@trezor/connect-common';
+import type { CoinInfo } from '@trezor/connect-common/libESM/types/coinInfo';
+import type { DerivationPath, ProtoWithAddressN, ProtoWithDerivationPath } from '@trezor/connect-common/libESM/types/params';
+export declare const HD_HARDENED = 2147483648;
+export declare const toHardened: (n: number) => number;
+export declare const fromHardened: (n: number) => number;
+export declare const getSlip44ByPath: (path: number[]) => number;
+export declare const getHDPath: (path: string) => number[];
+export declare const isSegwitPath: (path: number[] | undefined) => boolean;
+export declare const isTaprootPath: (path: number[] | undefined) => boolean;
+export declare const getAccountType: (path: number[] | undefined) => "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
+export declare const getScriptType: (path: number[] | undefined) => PROTO.InternalInputScriptType | undefined;
+export declare const getOutputScriptType: (path?: number[]) => PROTO.ChangeOutputScriptType | undefined;
+export declare const validatePath: (path: DerivationPath, length?: number, base?: boolean) => number[];
+export declare const getSerializedPath: (path: number[]) => string;
+export declare const fixPath: <T extends ProtoWithDerivationPath<PROTO.TxInputType> | ProtoWithDerivationPath<PROTO.TxOutputType>>(utxo: T) => ProtoWithAddressN<T>;
+export declare const getLabel: (label: string, coinInfo?: CoinInfo) => string;

package/libESM/utils/pathUtils.mjs

@@ -0,0 +1,141 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+export const HD_HARDENED = 0x80000000;
+export const toHardened = n => (n | HD_HARDENED) >>> 0;
+export const fromHardened = n => (n & ~HD_HARDENED) >>> 0;
+export const getSlip44ByPath = path => fromHardened(path[1]);
+const PATH_NOT_VALID = ERRORS.TypedError('Method_InvalidParameter', 'Not a valid path');
+const PATH_NEGATIVE_VALUES = ERRORS.TypedError('Method_InvalidParameter', 'Path cannot contain negative values');
+export const getHDPath = path => {
+  const parts = path.toLowerCase().split('/');
+  if (parts[0] !== 'm') throw PATH_NOT_VALID;
+  return parts.filter(p => p !== 'm' && p !== '').map(p => {
+    let hardened = false;
+    if (p.endsWith("'")) {
+      hardened = true;
+      p = p.substring(0, p.length - 1);
+    }
+    let n = parseInt(p, 10);
+    if (Number.isNaN(n)) {
+      throw PATH_NOT_VALID;
+    } else if (n < 0) {
+      throw PATH_NEGATIVE_VALUES;
+    }
+    if (hardened) {
+      n = toHardened(n);
+    }
+    return n;
+  });
+};
+export const isSegwitPath = path => Array.isArray(path) && path[0] === toHardened(49);
+const isBech32Path = path => Array.isArray(path) && path[0] === toHardened(84);
+export const isTaprootPath = path => Array.isArray(path) && (path[0] === toHardened(86) || path[0] === toHardened(10025));
+export const getAccountType = path => {
+  if (isTaprootPath(path)) return 'p2tr';
+  if (isBech32Path(path)) return 'p2wpkh';
+  if (isSegwitPath(path)) return 'p2sh';
+  return 'p2pkh';
+};
+export const getScriptType = path => {
+  if (!Array.isArray(path) || path.length < 1) return undefined;
+  const p1 = fromHardened(path[0]);
+  switch (p1) {
+    case 44:
+      return 'SPENDADDRESS';
+    case 48:
+      {
+        if (path.length < 4) return undefined;
+        const p3 = fromHardened(path[3]);
+        switch (p3) {
+          case 0:
+            return 'SPENDMULTISIG';
+          case 1:
+            return 'SPENDP2SHWITNESS';
+          case 2:
+            return 'SPENDWITNESS';
+          default:
+            return undefined;
+        }
+      }
+    case 49:
+      return 'SPENDP2SHWITNESS';
+    case 84:
+      return 'SPENDWITNESS';
+    case 86:
+    case 10025:
+      return 'SPENDTAPROOT';
+    default:
+      return undefined;
+  }
+};
+export const getOutputScriptType = path => {
+  if (!Array.isArray(path) || path.length < 1) return undefined;
+  const p = fromHardened(path[0]);
+  switch (p) {
+    case 44:
+      return 'PAYTOADDRESS';
+    case 48:
+      {
+        if (path.length < 4) return undefined;
+        const p3 = fromHardened(path[3]);
+        switch (p3) {
+          case 0:
+            return 'PAYTOMULTISIG';
+          case 1:
+            return 'PAYTOP2SHWITNESS';
+          case 2:
+            return 'PAYTOWITNESS';
+          default:
+            return undefined;
+        }
+      }
+    case 49:
+      return 'PAYTOP2SHWITNESS';
+    case 84:
+      return 'PAYTOWITNESS';
+    case 86:
+    case 10025:
+      return 'PAYTOTAPROOT';
+    default:
+      return undefined;
+  }
+};
+export const validatePath = (path, length = 0, base = false) => {
+  let valid;
+  if (typeof path === 'string') {
+    valid = getHDPath(path);
+  } else if (Array.isArray(path)) {
+    valid = path.map(p => {
+      if (Number.isNaN(p)) {
+        throw PATH_NOT_VALID;
+      } else if (p < 0) {
+        throw PATH_NEGATIVE_VALUES;
+      }
+      return p;
+    });
+  }
+  if (!valid) throw PATH_NOT_VALID;
+  if (length > 0 && valid.length < length) throw PATH_NOT_VALID;
+  return base ? valid.splice(0, 3) : valid;
+};
+export const getSerializedPath = path => `m/${path.map(i => {
+  const s = (i & ~HD_HARDENED).toString();
+  if (i & HD_HARDENED) {
+    return `${s}'`;
+  }
+  return s;
+}).join('/')}`;
+export const fixPath = utxo => {
+  if (utxo.address_n && Array.isArray(utxo.address_n)) {
+    utxo.address_n = utxo.address_n.map(i => i >>> 0);
+  }
+  if (utxo.address_n && typeof utxo.address_n === 'string') {
+    utxo.address_n = getHDPath(utxo.address_n);
+  }
+  return utxo;
+};
+export const getLabel = (label, coinInfo) => {
+  if (coinInfo) {
+    return label.replace('#NETWORK', coinInfo.label);
+  }
+  return label.replace('#NETWORK', '');
+};

package/libESM/utils/paymentRequest.d.mts

@@ -0,0 +1,8 @@
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+export declare const PAYMENT_REQUEST_AMOUNT_BYTES: {
+    readonly DEFAULT: 8;
+    readonly EVM: 32;
+};
+export declare const encodePaymentRequestAmount: <T extends {
+    amount?: PROTO.PaymentRequest["amount"];
+}>(paymentRequest: T, bytesLength: number) => T;

package/libESM/utils/paymentRequest.mjs

@@ -0,0 +1,25 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { formatBigUintToLE } from "@trezor/utils/libESM/formatBigUintToLE.mjs";
+export const PAYMENT_REQUEST_AMOUNT_BYTES = {
+  DEFAULT: 8,
+  EVM: 32
+};
+export const encodePaymentRequestAmount = (paymentRequest, bytesLength) => {
+  if (paymentRequest.amount === undefined) {
+    return paymentRequest;
+  }
+  if (typeof paymentRequest.amount !== 'string' || !/^\d+$/.test(paymentRequest.amount)) {
+    throw ERRORS.TypedError('Method_InvalidParameter', 'Invalid PaymentRequest.amount: expected a decimal string in subunits');
+  }
+  try {
+    return {
+      ...paymentRequest,
+      amount: formatBigUintToLE({
+        value: paymentRequest.amount,
+        bytesLength
+      })
+    };
+  } catch (error) {
+    throw ERRORS.TypedError('Method_InvalidParameter', `Invalid PaymentRequest.amount: ${error instanceof Error ? error.message : String(error)}`);
+  }
+};

package/libESM/utils/uiPromiseManager.d.mts

@@ -0,0 +1,8 @@
+import type { UiPromiseCreator, UiPromiseResponse } from '../events/ui-promise';
+export declare const createUiPromiseManager: () => {
+    exists: (type: UiPromiseResponse["type"]) => boolean;
+    create: UiPromiseCreator;
+    resolve: (event: UiPromiseResponse) => boolean;
+    rejectAll: (error: Error) => void;
+    clear: () => void;
+};

package/libESM/utils/uiPromiseManager.mjs

@@ -0,0 +1,51 @@
+import { createDeferred } from "@trezor/utils";
+export const createUiPromiseManager = () => {
+  let _uiPromises = [];
+  const exists = type => _uiPromises.some(p => p.id === type);
+  const create = (promiseEvent, device) => {
+    const requestId = crypto.randomUUID();
+    const uiPromise = {
+      ...createDeferred(promiseEvent),
+      device,
+      requestId
+    };
+    const existing = _uiPromises.findIndex(p => p.id === promiseEvent && !p.requestId);
+    if (existing >= 0) {
+      console.warn(`UiPromise '${promiseEvent}' already exists.`);
+      _uiPromises.splice(existing, 1);
+    }
+    const {
+      reject
+    } = uiPromise;
+    uiPromise.reject = error => {
+      reject(error);
+      _uiPromises = _uiPromises.filter(p => p.requestId !== requestId);
+    };
+    _uiPromises.push(uiPromise);
+    return uiPromise;
+  };
+  const resolve = event => {
+    const uiPromise = _uiPromises.find(p => {
+      if (p.id !== event.type) return false;
+      return event.requestId == null || p.requestId === event.requestId;
+    });
+    if (!uiPromise) return false;
+    uiPromise.resolve(event);
+    _uiPromises = _uiPromises.filter(p => p !== uiPromise);
+    return true;
+  };
+  const rejectAll = error => {
+    _uiPromises.forEach(p => p.reject(error));
+    _uiPromises = [];
+  };
+  const clear = () => {
+    _uiPromises = [];
+  };
+  return {
+    exists,
+    create,
+    resolve,
+    rejectAll,
+    clear
+  };
+};

package/libESM/workers/workers.browser.d.mts

@@ -0,0 +1,10 @@
+import type { BaseWorker } from '@trezor/blockchain-link/libESM/workers/baseWorker';
+type WorkerAsyncImporter = () => Promise<BaseWorker<unknown>>;
+declare const BlockbookWorker: () => Worker;
+declare const BlockfrostWorker: () => Worker;
+declare const RippleWorker: () => Worker;
+declare const StellarWorker: () => Worker;
+declare const SolanaWorker: WorkerAsyncImporter;
+declare const ElectrumWorker: undefined;
+declare const EvmRpcWorker: WorkerAsyncImporter;
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, EvmRpcWorker, };

package/libESM/workers/workers.browser.mjs

@@ -0,0 +1,16 @@
+const BlockbookWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/blockbook', import.meta.url), {
+  type: 'module'
+});
+const BlockfrostWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/blockfrost', import.meta.url), {
+  type: 'module'
+});
+const RippleWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/ripple', import.meta.url), {
+  type: 'module'
+});
+const StellarWorker = () => new Worker(new URL('@trezor/blockchain-link/src/workers/stellar', import.meta.url), {
+  type: 'module'
+});
+const SolanaWorker = () => import("@trezor/blockchain-link/libESM/workers/solana").then(w => w.default());
+const ElectrumWorker = undefined;
+const EvmRpcWorker = () => import("@trezor/blockchain-link/libESM/workers/evm-rpc").then(w => w.default());
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, EvmRpcWorker };

package/libESM/workers/workers.d.mts

@@ -0,0 +1,10 @@
+import type { BaseWorker } from '@trezor/blockchain-link/libESM/workers/baseWorker';
+type WorkerAsyncImporter = () => Promise<BaseWorker<unknown>>;
+declare const BlockbookWorker: WorkerAsyncImporter;
+declare const RippleWorker: WorkerAsyncImporter;
+declare const BlockfrostWorker: WorkerAsyncImporter;
+declare const ElectrumWorker: WorkerAsyncImporter;
+declare const SolanaWorker: WorkerAsyncImporter;
+declare const StellarWorker: WorkerAsyncImporter;
+declare const EvmRpcWorker: WorkerAsyncImporter;
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, EvmRpcWorker, };

package/libESM/workers/workers.mjs

@@ -0,0 +1,8 @@
+const BlockbookWorker = () => import("@trezor/blockchain-link/libESM/workers/blockbook").then(w => w.default());
+const RippleWorker = () => import("@trezor/blockchain-link/libESM/workers/ripple").then(w => w.default());
+const BlockfrostWorker = () => import("@trezor/blockchain-link/libESM/workers/blockfrost").then(w => w.default());
+const ElectrumWorker = () => import("@trezor/blockchain-link/libESM/workers/electrum").then(w => w.default());
+const SolanaWorker = () => import("@trezor/blockchain-link/libESM/workers/solana").then(w => w.default());
+const StellarWorker = () => import("@trezor/blockchain-link/libESM/workers/stellar").then(w => w.default());
+const EvmRpcWorker = () => import("@trezor/blockchain-link/libESM/workers/evm-rpc").then(w => w.default());
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, EvmRpcWorker };

package/libESM/workers/workers.native.d.mts

@@ -0,0 +1,7 @@
+import BlockbookWorker from '@trezor/blockchain-link/libESM/workers/blockbook';
+import BlockfrostWorker from '@trezor/blockchain-link/libESM/workers/blockfrost';
+import ElectrumWorker from '@trezor/blockchain-link/libESM/workers/electrum';
+import RippleWorker from '@trezor/blockchain-link/libESM/workers/ripple';
+import SolanaWorker from '@trezor/blockchain-link/libESM/workers/solana';
+import StellarWorker from '@trezor/blockchain-link/libESM/workers/stellar';
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker, };

package/libESM/workers/workers.native.mjs

@@ -0,0 +1,7 @@
+import BlockbookWorker from "@trezor/blockchain-link/libESM/workers/blockbook/index.mjs";
+import BlockfrostWorker from "@trezor/blockchain-link/libESM/workers/blockfrost/index.mjs";
+import ElectrumWorker from "@trezor/blockchain-link/libESM/workers/electrum/index.mjs";
+import RippleWorker from "@trezor/blockchain-link/libESM/workers/ripple/index.mjs";
+import SolanaWorker from "@trezor/blockchain-link/libESM/workers/solana/index.mjs";
+import StellarWorker from "@trezor/blockchain-link/libESM/workers/stellar/index.mjs";
+export { BlockbookWorker, RippleWorker, BlockfrostWorker, ElectrumWorker, SolanaWorker, StellarWorker };