@trezor/connect 9.6.2 → 9.6.3-beta.1

package/lib/utils/assetUtils.js

@@ -1,18 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryLocalAssetRequire = exports.firmwareReleaseConfigAssets = exports.firmwareAssets = void 0;
+exports.tryLocalAssetRequire = exports.firmwareReleaseConfigAssets = exports.getReleaseAsset = exports.getReleasesAssetByDeviceModelAndFirmwareType = void 0;
+const firmware_1 = require("@trezor/connect-common/files/firmware");
 const device_utils_1 = require("@trezor/device-utils");
-const utils_1 = require("@trezor/utils");
-const isDeviceModel = (model) => (0, utils_1.isArrayMember)(model, Object.values(device_utils_1.DeviceModelInternal));
-exports.firmwareAssets = {
-    [device_utils_1.DeviceModelInternal.UNKNOWN]: {},
-    [device_utils_1.DeviceModelInternal.T1B1]: require('@trezor/connect-common/files/firmware/t1b1/releases.json'),
-    [device_utils_1.DeviceModelInternal.T2T1]: require('@trezor/connect-common/files/firmware/t2t1/releases.json'),
-    [device_utils_1.DeviceModelInternal.T2B1]: require('@trezor/connect-common/files/firmware/t2b1/releases.json'),
-    [device_utils_1.DeviceModelInternal.T3B1]: require('@trezor/connect-common/files/firmware/t3b1/releases.json'),
-    [device_utils_1.DeviceModelInternal.T3T1]: require('@trezor/connect-common/files/firmware/t3t1/releases.json'),
-    [device_utils_1.DeviceModelInternal.T3W1]: require('@trezor/connect-common/files/firmware/t3w1/releases.json'),
+const getReleasesAssetByDeviceModelAndFirmwareType = (deviceModel, firmwareType) => {
+    const firmwareTypeInFileName = firmwareType === device_utils_1.FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
+    return firmware_1.firmwareAssets[deviceModel.toLowerCase()][firmwareTypeInFileName];
 };
+exports.getReleasesAssetByDeviceModelAndFirmwareType = getReleasesAssetByDeviceModelAndFirmwareType;
+const getReleaseAsset = (deviceModel, version, firmwareType) => {
+    const firmwareTypeInFileName = firmwareType === device_utils_1.FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
+    const fileName = `${deviceModel.toLowerCase()}-${version.join('.')}-${firmwareTypeInFileName}`;
+    const deviceModelLower = deviceModel.toLowerCase();
+    const asset = firmware_1.firmwareAssets?.[deviceModelLower]?.[firmwareTypeInFileName]?.[fileName];
+    return asset;
+};
+exports.getReleaseAsset = getReleaseAsset;
 exports.firmwareReleaseConfigAssets = require('@trezor/connect-common/files/firmware/release/releases.v1.json');
 const tryLocalAssetRequire = (url) => {
     const fileUrl = url.split('?')[0];
@@ -24,13 +27,6 @@ const tryLocalAssetRequire = (url) => {
         case './data/messages/messages.json':
             return require('@trezor/protobuf/messages.json');
     }
-    const firmwareMatch = fileUrl.match(/\/firmware\/(\w+)\/releases\.json$/);
-    if (firmwareMatch) {
-        const modelKey = firmwareMatch[1].toUpperCase();
-        if (isDeviceModel(modelKey)) {
-            return exports.firmwareAssets[modelKey];
-        }
-    }
     return null;
 };
 exports.tryLocalAssetRequire = tryLocalAssetRequire;

package/lib/utils/assets.native.js

@@ -10,7 +10,6 @@ function httpRequest(url, type, options) {
         })
             .then(response => {
             if (!response.ok) {
-                console.error('HTTP request failed', response);
                 throw new Error(`HTTP request failed with status ${response.status} ${response.statusText}`);
             }
             if (type === 'binary') {
@@ -22,7 +21,6 @@ function httpRequest(url, type, options) {
             return response.text();
         })
             .catch(error => {
-            console.error('HTTP request failed', error);
             throw error;
         });
     }

package/lib/utils/firmwareReleaseConfigUtils.d.ts

@@ -1,7 +1,10 @@
 import { FirmwareReleaseConfig } from '@trezor/device-utils';
-type FirmwareUpdateSource = 'production' | 'test-unsigned' | 'test-signed';
-export declare const RELEASES_URL_REMOTE_BASE = "https://data.trezor.io/suite/firmware";
-export declare const RELEASES_URL_REMOTE: Record<FirmwareUpdateSource, string>;
-export declare const getFirmwareReleaseConfig: () => Promise<FirmwareReleaseConfig>;
-export {};
+export declare const getFirmwareReleaseConfig: () => Promise<{
+    config: any;
+    isRemote: boolean;
+}>;
+export declare const getOnlyLocalFirmwareReleaseConfig: () => {
+    config: FirmwareReleaseConfig;
+    isRemote: false;
+};
 //# sourceMappingURL=firmwareReleaseConfigUtils.d.ts.map

package/lib/utils/firmwareReleaseConfigUtils.js

@@ -1,83 +1,98 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFirmwareReleaseConfig = exports.RELEASES_URL_REMOTE = exports.RELEASES_URL_REMOTE_BASE = void 0;
+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 JWS_SIGN_ALGORITHM = 'ES256';
-const VERSION = 1;
-const JWS_RELEASES_FILENAME_REMOTE = `releases.v${VERSION}.jws`;
-exports.RELEASES_URL_REMOTE_BASE = 'https://data.trezor.io/suite/firmware';
-exports.RELEASES_URL_REMOTE = {
-    production: `${exports.RELEASES_URL_REMOTE_BASE}/production/${JWS_RELEASES_FILENAME_REMOTE}`,
-    'test-unsigned': `${exports.RELEASES_URL_REMOTE_BASE}/unsigned/${JWS_RELEASES_FILENAME_REMOTE}`,
-    'test-signed': `${exports.RELEASES_URL_REMOTE_BASE}/signed/${JWS_RELEASES_FILENAME_REMOTE}`,
+const firmwareInfo_1 = require("../data/firmwareInfo");
+const JWS_CONFIG = {
+    SIGN_ALGORITHM: 'ES256',
+    VERSION: 1,
+    REMOTE_FILENAME: 'releases.v1.json',
+    REQUEST_TIMEOUT_MS: 5000,
 };
-const FORCE_LOCAL_JWS = true;
-const getReleaseJWS = async (firmwareUpdateSource = 'production') => {
-    if (FORCE_LOCAL_JWS) {
-        return {
-            releasesJws: assetUtils_1.firmwareReleaseConfigAssets.jws,
-            isRemote: false,
-        };
-    }
-    const remoteReleasesUrl = exports.RELEASES_URL_REMOTE[firmwareUpdateSource];
+const fetchRemoteJWS = async () => {
+    const { BASE_URL, MIDDLE_PATH, env } = (0, firmwareInfo_1.getOnlineFirmwareBaseUrl)();
+    const remoteReleasesUrl = new URL(BASE_URL);
+    remoteReleasesUrl.pathname = `${MIDDLE_PATH}/${env === 'production' ? 'config/' : ''}${JWS_CONFIG.REMOTE_FILENAME}`;
     try {
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 5000);
-        const response = await fetch(remoteReleasesUrl, {
-            signal: controller.signal,
-        });
+        const timeoutId = setTimeout(() => controller.abort(), JWS_CONFIG.REQUEST_TIMEOUT_MS);
+        const response = await fetch(remoteReleasesUrl.toString(), { signal: controller.signal });
         clearTimeout(timeoutId);
         if (!response.ok) {
-            throw new Error(response.statusText);
+            throw new Error(`Fetching error with status: ${response.status}`);
         }
-        const releasesJws = await response.text();
-        return {
-            releasesJws,
-            isRemote: true,
-        };
+        const data = await response.json();
+        return { jws: data.jws, source: 'remote', env };
     }
     catch (error) {
-        console.error(`Fetching of remote JWS config failed: ${error}`);
-        return {
-            releasesJws: assetUtils_1.firmwareReleaseConfigAssets.jws,
-            isRemote: false,
-        };
+        console.error(`Fetching remote firmware release failed: ${error}. Falling back to local config.`);
+        return { jws: assetUtils_1.firmwareReleaseConfigAssets.jws, source: 'local', env };
     }
 };
-const getFirmwareReleaseConfig = async () => {
-    const { releasesJws, isRemote } = await getReleaseJWS();
-    const decodedJws = (0, jws_1.decode)(releasesJws);
-    if (!decodedJws) {
-        throw new Error('Decoding of releases failed.');
-    }
-    if (isRemote) {
-        const decodedJwsLocal = (0, jws_1.decode)(assetUtils_1.firmwareReleaseConfigAssets.jws);
-        if (decodedJwsLocal && decodedJwsLocal.payload.sequence > decodedJws.payload.sequence) {
-            throw new Error('Local firmware release config cannot have greater sequence than remote.');
-        }
+const decodeJwsPayload = (jws) => {
+    const decoded = (0, jws_1.decode)(jws);
+    if (!decoded || !decoded.payload) {
+        throw new Error('Failed to decode JWS or payload is missing.');
     }
-    const algorithmInHeader = decodedJws?.header.alg;
-    if (algorithmInHeader !== JWS_SIGN_ALGORITHM) {
-        throw Error(`Wrong algorithm in JWS config header: ${algorithmInHeader}`);
+    return JSON.parse(decoded.payload);
+};
+const verifyJwsSignature = (jws, publicKey) => {
+    const decoded = (0, jws_1.decode)(jws);
+    if (decoded?.header.alg !== JWS_CONFIG.SIGN_ALGORITHM) {
+        throw new Error(`Invalid JWS algorithm: expected ${JWS_CONFIG.SIGN_ALGORITHM}, got ${decoded?.header.alg}`);
     }
-    const JWSPublicKey = (0, env_utils_1.getJWSPublicKey)('firmware-release');
-    if (!JWSPublicKey) {
-        throw new Error('JWS public key is not defined!');
+    if (!(0, jws_1.verify)(jws, JWS_CONFIG.SIGN_ALGORITHM, publicKey)) {
+        throw new Error('JWS signature is invalid.');
     }
-    try {
-        const isAuthenticityValid = (0, jws_1.verify)(releasesJws, JWS_SIGN_ALGORITHM, JWSPublicKey);
-        if (!isAuthenticityValid) {
-            throw new Error('Config authenticity is invalid');
+};
+const getFirmwareReleaseConfig = async () => {
+    const { jws: remoteJws, source: initialSource, env } = await fetchRemoteJWS();
+    let finalJws = remoteJws;
+    let finalSource = initialSource;
+    let config;
+    if (initialSource === 'remote') {
+        try {
+            const remotePayload = decodeJwsPayload(remoteJws);
+            const localPayload = decodeJwsPayload(assetUtils_1.firmwareReleaseConfigAssets.jws);
+            if (localPayload.version !== JWS_CONFIG.VERSION) {
+                throw new Error(`Local config has mismatched version: ${localPayload.version}`);
+            }
+            if (localPayload.sequence >= remotePayload.sequence) {
+                finalJws = assetUtils_1.firmwareReleaseConfigAssets.jws;
+                finalSource = 'local';
+                config = localPayload;
+            }
+            else {
+                config = remotePayload;
+            }
+        }
+        catch (error) {
+            console.error(`Error comparing remote/local JWS: ${error}. Using remote as is.`);
         }
-        const releases = JSON.parse(decodedJws.payload);
-        return releases;
     }
-    catch (error) {
-        console.error('Error validating:', error);
-        throw new Error(`Failed to validate release message: ${error.message}`);
+    const useProductionKey = ['test-signed', 'production'].includes(env) || finalSource === 'local';
+    const publicKey = (0, env_utils_1.getFirmwareReleaseJwsPublicKey)(useProductionKey);
+    verifyJwsSignature(finalJws, publicKey);
+    if (!config) {
+        config = decodeJwsPayload(finalJws);
     }
+    return {
+        config,
+        isRemote: finalSource === 'remote',
+    };
 };
 exports.getFirmwareReleaseConfig = getFirmwareReleaseConfig;
+const getOnlyLocalFirmwareReleaseConfig = () => {
+    const localJws = assetUtils_1.firmwareReleaseConfigAssets.jws;
+    const publicKey = (0, env_utils_1.getFirmwareReleaseJwsPublicKey)(true);
+    verifyJwsSignature(localJws, publicKey);
+    const config = decodeJwsPayload(localJws);
+    return {
+        config,
+        isRemote: false,
+    };
+};
+exports.getOnlyLocalFirmwareReleaseConfig = getOnlyLocalFirmwareReleaseConfig;
 //# sourceMappingURL=firmwareReleaseConfigUtils.js.map

package/lib/utils/firmwareUtils.d.ts

@@ -1,8 +1,12 @@
 import type { DeviceModelInternal, FirmwareRelease } from '@trezor/device-utils';
+import { CurrentVersion } from '../data/firmwareInfo';
 import { Features, FirmwareType, StrictFeatures, VersionArray } from '../types';
 export declare const isStrictFeatures: (extFeatures: Features) => extFeatures is StrictFeatures;
-export declare const isValidReleases: (extReleases: any) => extReleases is FirmwareRelease[];
-export declare const filterSafeListByBootloader: (releasesList: FirmwareRelease[], bootloaderVersion: VersionArray) => FirmwareRelease[];
-export declare const filterSafeListByFirmware: (releasesList: FirmwareRelease[], firmwareVersion: VersionArray) => FirmwareRelease[];
-export declare const buildFirmwareFileName: (firmwareType: FirmwareType, internalModel: DeviceModelInternal, version: VersionArray) => string;
+type VersionCheckProperty = 'min_firmware_version' | 'min_bootloader_version';
+export declare const findBestCompatibleRelease: (releasesOfDevice: Record<string, FirmwareRelease>, currentVesion: CurrentVersion, checkProperty: VersionCheckProperty) => FirmwareRelease | undefined;
+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 {};
 //# sourceMappingURL=firmwareUtils.d.ts.map

package/lib/utils/firmwareUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFirmwareFileName = exports.filterSafeListByFirmware = exports.filterSafeListByBootloader = exports.isValidReleases = exports.isStrictFeatures = void 0;
+exports.getFirmwareType = exports.getFirmwareMode = exports.buildIntermediaryFirmwareFileName = exports.buildLocalFirmwareFileName = exports.findBestCompatibleRelease = exports.isStrictFeatures = void 0;
 const utils_1 = require("@trezor/utils");
 const types_1 = require("../types");
 const isStrictFeatures = (extFeatures) => [1, 2].includes(extFeatures.major_version) &&
@@ -8,26 +8,68 @@ const isStrictFeatures = (extFeatures) => [1, 2].includes(extFeatures.major_vers
         extFeatures.bootloader_mode == null ||
         extFeatures.bootloader_mode === true);
 exports.isStrictFeatures = isStrictFeatures;
-const isValidReleases = (extReleases) => Array.isArray(extReleases) &&
-    extReleases.every(release => release.version && release.min_firmware_version && release.min_bootloader_version);
-exports.isValidReleases = isValidReleases;
-const filterSafeListByBootloader = (releasesList, bootloaderVersion) => {
-    const bootloaderVersions = releasesList.flatMap(item => item.bootloader_version ? [item.bootloader_version] : []);
-    const compatibleRelease = bootloaderVersions.find(item => utils_1.versionUtils.isNewerOrEqual(item, bootloaderVersion));
-    if (bootloaderVersions.length > 0 && !compatibleRelease) {
-        return [];
-    }
-    return releasesList.filter(item => (!item.min_bootloader_version ||
-        utils_1.versionUtils.isNewerOrEqual(bootloaderVersion, item.min_bootloader_version)) &&
-        (!item.bootloader_version ||
-            utils_1.versionUtils.isNewerOrEqual(item.bootloader_version, bootloaderVersion)));
+const findBestCompatibleRelease = (releasesOfDevice, currentVesion, checkProperty) => {
+    if (!releasesOfDevice || Object.keys(releasesOfDevice).length === 0) {
+        return;
+    }
+    const availableFirmwares = Object.values(releasesOfDevice);
+    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 => utils_1.versionUtils.isEqual(currentFirmwareVersion, fw.version));
+        if (!currentRelease?.bootloader_version) {
+            return;
+        }
+    }
+    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]));
+    return compatibleFirmware;
 };
-exports.filterSafeListByBootloader = filterSafeListByBootloader;
-const filterSafeListByFirmware = (releasesList, firmwareVersion) => releasesList.filter(item => utils_1.versionUtils.isNewerOrEqual(firmwareVersion, item.min_firmware_version));
-exports.filterSafeListByFirmware = filterSafeListByFirmware;
-const buildFirmwareFileName = (firmwareType, internalModel, version) => {
+exports.findBestCompatibleRelease = findBestCompatibleRelease;
+const buildLocalFirmwareFileName = (firmwareType, deviceModel, version) => {
     const firmwareTypeFileString = firmwareType === types_1.FirmwareType.BitcoinOnly ? '-bitcoinonly' : '';
-    return `trezor-${internalModel.toLocaleLowerCase()}-${version.join('.')}${firmwareTypeFileString}.bin`;
+    return `trezor-${deviceModel.toLowerCase()}-${version.join('.')}${firmwareTypeFileString}.bin`;
+};
+exports.buildLocalFirmwareFileName = buildLocalFirmwareFileName;
+const buildIntermediaryFirmwareFileName = (internalModel, version) => `trezor-${internalModel.toLowerCase()}-inter-v${version}.bin`;
+exports.buildIntermediaryFirmwareFileName = buildIntermediaryFirmwareFileName;
+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 = types_1.FirmwareType.Universal;
+    if (features.fw_vendor === 'Trezor Bitcoin-only') {
+        type = types_1.FirmwareType.BitcoinOnly;
+    }
+    else if (features.fw_vendor === 'Trezor') {
+        type = types_1.FirmwareType.Universal;
+    }
+    else if ((0, exports.getFirmwareMode)(features) !== 'bootloader') {
+        type =
+            features.capabilities &&
+                features.capabilities.length > 0 &&
+                !features.capabilities.includes('Capability_Bitcoin_like')
+                ? types_1.FirmwareType.BitcoinOnly
+                : types_1.FirmwareType.Universal;
+    }
+    else if ((0, exports.getFirmwareMode)(features) === 'bootloader' && features.unit_btconly) {
+        type = types_1.FirmwareType.BitcoinOnly;
+    }
+    return type;
 };
-exports.buildFirmwareFileName = buildFirmwareFileName;
+exports.getFirmwareType = getFirmwareType;
 //# sourceMappingURL=firmwareUtils.js.map

package/lib/utils/formatUtils.d.ts

@@ -5,6 +5,7 @@ export declare const btckb2satoshib: (n: string) => 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, length?: number) => boolean;
 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>;

package/lib/utils/formatUtils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepTransform = exports.hexToText = exports.messageToHex = exports.addHexPrefix = exports.stripHexPrefix = exports.hasHexPrefix = exports.btckb2satoshib = exports.formatTime = exports.formatAmount = void 0;
+exports.deepTransform = exports.hexToText = exports.messageToHex = exports.isHexString = exports.addHexPrefix = exports.stripHexPrefix = exports.hasHexPrefix = exports.btckb2satoshib = exports.formatTime = exports.formatAmount = void 0;
 const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
 const formatAmount = (n, coinInfo) => `${new bigNumber_1.BigNumber(n).div(10 ** coinInfo.decimals).toString(10)} ${coinInfo.shortcut}`;
 exports.formatAmount = formatAmount;
@@ -40,9 +40,10 @@ const isHexString = (value, length) => {
     }
     return true;
 };
+exports.isHexString = isHexString;
 const messageToHex = (message) => {
     let buffer;
-    if (isHexString(message)) {
+    if ((0, exports.isHexString)(message)) {
         let clean = (0, exports.stripHexPrefix)(message);
         if (clean.length % 2 !== 0) {
             clean = `0${clean}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.6.2",
+  "version": "9.6.3-beta.1",
   "author": "Trezor <info@trezor.io>",
   "homepage": "https://github.com/trezor/trezor-suite/tree/develop/packages/connect",
   "description": "High-level javascript interface for Trezor hardware wallet.",
@@ -78,25 +78,26 @@
     "@solana-program/system": "^0.7.0",
     "@solana-program/token": "^0.5.1",
     "@solana-program/token-2022": "^0.4.2",
-    "@solana/kit": "^2.1.1",
-    "@trezor/blockchain-link": "2.5.2",
-    "@trezor/blockchain-link-types": "1.4.2",
-    "@trezor/blockchain-link-utils": "1.4.2",
+    "@solana/kit": "^2.3.0",
+    "@trezor/blockchain-link": "2.5.3-beta.1",
+    "@trezor/blockchain-link-types": "1.4.3-beta.1",
+    "@trezor/blockchain-link-utils": "1.4.3-beta.1",
     "@trezor/connect-analytics": "1.3.5",
-    "@trezor/connect-common": "0.4.2",
+    "@trezor/connect-common": "0.4.3-beta.1",
     "@trezor/crypto-utils": "1.1.4",
-    "@trezor/device-utils": "1.1.2",
-    "@trezor/env-utils": "^1.4.2",
-    "@trezor/protobuf": "1.4.2",
-    "@trezor/protocol": "1.2.8",
+    "@trezor/device-utils": "1.1.3-beta.1",
+    "@trezor/env-utils": "^1.4.3-beta.1",
+    "@trezor/protobuf": "1.4.3-beta.1",
+    "@trezor/protocol": "1.2.9-beta.1",
     "@trezor/schema-utils": "1.3.4",
-    "@trezor/transport": "1.5.2",
-    "@trezor/type-utils": "1.1.8",
-    "@trezor/utils": "9.4.2",
-    "@trezor/utxo-lib": "2.4.2",
+    "@trezor/transport": "1.5.3-beta.1",
+    "@trezor/type-utils": "1.1.9-beta.1",
+    "@trezor/utils": "9.4.3-beta.1",
+    "@trezor/utxo-lib": "2.4.3-beta.1",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
+    "cbor": "^10.0.10",
     "cross-fetch": "^4.0.0",
     "jws": "^4.0.0"
   },
@@ -120,7 +121,7 @@
     "ts-node": "^10.9.2",
     "tsx": "^4.20.3",
     "web3-utils": "^4.3.2",
-    "webpack": "5.99.9",
+    "webpack": "5.100.0",
     "ws": "^8.18.0"
   },
   "peerDependencies": {

package/lib/api/firmware/getBinaryForFirmwareUpgrade.d.ts

@@ -1,12 +0,0 @@
-import { VersionArray } from '@trezor/device-utils';
-import { GetInfoProps } from '../../data/firmwareInfo';
-import { IntermediaryVersion } from '../../types';
-interface GetBinaryForFirmwareUpgradeProps extends GetInfoProps {
-    baseUrl: string;
-    btcOnly?: boolean;
-    version?: VersionArray;
-    intermediaryVersion?: IntermediaryVersion;
-}
-export declare const getBinaryForFirmwareUpgrade: ({ releases, baseUrl, version, btcOnly, intermediaryVersion, features, }: GetBinaryForFirmwareUpgradeProps) => Promise<ArrayBuffer | Buffer<ArrayBufferLike>>;
-export {};
-//# sourceMappingURL=getBinaryForFirmwareUpgrade.d.ts.map

package/lib/api/firmware/getBinaryForFirmwareUpgrade.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBinaryForFirmwareUpgrade = void 0;
-const utils_1 = require("@trezor/utils");
-const getBinary_1 = require("./getBinary");
-const firmwareInfo_1 = require("../../data/firmwareInfo");
-const assets_1 = require("../../utils/assets");
-const firmwareUtils_1 = require("../../utils/firmwareUtils");
-const getBinaryForFirmwareUpgrade = ({ releases, baseUrl, version, btcOnly, intermediaryVersion, features, }) => {
-    if (!(0, firmwareUtils_1.isStrictFeatures)(features)) {
-        throw new Error('Features of unexpected shape provided');
-    }
-    if (intermediaryVersion) {
-        return (0, assets_1.httpRequest)(`${baseUrl}/firmware/t1b1/trezor-t1b1-inter-v${intermediaryVersion}.bin`, 'binary');
-    }
-    const infoByBootloader = (0, firmwareInfo_1.getInfo)({ features, releases });
-    const releaseByFirmware = releases.find(r => version &&
-        utils_1.versionUtils.isVersionArray(version) &&
-        utils_1.versionUtils.isEqual(r.version, version));
-    if (!infoByBootloader || !releaseByFirmware) {
-        throw new Error('no firmware found for this device');
-    }
-    if (btcOnly && !releaseByFirmware.url_bitcoinonly) {
-        throw new Error(`firmware version ${version} does not exist in btc only variant`);
-    }
-    if (!utils_1.versionUtils.isEqual(releaseByFirmware.version, infoByBootloader.release.version)) {
-        throw new Error(`version provided as param (${releaseByFirmware.version}) does not match firmware version found by features in bootloader (${infoByBootloader.release.version})`);
-    }
-    return (0, getBinary_1.getBinary)({ release: releaseByFirmware, baseUrl, btcOnly });
-};
-exports.getBinaryForFirmwareUpgrade = getBinaryForFirmwareUpgrade;
-//# sourceMappingURL=getBinaryForFirmwareUpgrade.js.map

package/lib/data/getLanguage.d.ts

@@ -1,6 +0,0 @@
-export declare const getLanguage: ({ language, version, internal_model, }: {
-    language: string;
-    version: number[];
-    internal_model: string;
-}) => Promise<ArrayBuffer | Buffer<ArrayBufferLike>>;
-//# sourceMappingURL=getLanguage.d.ts.map

package/lib/data/getLanguage.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLanguage = void 0;
-const assets_1 = require("../utils/assets");
-const getLanguage = ({ language, version, internal_model, }) => {
-    const url = `https://data.trezor.io/firmware/translations/${internal_model.toLowerCase()}/translation-${internal_model.toUpperCase()}-${language}-${version.join('.')}.bin`;
-    return (0, assets_1.httpRequest)(url, 'binary');
-};
-exports.getLanguage = getLanguage;
-//# sourceMappingURL=getLanguage.js.map