@trezor/connect 9.6.1 → 9.6.2-beta.2

package/lib/data/coinInfo.d.ts

@@ -229,70 +229,6 @@ export declare const fixCoinInfoNetwork: (ci: BitcoinNetworkInfo, path: number[]
     };
     isBitcoin: boolean;
 };
-export declare const getCoinInfoByHash: (hash: string, networkInfo: any) => {
-    blockchainLink?: {
-        type: string;
-        url: string[];
-    } | undefined;
-    label: string;
-    blockTime: number;
-    minFee: number;
-    maxFee: number;
-    minPriorityFee: number;
-    name: string;
-    shortcut: string;
-    slip44: number;
-    support: {
-        T1B1: string | false;
-        T2T1: string | false;
-        T2B1: string | false;
-        T3B1: string | false;
-        T3T1: string | false;
-        T3W1: string | false;
-        UNKNOWN: string | false;
-        connect: boolean;
-    };
-    decimals: number;
-    defaultFees: {
-        feePerTx?: string | undefined;
-        feeLimit?: string | undefined;
-        baseFeePerGas?: string | undefined;
-        maxFeePerGas?: string | undefined;
-        maxPriorityFeePerGas?: string | undefined;
-        label: "normal" | "custom" | "high" | "economy" | "low";
-        blocks: number;
-        feePerUnit: string;
-    }[];
-} & {
-    cashAddrPrefix?: string | undefined;
-    xPubMagicSegwitNative?: number | undefined;
-    xPubMagicSegwit?: number | undefined;
-    taproot?: boolean | undefined;
-    type: "bitcoin";
-    dustLimit: number;
-    curveName: string;
-    forceBip143: boolean;
-    hashGenesisBlock: string;
-    maxAddressLength: number;
-    maxFeeSatoshiKb: number;
-    minAddressLength: number;
-    minFeeSatoshiKb: number;
-    segwit: boolean;
-    xPubMagic: number;
-    network: {
-        forkId?: number | undefined;
-        messagePrefix: string;
-        bech32: string;
-        bip32: {
-            public: number;
-            private: number;
-        };
-        pubKeyHash: number;
-        scriptHash: number;
-        wif: number;
-    };
-    isBitcoin: boolean;
-};
 export declare const getCoinInfo: (currency: string) => ({
     blockchainLink?: {
         type: string;

package/lib/data/coinInfo.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllNetworks = exports.getUniqueNetworks = exports.parseCoinsJson = exports.ethereumNetworkInfoBase = exports.getCoinName = exports.getCoinInfo = exports.getCoinInfoByHash = exports.fixCoinInfoNetwork = exports.getBech32Network = exports.getSegwitNetwork = exports.getMiscNetwork = exports.getEthereumNetwork = exports.getBitcoinNetwork = void 0;
+exports.getAllNetworks = exports.getUniqueNetworks = exports.parseCoinsJson = exports.ethereumNetworkInfoBase = exports.getCoinName = exports.getCoinInfo = exports.fixCoinInfoNetwork = exports.getBech32Network = exports.getSegwitNetwork = exports.getMiscNetwork = exports.getEthereumNetwork = exports.getBitcoinNetwork = void 0;
 const utils_1 = require("@trezor/utils");
 const defaultFeeLevels_1 = require("./defaultFeeLevels");
-const constants_1 = require("../constants");
 const pathUtils_1 = require("../utils/pathUtils");
 const bitcoinNetworks = [];
 const ethereumNetworks = [];
@@ -86,44 +85,6 @@ const fixCoinInfoNetwork = (ci, path) => {
     return coinInfo;
 };
 exports.fixCoinInfoNetwork = fixCoinInfoNetwork;
-const detectBtcVersion = (data) => {
-    if (data.subversion == null) {
-        return 'btc';
-    }
-    if (data.subversion.startsWith('/Bitcoin ABC')) {
-        return 'bch';
-    }
-    if (data.subversion.startsWith('/Bitcoin Cash')) {
-        return 'bch';
-    }
-    if (data.subversion.startsWith('/Bitcoin Gold')) {
-        return 'btg';
-    }
-    return 'btc';
-};
-const getCoinInfoByHash = (hash, networkInfo) => {
-    const networks = (0, utils_1.cloneObject)(bitcoinNetworks);
-    const result = networks.find(info => hash.toLowerCase() === info.hashGenesisBlock.toLowerCase());
-    if (!result) {
-        throw constants_1.ERRORS.TypedError('Method_UnknownCoin', `Coin info not found for hash: ${hash} ${networkInfo.hashGenesisBlock}`);
-    }
-    if (result.isBitcoin) {
-        const btcVersion = detectBtcVersion(networkInfo);
-        let fork;
-        if (btcVersion === 'bch') {
-            fork = networks.find(info => info.name === 'Bcash');
-        }
-        else if (btcVersion === 'btg') {
-            fork = networks.find(info => info.name === 'Bgold');
-        }
-        if (fork) {
-            return fork;
-        }
-        throw constants_1.ERRORS.TypedError('Method_UnknownCoin', `Coin info not found for hash: ${hash} ${networkInfo.hashGenesisBlock} BTC version:${btcVersion}`);
-    }
-    return result;
-};
-exports.getCoinInfoByHash = getCoinInfoByHash;
 const getCoinInfo = (currency) => (0, exports.getBitcoinNetwork)(currency) || (0, exports.getEthereumNetwork)(currency) || (0, exports.getMiscNetwork)(currency);
 exports.getCoinInfo = getCoinInfo;
 const getCoinName = (path) => {

package/lib/data/firmwareInfo.d.ts

@@ -1,6 +1,6 @@
 import { DeviceModelInternal, FirmwareRelease, VersionArray } from '@trezor/device-utils';
 import type { Features, ReleaseInfo } from '../types';
-export declare const parseFirmwareReleases: (json: any, deviceModel: DeviceModelInternal) => void;
+export declare const parseFirmwareReleases: (modelReleases: FirmwareRelease[], deviceModel: DeviceModelInternal) => void;
 export declare const getReleases: (deviceModel: DeviceModelInternal) => FirmwareRelease[];
 export declare const getOnlineReleases: (internalModel: DeviceModelInternal) => Promise<FirmwareRelease[]>;
 export interface GetInfoProps {

package/lib/data/firmwareInfo.js

@@ -6,9 +6,11 @@ const utils_1 = require("@trezor/utils");
 const assets_1 = require("../utils/assets");
 const firmwareUtils_1 = require("../utils/firmwareUtils");
 const releases = Object.values(device_utils_1.DeviceModelInternal).reduce((acc, key) => ({ ...acc, [key]: [] }), {});
-const parseFirmwareReleases = (json, deviceModel) => {
-    Object.keys(json).forEach(key => {
-        const release = json[key];
+const bundledReleases = {};
+const parseFirmwareReleases = (modelReleases, deviceModel) => {
+    const [latestRelease] = modelReleases;
+    bundledReleases[deviceModel] = latestRelease;
+    modelReleases.forEach(release => {
         releases[deviceModel]?.push({
             ...release,
         });

package/lib/data/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "9.6.1";
+export declare const VERSION = "9.6.2-beta.2";
 export declare const DEFAULT_DOMAIN: string;
 export declare const CONTENT_SCRIPT_VERSION = 1;
 export declare const DEEPLINK_VERSION = 1;

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEEPLINK_VERSION = exports.CONTENT_SCRIPT_VERSION = exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.6.1';
+exports.VERSION = '9.6.2-beta.2';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 const isBeta = exports.VERSION.includes('beta');
 exports.DEFAULT_DOMAIN = isBeta

package/lib/device/Device.d.ts

@@ -14,9 +14,6 @@ type RunOptions = {
     skipFirmwareChecks?: boolean;
     skipLanguageChecks?: boolean;
 };
-export declare const CANCEL_TIMEOUT = 1000;
-export declare const GET_FEATURES_TIMEOUT = 3000;
-export declare const GET_FEATURES_TIMEOUT_REACT_NATIVE = 20000;
 type Result<T> = {
     success: true;
     payload: T;
@@ -48,13 +45,16 @@ export interface DeviceEvents {
     };
     [DEVICE.THP_CREDENTIALS_CHANGED]: DeviceThpCredentialsChangedPayload;
 }
-type DeviceLifecycle = typeof DEVICE.CONNECT | typeof DEVICE.CONNECT_UNACQUIRED | typeof DEVICE.DISCONNECT | typeof DEVICE.CHANGED;
-type DeviceLifecycleListener = (lifecycle: DeviceLifecycle) => void;
+interface DeviceLifecycleEvents {
+    [DEVICE.CONNECT]: void;
+    [DEVICE.CONNECT_UNACQUIRED]: void;
+    [DEVICE.CHANGED]: void;
+    [DEVICE.DISCONNECT]: void;
+}
 type DeviceParams = {
     id: DeviceUniquePath;
     transport: Transport;
     descriptor: Descriptor;
-    listener: DeviceLifecycleListener;
 };
 export declare class Device extends TypedEmitter<DeviceEvents> {
     readonly transport: Transport;
@@ -147,17 +147,17 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     private availableTranslations;
     private authenticityChecks;
     private readonly uniquePath;
-    private emitLifecycle;
+    readonly lifecycle: TypedEmitter<DeviceLifecycleEvents>;
     private sessionDfd?;
-    handshakeFinished: boolean;
-    constructor({ id, transport, descriptor, listener }: DeviceParams);
+    constructor({ id, transport, descriptor }: DeviceParams);
     private readonly onTransportStopped;
     private readonly onTransportDeviceEvent;
     private getSessionChangePromise;
     private waitAndCompareSession;
     acquire(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<Session, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session" | "LIBUSB_ERROR_ACCESS">;
     release(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<null, "Network request failed" | "Wrong result type." | "device disconnected during action" | "unexpected error" | "session not found" | "Aborted by timeout" | "Aborted by signal" | "This transport can not be used in this environment" | "device not found" | "Unable to open device" | "wrong previous session"> | undefined;
-    handshake(delay?: number): Promise<void>;
+    setupThp(): Promise<void>;
+    handshake(): Promise<boolean>;
     private updateDescriptor;
     run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
     interrupt(reason: Error): Promise<void>;

package/lib/device/Device.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Device = exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = exports.GET_FEATURES_TIMEOUT = exports.CANCEL_TIMEOUT = void 0;
+exports.Device = void 0;
 const crypto_1 = require("crypto");
 const device_utils_1 = require("@trezor/device-utils");
 const protocol_1 = require("@trezor/protocol");
@@ -10,6 +10,7 @@ const DeviceCommands_1 = require("./DeviceCommands");
 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 coinInfo_1 = require("../data/coinInfo");
@@ -17,12 +18,10 @@ 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 debug_1 = require("../utils/debug");
 const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
 const _log = (0, debug_1.initLog)('Device');
-exports.CANCEL_TIMEOUT = 1_000;
-exports.GET_FEATURES_TIMEOUT = 3_000;
-exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = 20_000;
 class Device extends utils_1.TypedEmitter {
     transport;
     transportPath;
@@ -76,12 +75,10 @@ class Device extends utils_1.TypedEmitter {
         firmwareHash: null,
     };
     uniquePath;
-    emitLifecycle;
+    lifecycle = new utils_1.TypedEmitter();
     sessionDfd;
-    handshakeFinished = false;
-    constructor({ id, transport, descriptor, listener }) {
+    constructor({ id, transport, descriptor }) {
         super();
-        this.emitLifecycle = listener;
         this._protocol = protocol_1.v1;
         this.uniquePath = id;
         this.transport = transport;
@@ -175,49 +172,47 @@ class Device extends utils_1.TypedEmitter {
         });
         return this.releasePromise;
     }
-    async handshake(delay) {
-        if (delay) {
-            await (0, utils_1.resolveAfter)(501 + delay);
+    async setupThp() {
+        _log.info('Setup THP device');
+        this._protocol = protocol_1.v2;
+        if (this.transport.name === 'BridgeTransport' &&
+            !utils_1.versionUtils.isNewerOrEqual(this.transport.version, '3.0.0')) {
+            this.unreadableError = 'THP incompatible with bridge ' + this.transport.version;
         }
-        while (true) {
-            if (this.isUsedElsewhere()) {
-                this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
+        else {
+            try {
+                await this.transport.loadMessages('thp', protocol_1.thp.getProtobufDefinitions);
+                this.thp = new protocol_1.thp.ThpState();
             }
-            else {
-                try {
-                    await this.run();
-                }
-                catch (error) {
-                    _log.warn(`device.run error.message: ${error.message}, code: ${error.code}`);
-                    if (error.code === 'Device_NotFound' ||
-                        error.code === 'Device_Disconnected' ||
-                        error.message === transport_1.TRANSPORT_ERROR.DEVICE_NOT_FOUND ||
-                        error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION ||
-                        error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
-                    }
-                    else if ((this.possibleHIDdevice &&
-                        error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE) ||
-                        error.message === transport_1.TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
-                        this.unreadableError = error.message;
-                        this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
-                    }
-                    else if (error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE ||
-                        error.message === transport_1.TRANSPORT_ERROR.UNEXPECTED_ERROR ||
-                        error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS ||
-                        error.code === 'Device_UsedElsewhere' ||
-                        error.code === 'Device_InitializeFailed') {
-                        this.emitLifecycle(events_1.DEVICE.CONNECT_UNACQUIRED);
-                    }
-                    else {
-                        await (0, utils_1.resolveAfter)(501);
-                        continue;
-                    }
-                }
+            catch (error) {
+                this.unreadableError = error.message;
             }
-            this.handshakeFinished = true;
-            return;
         }
     }
+    async handshake() {
+        if (this.isUsedElsewhere()) {
+            return true;
+        }
+        try {
+            await this.run();
+        }
+        catch (error) {
+            _log.warn(`device.run error.message: ${error.message}, code: ${error.code}`);
+            if (error.code === 'Device_NotFound' ||
+                error.code === 'Device_Disconnected' ||
+                error.message === transport_1.TRANSPORT_ERROR.DEVICE_NOT_FOUND ||
+                error.message === transport_1.TRANSPORT_ERROR.DEVICE_DISCONNECTED_DURING_ACTION ||
+                error.message === transport_1.TRANSPORT_ERROR.HTTP_ERROR) {
+                return false;
+            }
+            if ((this.possibleHIDdevice &&
+                error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE) ||
+                error.message === transport_1.TRANSPORT_ERROR.LIBUSB_ERROR_ACCESS) {
+                this.unreadableError = error.message;
+            }
+        }
+        return true;
+    }
     async updateDescriptor(descriptor) {
         this.sessionDfd?.resolve(descriptor.session);
         await Promise.all([this.acquirePromise, this.releasePromise]);
@@ -227,7 +222,7 @@ class Device extends utils_1.TypedEmitter {
         if (!descriptor.session) {
             this.keepTransportSession = false;
         }
-        this.emitLifecycle(events_1.DEVICE.CHANGED);
+        this.lifecycle.emit(events_1.DEVICE.CHANGED);
     }
     run(fn, options = {}) {
         if (this.runPromise) {
@@ -255,7 +250,7 @@ class Device extends utils_1.TypedEmitter {
         })
             .then(() => {
             if (wasUnacquired && !this.isUnacquired()) {
-                this.emitLifecycle(events_1.DEVICE.CONNECT);
+                this.lifecycle.emit(events_1.DEVICE.CONNECT);
             }
         });
         return this.runPromise;
@@ -291,26 +286,23 @@ class Device extends utils_1.TypedEmitter {
         const { staticSessionId, deriveCardano } = this.getState() || {};
         if (acquireNeeded || !staticSessionId || (!deriveCardano && options.useCardanoDerivation)) {
             try {
-                if (fn) {
+                await (0, handshake_1.handshakeCancel)({ device: this, logger: _log, signal: abortSignal });
+                if (this.protocol.name === 'v2') {
+                    const withInteraction = !!fn;
+                    await (0, thp_1.getThpChannel)(this, withInteraction);
+                }
+                else if (fn) {
                     await this.initialize(!!options.useCardanoDerivation);
                 }
                 else {
-                    const isNative = DataManager_1.DataManager.getSettings('env') === 'react-native';
-                    const cancelTimeout = isNative
-                        ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
-                        : exports.CANCEL_TIMEOUT;
-                    if (['v1', 'bridge'].includes(this.protocol.name) && !this.possibleHIDdevice) {
-                        _log.debug('sending a preventive cancel on the first encounter with the device');
-                        await Promise.race([
-                            this.getCurrentSession().cancelCall(),
-                            new Promise((_, reject) => setTimeout(reject, cancelTimeout)),
-                        ]).catch(() => this.acquire());
-                    }
                     await this.getFeatures();
                 }
             }
             catch (error) {
                 _log.warn('Device._runInner error: ', error.message);
+                if (error.code === 'Device_ThpPairingTagInvalid') {
+                    return Promise.reject(error);
+                }
                 return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}${error.code ? `, code: ${error.code}` : ''}`));
             }
         }
@@ -632,8 +624,7 @@ class Device extends utils_1.TypedEmitter {
             this.transport.releaseSync(this.sessionAcquired);
             this.sessionAcquired = null;
         }
-        this.emitLifecycle(events_1.DEVICE.DISCONNECT);
-        this.emitLifecycle = () => { };
+        this.lifecycle.emit(events_1.DEVICE.DISCONNECT);
         return this.interrupt(constants_1.ERRORS.TypedError('Device_Disconnected'));
     }
     isBootloader() {

package/lib/device/DeviceCurrentSession.d.ts

@@ -1,10 +1,17 @@
 import { MessagesSchema as Messages } from '@trezor/protobuf';
 import { MessageResponse, Session, Transport } from '@trezor/transport';
 import { Device } from './Device';
+type AbortableOptions = {
+    timeout?: number;
+    signal?: AbortSignal;
+};
 export interface TypedCallProvider {
     typedCall: Messages.TypedCall;
     cancelCall: DeviceCurrentSession['cancelCall'];
     isDisposed: () => boolean;
+    call: DeviceCurrentSession['call'];
+    send: DeviceCurrentSession['send'];
+    receive: DeviceCurrentSession['receive'];
 }
 export declare class DeviceCurrentSession implements TypedCallProvider {
     private readonly device;
@@ -465,6 +472,15 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     } | {
         type: "ECDHSessionKey";
         message: import("@trezor/protobuf/lib/messages").ECDHSessionKey;
+    } | {
+        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;
@@ -819,7 +835,27 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     }>;
     private needCancelWorkaround;
     private callLoop;
-    private call;
+    call<T extends Messages.MessageKey>(name: T, data: Messages.MessagePayload<T>, 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<{
+        success: false;
+        error: Error;
+    } | {
+        success: true;
+        payload: undefined;
+    }>;
+    receive(options?: AbortableOptions): Promise<{
+        success: false;
+        error: Error;
+    } | {
+        success: true;
+        payload: MessageResponse;
+    }>;
     cancelCall(): Promise<{
         success: false;
         error: Error;
@@ -829,4 +865,5 @@ export declare class DeviceCurrentSession implements TypedCallProvider {
     }>;
     abort(reason: Error): Promise<void>;
 }
+export {};
 //# sourceMappingURL=DeviceCurrentSession.d.ts.map

package/lib/device/DeviceCurrentSession.js

@@ -99,7 +99,7 @@ class DeviceCurrentSession {
         let pinUnlocked = false;
         while (true) {
             const timeout = name === 'GetFeatures' ? getFeaturesTimeout() : undefined;
-            const callPromise = this.call(name, data, timeout);
+            const callPromise = this.call(name, data, { timeout });
             const [abortedDuringCall, response] = await Promise.race([
                 callPromise.then(res => [false, res]),
                 abortPromise.then(res => [true, res]),
@@ -206,7 +206,7 @@ class DeviceCurrentSession {
             }
         }
     }
-    async call(name, data, timeout) {
+    async call(name, data, options = {}) {
         if (this.disposed)
             return Promise.resolve(error(this.disposed));
         logger.debug('Sending', name, filterForLog(name, data));
@@ -216,7 +216,7 @@ class DeviceCurrentSession {
             session: this.session,
             protocol: this.device.protocol,
             thpState: this.device.getThpState(),
-            timeout,
+            ...options,
         });
         if (result.success) {
             const { type, message } = result.payload;
@@ -225,7 +225,31 @@ class DeviceCurrentSession {
         else {
             logger.warn('Received transport error', result.error, result.message);
         }
-        return result.success ? success(result.payload) : fail(result.error);
+        return result.success ? success(result.payload) : fail(result.message || result.error);
+    }
+    async send(name, data, options = {}) {
+        if (this.disposed)
+            return Promise.resolve(error(this.disposed));
+        const result = await this.transport.send({
+            name,
+            data,
+            session: this.session,
+            protocol: this.device.protocol,
+            thpState: this.device.getThpState(),
+            ...options,
+        });
+        return result.success ? success(result.payload) : fail(result.message || result.error);
+    }
+    async receive(options = {}) {
+        if (this.disposed)
+            return Promise.resolve(error(this.disposed));
+        const result = await this.transport.receive({
+            session: this.session,
+            protocol: this.device.protocol,
+            thpState: this.device.getThpState(),
+            ...options,
+        });
+        return result.success ? success(result.payload) : fail(result.message || result.error);
     }
     cancelCall() {
         return this.call('Cancel', {});

package/lib/device/DeviceList.js

@@ -79,29 +79,27 @@ class DeviceList extends utils_1.TypedEmitter {
             id: manifest?.appName || manifest?.appUrl || 'unknown app',
         });
     }
-    onDeviceConnected(descriptor, transport) {
+    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,
-            listener: lifecycle => {
-                if (lifecycle === events_1.DEVICE.DISCONNECT) {
-                    this.authPenaltyManager.remove(device);
-                    const index = this.devices.indexOf(device);
-                    if (index >= 0)
-                        this.devices.splice(index, 1);
-                }
-                this.emit(lifecycle, device);
-            },
-        });
-        this.devices.push(device);
+        const device = new Device_1.Device({ id: (0, types_1.DeviceUniquePath)(id), transport, descriptor });
         const penalty = this.authPenaltyManager.get();
-        this.handshakeLock(async () => {
-            if (this.devices.includes(device)) {
-                await device.handshake(penalty);
-            }
+        const stillConnected = await this.handshakeLock(() => (0, utils_1.resolveAfter)(penalty && penalty + 501).then(() => device.handshake()));
+        if (!stillConnected) {
+            return;
+        }
+        this.devices.push(device);
+        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.DISCONNECT, () => {
+            device.lifecycle.removeAllListeners();
+            this.authPenaltyManager.remove(device);
+            const index = this.devices.indexOf(device);
+            if (index >= 0)
+                this.devices.splice(index, 1);
+            this.emit(events_1.DEVICE.DISCONNECT, device);
         });
+        this.emit(device.isUnacquired() ? events_1.DEVICE.CONNECT_UNACQUIRED : events_1.DEVICE.CONNECT, device);
     }
     getOrCreateTransportManager(apiType) {
         if (!this.transportManagers[apiType]) {
@@ -132,38 +130,24 @@ class DeviceList extends utils_1.TypedEmitter {
             throw new Error(enumerateResult.error);
         }
         const descriptors = enumerateResult.payload;
-        const waitForDevicesPromise = pendingTransportEvent && descriptors.length
-            ? this.waitForDevices(transport, descriptors, signal)
-            : Promise.resolve();
         transport.handleDescriptorsChange(descriptors);
         transport.listen();
-        await waitForDevicesPromise;
+        if (pendingTransportEvent && descriptors.length) {
+            await this.waitForDevices(transport, signal);
+        }
     }
-    waitForDevices(transport, descriptors, signal) {
+    waitForDevices(transport, signal) {
         const { promise, reject, resolve } = (0, utils_1.createDeferred)();
         const onAbort = () => reject(signal.reason);
         signal.addEventListener('abort', onAbort);
         const onError = (error) => reject(new Error(error));
         transport.once(transport_1.TRANSPORT.ERROR, onError);
         const autoResolveTransportEventTimeout = setTimeout(resolve, 10000);
-        const remaining = descriptors.slice();
-        const onDeviceEvent = (device) => {
-            const index = remaining.findIndex(d => d.path === device.transportPath && transport === device.transport);
-            if (index >= 0)
-                remaining.splice(index, 1);
-            if (!remaining.length)
-                resolve();
-        };
-        this.on(events_1.DEVICE.CONNECT, onDeviceEvent);
-        this.on(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceEvent);
-        this.on(events_1.DEVICE.DISCONNECT, onDeviceEvent);
+        this.handshakeLock(resolve);
         return promise.finally(() => {
             transport.off(transport_1.TRANSPORT.ERROR, onError);
             signal.removeEventListener('abort', onAbort);
             clearTimeout(autoResolveTransportEventTimeout);
-            this.off(events_1.DEVICE.CONNECT, onDeviceEvent);
-            this.off(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceEvent);
-            this.off(events_1.DEVICE.DISCONNECT, onDeviceEvent);
         });
     }
     getDeviceCount() {

package/lib/device/TransportList.d.ts

@@ -1,9 +1,9 @@
-import { Transport } from '@trezor/transport';
+import { NodeUsbTransport, Transport, UdpTransport } from '@trezor/transport';
 import type { AbstractTransportParams } from '@trezor/transport/lib/transports/abstract';
 import { ConnectSettingsTransport } from '../types';
 type Params = AbstractTransportParams & {
     sessionsBackgroundUrl?: string | null;
 };
-export declare const createTransportList: (params: Params) => (existing: Transport[], transports?: ConnectSettingsTransport[]) => Transport[];
+export declare const createTransportList: (params: Params) => (existing: Transport[], transports?: ConnectSettingsTransport[]) => (Transport | NodeUsbTransport | UdpTransport)[];
 export {};
 //# sourceMappingURL=TransportList.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { Device } from '../Device';
+export declare const getThpChannel: (_device: Device, _withInteraction?: boolean) => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/device/thp/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThpChannel = void 0;
+const constants_1 = require("../../constants");
+const getThpChannel = async (_device, _withInteraction) => {
+    await new Promise((_, reject) => {
+        reject(constants_1.ERRORS.TypedError('Device_ThpStateMissing'));
+    });
+};
+exports.getThpChannel = getThpChannel;
+//# sourceMappingURL=index.js.map