@trezor/connect 9.6.2-beta.3 → 9.6.3-beta.1

package/lib/constants/errors.d.ts

@@ -1,3 +1,5 @@
+import { Messages } from '@trezor/protobuf';
+import { thp } from '@trezor/protocol';
 export declare const ERROR_CODES: {
     readonly Init_NotInitialized: "TrezorConnect not initialized";
     readonly Init_AlreadyInitialized: "TrezorConnect has been already initialized";
@@ -11,13 +13,14 @@ export declare const ERROR_CODES: {
     readonly Method_InvalidParameter: "";
     readonly Method_NotAllowed: "Method not allowed for this configuration";
     readonly Method_PermissionsNotGranted: "Permissions not granted";
-    readonly Method_Cancel: "Cancelled";
+    readonly Method_Cancel: "Canceled";
     readonly Method_Interrupted: "Popup closed";
     readonly Method_UnknownCoin: "Coin not found";
     readonly Method_AddressNotMatch: "Addresses do not match";
     readonly Method_Discovery_BundleException: "";
     readonly Method_Override: "override";
     readonly Method_NoResponse: "Call resolved without response";
+    readonly Method_Unsupported: "Unsupported method";
     readonly Backend_NotSupported: "BlockchainLink settings not found in coins.json";
     readonly Backend_WorkerMissing: "";
     readonly Backend_Disconnected: "Backend disconnected";
@@ -37,24 +40,24 @@ export declare const ERROR_CODES: {
     readonly Device_MissingCapabilityBtcOnly: "Device is missing capability (BTC only)";
     readonly Device_ThpPairingTagInvalid: "Pairing tag mismatch";
     readonly Device_ThpStateMissing: "ThpState missing";
-    readonly Failure_ActionCancelled: "Action cancelled by user";
-    readonly Failure_FirmwareError: "Firmware installation failed";
+    readonly Device_ThpPairingMethodsException: "No common pairing methods";
     readonly Failure_UnknownCode: "Unknown error";
-    readonly Failure_PinCancelled: "PIN cancelled";
-    readonly Failure_PinInvalid: "PIN invalid";
-    readonly Failure_PinMismatch: "PIN mismatch";
-    readonly Failure_WipeCodeMismatch: "Wipe code mismatch";
     readonly Failure_EntropyCheck: "";
     readonly Deeplink_VersionMismatch: "Not compatible with current version of the app";
 };
-export type ErrorCode = keyof typeof ERROR_CODES;
+type TypedErrorCode = keyof typeof ERROR_CODES;
+export type ErrorCode = TypedErrorCode | Messages.FailureType | thp.ThpError['code'];
 export declare class TrezorError extends Error {
     code: ErrorCode;
     message: string;
-    constructor(code: ErrorCode, message: string);
+    constructor(code: ErrorCode, message: string, options?: ErrorOptions);
     toString(): string;
 }
+export declare const nestError: (cause: Error) => Error;
+export declare class TransportError extends Error {
+}
 export declare const TypedError: (id: ErrorCode, message?: string) => TrezorError;
 export declare const serializeError: (payload: any) => any;
 export declare const LIBUSB_ERROR_MESSAGE = "LIBUSB_ERROR";
+export {};
 //# sourceMappingURL=errors.d.ts.map

package/lib/constants/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIBUSB_ERROR_MESSAGE = exports.serializeError = exports.TypedError = exports.TrezorError = exports.ERROR_CODES = void 0;
+exports.LIBUSB_ERROR_MESSAGE = exports.serializeError = exports.TypedError = exports.TransportError = exports.nestError = exports.TrezorError = exports.ERROR_CODES = void 0;
 exports.ERROR_CODES = {
     Init_NotInitialized: 'TrezorConnect not initialized',
     Init_AlreadyInitialized: 'TrezorConnect has been already initialized',
@@ -14,13 +14,14 @@ exports.ERROR_CODES = {
     Method_InvalidParameter: '',
     Method_NotAllowed: 'Method not allowed for this configuration',
     Method_PermissionsNotGranted: 'Permissions not granted',
-    Method_Cancel: 'Cancelled',
+    Method_Cancel: 'Canceled',
     Method_Interrupted: 'Popup closed',
     Method_UnknownCoin: 'Coin not found',
     Method_AddressNotMatch: 'Addresses do not match',
     Method_Discovery_BundleException: '',
     Method_Override: 'override',
     Method_NoResponse: 'Call resolved without response',
+    Method_Unsupported: 'Unsupported method',
     Backend_NotSupported: 'BlockchainLink settings not found in coins.json',
     Backend_WorkerMissing: '',
     Backend_Disconnected: 'Backend disconnected',
@@ -40,21 +41,16 @@ exports.ERROR_CODES = {
     Device_MissingCapabilityBtcOnly: 'Device is missing capability (BTC only)',
     Device_ThpPairingTagInvalid: 'Pairing tag mismatch',
     Device_ThpStateMissing: 'ThpState missing',
-    Failure_ActionCancelled: 'Action cancelled by user',
-    Failure_FirmwareError: 'Firmware installation failed',
+    Device_ThpPairingMethodsException: 'No common pairing methods',
     Failure_UnknownCode: 'Unknown error',
-    Failure_PinCancelled: 'PIN cancelled',
-    Failure_PinInvalid: 'PIN invalid',
-    Failure_PinMismatch: 'PIN mismatch',
-    Failure_WipeCodeMismatch: 'Wipe code mismatch',
     Failure_EntropyCheck: '',
     Deeplink_VersionMismatch: 'Not compatible with current version of the app',
 };
 class TrezorError extends Error {
     code;
     message;
-    constructor(code, message) {
-        super(message);
+    constructor(code, message, options) {
+        super(message, options);
         this.code = code;
         this.message = message;
     }
@@ -63,22 +59,20 @@ class TrezorError extends Error {
     }
 }
 exports.TrezorError = TrezorError;
-const TypedError = (id, message) => new TrezorError(id, message || exports.ERROR_CODES[id]);
+const nestError = (cause) => cause instanceof TrezorError
+    ? new TrezorError(cause.code, cause.message, { cause })
+    : new Error(cause.message, { cause });
+exports.nestError = nestError;
+class TransportError extends Error {
+}
+exports.TransportError = TransportError;
+const TypedError = (id, message) => new TrezorError(id, message || exports.ERROR_CODES[id] || id);
 exports.TypedError = TypedError;
 const serializeError = (payload) => {
-    if (payload && payload.error instanceof Error) {
-        return { error: payload.error.message, code: payload.error.code };
-    }
-    if (payload instanceof TrezorError) {
-        return { error: payload.message, code: payload.code };
-    }
-    if (payload instanceof Error) {
-        return {
-            error: payload.message,
-            code: 'code' in payload ? payload.code : 'Failure_UnknownCode',
-        };
-    }
-    return { ...payload };
+    const error = payload?.error instanceof Error ? payload.error : payload;
+    return error instanceof Error
+        ? { error: error.message, code: 'code' in error ? error.code : 'Failure_UnknownCode' }
+        : { ...payload };
 };
 exports.serializeError = serializeError;
 exports.LIBUSB_ERROR_MESSAGE = 'LIBUSB_ERROR';

package/lib/core/AbstractMethod.d.ts

@@ -11,14 +11,16 @@ export type Payload<M> = Extract<CallMethodPayload, {
 export type MethodReturnType<M extends CallMethodPayload['method']> = CallMethodResponse<M>;
 export type MethodPermission = 'read' | 'write' | 'management' | 'push_tx';
 export type DeviceMode = typeof UI.SEEDLESS | typeof UI.BOOTLOADER | typeof UI.INITIALIZE;
-export interface MethodInfo {
+export type MethodInfo = {
+    useUi: boolean;
     useDevice: boolean;
     useDeviceState: boolean;
     name: string;
     requiredPermissions: MethodPermission[];
     info: string;
+    precomposed?: PrecomposeResultFinal;
     confirmation?: UiRequestConfirmation['payload'];
-}
+};
 export declare const DEFAULT_FIRMWARE_RANGE: FirmwareRange;
 export declare abstract class AbstractMethod<Name extends CallMethodPayload['method'], Params = undefined> {
     responseID: number;
@@ -64,28 +66,7 @@ export declare abstract class AbstractMethod<Name extends CallMethodPayload['met
     checkFirmwareRange(): "ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined;
     isManagementRestricted({ popup, origin }: Pick<ConnectSettings, 'popup' | 'origin'>): boolean | undefined;
     abstract init(): void;
-    getMethodInfo(): Promise<{
-        useUi: boolean;
-        useDevice: boolean;
-        useDeviceState: boolean;
-        name: Name;
-        requiredPermissions: MethodPermission[];
-        info: string;
-        confirmation: {
-            view: "thp-pairing-start" | "thp-pairing-failed" | "no-backup" | "export-xpub" | "export-address" | "export-account-info" | "device-management";
-            label?: string;
-            customConfirmButton?: {
-                className: string;
-                label: string;
-            };
-            customCancelButton?: {
-                className: string;
-                label: string;
-            };
-            analytics?: import("@trezor/connect-analytics").EventTypeDeviceSelected;
-        } | undefined;
-        precomposed: PrecomposeResultFinal | undefined;
-    }>;
+    getMethodInfo(): MethodInfo;
     payloadToPrecomposed(): Promise<PrecomposeResultFinal | undefined>;
     checkDeviceCapability(): void;
     abstract run(): Promise<MethodReturnType<Name>>;

package/lib/core/AbstractMethod.js

@@ -213,7 +213,7 @@ class AbstractMethod {
             return !allowed;
         }
     }
-    async getMethodInfo() {
+    getMethodInfo() {
         return {
             useUi: this.useUi,
             useDevice: this.useDevice,
@@ -221,8 +221,8 @@ class AbstractMethod {
             name: this.name,
             requiredPermissions: this.requiredPermissions,
             info: this.info,
+            precomposed: undefined,
             confirmation: this.confirmation,
-            precomposed: await this.payloadToPrecomposed(),
         };
     }
     payloadToPrecomposed() {

package/lib/core/index.js

@@ -246,7 +246,10 @@ const onCall = async (context, message) => {
         return Promise.resolve();
     }
     if (method.payload.__info) {
-        const response = await method.getMethodInfo();
+        const response = method.getMethodInfo();
+        if (method.payload.__precomposed) {
+            response.precomposed = await method.payloadToPrecomposed();
+        }
         sendCoreMessage((0, events_2.createResponseMessage)(method.responseID, true, response));
         return Promise.resolve();
     }
@@ -726,6 +729,7 @@ class Core extends events_1.default {
                             log: _log,
                             abortSignal: this.abortController.signal,
                             registerEvents: registerDeviceEvents(coreContext),
+                            uiPromises: coreContext.uiPromises,
                         },
                     })
                         .then(payload => {

package/lib/core/onCallFirmwareUpdate.d.ts

@@ -1,10 +1,21 @@
 import type { Device } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
-import { CoreEventMessage } from '../events';
+import { CoreEventMessage, UiPromiseCreator } from '../events';
 import { CommonParams, DeviceUniquePath } from '../types';
 import { FirmwareUpdateResponse } from '../types/api/firmwareUpdate';
 import type { Log } from '../utils/debug';
 type PostMessage = (message: CoreEventMessage) => void;
+type ReconnectContext = {
+    deviceList: DeviceList;
+    device: Device;
+    registerEvents: (device: Device) => void;
+    postMessage: PostMessage;
+    log: Log;
+    abortSignal: AbortSignal;
+    uiPromises: {
+        create: UiPromiseCreator;
+    };
+};
 export type Params = {
     language?: string;
     baseUrl?: string;
@@ -18,6 +29,7 @@ type Context = {
     initDevice: (path?: DeviceUniquePath) => Promise<Device>;
     log: Log;
     abortSignal: AbortSignal;
+    uiPromises: ReconnectContext['uiPromises'];
 };
 type OnCallFirmwareUpdateParams = {
     params: Params;

package/lib/core/onCallFirmwareUpdate.js

@@ -7,7 +7,8 @@ const firmware_1 = require("../api/firmware");
 const constants_1 = require("../constants");
 const firmwareInfo_1 = require("../data/firmwareInfo");
 const events_1 = require("../events");
-const waitForReconnectedDevice = async ({ bootloader, method, intermediary }, { deviceList, device, registerEvents, postMessage, log, abortSignal }) => {
+const types_1 = require("../types");
+const waitForReconnectedDevice = async ({ bootloader, method, intermediary }, { deviceList, device, registerEvents, postMessage, log, abortSignal, uiPromises, }) => {
     const target = intermediary || !bootloader ? 'normal' : 'bootloader';
     let i = 0;
     if (method !== 'auto') {
@@ -25,6 +26,7 @@ const waitForReconnectedDevice = async ({ bootloader, method, intermediary }, {
     }
     log.debug('onCallFirmwareUpdate', `waiting for device to reconnect in ${bootloader ? 'bootloader' : 'normal'} mode`);
     let reconnectedDevice;
+    let thpPairingError = false;
     do {
         postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_RECONNECT, {
             device: device.toMessageObject(),
@@ -41,14 +43,29 @@ const waitForReconnectedDevice = async ({ bootloader, method, intermediary }, {
         }
         if (reconnectedDevice && !reconnectedDevice.features) {
             log.debug('onCallFirmwareUpdate', 'we were unable to read device.features on the first interaction after seeing it, retrying...');
+            let runFn;
+            if (reconnectedDevice.getThpState()?.properties) {
+                const uiPromise = uiPromises.create(events_1.UI.RECEIVE_CONFIRMATION, reconnectedDevice);
+                postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+                    view: thpPairingError ? 'thp-pairing-failed' : 'thp-pairing-start',
+                }));
+                const uiResp = await uiPromise.promise;
+                if (!uiResp.payload) {
+                    throw constants_1.ERRORS.TypedError('Method_PermissionsNotGranted');
+                }
+                runFn = () => Promise.resolve();
+            }
             try {
                 registerEvents(reconnectedDevice);
-                await reconnectedDevice.run(undefined, {
+                await reconnectedDevice.run(runFn, {
                     skipFirmwareChecks: true,
                     skipLanguageChecks: true,
                 });
             }
-            catch {
+            catch (error) {
+                if (error.code === 'Device_ThpPairingTagInvalid') {
+                    thpPairingError = true;
+                }
             }
         }
         i++;
@@ -76,27 +93,68 @@ const waitForReconnectedDevice = async ({ bootloader, method, intermediary }, {
     }
     return reconnectedDevice;
 };
+const getRebootMethod = async ({ deviceList, device, log, postMessage, }) => {
+    let method = 'wait';
+    if (!device.bluetoothProps) {
+        return method;
+    }
+    const ctrl = new AbortController();
+    const disconnectedPromise = new Promise(resolve => {
+        const handleDisconnect = () => {
+            log.info(`waitForBluetoothReboot device-disconnected. aborted: ${ctrl.signal.aborted}`);
+            if (!ctrl.signal.aborted) {
+                ctrl.abort();
+                method = 'auto';
+            }
+            resolve();
+        };
+        deviceList.once('device-disconnect', handleDisconnect);
+        ctrl.signal.addEventListener('abort', () => {
+            deviceList.off('device-disconnect', handleDisconnect);
+            resolve();
+        });
+    });
+    await device.release();
+    const restartPromise = new Promise(resolve => {
+        (0, utils_1.resolveAfter)(4000).then(() => {
+            log.info(`waitForBluetoothReboot restartPromise. aborted: ${ctrl.signal.aborted}`);
+            if (!ctrl.signal.aborted) {
+                ctrl.abort();
+                postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_DISCONNECT, {
+                    device: device.toMessageObject(),
+                }));
+            }
+            resolve();
+        });
+    });
+    await Promise.race([disconnectedPromise, restartPromise]);
+    return method;
+};
 const getInstallationParams = (device, params) => {
-    const btcOnly = params.btcOnly ?? device.firmwareType === 'bitcoin-only';
+    const btcOnly = params.btcOnly ?? device.firmwareType === types_1.FirmwareType.BitcoinOnly;
     if (!device.features.bootloader_mode) {
         const version = params.binary
             ? (0, firmware_1.parseFirmwareHeaders)(Buffer.from(params.binary)).version
             : undefined;
         const isUpdatingToNewerVersion = !version
-            ? device.firmwareRelease?.isNewer
+            ? device.firmwareReleaseConfigInfo?.isNewer
             : (0, versionUtils_1.isNewer)(version, [
                 device.features.major_version,
                 device.features.minor_version,
                 device.features.patch_version,
             ]);
-        const isUpdatingToEqualFirmwareType = (device.firmwareType === 'bitcoin-only') === btcOnly;
+        const isUpdatingToEqualFirmwareType = (device.firmwareType === types_1.FirmwareType.BitcoinOnly) === btcOnly;
         const upgrade = device.atLeast('2.6.3') && isUpdatingToNewerVersion && isUpdatingToEqualFirmwareType;
         const manual = !device.atLeast(['1.10.0', '2.6.0']) && !upgrade;
-        const language = false;
+        const getUpdateFlowType = () => {
+            if (manual)
+                return 'manual';
+            return upgrade ? 'reboot_and_upgrade' : 'reboot_and_wait';
+        };
         return {
             manual,
             upgrade,
-            language,
+            updateFlowType: getUpdateFlowType(),
             btcOnly,
         };
     }
@@ -104,80 +162,100 @@ const getInstallationParams = (device, params) => {
         return {
             manual: false,
             upgrade: false,
-            language: false,
+            updateFlowType: 'unknown_flow',
             btcOnly,
         };
     }
 };
 const getFwHeader = (binary) => Buffer.from(binary.slice(0, 6000)).toString('hex');
-const getBinaryHelper = (device, params, log, postMessage, btcOnly) => {
+const getBinaryHelper = async ({ device, params, firmwareType, isIntermediary, log, }) => {
     if (params.binary) {
-        return {
+        return Promise.resolve({
             binary: params.binary,
             binaryVersion: (0, firmware_1.parseFirmwareHeaders)(Buffer.from(params.binary)).version,
             releaseVersion: undefined,
-        };
+        });
     }
-    if (!device.firmwareRelease) {
-        throw constants_1.ERRORS.TypedError('Runtime', 'device.firmwareRelease is not set');
+    if (!device.firmwareReleaseConfigInfo) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'device.firmwareReleaseConfigInfo is not set');
     }
-    const { intermediaryVersion, release: { version }, } = device.firmwareRelease;
-    log.debug('onCallFirmwareUpdate loading binary', 'intermediaryVersion', intermediaryVersion, 'version', version, 'btcOnly', btcOnly);
-    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
-        device: device.toMessageObject(),
-        operation: 'downloading',
-        progress: 0,
-    }));
-    return (0, firmware_1.getBinaryForFirmwareUpgrade)({
-        features: device.features,
-        releases: (0, firmwareInfo_1.getReleases)(device.features?.internal_model),
-        baseUrl: params.baseUrl || 'https://data.trezor.io',
-        version,
-        btcOnly,
-        intermediaryVersion,
-    })
-        .then(res => {
-        if (res.byteLength < 200) {
-            throw constants_1.ERRORS.TypedError('Runtime', 'Firmware binary is too small');
-        }
-        return res;
-    })
-        .then(res => {
-        postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
-            device: device.toMessageObject(),
-            operation: 'downloading',
-            progress: 100,
-        }));
-        return {
-            binary: res,
-            binaryVersion: (0, firmware_1.parseFirmwareHeaders)(Buffer.from(res)).version,
-            releaseVersion: version,
-        };
+    const deviceModel = device.features?.internal_model;
+    const { release: { version }, intermediary, } = device.firmwareReleaseConfigInfo;
+    log.debug('onCallFirmwareUpdate loading binary', 'isIntermediary', isIntermediary, 'version', version, 'firmwareType', firmwareType, 'deviceModel', deviceModel);
+    const release = await (0, firmwareInfo_1.getReleaseByVersion)(device.features, version, firmwareType);
+    if (!release) {
+        throw new Error('Missing Firmware release for device');
+    }
+    const { baseUrl, path } = (0, firmwareInfo_1.getFirmwareLocation)({
+        firmwareVersion: version,
+        remotePath: release.url,
+        deviceModel,
+        firmwareType,
+        intermediaryVersion: isIntermediary && intermediary ? intermediary.version : undefined,
     });
+    return (0, firmware_1.getBinary)({ baseUrl, path, version });
 };
 const onCallFirmwareUpdate = async ({ params, context, }) => {
     const { deviceList, registerEvents, postMessage, initDevice, log } = context;
     log.debug('onCallFirmwareUpdate with params: ', params);
+    const firmwareType = params.btcOnly ? types_1.FirmwareType.BitcoinOnly : types_1.FirmwareType.Universal;
     const device = await initDevice(params?.device?.path);
+    if (!device.features) {
+        throw constants_1.ERRORS.TypedError('Device_NotFound', 'Device missing features');
+    }
     if (deviceList.getDeviceCount() > 1) {
         throw constants_1.ERRORS.TypedError('Device_MultipleNotSupported', 'Firmware update allowed with only 1 device connected');
     }
     log.debug('onCallFirmwareUpdate', 'device', device);
     registerEvents(device);
-    const { manual, upgrade, language, btcOnly } = getInstallationParams(device, params);
+    const { manual, upgrade, updateFlowType, btcOnly } = getInstallationParams(device, params);
     log.debug('onCallFirmwareUpdate', 'installation params', {
         manual,
         upgrade,
-        language,
+        updateFlowType,
         btcOnly,
     });
-    let binaryInfo = await getBinaryHelper(device, params, log, postMessage, btcOnly);
-    const { binary } = binaryInfo;
+    const intermediary = !params.binary && device?.firmwareReleaseConfigInfo?.intermediary;
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        operation: 'downloading',
+        progress: 0,
+    }));
+    let intermediaryBinaryInfo;
+    let finalBinaryInfo;
+    const fwFetchPromises = [];
+    if (intermediary) {
+        fwFetchPromises.push(getBinaryHelper({ device, params, firmwareType, isIntermediary: true, log }));
+    }
+    fwFetchPromises.push(getBinaryHelper({ device, params, firmwareType, isIntermediary: false, log }));
+    const [firstResult, finalResult] = await Promise.all(fwFetchPromises);
+    if (intermediary) {
+        intermediaryBinaryInfo = firstResult;
+        finalBinaryInfo = finalResult;
+    }
+    else {
+        finalBinaryInfo = firstResult;
+    }
+    const firstBinaryInfo = intermediary ? intermediaryBinaryInfo : finalBinaryInfo;
+    if (!firstBinaryInfo) {
+        throw new Error('Missing binary, something went wrong.');
+    }
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        operation: 'downloading',
+        progress: 100,
+    }));
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_DOWNLOADED, {
+        binary: finalBinaryInfo.binary,
+        binaryVersion: finalBinaryInfo.binaryVersion,
+        releaseVersion: finalBinaryInfo.releaseVersion,
+        firmwareType: device.firmwareType,
+        internalModel: device.features.internal_model,
+    }));
     const deviceInitiallyConnectedInBootloader = device.features.bootloader_mode;
-    const deviceInitiallyConnectedWithoutFirmware = device.features.firmware_present === false;
     let reconnectedDevice = device;
     if (deviceInitiallyConnectedInBootloader) {
-        log.warn('onCallFirmwareUpdate', 'device is already in bootloader mode. language will not be updated');
+        log.warn('onCallFirmwareUpdate', 'device is already in bootloader mode.');
         await device.acquire();
     }
     else if (manual) {
@@ -187,73 +265,59 @@ const onCallFirmwareUpdate = async ({ params, context, }) => {
         const rebootParams = upgrade
             ? {
                 boot_command: constants_1.PROTO.BootCommand.INSTALL_UPGRADE,
-                firmware_header: getFwHeader(binary),
+                firmware_header: getFwHeader(firstBinaryInfo.binary),
             }
             : {};
         await device.acquire();
-        const targetLanguage = params.language || device.features.language || 'en-US';
-        const languageBlob = device.firmwareRelease && language && targetLanguage !== 'en-US'
-            ? await (0, firmware_1.getLanguage)({
-                language: targetLanguage,
-                version: device.firmwareRelease.release.version,
-                internal_model: device.features.internal_model,
-            }).catch(() => {
-            })
-            : null;
         const disconnectedPromise = new Promise(resolve => {
             deviceList.once('device-disconnect', resolve);
         });
-        if (!languageBlob) {
-            await device.getCommands().typedCall('RebootToBootloader', 'Success', rebootParams);
-        }
-        else {
-            let rebootResponse = await device.getCommands().typedCall('RebootToBootloader', ['DataChunkRequest', 'Success'], { ...rebootParams, language_data_length: languageBlob?.byteLength });
-            log.debug('onCallFirmwareUpdate', 'RebootToBootloader response', rebootResponse.message);
-            while (languageBlob && rebootResponse.type !== 'Success') {
-                const start = rebootResponse.message.data_offset;
-                const end = rebootResponse.message.data_offset + rebootResponse.message.data_length;
-                const chunk = languageBlob.slice(start, end);
-                rebootResponse = await device.getCommands().typedCall('DataChunkAck', ['DataChunkRequest', 'Success'], { data_chunk: Buffer.from(chunk).toString('hex') });
-            }
-        }
+        await device.getCommands().typedCall('RebootToBootloader', 'Success', rebootParams);
         log.info('onCallFirmwareUpdate', 'waiting for disconnected event after rebootToBootloader...');
+        if (device.bluetoothProps) {
+            await device.release();
+            postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_DISCONNECT, {
+                device: device.toMessageObject(),
+            }));
+        }
         await disconnectedPromise;
         if (device.features.major_version === 1) {
             await (0, utils_1.resolveAfter)(2000);
         }
         reconnectedDevice = await waitForReconnectedDevice({ bootloader: true, method: 'auto' }, { ...context, device });
     }
-    const intermediary = !params.binary && device.firmwareRelease?.intermediaryVersion;
     const bootloaderVersion = reconnectedDevice.getVersion();
     await reconnectedDevice.initialize(false);
-    let stripped = (0, firmware_1.stripFwHeaders)(binary);
-    await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall, postMessage, reconnectedDevice, { payload: !intermediary && (0, firmware_1.shouldStripFwHeaders)(device.features) ? stripped : binary });
+    let stripped = (0, firmware_1.stripFwHeaders)(firstBinaryInfo.binary);
+    const payload = !intermediary && (0, firmware_1.shouldStripFwHeaders)(device.features) ? stripped : firstBinaryInfo.binary;
+    await (0, firmware_1.uploadFirmware)({
+        typedCall: reconnectedDevice.getCommands().typedCall,
+        postMessage,
+        device: reconnectedDevice,
+        firmwareUploadRequest: { payload },
+        updateFlowType,
+    });
     log.info('onCallFirmwareUpdate', 'firmware uploaded');
     if (intermediary) {
         log.info('onCallFirmwareUpdate', '...but it was the intermediary firmware, so one more go');
         reconnectedDevice = await waitForReconnectedDevice({ bootloader: true, method: 'manual', intermediary: true }, { ...context, device: reconnectedDevice });
-        binaryInfo = await getBinaryHelper(reconnectedDevice, params, log, postMessage, btcOnly);
-        stripped = (0, firmware_1.stripFwHeaders)(binaryInfo.binary);
+        stripped = (0, firmware_1.stripFwHeaders)(finalBinaryInfo.binary);
         await reconnectedDevice.initialize(false);
-        await (0, firmware_1.uploadFirmware)(reconnectedDevice.getCommands().typedCall, postMessage, reconnectedDevice, { payload: stripped });
-    }
-    reconnectedDevice = await waitForReconnectedDevice({ bootloader: false, method: 'wait' }, { ...context, device: reconnectedDevice });
-    if (reconnectedDevice.atLeast('2.7.0') &&
-        deviceInitiallyConnectedWithoutFirmware &&
-        params.language) {
-        try {
-            log.info('onCallFirmwareUpdate', 'changing language for fresh device to: ', params.language);
-            await reconnectedDevice.changeLanguage({ language: params.language });
-        }
-        catch (err) {
-            log.error('onCallFirmwareUpdate', 'changeLanguage failed silently: ', err);
-        }
+        await (0, firmware_1.uploadFirmware)({
+            typedCall: reconnectedDevice.getCommands().typedCall,
+            postMessage,
+            device: reconnectedDevice,
+            firmwareUploadRequest: { payload: stripped },
+            updateFlowType,
+        });
     }
+    const method = await getRebootMethod({ deviceList, device, log, postMessage });
+    reconnectedDevice = await waitForReconnectedDevice({ bootloader: false, method }, { ...context, device: reconnectedDevice });
     const installedVersion = reconnectedDevice.getVersion();
     if (!bootloaderVersion || !installedVersion) {
         throw constants_1.ERRORS.TypedError('Runtime', 'reconnectedDevice.installedVersion is not set');
     }
-    const { binaryVersion, releaseVersion } = binaryInfo;
+    const { binaryVersion, releaseVersion } = finalBinaryInfo;
     const assertBinaryVersion = (0, versionUtils_1.isEqual)(installedVersion, binaryVersion);
     const assertReleaseVersion = releaseVersion ? (0, versionUtils_1.isEqual)(installedVersion, releaseVersion) : true;
     await reconnectedDevice.release();

package/lib/data/DataManager.d.ts

@@ -1,3 +1,4 @@
+import { ConditionalRelease, DeviceModelInternal, FirmwareReleaseConfig, FirmwareType, IntermediaryReleaseConfig, ReleasesConfig } from '@trezor/device-utils';
 import type { ConnectSettings, LocalFirmwares } from '../types/settings';
 type AssetKeys = `firmware-${string}` | 'coins' | 'coinsEth';
 type AssetCollection = {
@@ -8,12 +9,23 @@ export declare class DataManager {
     private static settings;
     private static messages;
     private static localFirmwares;
-    static load(settings: ConnectSettings, withAssets?: boolean): void;
+    private static firmwareReleasesConfig;
+    private static firmwareIntermediaryReleasesConfig;
+    private static localFirmwareReleaseConfig;
+    static load(settings: ConnectSettings, withAssets?: boolean, onlyLocalFirmwareConfig?: boolean): Promise<void>;
+    static prepareLocalFirmwareReleaseData(): void;
+    static loadFirmwareRelaseConfig(onlyLocal: boolean): Promise<void>;
     static getProtobufMessages(): Record<string, any>;
     static getSettings(key?: undefined): ConnectSettings;
     static getSettings<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];
     static setLocalFirmwares(firmwares: LocalFirmwares): void;
     static getLocalFirmwares(): LocalFirmwares;
+    static setLocalFirmwareReleaseConfig(localFirmwareReleaseConfig: FirmwareReleaseConfig): void;
+    static getLocalFirmwareReleaseConfig(): FirmwareReleaseConfig;
+    static setFirmwareReleaseConfig(releaseConfig: ReleasesConfig): void;
+    static getFirmwareReleaseConfig(): Partial<Record<"T1B1" | "T2T1" | "T2B1" | "T3B1" | "T3T1" | "T3W1" | "UNKNOWN", Record<FirmwareType, ConditionalRelease>>>;
+    static setFirmwareIntermediaryReleaseConfig(intermediariesConfig: Record<DeviceModelInternal, IntermediaryReleaseConfig[]>): void;
+    static getFirmwareIntermediaryReleaseConfig(): Record<"T1B1" | "T2T1" | "T2B1" | "T3B1" | "T3T1" | "T3W1" | "UNKNOWN", IntermediaryReleaseConfig[]> | undefined;
 }
 export {};
 //# sourceMappingURL=DataManager.d.ts.map