@trezor/connect 9.0.11 → 9.1.1

package/lib/data/coinInfo.js

@@ -1,21 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAllNetworks = exports.getUniqueNetworks = exports.parseCoinsJson = exports.getCoinName = exports.getCoinInfo = exports.getCoinInfoByHash = exports.fixCoinInfoNetwork = exports.getBech32Network = exports.getSegwitNetwork = exports.getMiscNetwork = exports.getEthereumNetwork = exports.getBitcoinNetwork = exports.cloneCoinInfo = void 0;
+exports.getAllNetworks = exports.getUniqueNetworks = exports.parseCoinsJson = exports.getCoinName = exports.getCoinInfo = exports.getCoinInfoByHash = exports.fixCoinInfoNetwork = exports.getBech32Network = exports.getSegwitNetwork = exports.getMiscNetwork = exports.getEthereumNetwork = exports.getBitcoinNetwork = void 0;
 const constants_1 = require("../constants");
 const pathUtils_1 = require("../utils/pathUtils");
+const utils_1 = require("@trezor/utils");
 const bitcoinNetworks = [];
 const ethereumNetworks = [];
 const miscNetworks = [];
-function cloneCoinInfo(info) {
-    const jsonString = JSON.stringify(info);
-    if (jsonString === undefined) {
-        return info;
-    }
-    return JSON.parse(jsonString);
-}
-exports.cloneCoinInfo = cloneCoinInfo;
 const getBitcoinNetwork = (pathOrName) => {
-    const networks = cloneCoinInfo(bitcoinNetworks);
+    const networks = (0, utils_1.cloneObject)(bitcoinNetworks);
     if (typeof pathOrName === 'string') {
         const name = pathOrName.toLowerCase();
         return networks.find(n => n.name.toLowerCase() === name ||
@@ -27,7 +20,7 @@ const getBitcoinNetwork = (pathOrName) => {
 };
 exports.getBitcoinNetwork = getBitcoinNetwork;
 const getEthereumNetwork = (pathOrName) => {
-    const networks = cloneCoinInfo(ethereumNetworks);
+    const networks = (0, utils_1.cloneObject)(ethereumNetworks);
     if (typeof pathOrName === 'string') {
         const name = pathOrName.toLowerCase();
         return networks.find(n => n.name.toLowerCase() === name || n.shortcut.toLowerCase() === name);
@@ -37,7 +30,7 @@ const getEthereumNetwork = (pathOrName) => {
 };
 exports.getEthereumNetwork = getEthereumNetwork;
 const getMiscNetwork = (pathOrName) => {
-    const networks = cloneCoinInfo(miscNetworks);
+    const networks = (0, utils_1.cloneObject)(miscNetworks);
     if (typeof pathOrName === 'string') {
         const name = pathOrName.toLowerCase();
         return networks.find(n => n.name.toLowerCase() === name || n.shortcut.toLowerCase() === name);
@@ -73,7 +66,7 @@ const getBech32Network = (coin) => {
 };
 exports.getBech32Network = getBech32Network;
 const fixCoinInfoNetwork = (ci, path) => {
-    const coinInfo = cloneCoinInfo(ci);
+    const coinInfo = (0, utils_1.cloneObject)(ci);
     if (path[0] === (0, pathUtils_1.toHardened)(84)) {
         const bech32Network = (0, exports.getBech32Network)(coinInfo);
         if (bech32Network) {
@@ -108,7 +101,7 @@ const detectBtcVersion = (data) => {
     return 'btc';
 };
 const getCoinInfoByHash = (hash, networkInfo) => {
-    const networks = cloneCoinInfo(bitcoinNetworks);
+    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}`);

package/lib/data/config.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = void 0;
 const constants_1 = require("@trezor/transport/lib/constants");
 exports.config = {
-    webusb: constants_1.TREZOR_DESCS,
+    webusb: constants_1.TREZOR_USB_DESCRIPTORS,
     whitelist: [
         { origin: 'chrome-extension://imloifkgjagghnncjkhggdhalmcnfklk', priority: 1 },
         { origin: 'chrome-extension://niebkpllfhmpfbffbfifagfgoamhpflf', priority: 1 },
@@ -184,6 +184,7 @@ exports.config = {
             capabilities: ['coinjoin'],
             methods: [
                 'authorizeCoinjoin',
+                'cancelCoinjoinAuthorization',
                 'getOwnershipId',
                 'getOwnershipProof',
                 'setBusy',
@@ -191,6 +192,11 @@ exports.config = {
             ],
             min: ['1.12.1', '2.5.3'],
         },
+        {
+            methods: ['showDeviceTutorial'],
+            min: ['0', '2.6.1'],
+            comment: ['Only on T2B1'],
+        },
     ],
 };
 //# sourceMappingURL=config.js.map

package/lib/data/version.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "9.0.11";
+export declare const VERSION = "9.1.1";
 export declare const DEFAULT_DOMAIN: string;
 //# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.0.11';
+exports.VERSION = '9.1.1';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 exports.DEFAULT_DOMAIN = `https://connect.trezor.io/${versionN[0]}/`;
 //# sourceMappingURL=version.js.map

package/lib/device/Device.d.ts

@@ -3,7 +3,7 @@ import { DeviceCommands } from './DeviceCommands';
 import { PROTO, NETWORK } from '../constants';
 import { DEVICE, DeviceButtonRequestPayload } from '../events';
 import { Deferred } from '../utils/deferred';
-import type { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
+import type { Transport, Descriptor } from '@trezor/transport';
 import type { Device as DeviceTyped, DeviceFirmwareStatus, Features, ReleaseInfo, UnavailableCapabilities } from '../types';
 export type RunOptions = {
     skipFinalReload?: boolean;
@@ -24,15 +24,14 @@ export interface DeviceEvents {
 }
 export declare class Device extends TypedEmitter<DeviceEvents> {
     transport: Transport;
-    originalDescriptor: DeviceDescriptor;
+    originalDescriptor: Descriptor;
     unreadableError?: string;
     firmwareStatus: DeviceFirmwareStatus;
     firmwareRelease?: ReleaseInfo | null;
     features: Features;
     featuresNeedsReload: boolean;
-    deferredActions: {
-        [key: string]: Deferred<void>;
-    };
+    acquirePromise?: ReturnType<Transport['acquire']>;
+    releasePromise?: ReturnType<Transport['release']>;
     runPromise?: Deferred<void> | null;
     loaded: boolean;
     inconsistent: boolean;
@@ -46,9 +45,9 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     unavailableCapabilities: UnavailableCapabilities;
     networkTypeState: NETWORK.NetworkType[];
     firmwareType: 'regular' | 'bitcoin-only';
-    constructor(transport: Transport, descriptor: DeviceDescriptor);
-    static fromDescriptor(transport: Transport, originalDescriptor: DeviceDescriptor): Device;
-    static createUnacquired(transport: Transport, descriptor: DeviceDescriptor, unreadableError?: string): Device;
+    constructor(transport: Transport, descriptor: Descriptor);
+    static fromDescriptor(transport: Transport, originalDescriptor: Descriptor): Device;
+    static createUnacquired(transport: Transport, descriptor: Descriptor, unreadableError?: string): Device;
     acquire(): Promise<void>;
     release(): Promise<void>;
     cleanup(): Promise<void>;
@@ -70,7 +69,6 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     getFeatures(): Promise<void>;
     _updateFeatures(feat: Features): void;
     isUnacquired(): boolean;
-    updateDescriptor(upcomingDescriptor: DeviceDescriptor): Promise<void>;
     disconnect(): void;
     isBootloader(): boolean;
     isInitialized(): boolean;
@@ -87,7 +85,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     getDevicePath(): string;
     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;
-    dispose(): Promise<void> | undefined;
+    dispose(): import("packages/transport/lib/types").AbortableCall<void, "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" | "session not found"> | undefined;
     getMode(): "normal" | "bootloader" | "initialize" | "seedless";
     toMessageObject(): DeviceTyped;
     _getNetworkTypeState(): "bitcoin" | "ethereum" | "nem" | "eos" | "stellar" | "cardano" | "ripple" | "tezos" | "binance";

package/lib/device/Device.js

@@ -21,7 +21,8 @@ class Device extends typedEventEmitter_1.TypedEmitter {
     constructor(transport, descriptor) {
         super();
         this.featuresNeedsReload = false;
-        this.deferredActions = {};
+        this.acquirePromise = undefined;
+        this.releasePromise = undefined;
         this.loaded = false;
         this.inconsistent = false;
         this.keepSession = false;
@@ -52,54 +53,53 @@ class Device extends typedEventEmitter_1.TypedEmitter {
         return device;
     }
     async acquire() {
-        this.deferredActions[events_1.DEVICE.ACQUIRE] = (0, deferred_1.create)();
-        this.deferredActions[events_1.DEVICE.ACQUIRED] = (0, deferred_1.create)();
-        try {
-            const sessionID = await this.transport.acquire({
+        this.acquirePromise = this.transport.acquire({
+            input: {
                 path: this.originalDescriptor.path,
                 previous: this.originalDescriptor.session,
-            }, false);
-            _log.debug('Expected session id:', sessionID);
-            this.activitySessionID = sessionID;
-            this.deferredActions[events_1.DEVICE.ACQUIRED].resolve();
-            delete this.deferredActions[events_1.DEVICE.ACQUIRED];
-            if (this.commands) {
-                this.commands.dispose();
-            }
-            this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, sessionID);
-            this.deferredActions[events_1.DEVICE.RELEASE] = (0, deferred_1.create)();
-        }
-        catch (error) {
-            this.deferredActions[events_1.DEVICE.ACQUIRED].resolve();
-            delete this.deferredActions[events_1.DEVICE.ACQUIRED];
+            },
+        });
+        const acquireResult = await this.acquirePromise.promise;
+        this.acquirePromise = undefined;
+        if (!acquireResult.success) {
             if (this.runPromise) {
-                this.runPromise.reject(error);
-            }
-            else {
-                throw error;
+                this.runPromise.reject(new Error(acquireResult.error));
+                this.runPromise = null;
             }
-            this.runPromise = null;
+            throw acquireResult.error;
+        }
+        const sessionID = acquireResult.payload;
+        _log.debug('Expected session id:', sessionID);
+        this.activitySessionID = sessionID;
+        this.originalDescriptor.session = sessionID;
+        if (this.commands) {
+            this.commands.dispose();
         }
+        this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, sessionID);
     }
     async release() {
-        if (this.isUsedHere() && !this.keepSession && this.activitySessionID) {
+        if (this.isUsedHere() &&
+            !this.keepSession &&
+            this.activitySessionID &&
+            !this.releasePromise) {
             if (this.commands) {
                 this.commands.dispose();
                 if (this.commands.callPromise) {
-                    try {
-                        await this.commands.callPromise;
-                    }
-                    catch (error) {
-                        this.commands.callPromise = undefined;
-                    }
+                    await this.commands.callPromise.promise;
                 }
             }
-            try {
-                await this.transport.release(this.activitySessionID, false, false);
-                if (this.deferredActions[events_1.DEVICE.RELEASE])
-                    await this.deferredActions[events_1.DEVICE.RELEASE].promise;
+            if (this.releasePromise) {
+                await this.releasePromise;
             }
-            catch (err) {
+            this.releasePromise = this.transport.release({
+                session: this.activitySessionID,
+                path: this.originalDescriptor.path,
+            });
+            const releaseResponse = await this.releasePromise.promise;
+            this.releasePromise = undefined;
+            if (releaseResponse.success) {
+                this.activitySessionID = null;
+                this.originalDescriptor.session = null;
             }
         }
     }
@@ -118,26 +118,25 @@ class Device extends typedEventEmitter_1.TypedEmitter {
         return this.runPromise.promise;
     }
     async override(error) {
-        if (this.deferredActions[events_1.DEVICE.ACQUIRE]) {
-            await this.deferredActions[events_1.DEVICE.ACQUIRE].promise;
+        if (this.acquirePromise) {
+            await this.acquirePromise.promise;
         }
         if (this.runPromise) {
             await this.interruptionFromUser(error);
         }
-        if (!this.keepSession && this.deferredActions[events_1.DEVICE.RELEASE]) {
-            await this.deferredActions[events_1.DEVICE.RELEASE].promise;
+        if (this.releasePromise) {
+            await this.releasePromise.promise;
         }
     }
     async interruptionFromUser(error) {
         _log.debug('interruptionFromUser');
-        if (this.commands) {
-            await this.commands.cancel();
-            this.commands.dispose();
-        }
         if (this.runPromise) {
             this.runPromise.reject(error);
             this.runPromise = null;
         }
+        if (this.commands) {
+            await this.commands.cancel();
+        }
     }
     interruptionFromOutside() {
         _log.debug('interruptionFromOutside');
@@ -148,9 +147,13 @@ class Device extends typedEventEmitter_1.TypedEmitter {
             this.runPromise.reject(constants_1.ERRORS.TypedError('Device_UsedElsewhere'));
             this.runPromise = null;
         }
+        this.transport.releaseDevice(this.originalDescriptor.path);
     }
     async _runInner(fn, options) {
         var _a;
+        if (this.releasePromise) {
+            await this.releasePromise.promise;
+        }
         if (!this.isUsedHere() || ((_a = this.commands) === null || _a === void 0 ? void 0 : _a.disposed) || !this.getExternalState()) {
             await this.acquire();
             try {
@@ -170,15 +173,16 @@ class Device extends typedEventEmitter_1.TypedEmitter {
                     return this._runInner(() => Promise.resolve({}), options);
                 }
                 this.inconsistent = true;
-                await this.deferredActions[events_1.DEVICE.ACQUIRE].promise;
                 this.runPromise = null;
-                return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message}, code: ${error.code}`));
+                return Promise.reject(constants_1.ERRORS.TypedError('Device_InitializeFailed', `Initialize failed: ${error.message} ${error.code ? `, code: ${error.code}` : ''}`));
             }
         }
         if (options.keepSession) {
             this.keepSession = true;
         }
-        await this.deferredActions[events_1.DEVICE.ACQUIRE].promise;
+        if (this.listeners(events_1.DEVICE.ACQUIRED).length > 0) {
+            this.emit(events_1.DEVICE.ACQUIRED);
+        }
         if (fn) {
             await fn();
         }
@@ -315,6 +319,9 @@ class Device extends typedEventEmitter_1.TypedEmitter {
         if (!feat.model && feat.major_version === 1) {
             feat.model = '1';
         }
+        if (!feat.internal_model) {
+            feat.internal_model = (0, deviceFeaturesUtils_1.ensureInternalModelFeature)(feat.model);
+        }
         this.features = feat;
         this.featuresNeedsReload = false;
         this.firmwareType =
@@ -327,55 +334,9 @@ class Device extends typedEventEmitter_1.TypedEmitter {
     isUnacquired() {
         return this.features === undefined;
     }
-    async updateDescriptor(upcomingDescriptor) {
-        const originalSession = this.originalDescriptor.session;
-        const upcomingSession = upcomingDescriptor.session;
-        _log.debug('updateDescriptor', 'currentSession', originalSession, 'upcoming', upcomingSession, 'lastUsedID', this.activitySessionID);
-        if (!originalSession && !upcomingSession && !this.activitySessionID) {
-            return;
-        }
-        if (this.deferredActions[events_1.DEVICE.ACQUIRED]) {
-            await this.deferredActions[events_1.DEVICE.ACQUIRED].promise;
-        }
-        if (!upcomingSession) {
-            if (this.listeners(events_1.DEVICE.ACQUIRED).length > 0) {
-                this.emit(events_1.DEVICE.ACQUIRED);
-            }
-        }
-        const methodStillRunning = this.commands && !this.commands.disposed;
-        if (!upcomingSession && !methodStillRunning) {
-            if (originalSession === this.activitySessionID) {
-                _log.debug('Session released by this app');
-                if (this.deferredActions[events_1.DEVICE.RELEASE]) {
-                    this.deferredActions[events_1.DEVICE.RELEASE].resolve();
-                    delete this.deferredActions[events_1.DEVICE.RELEASE];
-                }
-                this.activitySessionID = null;
-            }
-            else {
-                _log.debug('Session released by other app');
-                this.featuresNeedsReload = true;
-            }
-            this.keepSession = false;
-        }
-        else if (upcomingSession === this.activitySessionID) {
-            _log.debug('Session acquired by this app');
-            if (this.deferredActions[events_1.DEVICE.ACQUIRE]) {
-                this.deferredActions[events_1.DEVICE.ACQUIRE].resolve();
-            }
-        }
-        else {
-            _log.debug('Session acquired by other app');
-            this.interruptionFromOutside();
-        }
-        this.originalDescriptor = upcomingDescriptor;
-    }
     disconnect() {
         _log.debug('Disconnect cleanup');
-        if (this.deferredActions[events_1.DEVICE.RELEASE]) {
-            this.deferredActions[events_1.DEVICE.RELEASE].resolve();
-            delete this.deferredActions[events_1.DEVICE.RELEASE];
-        }
+        this.activitySessionID = null;
         this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
         this.runPromise = null;
     }
@@ -454,7 +415,11 @@ class Device extends typedEventEmitter_1.TypedEmitter {
                 if (this.commands) {
                     this.commands.cancel();
                 }
-                return this.transport.release(this.activitySessionID, true);
+                return this.transport.release({
+                    session: this.activitySessionID,
+                    path: this.originalDescriptor.path,
+                    onClose: true,
+                });
             }
             catch (err) {
             }

package/lib/device/DeviceCommands.d.ts

@@ -11,7 +11,7 @@ export type TypedResponseMessage<T extends MessageKey> = {
 type TypedCallResponseMap = {
     [K in keyof MessageType]: TypedResponseMessage<K>;
 };
-export type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
+type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
 export type PassphrasePromptResponse = {
     passphrase?: string;
     passphraseOnDevice?: boolean;
@@ -22,8 +22,9 @@ export declare class DeviceCommands {
     transport: Transport;
     sessionId: string;
     disposed: boolean;
-    callPromise?: Promise<DefaultMessageResponse>;
+    callPromise?: ReturnType<Transport['call']>;
     _cancelableRequest?: (error?: any) => void;
+    _cancelableRequestBySend?: boolean;
     constructor(device: Device, transport: Transport, sessionId: string);
     dispose(): void;
     isDisposed(): boolean;
@@ -48,7 +49,7 @@ export declare class DeviceCommands {
     ethereumGetPublicKey({ address_n, show_display, }: Messages.EthereumGetPublicKey): Promise<HDNodeResponse>;
     preauthorize(throwError: boolean): Promise<boolean>;
     getDeviceState(networkType?: string): Promise<string>;
-    call(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;
+    private call;
     typedCall<T extends MessageKey, R extends MessageKey[]>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedCallResponseMap[R[number]]>;
     typedCall<T extends MessageKey, R extends MessageKey>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedResponseMessage<R>>;
     _commonCall(type: MessageKey, msg?: DefaultMessageResponse['message']): Promise<DefaultMessageResponse>;

package/lib/device/DeviceCommands.js

@@ -240,20 +240,20 @@ class DeviceCommands {
         return this._getAddressForNetworkType();
     }
     async call(type, msg = {}) {
-        const logMessage = filterForLog(type, msg);
-        logger.debug('Sending', type, logMessage);
-        try {
-            const promise = this.transport.call(this.sessionId, type, msg, false);
-            this.callPromise = promise;
-            const res = await promise;
-            const logMessage = filterForLog(res.type, res.message);
-            logger.debug('Received', res.type, logMessage);
-            return res;
-        }
-        catch (error) {
-            logger.warn('Received error', error);
-            throw error;
-        }
+        logger.debug('Sending', type, filterForLog(type, msg));
+        this.callPromise = this.transport.call({
+            session: this.sessionId,
+            name: type,
+            data: msg,
+        });
+        const res = await this.callPromise.promise;
+        this.callPromise = undefined;
+        if (!res.success) {
+            logger.warn('Received error', res.error);
+            throw new Error(res.error);
+        }
+        logger.debug('Received', res.payload.type, filterForLog(res.payload.type, res.payload.message));
+        return res.payload;
     }
     async typedCall(type, resType, msg) {
         if (this.disposed) {
@@ -264,16 +264,20 @@ class DeviceCommands {
             assertType(response, resType);
         }
         catch (error) {
-            await this.transport.read(this.sessionId, false);
+            await this.transport.receive({ session: this.sessionId });
             throw error;
         }
         return response;
     }
     async _commonCall(type, msg) {
         const resp = await this.call(type, msg);
+        if (this.disposed) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'typedCall: DeviceCommands already disposed');
+        }
         return this._filterCommonTypes(resp);
     }
     _filterCommonTypes(res) {
+        this._cancelableRequestBySend = false;
         if (res.type === 'Failure') {
             const { code } = res.message;
             let { message } = res.message;
@@ -289,6 +293,7 @@ class DeviceCommands {
             return Promise.resolve(res);
         }
         if (res.type === 'ButtonRequest') {
+            this._cancelableRequestBySend = true;
             if (res.message.code === '_Deprecated_ButtonRequest_PassphraseType') {
                 res.message.code = 'ButtonRequest_PassphraseType';
             }
@@ -475,13 +480,30 @@ class DeviceCommands {
         if (this.disposed) {
             return;
         }
+        this.dispose();
+        if (!this._cancelableRequestBySend) {
+            if (this.callPromise) {
+                await this.callPromise.promise;
+            }
+            return;
+        }
         const { name, version } = this.transport;
         if (name === 'BridgeTransport' && (0, versionUtils_1.versionCompare)(version, '2.0.28') < 1) {
-            await this.device.legacyForceRelease();
+            try {
+                await this.device.legacyForceRelease();
+            }
+            catch (err) {
+            }
         }
         else {
-            await this.transport.post(this.sessionId, 'Cancel', {}, false).catch(() => { });
-            await this.transport.read(this.sessionId, false).catch(() => { });
+            await this.transport.send({
+                session: this.sessionId,
+                name: 'Cancel',
+                data: {},
+            }).promise;
+            if (this.callPromise) {
+                await this.callPromise.promise;
+            }
         }
     }
 }

package/lib/device/DeviceList.d.ts

@@ -1,20 +1,11 @@
 import { TypedEmitter } from '@trezor/utils/lib/typedEventEmitter';
-import { Transport, TrezorDeviceInfoWithSession as DeviceDescriptor } from '@trezor/transport';
-import { TRANSPORT, DEVICE, TransportInfo } from '../events';
-import { DescriptorStream } from './DescriptorStream';
+import { Transport, TRANSPORT, Descriptor } from '@trezor/transport';
+import { DEVICE, TransportInfo } from '../events';
 import { Device } from './Device';
 import type { Device as DeviceTyped } from '../types';
-type LowLevelPlugin = {
-    name: 'WebUsbPlugin' | 'ReactNativePlugin';
-    unreadableHidDeviceChange: {
-        on: (event: string, fn: any) => void;
-    };
-    unreadableHidDevice: boolean;
-};
 interface DeviceListEvents {
     [TRANSPORT.START]: TransportInfo;
     [TRANSPORT.ERROR]: string;
-    [TRANSPORT.STREAM]: DescriptorStream;
     [DEVICE.CONNECT]: DeviceTyped;
     [DEVICE.CONNECT_UNACQUIRED]: DeviceTyped;
     [DEVICE.DISCONNECT]: DeviceTyped;
@@ -24,42 +15,41 @@ interface DeviceListEvents {
 }
 export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     transport: Transport;
-    transportPlugin: LowLevelPlugin | typeof undefined;
-    stream: DescriptorStream;
+    transports: Transport[];
     devices: {
         [path: string]: Device;
     };
+    messages: JSON | Record<string, any>;
     creatingDevicesDescriptors: {
-        [k: string]: DeviceDescriptor;
+        [k: string]: Descriptor;
     };
-    messages: JSON | Record<string, any>;
     transportStartPending: number;
     penalizedDevices: {
         [deviceID: string]: number;
     };
-    fetchController?: AbortController | null;
     constructor();
     init(): Promise<void>;
-    resolveTransportEvent(): void;
+    private resolveTransportEvent;
     waitForTransportFirstEvent(): Promise<void>;
-    _initStream(): void;
-    _createAndSaveDevice(descriptor: DeviceDescriptor): Promise<void>;
-    _createUnacquiredDevice(descriptor: DeviceDescriptor): Device;
-    _createUnreadableDevice(descriptor: DeviceDescriptor, unreadableError: string): Device;
+    private _createAndSaveDevice;
+    private _createUnacquiredDevice;
+    private _createUnreadableDevice;
     getDevice(path: string): Device;
     getFirstDevicePath(): string;
     asArray(): DeviceTyped[];
     allDevices(): Device[];
     length(): number;
-    transportType(): string;
+    transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport";
     getTransportInfo(): TransportInfo;
     dispose(): Promise<void>;
     disconnectDevices(): void;
-    enumerate(): void;
+    enumerate(): Promise<void>;
     addAuthPenalty(device: Device): void;
-    getAuthPenalty(): number;
+    private getAuthPenalty;
     removeAuthPenalty(device: Device): void;
+    private handle;
+    private _takeAndCreateDevice;
+    private _handleUsedElsewhere;
 }
-export declare const getDeviceList: () => Promise<DeviceList>;
 export {};
 //# sourceMappingURL=DeviceList.d.ts.map