@trezor/connect 9.3.1-beta.1 → 9.3.1-beta.2

package/lib/device/DeviceList.d.ts

@@ -1,5 +1,5 @@
 import { TypedEmitter } from '@trezor/utils';
-import { Transport, TRANSPORT, Descriptor } from '@trezor/transport';
+import { Transport, TRANSPORT } from '@trezor/transport';
 import { DEVICE, TransportInfo } from '../events';
 import { Device } from './Device';
 import type { ConnectSettings, Device as DeviceTyped } from '../types';
@@ -13,28 +13,44 @@ interface DeviceListEvents {
     [DEVICE.RELEASED]: DeviceTyped;
     [DEVICE.ACQUIRED]: DeviceTyped;
 }
-export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
-    transport: Transport;
-    transports: Transport[];
-    devices: {
-        [path: string]: Device;
-    };
-    creatingDevicesDescriptors: {
-        [k: string]: Descriptor;
-    };
-    transportStartPending: number;
-    penalizedDevices: {
-        [deviceID: string]: number;
-    };
-    transportFirstEventPromise: Promise<void> | undefined;
-    private settings;
-    constructor({ settings, messages, }: {
-        settings: ConnectSettings;
-        messages: Record<string, any>;
-    });
-    init(): Promise<void>;
-    private resolveTransportEvent;
-    waitForTransportFirstEvent(): Promise<void>;
+export interface IDeviceList {
+    isConnected(): this is DeviceList;
+    assertConnected(): asserts this is DeviceList;
+    pendingConnection(): Promise<void> | undefined;
+    setTransports: DeviceList['setTransports'];
+    addAuthPenalty: DeviceList['addAuthPenalty'];
+    removeAuthPenalty: DeviceList['removeAuthPenalty'];
+    on: DeviceList['on'];
+    once: DeviceList['once'];
+    init: DeviceList['init'];
+    dispose: DeviceList['dispose'];
+}
+type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug'> & {
+    messages: Record<string, any>;
+};
+type InitParams = Pick<ConnectSettings, 'pendingTransportEvent' | 'transportReconnect'>;
+export declare class DeviceList extends TypedEmitter<DeviceListEvents> implements IDeviceList {
+    private transport;
+    private transports;
+    private devices;
+    private creatingDevicesDescriptors;
+    private readonly authPenaltyManager;
+    private initPromise?;
+    private rejectPending?;
+    private transportCommonArgs;
+    isConnected(): this is DeviceList;
+    assertConnected(): asserts this is DeviceList;
+    pendingConnection(): Promise<void> | undefined;
+    constructor({ messages, priority, debug }: ConstructorParams);
+    private createTransport;
+    setTransports(transports: ConnectSettings['transports']): void;
+    private onTransportUpdate;
+    init(initParams?: InitParams): Promise<void>;
+    private createInitPromise;
+    private createReconnectPromise;
+    private selectTransport;
+    private initializeTransport;
+    private waitForDevices;
     private _createAndSaveDevice;
     private _createUnacquiredDevice;
     private _createUnreadableDevice;
@@ -45,11 +61,10 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> {
     length(): number;
     transportType(): "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport";
     getTransportInfo(): TransportInfo;
-    dispose(): void;
-    disconnectDevices(): void;
-    enumerate(): Promise<void>;
+    dispose(): Promise<void>;
+    cleanup(): Promise<void>;
+    enumerate(transport?: Transport): Promise<void>;
     addAuthPenalty(device: Device): void;
-    private getAuthPenalty;
     removeAuthPenalty(device: Device): void;
     private handle;
     private _takeAndCreateDevice;

package/lib/device/DeviceList.js

@@ -10,239 +10,264 @@ const transportInfo_1 = require("../data/transportInfo");
 const debug_1 = require("../utils/debug");
 const promiseUtils_1 = require("../utils/promiseUtils");
 const _log = (0, debug_1.initLog)('DeviceList');
-let autoResolveTransportEventTimeout;
+const createAuthPenaltyManager = (priority) => {
+    const penalizedDevices = {};
+    const get = () => 100 * priority +
+        Object.keys(penalizedDevices).reduce((penalty, key) => Math.max(penalty, penalizedDevices[key]), 0);
+    const add = (device) => {
+        if (!device.isInitialized() || device.isBootloader() || !device.features.device_id)
+            return;
+        const deviceID = device.features.device_id;
+        const penalty = penalizedDevices[deviceID] ? penalizedDevices[deviceID] + 500 : 2000;
+        penalizedDevices[deviceID] = Math.min(penalty, 5000);
+    };
+    const remove = (device) => {
+        if (!device.isInitialized() || device.isBootloader() || !device.features.device_id)
+            return;
+        const deviceID = device.features.device_id;
+        delete penalizedDevices[deviceID];
+    };
+    const clear = () => Object.keys(penalizedDevices).forEach(key => delete penalizedDevices[key]);
+    return { get, add, remove, clear };
+};
 class DeviceList extends utils_1.TypedEmitter {
-    constructor({ settings, messages, }) {
+    isConnected() {
+        return !!this.transport;
+    }
+    assertConnected() {
+        if (!this.transport)
+            throw constants_1.ERRORS.TypedError('Transport_Missing');
+    }
+    pendingConnection() {
+        return this.initPromise;
+    }
+    constructor({ messages, priority, debug }) {
         super();
-        this.transports = [];
         this.devices = {};
         this.creatingDevicesDescriptors = {};
-        this.transportStartPending = 0;
-        this.penalizedDevices = {};
-        this.settings = settings;
-        const transports = [...(settings.transports || [])];
-        if (!transports.length) {
-            transports.push('BridgeTransport');
-        }
-        const transportLogger = (0, debug_1.initLog)('@trezor/transport', this.settings.debug);
+        const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
         const abortController = new AbortController();
-        const transportCommonArgs = {
+        this.authPenaltyManager = createAuthPenaltyManager(priority);
+        this.transportCommonArgs = {
             messages,
             logger: transportLogger,
             signal: abortController.signal,
         };
-        transports.forEach(transportType => {
-            if (typeof transportType === 'string') {
-                switch (transportType) {
-                    case 'WebUsbTransport':
-                        this.transports.push(new transport_1.WebUsbTransport(transportCommonArgs));
-                        break;
-                    case 'NodeUsbTransport':
-                        this.transports.push(new transport_1.NodeUsbTransport(transportCommonArgs));
-                        break;
-                    case 'BridgeTransport':
-                        this.transports.push(new transport_1.BridgeTransport({
-                            latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
-                            ...transportCommonArgs,
-                        }));
-                        break;
-                    case 'UdpTransport':
-                        this.transports.push(new transport_1.UdpTransport(transportCommonArgs));
-                        break;
-                    default:
-                        throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
-                }
+        this.transports = [
+            new transport_1.BridgeTransport({
+                latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
+                ...this.transportCommonArgs,
+            }),
+        ];
+    }
+    createTransport(transportType) {
+        const { transportCommonArgs } = this;
+        if (typeof transportType === 'string') {
+            switch (transportType) {
+                case 'WebUsbTransport':
+                    return new transport_1.WebUsbTransport(transportCommonArgs);
+                case 'NodeUsbTransport':
+                    return new transport_1.NodeUsbTransport(transportCommonArgs);
+                case 'BridgeTransport':
+                    return new transport_1.BridgeTransport({
+                        latestVersion: (0, transportInfo_1.getBridgeInfo)().version.join('.'),
+                        ...transportCommonArgs,
+                    });
+                case 'UdpTransport':
+                    return new transport_1.UdpTransport(transportCommonArgs);
             }
-            else if (typeof transportType === 'function' && 'prototype' in transportType) {
-                const transportInstance = new transportType(transportCommonArgs);
-                if ((0, transport_1.isTransportInstance)(transportInstance)) {
-                    this.transports.push(transportInstance);
-                }
+        }
+        else if (typeof transportType === 'function' && 'prototype' in transportType) {
+            const transportInstance = new transportType(transportCommonArgs);
+            if ((0, transport_1.isTransportInstance)(transportInstance)) {
+                return transportInstance;
             }
-            else if ((0, transport_1.isTransportInstance)(transportType)) {
-                if (!transportType.getMessage()) {
-                    transportType.updateMessages(messages);
-                }
-                this.transports.push(transportType);
+        }
+        else if ((0, transport_1.isTransportInstance)(transportType)) {
+            if (!transportType.getMessage()) {
+                transportType.updateMessages(transportCommonArgs.messages);
             }
-            else {
-                throw constants_1.ERRORS.TypedError('Runtime', 'DeviceList.init: transports[] of unexpected type');
+            return transportType;
+        }
+        throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
+    }
+    setTransports(transports) {
+        const transportTypes = (transports === null || transports === void 0 ? void 0 : transports.length) ? transports : ['BridgeTransport'];
+        this.transports = transportTypes.map(this.createTransport.bind(this));
+    }
+    onTransportUpdate(diff, transport) {
+        diff.disconnected.forEach(descriptor => {
+            const path = descriptor.path.toString();
+            const device = this.devices[path];
+            if (device) {
+                device.disconnect();
+                delete this.devices[path];
+                this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
             }
         });
-    }
-    async init() {
-        try {
-            _log.debug('Initializing transports');
-            let lastError;
-            for (const transport of this.transports) {
-                this.transport = transport;
-                const result = await this.transport.init().promise;
-                if (result.success) {
-                    lastError = undefined;
-                    break;
-                }
-                else {
-                    lastError = result.error;
-                }
+        diff.connected.forEach(async (descriptor) => {
+            const path = descriptor.path.toString();
+            this.creatingDevicesDescriptors[path] = descriptor;
+            const penalty = this.authPenaltyManager.get();
+            if (penalty) {
+                await (0, promiseUtils_1.resolveAfter)(501 + penalty, null).promise;
             }
-            if (lastError) {
-                this.emit(transport_1.TRANSPORT.ERROR, lastError);
-                return;
+            if (this.creatingDevicesDescriptors[path].session == null) {
+                await this._createAndSaveDevice(descriptor, transport);
             }
-            this.transport.on(transport_1.TRANSPORT.UPDATE, diff => {
-                diff.disconnected.forEach(descriptor => {
-                    const path = descriptor.path.toString();
-                    const device = this.devices[path];
-                    if (device) {
-                        device.disconnect();
-                        delete this.devices[path];
-                        this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
-                    }
-                });
-                diff.connected.forEach(async (descriptor) => {
-                    const path = descriptor.path.toString();
-                    this.creatingDevicesDescriptors[path] = descriptor;
-                    const { priority } = this.settings;
-                    const penalty = this.getAuthPenalty();
-                    if (priority || penalty) {
-                        await (0, promiseUtils_1.resolveAfter)(501 + penalty + 100 * priority, null).promise;
-                    }
-                    if (this.creatingDevicesDescriptors[path].session == null) {
-                        await this._createAndSaveDevice(descriptor);
-                    }
-                    else {
-                        const device = this._createUnacquiredDevice(descriptor);
-                        this.devices[path] = device;
-                        this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-                    }
-                });
-                diff.acquiredElsewhere.forEach((descriptor) => {
-                    const path = descriptor.path.toString();
-                    const device = this.devices[path];
-                    if (device) {
-                        device.featuresNeedsReload = true;
-                        device.interruptionFromOutside();
-                    }
-                });
-                diff.released.forEach(descriptor => {
-                    var _a;
-                    const path = descriptor.path.toString();
-                    const device = this.devices[path];
-                    const methodStillRunning = !((_a = device === null || device === void 0 ? void 0 : device.commands) === null || _a === void 0 ? void 0 : _a.disposed);
-                    if (device && methodStillRunning) {
-                        device.keepSession = false;
-                    }
-                });
-                diff.releasedElsewhere.forEach(async (descriptor) => {
-                    const path = descriptor.path.toString();
-                    const device = this.devices[path];
-                    await (0, promiseUtils_1.resolveAfter)(1000, null).promise;
-                    if (device) {
-                        if (!device.isUsed() && device.isUnacquired() && !device.isInconsistent()) {
-                            _log.debug('Create device from unacquired', device.toMessageObject());
-                            await this._createAndSaveDevice(descriptor);
-                        }
-                    }
-                });
-                const events = [
-                    {
-                        d: diff.changedSessions,
-                        e: events_1.DEVICE.CHANGED,
-                    },
-                    {
-                        d: diff.acquired,
-                        e: events_1.DEVICE.ACQUIRED,
-                    },
-                    {
-                        d: diff.released,
-                        e: events_1.DEVICE.RELEASED,
-                    },
-                ];
-                events.forEach(({ d, e }) => {
-                    d.forEach(descriptor => {
-                        const path = descriptor.path.toString();
-                        const device = this.devices[path];
-                        if (device) {
-                            _log.debug('Event', e, device.toMessageObject());
-                            this.emit(e, device.toMessageObject());
-                        }
-                    });
-                });
-                diff.descriptors.forEach(d => {
-                    this.creatingDevicesDescriptors[d.path] = d;
-                    if (this.devices[d.path]) {
-                        this.devices[d.path].originalDescriptor = {
-                            session: d.session,
-                            path: d.path,
-                            product: d.product,
-                            type: d.type,
-                        };
-                    }
-                });
-            });
-            this.transport.on(transport_1.TRANSPORT.ERROR, error => {
-                this.emit(transport_1.TRANSPORT.ERROR, error);
-            });
-            const enumerateResult = await this.transport.enumerate().promise;
-            if (!enumerateResult.success) {
-                this.emit(transport_1.TRANSPORT.ERROR, enumerateResult.error);
-                return;
+            else {
+                const device = this._createUnacquiredDevice(descriptor, transport);
+                this.devices[path] = device;
+                this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
             }
-            const descriptors = enumerateResult.payload;
-            if (descriptors.length > 0 && this.settings.pendingTransportEvent) {
-                this.transportStartPending = descriptors.length;
-                this.on(events_1.DEVICE.CONNECT, this.resolveTransportEvent.bind(this));
-                this.on(events_1.DEVICE.CONNECT_UNACQUIRED, this.resolveTransportEvent.bind(this));
-                autoResolveTransportEventTimeout = setTimeout(() => {
-                    this.emit(transport_1.TRANSPORT.START, this.getTransportInfo());
-                }, 10000);
+        });
+        diff.acquiredElsewhere.forEach((descriptor) => {
+            const path = descriptor.path.toString();
+            const device = this.devices[path];
+            if (device) {
+                device.featuresNeedsReload = true;
+                device.interruptionFromOutside();
             }
-            else {
-                this.emit(transport_1.TRANSPORT.START, this.getTransportInfo());
+        });
+        diff.released.forEach(descriptor => {
+            var _a;
+            const path = descriptor.path.toString();
+            const device = this.devices[path];
+            const methodStillRunning = !((_a = device === null || device === void 0 ? void 0 : device.commands) === null || _a === void 0 ? void 0 : _a.isDisposed());
+            if (device && methodStillRunning) {
+                device.keepSession = false;
             }
-            this.transport.handleDescriptorsChange(descriptors);
-            this.transport.listen();
-        }
-        catch (error) {
-            console.error('DeviceList init error', error);
-        }
+        });
+        diff.releasedElsewhere.forEach(async (descriptor) => {
+            const path = descriptor.path.toString();
+            const device = this.devices[path];
+            await (0, promiseUtils_1.resolveAfter)(1000, null).promise;
+            if (device) {
+                if (!device.isUsed() && device.isUnacquired() && !device.isInconsistent()) {
+                    _log.debug('Create device from unacquired', device.toMessageObject());
+                    await this._createAndSaveDevice(descriptor, transport);
+                }
+            }
+        });
+        const forEachDescriptor = (d, e) => {
+            d.forEach(descriptor => {
+                const path = descriptor.path.toString();
+                const device = this.devices[path];
+                if (device) {
+                    _log.debug('Event', e, device.toMessageObject());
+                    this.emit(e, device.toMessageObject());
+                }
+            });
+        };
+        forEachDescriptor(diff.changedSessions, events_1.DEVICE.CHANGED);
+        forEachDescriptor(diff.acquired, events_1.DEVICE.ACQUIRED);
+        forEachDescriptor(diff.released, events_1.DEVICE.RELEASED);
+        diff.descriptors.forEach(d => {
+            this.creatingDevicesDescriptors[d.path] = d;
+            if (this.devices[d.path]) {
+                this.devices[d.path].originalDescriptor = {
+                    session: d.session,
+                    path: d.path,
+                    product: d.product,
+                    type: d.type,
+                };
+            }
+        });
     }
-    resolveTransportEvent() {
-        this.transportStartPending--;
-        if (autoResolveTransportEventTimeout) {
-            clearTimeout(autoResolveTransportEventTimeout);
+    init(initParams = {}) {
+        if (!this.initPromise) {
+            _log.debug('Initializing transports');
+            this.initPromise = this.createInitPromise(initParams);
         }
-        if (this.transportStartPending === 0) {
+        return this.initPromise;
+    }
+    createInitPromise(initParams) {
+        return this.selectTransport(this.transports)
+            .then(transport => this.initializeTransport(transport, initParams))
+            .then(transport => {
+            this.transport = transport;
             this.emit(transport_1.TRANSPORT.START, this.getTransportInfo());
+            this.initPromise = undefined;
+        })
+            .catch(error => {
+            this.cleanup();
+            this.emit(transport_1.TRANSPORT.ERROR, error);
+            this.initPromise = initParams.transportReconnect
+                ? this.createReconnectPromise(initParams)
+                : undefined;
+        });
+    }
+    createReconnectPromise(initParams) {
+        const { promise, reject } = (0, promiseUtils_1.resolveAfter)(1000, initParams);
+        this.rejectPending = reject;
+        return promise.then(this.createInitPromise.bind(this));
+    }
+    async selectTransport([transport, ...rest]) {
+        const result = await transport.init().promise;
+        if (result.success)
+            return transport;
+        else if (rest.length)
+            return this.selectTransport(rest);
+        else
+            throw new Error(result.error);
+    }
+    async initializeTransport(transport, initParams) {
+        transport.on(transport_1.TRANSPORT.UPDATE, diff => this.onTransportUpdate(diff, transport));
+        transport.on(transport_1.TRANSPORT.ERROR, error => {
+            this.cleanup();
+            this.emit(transport_1.TRANSPORT.ERROR, error);
+            if (initParams.transportReconnect) {
+                this.initPromise = this.createReconnectPromise(initParams);
+            }
+        });
+        const enumerateResult = await transport.enumerate().promise;
+        if (!enumerateResult.success) {
+            throw new Error(enumerateResult.error);
+        }
+        const descriptors = enumerateResult.payload;
+        transport.handleDescriptorsChange(descriptors);
+        transport.listen();
+        const awaitedDevices = descriptors.length - Object.keys(this.devices).length;
+        if (awaitedDevices > 0 && initParams.pendingTransportEvent) {
+            await this.waitForDevices(awaitedDevices, 10000);
         }
+        return transport;
     }
-    async waitForTransportFirstEvent() {
-        this.transportFirstEventPromise = new Promise(resolve => {
-            const handler = () => {
-                this.removeListener(transport_1.TRANSPORT.START, handler);
-                this.removeListener(transport_1.TRANSPORT.ERROR, handler);
+    waitForDevices(deviceCount, autoResolveMs) {
+        const { promise, resolve, reject } = (0, utils_1.createDeferred)();
+        let transportStartPending = deviceCount;
+        const autoResolveTransportEventTimeout = setTimeout(resolve, autoResolveMs);
+        this.rejectPending = reject;
+        const onDeviceConnect = () => {
+            transportStartPending--;
+            if (transportStartPending === 0) {
                 resolve();
-            };
-            this.on(transport_1.TRANSPORT.START, handler);
-            this.on(transport_1.TRANSPORT.ERROR, handler);
+            }
+        };
+        this.on(events_1.DEVICE.CONNECT, onDeviceConnect);
+        this.on(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceConnect);
+        return promise.finally(() => {
+            this.rejectPending = undefined;
+            clearTimeout(autoResolveTransportEventTimeout);
+            this.off(events_1.DEVICE.CONNECT, onDeviceConnect);
+            this.off(events_1.DEVICE.CONNECT_UNACQUIRED, onDeviceConnect);
         });
-        await this.transportFirstEventPromise;
     }
-    async _createAndSaveDevice(descriptor) {
+    async _createAndSaveDevice(descriptor, transport) {
         _log.debug('Creating Device', descriptor);
-        await this.handle(descriptor);
+        await this.handle(descriptor, transport);
     }
-    _createUnacquiredDevice(descriptor) {
+    _createUnacquiredDevice(descriptor, transport) {
         _log.debug('Creating Unacquired Device', descriptor);
-        const device = Device_1.Device.createUnacquired(this.transport, descriptor);
+        const device = Device_1.Device.createUnacquired(transport, descriptor);
         device.once(events_1.DEVICE.ACQUIRED, () => {
             this.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
         });
         return device;
     }
-    _createUnreadableDevice(descriptor, unreadableError) {
+    _createUnreadableDevice(descriptor, transport, unreadableError) {
         _log.debug('Creating Unreadable Device', descriptor, unreadableError);
-        return Device_1.Device.createUnacquired(this.transport, descriptor, unreadableError);
+        return Device_1.Device.createUnacquired(transport, descriptor, unreadableError);
     }
     getDevice(path) {
         return this.devices[path];
@@ -271,20 +296,24 @@ class DeviceList extends utils_1.TypedEmitter {
     }
     dispose() {
         this.removeAllListeners();
-        if (autoResolveTransportEventTimeout) {
-            clearTimeout(autoResolveTransportEventTimeout);
-        }
-        Promise.all(this.allDevices().map(device => device.dispose())).then(() => {
-            this.transport.stop();
-        });
+        return this.cleanup();
     }
-    disconnectDevices() {
-        this.allDevices().forEach(device => {
+    async cleanup() {
+        var _a;
+        const { transport } = this;
+        const devices = this.allDevices();
+        this.transport = undefined;
+        this.authPenaltyManager.clear();
+        Object.keys(this.devices).forEach(key => delete this.devices[key]);
+        (_a = this.rejectPending) === null || _a === void 0 ? void 0 : _a.call(this, new Error('Disposed'));
+        devices.forEach(device => {
             this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
         });
+        await Promise.all(devices.map(device => device.dispose()));
+        transport === null || transport === void 0 ? void 0 : transport.stop();
     }
-    async enumerate() {
-        const res = await this.transport.enumerate().promise;
+    async enumerate(transport = this.transport) {
+        const res = await transport.enumerate().promise;
         if (!res.success) {
             return;
         }
@@ -301,29 +330,16 @@ class DeviceList extends utils_1.TypedEmitter {
         });
     }
     addAuthPenalty(device) {
-        if (!device.isInitialized() || device.isBootloader() || !device.features.device_id)
-            return;
-        const deviceID = device.features.device_id;
-        const penalty = this.penalizedDevices[deviceID]
-            ? this.penalizedDevices[deviceID] + 500
-            : 2000;
-        this.penalizedDevices[deviceID] = Math.min(penalty, 5000);
-    }
-    getAuthPenalty() {
-        const { penalizedDevices } = this;
-        return Object.keys(penalizedDevices).reduce((penalty, key) => Math.max(penalty, penalizedDevices[key]), 0);
+        return this.authPenaltyManager.add(device);
     }
     removeAuthPenalty(device) {
-        if (!device.isInitialized() || device.isBootloader() || !device.features.device_id)
-            return;
-        const deviceID = device.features.device_id;
-        delete this.penalizedDevices[deviceID];
+        return this.authPenaltyManager.remove(device);
     }
-    async handle(descriptor) {
+    async handle(descriptor, transport) {
         var _a;
         const path = descriptor.path.toString();
         try {
-            await this._takeAndCreateDevice(descriptor);
+            await this._takeAndCreateDevice(descriptor, transport);
         }
         catch (error) {
             _log.debug('Cannot create device', error);
@@ -336,37 +352,37 @@ class DeviceList extends utils_1.TypedEmitter {
                 delete this.devices[path];
             }
             else if (error.message === transport_1.TRANSPORT_ERROR.SESSION_WRONG_PREVIOUS) {
-                this.enumerate();
-                this._handleUsedElsewhere(descriptor);
+                this.enumerate(transport);
+                this._handleUsedElsewhere(descriptor, transport);
             }
             else if (error.message === transport_1.TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE ||
                 ((_a = error.message) === null || _a === void 0 ? void 0 : _a.indexOf(constants_1.ERRORS.LIBUSB_ERROR_MESSAGE)) >= 0 ||
                 error.code === 'Device_InitializeFailed') {
-                const device = this._createUnreadableDevice(this.creatingDevicesDescriptors[path], error.message);
+                const device = this._createUnreadableDevice(this.creatingDevicesDescriptors[path], transport, error.message);
                 this.devices[path] = device;
                 this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
             }
             else if (error.code === 'Device_UsedElsewhere') {
-                this._handleUsedElsewhere(descriptor);
+                this._handleUsedElsewhere(descriptor, transport);
             }
             else {
                 await (0, promiseUtils_1.resolveAfter)(501, null).promise;
-                await this.handle(descriptor);
+                await this.handle(descriptor, transport);
             }
         }
         delete this.creatingDevicesDescriptors[path];
     }
-    async _takeAndCreateDevice(descriptor) {
-        const device = Device_1.Device.fromDescriptor(this.transport, descriptor);
+    async _takeAndCreateDevice(descriptor, transport) {
+        const device = Device_1.Device.fromDescriptor(transport, descriptor);
         const path = descriptor.path.toString();
         this.devices[path] = device;
         const promise = device.run();
         await promise;
         this.emit(events_1.DEVICE.CONNECT, device.toMessageObject());
     }
-    _handleUsedElsewhere(descriptor) {
+    _handleUsedElsewhere(descriptor, transport) {
         const path = descriptor.path.toString();
-        const device = this._createUnacquiredDevice(this.creatingDevicesDescriptors[path]);
+        const device = this._createUnacquiredDevice(this.creatingDevicesDescriptors[path], transport);
         this.devices[path] = device;
         this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
     }