@trezor/connect 9.6.3-beta.2 → 9.6.4-beta.1

package/lib/device/DeviceList.d.ts

@@ -1,7 +1,6 @@
 import { TRANSPORT } from '@trezor/transport';
-import type { TransportApiType } from '@trezor/transport/lib/transports/abstract';
 import { TypedEmitter } from '@trezor/utils';
-import { DEVICE, TransportError, TransportInfo } from '../events';
+import { DEVICE, DecodedTrezorPushNotification, TransportError, TransportInfo } from '../events';
 import { Device } from './Device';
 import { ConnectSettings, DeviceUniquePath, StaticSessionId } from '../types';
 interface DeviceListEvents {
@@ -9,6 +8,9 @@ interface DeviceListEvents {
     [TRANSPORT.ERROR]: TransportError;
     [DEVICE.CONNECT]: Device;
     [DEVICE.CONNECT_UNACQUIRED]: Device;
+    [DEVICE.TREZOR_PUSH_NOTIFICATION]: DecodedTrezorPushNotification & {
+        device: Device;
+    };
     [DEVICE.DISCONNECT]: Device;
     [DEVICE.CHANGED]: Device;
 }
@@ -39,8 +41,8 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     isConnected(): this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
     getActiveTransports(): {
-        apiType: TransportApiType;
-        type: "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport" | "NativeUsbTransport" | "BluetoothTransport";
+        apiType: "usb" | "bluetooth" | "udp";
+        type: "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport" | "NativeUsbTransport" | "BluetoothTransport" | "NativeBluetoothTransport";
         version: string;
         outdated: boolean;
     }[];
@@ -51,6 +53,7 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
     private initializeTransport;
     private waitForDevices;
     getDeviceCount(): number;
+    getPrioritizedDevices(): Device[];
     getAllDevices(): readonly Device[];
     getOnlyDevice(): Device | undefined;
     getDeviceByPath(path: DeviceUniquePath): Device | undefined;

package/lib/device/DeviceList.js

@@ -81,7 +81,7 @@ class DeviceList extends utils_1.TypedEmitter {
     }
     async onDeviceConnected(descriptor, transport) {
         const id = (this.deviceCounter++).toString(16).slice(-8);
-        const device = new Device_1.Device({ id: (0, types_1.DeviceUniquePath)(id), transport, descriptor });
+        const device = new Device_1.Device({ id: (0, types_1.asDeviceUniquePath)(id), transport, descriptor });
         const penalty = this.authPenaltyManager.get();
         const stillConnected = await this.handshakeLock(() => (0, utils_1.resolveAfter)(penalty && penalty + 501).then(() => device.handshake()));
         if (!stillConnected) {
@@ -91,6 +91,12 @@ class DeviceList extends utils_1.TypedEmitter {
         device.lifecycle.on(events_1.DEVICE.CONNECT, () => this.emit(events_1.DEVICE.CONNECT, device));
         device.lifecycle.on(events_1.DEVICE.CHANGED, () => this.emit(events_1.DEVICE.CHANGED, device));
         device.lifecycle.on(events_1.DEVICE.CONNECT_UNACQUIRED, () => this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device));
+        device.lifecycle.on(events_1.DEVICE.TREZOR_PUSH_NOTIFICATION, payload => {
+            this.emit(events_1.DEVICE.TREZOR_PUSH_NOTIFICATION, {
+                device,
+                ...payload,
+            });
+        });
         device.lifecycle.on(events_1.DEVICE.DISCONNECT, () => {
             device.lifecycle.removeAllListeners();
             this.authPenaltyManager.remove(device);
@@ -153,18 +159,22 @@ class DeviceList extends utils_1.TypedEmitter {
     getDeviceCount() {
         return this.devices.length;
     }
+    getPrioritizedDevices() {
+        return [...this.devices].sort((a, b) => (a.descriptor.apiType === 'bluetooth' ? 1 : 0) -
+            (b.descriptor.apiType === 'bluetooth' ? 1 : 0));
+    }
     getAllDevices() {
-        return this.devices;
+        return this.getPrioritizedDevices();
     }
     getOnlyDevice() {
         return this.devices.length === 1 ? this.devices[0] : undefined;
     }
     getDeviceByPath(path) {
-        return this.devices.find(d => d.getUniquePath() === path);
+        return this.getPrioritizedDevices().find(d => d.getUniquePath() === path);
     }
     getDeviceByStaticState(state) {
         const deviceId = state.split('@')[1].split(':')[0];
-        return this.devices.find(d => d.features?.device_id === deviceId);
+        return this.getPrioritizedDevices().find(d => d.features?.device_id === deviceId);
     }
     async dispose() {
         this.removeAllListeners();

package/lib/device/StateStorage.d.ts

@@ -1,5 +1,5 @@
-import { DeviceState } from '../types';
 import { Device } from './Device';
+import { DeviceState } from '../types/device';
 export interface IStateStorage {
     saveState(device: Device, state: DeviceState): void;
     loadState(device: Device): DeviceState | undefined;

package/lib/device/checkFirmwareRevision.d.ts

@@ -1,5 +1,5 @@
 import type { FirmwareType, VersionArray } from '@trezor/device-utils';
-import { PROTO } from '../constants';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import { FirmwareRevisionCheckResult } from '../types/device';
 export type CheckFirmwareRevisionParams = {
     firmwareVersion: VersionArray;

package/lib/device/checkFirmwareRevision.js

@@ -4,8 +4,8 @@ exports.checkFirmwareRevision = void 0;
 const utils_1 = require("@trezor/utils");
 const calculateRevisionForDevice_1 = require("./calculateRevisionForDevice");
 const firmwareInfo_1 = require("../data/firmwareInfo");
-const assets_browser_1 = require("../utils/assets-browser");
-const isNotFoundError = (e) => e instanceof assets_browser_1.HttpRequestError && e.response.status === 404;
+const assetUtils_1 = require("../utils/assetUtils");
+const isNotFoundError = (e) => e instanceof assetUtils_1.HttpRequestError && e.response.status === 404;
 const isNodeJSOfflineError = (e) => ['FetchError', 'AbortError'].includes(e.name);
 const isReactNativeOfflineError = (e) => e.name === 'TypeError' && e.message.includes('Network request failed');
 const isAbortControllerTimeout = (e) => e.name === 'AbortError' ||

package/lib/device/thp/handshake.d.ts

@@ -1,4 +1,4 @@
 import type { Device } from '../Device';
 export declare const createThpChannel: (device: Device) => Promise<void>;
-export declare const thpHandshake: (device: Device) => Promise<void>;
+export declare const thpHandshake: (device: Device, unlockPin?: boolean) => Promise<void>;
 //# sourceMappingURL=handshake.d.ts.map

package/lib/device/thp/handshake.js

@@ -38,7 +38,7 @@ const createThpChannel = async (device) => {
     });
 };
 exports.createThpChannel = createThpChannel;
-const thpHandshake = async (device) => {
+const thpHandshake = async (device, unlockPin = false) => {
     const thpState = device.getThpState();
     if (!thpState?.handshakeCredentials) {
         throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
@@ -49,9 +49,11 @@ const thpHandshake = async (device) => {
         : (0, crypto_1.randomBytes)(32);
     const hostStaticKeys = protocol_1.thp.getCurve25519KeyPair(staticKey);
     const knownCredentials = (settings?.knownCredentials || []).sort(cre => cre.autoconnect ? -1 : 1);
+    const tryToUnlock = unlockPin ? 1 : 0;
     const hostEphemeralKeys = protocol_1.thp.getCurve25519KeyPair((0, crypto_1.randomBytes)(32));
     const handshakeInit = await (0, thpCall_1.thpCall)(device, 'ThpHandshakeInitRequest', {
         key: hostEphemeralKeys.publicKey,
+        tryToUnlock,
     });
     const { trezorEncryptedStaticPubkey } = handshakeInit.message;
     const handshakeCredentials = protocol_1.thp.handleHandshakeInit({
@@ -60,6 +62,7 @@ const thpHandshake = async (device) => {
         hostStaticKeys,
         hostEphemeralKeys,
         knownCredentials,
+        tryToUnlock,
         protobufEncoder: (name, data) => (0, protobuf_1.encodeMessage)(device.transport.getMessages(), name, data),
     });
     const { hostKey, trezorKey, hostEncryptedStaticPubkey } = handshakeCredentials;
@@ -77,9 +80,17 @@ const thpHandshake = async (device) => {
         hostPubkey: hostEncryptedStaticPubkey,
         encryptedPayload: handshakeCredentials.encryptedPayload,
     });
-    thpState.setIsPaired(!!handshakeCompletion.message.state);
+    if (!handshakeCompletion.message.state && handshakeCredentials.credentials) {
+        thpState.removePairingCredential(handshakeCredentials.credentials);
+        const { credential } = handshakeCredentials.credentials;
+        const index = settings?.knownCredentials?.findIndex(c => c.credential === credential) ?? -1;
+        if (index >= 0) {
+            settings?.knownCredentials?.splice(index, 1);
+        }
+    }
+    thpState.setIsPaired(handshakeCompletion.message.state !== 0);
     thpState.setPhase('pairing');
-    if (thpState.isPaired && thpState.isAutoconnectPaired) {
+    if (thpState.isAutoconnectPaired || handshakeCompletion.message.state === 2) {
         await (0, thpCall_1.thpCall)(device, 'ThpEndRequest', {});
         thpState.setPhase('paired');
     }

package/lib/device/thp/index.d.ts

@@ -2,5 +2,5 @@ import type { Device } from '../Device';
 export { abortThpWorkflow } from './thpCall';
 export { getThpCredentials } from './pairing';
 export { createThpSession } from './session';
-export declare const getThpChannel: (device: Device, withInteraction?: boolean) => Promise<void>;
+export declare const getThpChannel: (device: Device, withInteraction?: boolean) => Promise<"pin-locked" | "thp-locked" | undefined>;
 //# sourceMappingURL=index.d.ts.map

package/lib/device/thp/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getThpChannel = exports.createThpSession = exports.getThpCredentials = exports.abortThpWorkflow = void 0;
+const device_1 = require("../../events/device");
 const handshake_1 = require("./handshake");
 const pairing_1 = require("./pairing");
 var thpCall_1 = require("./thpCall");
@@ -11,17 +12,41 @@ var session_1 = require("./session");
 Object.defineProperty(exports, "createThpSession", { enumerable: true, get: function () { return session_1.createThpSession; } });
 const getThpChannel = async (device, withInteraction) => {
     const thpState = device.getThpState();
+    if (!thpState)
+        return;
     try {
-        if (thpState?.phase === 'handshake') {
+        if (thpState.phase === 'handshake') {
             await (0, handshake_1.createThpChannel)(device);
-            await (0, handshake_1.thpHandshake)(device);
+            try {
+                await (0, handshake_1.thpHandshake)(device);
+            }
+            catch (error) {
+                const isPinLocked = error.code === 'ThpDeviceLocked';
+                const isTransportBusy = error.message === 'ThpTransportBusy';
+                if (!isPinLocked && !isTransportBusy)
+                    throw error;
+                thpState.resetState();
+                if (isPinLocked && !withInteraction)
+                    return 'pin-locked';
+                if (isPinLocked) {
+                    device.emit(device_1.DEVICE.BUTTON, {
+                        device,
+                        payload: { code: 'ButtonRequest_PinEntry' },
+                    });
+                }
+                await (0, handshake_1.createThpChannel)(device);
+                await (0, handshake_1.thpHandshake)(device, isPinLocked);
+            }
         }
-        if (thpState?.phase === 'pairing' && withInteraction) {
+        if (thpState.phase === 'pairing' && withInteraction) {
             await (0, pairing_1.thpPairing)(device);
         }
+        if (thpState.phase !== 'paired') {
+            return 'thp-locked';
+        }
     }
     catch (error) {
-        thpState?.resetState();
+        thpState.resetState();
         throw error;
     }
 };

package/lib/device/thp/pairing.js

@@ -83,9 +83,7 @@ const processThpPairingResponse = (device, payload) => {
 const waitForPairingCancel = (device) => {
     const readAbort = new AbortController();
     device.getThpState()?.setExpectedResponses([0x04]);
-    const readCancel = device.getCurrentSession().receive({
-        signal: readAbort.signal,
-    });
+    const readCancel = device.getCurrentSession().receive({ signal: readAbort.signal });
     return {
         readAbort,
         readCancel,

package/lib/device/thp/session.js

@@ -4,7 +4,7 @@ exports.createThpSession = void 0;
 const thpCall_1 = require("./thpCall");
 const createThpSession = async (device, deriveCardano) => {
     let passphrase;
-    if (!device.features.passphrase_protection) {
+    if (device.features.passphrase_protection === false) {
         passphrase = { passphrase: '' };
     }
     else {

package/lib/device/workflow/checkFirmwareHash.js

@@ -51,7 +51,12 @@ const checkFirmwareHash = async ({ device, logger, }) => {
         return createFailResult('check-unsupported');
     }
     const strippedBinary = (0, firmware_1.stripFwHeaders)(firmwareBinary.binary);
-    const { hash: expectedHash, challenge } = (0, firmware_1.calculateFirmwareHash)(device.features.internal_model, strippedBinary, (0, crypto_1.randomBytes)(32));
+    const { hash: expectedHash, challenge } = (0, firmware_1.calculateFirmwareHash)({
+        internal_model: device.features.internal_model,
+        firmwareVersion,
+        fw: strippedBinary,
+        key: (0, crypto_1.randomBytes)(32),
+    });
     try {
         const ts = performance.now();
         const deviceResponse = await device

package/lib/device/workflow/handshake.js

@@ -13,10 +13,9 @@ const handshakeCancel = async ({ device, logger, signal }) => {
     if (device.features || device.getThpState()?.properties) {
         return;
     }
+    const timeout = device.possibleT1 ? CANCEL_TIMEOUT : undefined;
     logger?.debug('handshake Cancel start');
-    const send = await device
-        .getCurrentSession()
-        .send('Cancel', {}, { signal, timeout: CANCEL_TIMEOUT });
+    const send = await device.getCurrentSession().send('Cancel', {}, { signal, timeout });
     if (!send.success) {
         logger?.debug(`handshake Cancel send error ${send.error}`);
         return;
@@ -24,10 +23,7 @@ const handshakeCancel = async ({ device, logger, signal }) => {
     logger?.debug('handshake Cancel sent');
     for (let attempt = 0; attempt < ATTEMPTS_LIMIT; ++attempt) {
         logger?.debug(`handshake Cancel read attempt ${attempt}`);
-        const result = await device.getCurrentSession().receive({
-            signal,
-            timeout: CANCEL_TIMEOUT,
-        });
+        const result = await device.getCurrentSession().receive({ signal, timeout });
         if (!result.success && result.error.message === transport_1.TRANSPORT_ERROR.ABORTED_BY_TIMEOUT) {
             if (isLegacyBridge(device.transport)) {
                 await (0, utils_1.resolveAfter)(501);

package/lib/device/workflow/trezorPushNotification.d.ts

@@ -0,0 +1,3 @@
+import { TpnWorkflowContext } from '../../types/workflow';
+export declare const trezorPushNotificationHandler: ({ device, message }: TpnWorkflowContext) => Promise<void>;
+//# sourceMappingURL=trezorPushNotification.d.ts.map

package/lib/device/workflow/trezorPushNotification.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trezorPushNotificationHandler = void 0;
+const protocol_1 = require("@trezor/protocol");
+const utils_1 = require("@trezor/utils");
+const device_1 = require("../../events/device");
+const thp_1 = require("../thp");
+const setupDeviceMode = async (device, mode) => {
+    if (mode === protocol_1.TrezorPushNotificationMode.BootloaderMode && !device.features) {
+        device.setBusy('rebooting');
+        await device.acquire();
+        await device.getFeatures();
+        await device.release();
+    }
+    if (mode === protocol_1.TrezorPushNotificationMode.NormalMode &&
+        (!device.features || !device.getThpState())) {
+        device.setBusy('rebooting');
+        await device.setupThp();
+        await device.acquire();
+        await (0, utils_1.resolveAfter)(1000);
+        await (0, thp_1.getThpChannel)(device, false);
+        if (device.getThpState()?.phase === 'paired') {
+            await device.getFeatures();
+        }
+        else {
+            device.setBusy('thp-locked');
+            device.lifecycle.emit(device_1.DEVICE.CHANGED);
+        }
+        await device.release();
+    }
+};
+const trezorPushNotificationHandler = async ({ device, message }) => {
+    const decoded = protocol_1.tpn.decode(message);
+    device.lifecycle.emit(device_1.DEVICE.TREZOR_PUSH_NOTIFICATION, decoded);
+    const { type, mode } = decoded;
+    const modeChanged = (mode === protocol_1.TrezorPushNotificationMode.BootloaderMode &&
+        (device.getThpState()?.properties ||
+            (device.features && !device.features.bootloader_mode))) ||
+        (mode === protocol_1.TrezorPushNotificationMode.NormalMode && device.features?.bootloader_mode);
+    if (modeChanged) {
+        device.reset();
+        device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'rebooting');
+        device.lifecycle.emit(device_1.DEVICE.CHANGED);
+    }
+    switch (type) {
+        case protocol_1.TrezorPushNotificationType.SETTING_CHANGE:
+        case protocol_1.TrezorPushNotificationType.PIN_CHANGE:
+            if (!device.isUsed()) {
+                await device.acquire();
+                await device.getFeatures();
+                await device.release();
+            }
+            break;
+        case protocol_1.TrezorPushNotificationType.LOCK:
+            device.setBusy(mode === protocol_1.TrezorPushNotificationMode.BootloaderMode
+                ? 'bootloader-locked'
+                : 'hard-locked');
+            device.lifecycle.emit(device_1.DEVICE.CHANGED);
+            break;
+        case protocol_1.TrezorPushNotificationType.UNLOCK:
+            await setupDeviceMode(device, decoded.mode);
+            break;
+        case protocol_1.TrezorPushNotificationType.SOFTLOCK:
+            device.setBusy('pin-locked');
+            device.lifecycle.emit(device_1.DEVICE.CHANGED);
+            break;
+        case protocol_1.TrezorPushNotificationType.SOFTUNLOCK:
+            device.setBusy(device.features ? undefined : 'thp-locked');
+            device.lifecycle.emit(device_1.DEVICE.CHANGED);
+            break;
+        default:
+            break;
+    }
+};
+exports.trezorPushNotificationHandler = trezorPushNotificationHandler;
+//# sourceMappingURL=trezorPushNotification.js.map

package/lib/device/workflow/validateState.js

@@ -78,6 +78,9 @@ const getInvalidThpDeviceState = async (context) => {
                 thpState?.setSessionId(Buffer.alloc(1));
                 return undefined;
             }
+            if (e.code === 'Failure_PinCancelled') {
+                throw e;
+            }
         });
     }
     if (!uniqueState || (!currentState?.deriveCardano && method.useCardanoDerivation)) {

package/lib/events/call.d.ts

@@ -1,5 +1,5 @@
 import type { IFRAME } from './iframe';
-import { Device } from '../device/Device';
+import type { Device } from '../device/Device';
 import type { TrezorConnect } from '../types/api';
 import type { CommonParams, DeviceIdentity } from '../types/params';
 type UnwrappedResponse<Response> = Response extends Promise<infer R> ? R extends {

package/lib/events/device.d.ts

@@ -1,8 +1,9 @@
 import type { VersionArray } from '@trezor/device-utils';
-import type { ThpCredentials, ThpPairingMethod } from '@trezor/protocol';
-import type { PROTO } from '../constants';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { DecodedTrezorPushNotification, ThpCredentials, ThpPairingMethod } from '@trezor/protocol';
 import type { Device } from '../types/device';
 import type { MessageFactoryFn } from '../types/utils';
+export { type DecodedTrezorPushNotification, TrezorPushNotificationMode, TrezorPushNotificationType, } from '@trezor/protocol/lib/protocol-tpn';
 export declare const DEVICE_EVENT = "DEVICE_EVENT";
 export declare const DEVICE: {
     readonly CONNECT: "device-connect";
@@ -10,6 +11,7 @@ export declare const DEVICE: {
     readonly DISCONNECT: "device-disconnect";
     readonly CHANGED: "device-changed";
     readonly FIRMWARE_VERSION_CHANGED: "device-firmware_version_changed";
+    readonly TREZOR_PUSH_NOTIFICATION: "device-trezor_push_notification";
     readonly THP_CREDENTIALS_CHANGED: "device-thp_credentials_changed";
     readonly BUTTON: "button";
     readonly PIN: "pin";
@@ -50,10 +52,16 @@ export interface DeviceThpCredentialsChanged {
         device: Device;
     };
 }
+export interface DeviceTrezorPushNotification {
+    type: typeof DEVICE.TREZOR_PUSH_NOTIFICATION;
+    payload: DecodedTrezorPushNotification & {
+        device: Device;
+    };
+}
 export type DeviceEvent = {
     type: typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.CHANGED | typeof DEVICE.DISCONNECT;
     payload: Device;
-} | DeviceButtonRequest | DeviceThpCredentialsChanged | DeviceVersionChanged;
+} | DeviceButtonRequest | DeviceThpCredentialsChanged | DeviceVersionChanged | DeviceTrezorPushNotification;
 export type DeviceEventMessage = DeviceEvent & {
     event: typeof DEVICE_EVENT;
 };

package/lib/events/device.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDeviceMessage = exports.DEVICE = exports.DEVICE_EVENT = void 0;
+exports.createDeviceMessage = exports.DEVICE = exports.DEVICE_EVENT = exports.TrezorPushNotificationType = exports.TrezorPushNotificationMode = void 0;
+var protocol_tpn_1 = require("@trezor/protocol/lib/protocol-tpn");
+Object.defineProperty(exports, "TrezorPushNotificationMode", { enumerable: true, get: function () { return protocol_tpn_1.TrezorPushNotificationMode; } });
+Object.defineProperty(exports, "TrezorPushNotificationType", { enumerable: true, get: function () { return protocol_tpn_1.TrezorPushNotificationType; } });
 exports.DEVICE_EVENT = 'DEVICE_EVENT';
 exports.DEVICE = {
     CONNECT: 'device-connect',
@@ -8,6 +11,7 @@ exports.DEVICE = {
     DISCONNECT: 'device-disconnect',
     CHANGED: 'device-changed',
     FIRMWARE_VERSION_CHANGED: 'device-firmware_version_changed',
+    TREZOR_PUSH_NOTIFICATION: 'device-trezor_push_notification',
     THP_CREDENTIALS_CHANGED: 'device-thp_credentials_changed',
     BUTTON: 'button',
     PIN: 'pin',

package/lib/events/popup.d.ts

@@ -1,6 +1,6 @@
 import type { TransportInfo } from './transport';
 import { UI_EVENT } from './ui-request';
-import type { ConnectSettings, SystemInfo } from '../types';
+import type { ConnectSettings, SystemInfo } from '../types/settings';
 import type { MessageFactoryFn } from '../types/utils';
 export declare const POPUP: {
     readonly BOOTSTRAP: "popup-bootstrap";

package/lib/events/transport.d.ts

@@ -1,29 +1,11 @@
 import type { Transport } from '@trezor/transport';
 import { TRANSPORT } from '@trezor/transport/lib/constants';
-import { ConnectSettings } from '../exports';
+import { BridgeInfo } from '../data/transportInfo';
+import { UdevInfo } from '../data/udevInfo';
+import { ConnectSettings } from '../types/settings';
 import type { MessageFactoryFn } from '../types/utils';
 export { TRANSPORT } from '@trezor/transport/lib/constants';
 export declare const TRANSPORT_EVENT = "TRANSPORT_EVENT";
-export interface BridgeInfo {
-    version: number[];
-    packages: {
-        name: string;
-        platform: string[];
-        url: string;
-        signature?: string;
-        preferred?: boolean;
-    }[];
-    changelog: string;
-}
-export interface UdevInfo {
-    packages: {
-        name: string;
-        platform: string[];
-        url: string;
-        signature?: string;
-        preferred?: boolean;
-    }[];
-}
 export interface TransportInfo {
     apiType: Transport['apiType'];
     type: Transport['name'];

package/lib/events/ui-request.d.ts

@@ -1,10 +1,12 @@
 import type { EventTypeDeviceSelected } from '@trezor/connect-analytics';
-import { DeviceModelInternal } from '@trezor/device-utils';
-import type { PROTO } from '../constants';
-import type { BinaryInfo, BitcoinNetworkInfo, CoinInfo, Device, FirmwareType, SelectFeeLevel } from '../types';
+import { DeviceModelInternal, FirmwareRelease, FirmwareType, VersionArray } from '@trezor/device-utils';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import type { DeviceButtonRequest, DeviceThpPairingPayload } from './device';
-import { MethodPermission } from '../core/AbstractMethod';
+import type { MethodPermission } from '../core/AbstractMethod';
 import type { DiscoveryAccount, DiscoveryAccountType } from '../types/account';
+import type { BitcoinNetworkInfo, CoinInfo } from '../types/coinInfo';
+import type { Device } from '../types/device';
+import type { SelectFeeLevel } from '../types/fees';
 import type { MessageFactoryFn } from '../types/utils';
 export declare const UI_EVENT = "UI_EVENT";
 export declare const UI_REQUEST: {
@@ -176,12 +178,17 @@ export interface UiRequestSelectDevice {
         webusb: boolean;
     };
 }
+export type FirmwareStoreEvent = {
+    binary: ArrayBuffer;
+    binaryVersion: VersionArray;
+    internalModel: DeviceModelInternal;
+    release: FirmwareRelease | undefined;
+    firmwareType?: FirmwareType;
+    releaseVersion?: number[];
+};
 export interface UiRequestFirmwareDownloaded {
     type: typeof UI_REQUEST.FIRMWARE_DOWNLOADED;
-    payload: BinaryInfo | {
-        internalModel?: DeviceModelInternal;
-        firmwareType?: FirmwareType;
-    };
+    payload: FirmwareStoreEvent;
 }
 export interface UiRequestUnexpectedDeviceMode {
     type: typeof UI_REQUEST.BOOTLOADER | typeof UI_REQUEST.NOT_IN_BOOTLOADER | typeof UI_REQUEST.INITIALIZE | typeof UI_REQUEST.SEEDLESS | typeof UI_REQUEST.DEVICE_NEEDS_BACKUP;