@trezor/connect 9.6.2 → 9.6.3-beta.1

package/lib/device/Device.d.ts

@@ -1,3 +1,4 @@
+import { FirmwareRelease } from '@trezor/device-utils';
 import { TransportProtocol, thp as protocolThp } from '@trezor/protocol';
 import { Session } from '@trezor/transport';
 import { type Descriptor, type Transport } from '@trezor/transport';
@@ -6,7 +7,7 @@ import { PROTO } from '../constants';
 import { TypedCallProvider } from './DeviceCurrentSession';
 import { IStateStorage } from './StateStorage';
 import { DEVICE, DeviceButtonRequestPayload, DeviceThpCredentialsChangedPayload, DeviceThpPairingPayload, DeviceVersionChanged, UiResponsePassphrase, UiResponsePin, UiResponseThpPairingTag, UiResponseWord } from '../events';
-import { DeviceFirmwareStatus, DeviceState, Device as DeviceTyped, DeviceUniquePath, FirmwareType, ReleaseInfo, UnavailableCapabilities, VersionArray } from '../types';
+import { DeviceFirmwareStatus, DeviceState, Device as DeviceTyped, DeviceUniquePath, FirmwareHashCheckResult, FirmwareReleaseConfigInfo, FirmwareType, UnavailableCapabilities, VersionArray } from '../types';
 type RunOptions = {
     skipFinalReload?: boolean;
     keepSession?: boolean;
@@ -71,12 +72,14 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private unreadableError?;
     private _firmwareStatus;
     get firmwareStatus(): DeviceFirmwareStatus;
-    private _firmwareRelease?;
-    get firmwareRelease(): ReleaseInfo | null | undefined;
+    private _currentRelease?;
+    get currentRelease(): FirmwareRelease | undefined;
+    private _firmwareReleaseConfigInfo?;
+    get firmwareReleaseConfigInfo(): FirmwareReleaseConfigInfo | undefined;
     private _features;
     get features(): {
-        _passphrase_cached?: boolean | undefined;
         busy?: boolean | undefined;
+        _passphrase_cached?: boolean | undefined;
         homescreen_format?: "Toif" | "Jpeg" | "ToiG" | undefined;
         hide_passphrase_from_host?: boolean | undefined;
         unit_color?: number | undefined;
@@ -89,6 +92,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
         haptic_feedback?: boolean | undefined;
         recovery_type?: "NormalRecovery" | "DryRun" | "UnlockRepeatedBackup" | undefined;
         optiga_sec?: number | undefined;
+        soc?: number | undefined;
         vendor: string;
         major_version: number;
         minor_version: number;
@@ -138,6 +142,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private instance;
     private state;
     private stateStorage?;
+    private busy?;
     private _unavailableCapabilities;
     get unavailableCapabilities(): Readonly<UnavailableCapabilities>;
     private _firmwareType?;
@@ -201,6 +206,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
             xpub: string;
         }>;
         ethereumGetAddress: (params: PROTO.EthereumGetAddress) => Promise<{
+            mac?: string | undefined;
             _old_address?: string | undefined;
             address: string;
         }>;
@@ -233,8 +239,11 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     initialize(useCardanoDerivation: boolean): Promise<void>;
     initStorage(storage: IStateStorage): void;
     getFeatures(): Promise<void>;
-    private checkFirmwareHashWithRetries;
-    private checkFirmwareHash;
+    getAuthenticityChecks(): {
+        firmwareRevision: import("../types").FirmwareRevisionCheckResult | null;
+        firmwareHash: FirmwareHashCheckResult | null;
+    };
+    setAuthenticityChecks(firmwareHash: FirmwareHashCheckResult | null): void;
     private checkFirmwareRevisionWithRetries;
     private checkFirmwareRevision;
     changeLanguage({ language, binary, }: {
@@ -247,6 +256,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
         message: string;
     }>;
     private _uploadTranslationData;
+    private _updateCurrentRelease;
     private _updateFeatures;
     prompt<T extends typeof DEVICE.PIN | typeof DEVICE.PASSPHRASE | typeof DEVICE.WORD | typeof DEVICE.THP_PAIRING>(type: T, args: Omit<DeviceEvents[T], 'callback'>): Promise<Parameters<DeviceEvents[T]["callback"]>[0]>;
     isUnacquired(): boolean;
@@ -263,7 +273,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     getUniquePath(): DeviceUniquePath;
     isT1(): boolean;
     hasUnexpectedMode(allow: string[], require: string[]): "ui-device_bootloader_mode" | "ui-device_not_in_bootloader_mode" | "ui-device_not_initialized" | "ui-device_seedless" | null;
-    private getMode;
+    private getStatus;
     toMessageObject(): DeviceTyped;
 }
 export {};

package/lib/device/Device.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Device = void 0;
-const crypto_1 = require("crypto");
 const device_utils_1 = require("@trezor/device-utils");
 const protocol_1 = require("@trezor/protocol");
 const transport_1 = require("@trezor/transport");
@@ -11,16 +10,15 @@ const constants_1 = require("../constants");
 const DeviceCurrentSession_1 = require("./DeviceCurrentSession");
 const checkFirmwareRevision_1 = require("./checkFirmwareRevision");
 const thp_1 = require("./thp");
-const firmware_1 = require("../api/firmware");
-const DataManager_1 = require("../data/DataManager");
+const checkFirmwareHashWithRetries_1 = require("./workflow/checkFirmwareHashWithRetries");
 const coinInfo_1 = require("../data/coinInfo");
 const firmwareInfo_1 = require("../data/firmwareInfo");
-const getLanguage_1 = require("../data/getLanguage");
 const events_1 = require("../events");
-const types_1 = require("../types");
 const handshake_1 = require("./workflow/handshake");
+const assetUtils_1 = require("../utils/assetUtils");
 const debug_1 = require("../utils/debug");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
+const firmwareUtils_1 = require("../utils/firmwareUtils");
 const _log = (0, debug_1.initLog)('Device');
 class Device extends utils_1.TypedEmitter {
     transport;
@@ -41,9 +39,13 @@ class Device extends utils_1.TypedEmitter {
     get firmwareStatus() {
         return this._firmwareStatus;
     }
-    _firmwareRelease;
-    get firmwareRelease() {
-        return this._firmwareRelease;
+    _currentRelease;
+    get currentRelease() {
+        return this._currentRelease;
+    }
+    _firmwareReleaseConfigInfo;
+    get firmwareReleaseConfigInfo() {
+        return this._firmwareReleaseConfigInfo;
     }
     _features;
     get features() {
@@ -59,6 +61,7 @@ class Device extends utils_1.TypedEmitter {
     instance = 0;
     state = [];
     stateStorage = undefined;
+    busy;
     _unavailableCapabilities = {};
     get unavailableCapabilities() {
         return this._unavailableCapabilities;
@@ -69,7 +72,7 @@ class Device extends utils_1.TypedEmitter {
     }
     name = 'Trezor';
     color;
-    availableTranslations = [];
+    availableTranslations = {};
     authenticityChecks = {
         firmwareRevision: null,
         firmwareHash: null,
@@ -256,6 +259,7 @@ class Device extends utils_1.TypedEmitter {
         return this.runPromise;
     }
     async interrupt(reason) {
+        await (0, thp_1.abortThpWorkflow)(this, () => this.runAbort?.abort(reason));
         await this.currentSession?.abort(reason);
         this.runAbort?.abort(reason);
         await this.currentRun;
@@ -290,6 +294,9 @@ class Device extends utils_1.TypedEmitter {
                 if (this.protocol.name === 'v2') {
                     const withInteraction = !!fn;
                     await (0, thp_1.getThpChannel)(this, withInteraction);
+                    if (this.getThpState()?.isAutoconnectPaired || withInteraction) {
+                        await this.getFeatures();
+                    }
                 }
                 else if (fn) {
                     await this.initialize(!!options.useCardanoDerivation);
@@ -297,9 +304,13 @@ class Device extends utils_1.TypedEmitter {
                 else {
                     await this.getFeatures();
                 }
+                this.busy = false;
             }
             catch (error) {
                 _log.warn('Device._runInner error: ', error.message);
+                if (error.code === 'Failure_Busy') {
+                    this.busy = true;
+                }
                 if (error.code === 'Device_ThpPairingTagInvalid') {
                     return Promise.reject(error);
                 }
@@ -307,7 +318,7 @@ class Device extends utils_1.TypedEmitter {
             }
         }
         if (!options.skipFirmwareChecks) {
-            await this.checkFirmwareHashWithRetries();
+            await (0, checkFirmwareHashWithRetries_1.checkFirmwareHashWithRetries)({ device: this, logger: _log });
             await this.checkFirmwareRevisionWithRetries();
         }
         if (!options.skipLanguageChecks &&
@@ -388,6 +399,7 @@ class Device extends utils_1.TypedEmitter {
         }
         const { message } = await this.getCurrentSession().typedCall('Initialize', 'Features', payload);
         this._updateFeatures(message);
+        this._updateCurrentRelease(message);
         this.setState({ deriveCardano: payload?.derive_cardano });
     }
     initStorage(storage) {
@@ -397,74 +409,13 @@ class Device extends utils_1.TypedEmitter {
     async getFeatures() {
         const { message } = await this.getCurrentSession().typedCall('GetFeatures', 'Features', {});
         this._updateFeatures(message);
+        this._updateCurrentRelease(message);
     }
-    async checkFirmwareHashWithRetries() {
-        const lastResult = this.authenticityChecks.firmwareHash;
-        const notDoneYet = lastResult === null;
-        const attemptsDone = lastResult?.attemptCount ?? 0;
-        if (attemptsDone >= constants_1.FIRMWARE.HASH_CHECK_MAX_ATTEMPTS)
-            return;
-        const wasError = lastResult !== null && !lastResult.success;
-        const wasErrorRetriable = wasError && (0, utils_1.isArrayMember)(lastResult.error, constants_1.FIRMWARE.HASH_CHECK_RETRIABLE_ERRORS);
-        const lastErrorPayload = wasError ? lastResult?.errorPayload : null;
-        if (notDoneYet || wasErrorRetriable) {
-            const result = await this.checkFirmwareHash();
-            this.authenticityChecks = {
-                ...this.authenticityChecks,
-                firmwareHash: result,
-            };
-            if (result === null)
-                return;
-            result.attemptCount = attemptsDone + 1;
-            if (result.success && lastErrorPayload) {
-                result.warningPayload = { lastErrorPayload, successOnAttempt: result.attemptCount };
-            }
-        }
+    getAuthenticityChecks() {
+        return this.authenticityChecks;
     }
-    async checkFirmwareHash() {
-        const createFailResult = (error, errorPayload) => ({
-            success: false,
-            error,
-            errorPayload,
-        });
-        const baseUrl = DataManager_1.DataManager.getSettings('binFilesBaseUrl');
-        const enabled = DataManager_1.DataManager.getSettings('enableFirmwareHashCheck');
-        if (!enabled || baseUrl === undefined)
-            return createFailResult('check-skipped');
-        const firmwareVersion = this.getVersion();
-        if (firmwareVersion === undefined || !this.features || this.features.bootloader_mode) {
-            return null;
-        }
-        const checkSupported = !this.unavailableCapabilities.getFirmwareHash;
-        if (!checkSupported)
-            return createFailResult('check-unsupported');
-        const release = (0, firmwareInfo_1.getReleases)(this.features.internal_model).find(r => utils_1.versionUtils.isEqual(r.version, firmwareVersion));
-        if (release === undefined)
-            return createFailResult('unknown-release');
-        const btcOnly = this.firmwareType === types_1.FirmwareType.BitcoinOnly;
-        const binary = await (0, firmware_1.getBinaryOptional)({ baseUrl, btcOnly, release });
-        if (binary === null) {
-            return createFailResult('check-unsupported');
-        }
-        if (binary.byteLength < 200) {
-            _log.warn(`Firmware binary for hash check suspiciously small (< 200 b)`);
-            return createFailResult('check-unsupported');
-        }
-        const strippedBinary = (0, firmware_1.stripFwHeaders)(binary);
-        const { hash: expectedHash, challenge } = (0, firmware_1.calculateFirmwareHash)(this.features.major_version, strippedBinary, (0, crypto_1.randomBytes)(32));
-        try {
-            const deviceResponse = await this.getCurrentSession().typedCall('GetFirmwareHash', 'FirmwareHash', { challenge });
-            if (!deviceResponse?.message?.hash) {
-                return createFailResult('other-error', 'Device response is missing hash');
-            }
-            if (deviceResponse.message.hash !== expectedHash) {
-                return createFailResult('hash-mismatch');
-            }
-            return { success: true };
-        }
-        catch (errorPayload) {
-            return createFailResult('other-error', (0, utils_1.serializeError)(errorPayload));
-        }
+    setAuthenticityChecks(firmwareHash) {
+        this.authenticityChecks.firmwareHash = firmwareHash;
     }
     async checkFirmwareRevisionWithRetries() {
         const lastResult = this.authenticityChecks.firmwareRevision;
@@ -477,18 +428,19 @@ class Device extends utils_1.TypedEmitter {
     }
     async checkFirmwareRevision() {
         const firmwareVersion = this.getVersion();
-        if (!firmwareVersion || !this.features) {
+        if (!firmwareVersion || !this.features || !this.firmwareType) {
             return;
         }
-        if (this.features.bootloader_mode === true) {
+        if (this.features && this.features.bootloader_mode === true) {
             return;
         }
-        const release = (0, firmwareInfo_1.getRelease)(this.features.internal_model, firmwareVersion);
+        const release = (0, assetUtils_1.getReleaseAsset)(this.features.internal_model, firmwareVersion, this.firmwareType);
         const result = await (0, checkFirmwareRevision_1.checkFirmwareRevision)({
             internalModel: this.features.internal_model,
             deviceRevision: this.features.revision,
             firmwareVersion,
             expectedRevision: release?.firmware_revision,
+            firmwareType: this.firmwareType,
         });
         this.authenticityChecks = {
             ...this.authenticityChecks,
@@ -506,11 +458,14 @@ class Device extends utils_1.TypedEmitter {
         if (!version) {
             throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: device version unknown');
         }
-        const downloadedBinary = await (0, getLanguage_1.getLanguage)({
-            language,
-            version,
-            internal_model: this.features.internal_model,
-        });
+        if (!this.firmwareType) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: firmware type unknown');
+        }
+        if (!this._currentRelease) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: release not found');
+        }
+        const languageBinPath = this._currentRelease.translations[language];
+        const downloadedBinary = await (0, firmwareInfo_1.getLanguage)(languageBinPath);
         if (!downloadedBinary) {
             throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: translation not found');
         }
@@ -533,6 +488,22 @@ class Device extends utils_1.TypedEmitter {
         }
         return response.message;
     }
+    async _updateCurrentRelease(feat) {
+        const newVersion = [
+            feat.major_version,
+            feat.minor_version,
+            feat.patch_version,
+        ];
+        const newFirmwareType = (0, firmwareUtils_1.getFirmwareType)(feat);
+        if (this._currentRelease &&
+            newFirmwareType === this.firmwareType &&
+            utils_1.versionUtils.isEqual(this._currentRelease.version, newVersion)) {
+            return;
+        }
+        const release = await (0, firmwareInfo_1.getReleaseByVersion)(feat, newVersion, newFirmwareType);
+        this._currentRelease = release;
+        this.availableTranslations = this._currentRelease?.translations ?? {};
+    }
     _updateFeatures(feat) {
         const capabilities = (0, deviceFeaturesUtils_1.parseCapabilities)(feat);
         feat.capabilities = capabilities;
@@ -563,25 +534,13 @@ class Device extends utils_1.TypedEmitter {
                 });
             }
             this._unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
-            this._firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat);
-            this._firmwareRelease = (0, firmwareInfo_1.getReleaseInfo)(feat);
-            this.availableTranslations = this.firmwareRelease?.translations ?? [];
+            this._firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat, (0, firmwareUtils_1.getFirmwareType)(feat));
+            this._firmwareReleaseConfigInfo = (0, firmwareInfo_1.getFirmwareReleaseConfigInfo)(feat, (0, firmwareUtils_1.getFirmwareType)(feat));
+            this._currentRelease = (0, assetUtils_1.getReleaseAsset)(feat.internal_model, newVersion, (0, firmwareUtils_1.getFirmwareType)(feat));
+            this.availableTranslations = this._currentRelease?.translations ?? {};
         }
         this._features = feat;
-        if (feat.fw_vendor === 'Trezor Bitcoin-only') {
-            this._firmwareType = types_1.FirmwareType.BitcoinOnly;
-        }
-        else if (feat.fw_vendor === 'Trezor') {
-            this._firmwareType = types_1.FirmwareType.Universal;
-        }
-        else if (this.getMode() !== 'bootloader') {
-            this._firmwareType =
-                feat.capabilities &&
-                    feat.capabilities.length > 0 &&
-                    !feat.capabilities.includes('Capability_Bitcoin_like')
-                    ? types_1.FirmwareType.BitcoinOnly
-                    : types_1.FirmwareType.Universal;
-        }
+        this._firmwareType = (0, firmwareUtils_1.getFirmwareType)(feat);
         const deviceInfo = device_utils_1.models[feat.internal_model] ?? {
             name: `Unknown ${feat.internal_model}`,
             colors: {},
@@ -684,14 +643,14 @@ class Device extends utils_1.TypedEmitter {
         }
         return null;
     }
-    getMode() {
-        if (this.features.bootloader_mode)
-            return 'bootloader';
-        if (!this.features.initialized)
-            return 'initialize';
-        if (this.features.no_backup)
-            return 'seedless';
-        return 'normal';
+    getStatus() {
+        if (this.isUsedElsewhere())
+            return 'occupied';
+        if (this.wasUsedElsewhere)
+            return 'used';
+        if (this.busy)
+            return 'busy';
+        return 'available';
     }
     toMessageObject() {
         const { name, uniquePath: path } = this;
@@ -715,13 +674,11 @@ class Device extends utils_1.TypedEmitter {
                 transportSessionOwner: this.sessionAcquired ? undefined : sessionOwner,
                 bluetoothProps: this.bluetoothProps,
                 thp: this.thp?.serialize(),
+                status: this.busy ? 'busy' : undefined,
             };
         }
         const defaultLabel = 'My Trezor';
         const label = this.features.label === '' || !this.features.label ? defaultLabel : this.features.label;
-        const status = this.isUsedElsewhere()
-            ? 'occupied'
-            : (this.wasUsedElsewhere && 'used') || 'available';
         return {
             ...base,
             type: 'acquired',
@@ -729,11 +686,11 @@ class Device extends utils_1.TypedEmitter {
             label,
             _state: this.getState(),
             state: this.getState()?.staticSessionId,
-            status,
-            mode: this.getMode(),
+            status: this.getStatus(),
+            mode: (0, firmwareUtils_1.getFirmwareMode)(this.features),
             color: this.color,
             firmware: this.firmwareStatus,
-            firmwareRelease: this.firmwareRelease,
+            firmwareReleaseConfigInfo: this.firmwareReleaseConfigInfo,
             firmwareType: this.firmwareType,
             features: this.features,
             unavailableCapabilities: this.unavailableCapabilities,

package/lib/device/DeviceCommands.d.ts

@@ -45,6 +45,7 @@ export declare const DeviceCommands: (deviceTypedCall: TypedCallProvider) => {
         xpub: string;
     }>;
     ethereumGetAddress: (params: Messages.EthereumGetAddress) => Promise<{
+        mac?: string | undefined;
         _old_address?: string | undefined;
         address: string;
     }>;

package/lib/device/DeviceCurrentSession.d.ts

@@ -49,18 +49,6 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "TxOutputType";
         message: import("@trezor/protobuf/lib/messages").TxOutputType;
-    } | {
-        type: "PaymentRequestMemo";
-        message: import("@trezor/protobuf/lib/messages").PaymentRequestMemo;
-    } | {
-        type: "TextMemo";
-        message: import("@trezor/protobuf/lib/messages").TextMemo;
-    } | {
-        type: "RefundMemo";
-        message: import("@trezor/protobuf/lib/messages").RefundMemo;
-    } | {
-        type: "CoinPurchaseMemo";
-        message: import("@trezor/protobuf/lib/messages").CoinPurchaseMemo;
     } | {
         type: "TxAckInputWrapper";
         message: import("@trezor/protobuf/lib/messages").TxAckInputWrapper;
@@ -94,6 +82,9 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "CardanoAddressParametersType";
         message: import("@trezor/protobuf/lib/messages").CardanoAddressParametersType;
+    } | {
+        type: "PaymentRequest";
+        message: import("@trezor/protobuf/lib/messages").PaymentRequest;
     } | {
         type: "CardanoPoolMetadataType";
         message: import("@trezor/protobuf/lib/messages").CardanoPoolMetadataType;
@@ -109,6 +100,21 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "CardanoCVoteRegistrationParametersType";
         message: import("@trezor/protobuf/lib/messages").CardanoCVoteRegistrationParametersType;
+    } | {
+        type: "PaymentRequestMemo";
+        message: import("@trezor/protobuf/lib/messages").PaymentRequestMemo;
+    } | {
+        type: "TextMemo";
+        message: import("@trezor/protobuf/lib/messages").TextMemo;
+    } | {
+        type: "RefundMemo";
+        message: import("@trezor/protobuf/lib/messages").RefundMemo;
+    } | {
+        type: "CoinPurchaseMemo";
+        message: import("@trezor/protobuf/lib/messages").CoinPurchaseMemo;
+    } | {
+        type: "TextDetailsMemo";
+        message: import("@trezor/protobuf/lib/messages").TextDetailsMemo;
     } | {
         type: "IdentityType";
         message: import("@trezor/protobuf/lib/messages").IdentityType;
@@ -307,9 +313,6 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "TxRequest";
         message: import("@trezor/protobuf/lib/messages").TxRequest;
-    } | {
-        type: "TxAckPaymentRequest";
-        message: import("@trezor/protobuf/lib/messages").TxAckPaymentRequest;
     } | {
         type: "TxAck";
         message: import("@trezor/protobuf/lib/messages").TxAck;
@@ -442,6 +445,18 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "CardanoSignTxFinished";
         message: import("@trezor/protobuf/lib/messages").CardanoSignTxFinished;
+    } | {
+        type: "CardanoSignMessageInit";
+        message: import("@trezor/protobuf/lib/messages").CardanoSignMessageInit;
+    } | {
+        type: "CardanoMessageDataRequest";
+        message: import("@trezor/protobuf/lib/messages").CardanoMessageDataRequest;
+    } | {
+        type: "CardanoMessageDataResponse";
+        message: import("@trezor/protobuf/lib/messages").CardanoMessageDataResponse;
+    } | {
+        type: "CardanoMessageSignature";
+        message: import("@trezor/protobuf/lib/messages").CardanoMessageSignature;
     } | {
         type: "Success";
         message: import("@trezor/protobuf/lib/messages").Success;
@@ -472,15 +487,15 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "ECDHSessionKey";
         message: import("@trezor/protobuf/lib/messages").ECDHSessionKey;
+    } | {
+        type: "PaymentNotification";
+        message: import("@trezor/protobuf/lib/messages").PaymentNotification;
     } | {
         type: "DebugLinkGetPairingInfo";
         message: import("@trezor/protobuf/lib/messages").DebugLinkGetPairingInfo;
     } | {
         type: "DebugLinkPairingInfo";
         message: import("@trezor/protobuf/lib/messages").DebugLinkPairingInfo;
-    } | {
-        type: "DebugLinkToggleThpPairingDialog";
-        message: import("@trezor/protobuf/lib/messages").DebugLinkToggleThpPairingDialog;
     } | {
         type: "DebugLinkResetDebugEvents";
         message: import("@trezor/protobuf/lib/messages").DebugLinkResetDebugEvents;
@@ -574,6 +589,12 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "EthereumTypedDataSignature";
         message: import("@trezor/protobuf/lib/messages").EthereumTypedDataSignature;
+    } | {
+        type: "EvoluGetNode";
+        message: import("@trezor/protobuf/lib/messages").EvoluGetNode;
+    } | {
+        type: "EvoluNode";
+        message: import("@trezor/protobuf/lib/messages").EvoluNode;
     } | {
         type: "Initialize";
         message: import("@trezor/protobuf/lib/messages").Initialize;
@@ -835,14 +856,14 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     }>;
     private needCancelWorkaround;
     private callLoop;
-    call<T extends Messages.MessageKey>(name: T, data: Messages.MessagePayload<T>, options?: AbortableOptions): Promise<{
+    call(name: string, data: Record<string, unknown>, options?: AbortableOptions): Promise<{
         success: false;
         error: Error;
     } | {
         success: true;
         payload: MessageResponse;
     }>;
-    send<T extends Messages.MessageKey>(name: T, data: Messages.MessagePayload<T>, options?: AbortableOptions): Promise<{
+    send(name: string, data: Record<string, unknown>, options?: AbortableOptions): Promise<{
         success: false;
         error: Error;
     } | {