@trezor/connect 9.5.0 → 9.5.1-beta.1

package/lib/data/coinInfo.d.ts

@@ -23,8 +23,14 @@ export declare const getBitcoinNetwork: (pathOrName: DerivationPath) => ({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -83,8 +89,14 @@ export declare const getEthereumNetwork: (pathOrNetworkSymbol: DerivationPath) =
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -118,8 +130,14 @@ export declare const getMiscNetwork: (pathOrName: DerivationPath) => ({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -177,8 +195,14 @@ export declare const fixCoinInfoNetwork: (ci: BitcoinNetworkInfo, path: number[]
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -237,8 +261,14 @@ export declare const getCoinInfoByHash: (hash: string, networkInfo: any) => {
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -297,8 +327,14 @@ export declare const getCoinInfo: (currency: string) => ({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -356,8 +392,14 @@ export declare const getCoinInfo: (currency: string) => ({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -390,8 +432,14 @@ export declare const getCoinInfo: (currency: string) => ({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -434,8 +482,14 @@ export declare const getAllNetworks: () => (({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -493,8 +547,14 @@ export declare const getAllNetworks: () => (({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;
@@ -527,8 +587,14 @@ export declare const getAllNetworks: () => (({
     };
     decimals: number;
     defaultFees: {
+        maxFeePerGas?: string | undefined;
+        maxPriorityFeePerGas?: string | undefined;
+        maxWaitTimeEstimate?: number | undefined;
+        minWaitTimeEstimate?: number | undefined;
         feeLimit?: string | undefined;
         feePerTx?: string | undefined;
+        baseFeePerGas?: string | undefined;
+        effectiveGasPrice?: string | undefined;
         label: "normal" | "custom" | "high" | "economy" | "low";
         feePerUnit: string;
         blocks: number;

package/lib/data/connectSettings.js

@@ -124,6 +124,9 @@ const parseConnectSettings = (input = {}) => {
     if (typeof input.enableFirmwareHashCheck === 'boolean') {
         settings.enableFirmwareHashCheck = Boolean(input.enableFirmwareHashCheck);
     }
+    if (typeof input.npmVersion === 'string') {
+        settings.npmVersion = input.npmVersion;
+    }
     return settings;
 };
 exports.parseConnectSettings = parseConnectSettings;

package/lib/data/defaultFeeLevels.js

@@ -29,7 +29,7 @@ const getEvmChainGweiGasPrice = (chain) => EVM_GAS_PRICE_PER_CHAIN_IN_GWEI[chain
 const getBitcoinFeeLevels = (coin) => {
     const defaultFees = coin.default_fee_b;
     const shortcut = coin.shortcut.toLowerCase();
-    const keys = Object.keys(defaultFees);
+    const keys = (0, utils_1.typedObjectKeys)(defaultFees);
     const levels = keys
         .sort((levelA, levelB) => defaultFees[levelB] - defaultFees[levelA])
         .map(level => {

package/lib/data/version.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "9.5.0";
+export declare const VERSION = "9.5.1-beta.1";
 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.5.0';
+exports.VERSION = '9.5.1-beta.1';
 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

@@ -15,6 +15,7 @@ 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;
 export interface DeviceEvents {
@@ -39,6 +40,7 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     readonly transportPath: import("@trezor/transport/lib/types").PathPublic;
     private readonly transportSessionOwner;
     private readonly transportDescriptorType;
+    private readonly bluetoothProps;
     private session;
     private lastAcquiredHere;
     private unreadableError?;
@@ -189,11 +191,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;
-    dispose(): Promise<import("@trezor/transport/lib/types").Success<null> | {
-        success: false;
-        error: "session not found" | "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";
-        message?: string;
-    } | undefined>;
+    dispose(): import("@trezor/transport/lib/types").AsyncResultWithTypedError<null, "session not found" | "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"> | undefined;
     private getMode;
     toMessageObject(): DeviceTyped;
 }

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 = void 0;
+exports.Device = exports.GET_FEATURES_TIMEOUT_REACT_NATIVE = exports.GET_FEATURES_TIMEOUT = exports.CANCEL_TIMEOUT = void 0;
 const crypto_1 = require("crypto");
 const protocol_1 = require("@trezor/protocol");
 const transport_1 = require("@trezor/transport");
@@ -20,6 +20,7 @@ const types_1 = require("../types");
 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;
 const parseRunOptions = (options) => {
@@ -33,6 +34,7 @@ class Device extends utils_1.TypedEmitter {
     transportPath;
     transportSessionOwner;
     transportDescriptorType;
+    bluetoothProps;
     session;
     lastAcquiredHere;
     unreadableError;
@@ -89,6 +91,7 @@ class Device extends utils_1.TypedEmitter {
         this.transportPath = descriptor.path;
         this.transportSessionOwner = descriptor.sessionOwner;
         this.transportDescriptorType = descriptor.type;
+        this.bluetoothProps = descriptor.id ? { id: descriptor.id } : undefined;
         this.session = descriptor.session;
         this.lastAcquiredHere = false;
         this.firstRunPromise = (0, utils_1.createDeferred)();
@@ -326,16 +329,22 @@ class Device extends utils_1.TypedEmitter {
                     await this.initialize(!!options.useCardanoDerivation);
                 }
                 else {
-                    const getFeaturesTimeout = DataManager_1.DataManager.getSettings('env') === 'react-native'
+                    const isNative = DataManager_1.DataManager.getSettings('env') === 'react-native';
+                    const getFeaturesTimeout = isNative
                         ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
                         : exports.GET_FEATURES_TIMEOUT;
-                    if (['v1', 'bridge'].includes(this.protocol.name)) {
+                    const cancelTimeout = isNative
+                        ? exports.GET_FEATURES_TIMEOUT_REACT_NATIVE
+                        : exports.CANCEL_TIMEOUT;
+                    if (['v1', 'bridge'].includes(this.protocol.name) &&
+                        ![0, 2].includes(this.transportDescriptorType)) {
                         _log.debug('sending a preventive cancel on the first encounter with the device');
-                        try {
-                            await this.getCommands().typedCall('Cancel', 'Failure', {});
-                        }
-                        catch {
-                        }
+                        await Promise.race([
+                            this.getCommands()
+                                .typedCall('Cancel', 'Failure', {})
+                                .catch(() => { }),
+                            new Promise((_, reject) => setTimeout(reject, cancelTimeout)),
+                        ]).catch(() => this.acquire());
                     }
                     let getFeaturesTimeoutId;
                     await Promise.race([
@@ -764,20 +773,14 @@ class Device extends utils_1.TypedEmitter {
         }
         return null;
     }
-    async dispose() {
+    dispose() {
         this.removeAllListeners();
         if (this.session && this.lastAcquiredHere) {
-            try {
-                await this.cancelableAction?.();
-                await this.commands?.cancel();
-                return this.transport.release({
-                    session: this.session,
-                    path: this.transportPath,
-                    onClose: true,
-                });
-            }
-            catch {
-            }
+            return this.transport.release({
+                session: this.session,
+                path: this.transportPath,
+                onClose: true,
+            });
         }
     }
     getMode() {
@@ -808,6 +811,7 @@ class Device extends utils_1.TypedEmitter {
                 label: 'Unacquired device',
                 name: this.name,
                 transportSessionOwner: this.transportSessionOwner,
+                bluetoothProps: this.bluetoothProps,
             };
         }
         const defaultLabel = 'My Trezor';
@@ -832,6 +836,7 @@ class Device extends utils_1.TypedEmitter {
             unavailableCapabilities: this.unavailableCapabilities,
             availableTranslations: this.availableTranslations,
             authenticityChecks: this.authenticityChecks,
+            bluetoothProps: this.bluetoothProps,
         };
     }
 }

package/lib/device/DeviceList.d.ts

@@ -28,13 +28,14 @@ type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | '_sessions
 };
 type InitParams = Pick<ConnectSettings, 'transports' | 'pendingTransportEvent' | 'transportReconnect'>;
 export declare class DeviceList extends TypedEmitter<DeviceListEvents> implements IDeviceList {
-    private readonly transport;
+    private readonly transportManagers;
     private transports;
     private readonly devices;
     private deviceCounter;
     private readonly handshakeLock;
     private readonly authPenaltyManager;
-    private transportCommonArgs;
+    private updateTransports;
+    private getConnectedTransports;
     isConnected(): this is DeviceList;
     pendingConnection(): Promise<void> | undefined;
     getActiveTransports(): {
@@ -43,22 +44,14 @@ export declare class DeviceList extends TypedEmitter<DeviceListEvents> implement
         version: string;
         outdated: boolean;
     }[];
-    private readonly locks;
-    private transportLock;
-    private readonly scheduledUpgradeChecks;
     constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }: ConstructorParams);
-    private tryGetTransport;
-    private getOrCreateTransport;
-    private createTransports;
     private onDeviceConnected;
     private onDeviceDisconnected;
     private onDeviceSessionChanged;
     private onDeviceRequestRelease;
-    init(initParams?: InitParams): Promise<void>;
-    private createInitPromise;
-    private createReconnectDelay;
-    private scheduleUpgradeCheck;
-    private selectTransport;
+    private getOrCreateTransportManager;
+    init({ transports, transportReconnect, pendingTransportEvent }?: InitParams): Promise<void>;
+    private startTransport;
     private initializeTransport;
     private waitForDevices;
     getDeviceCount(): number;

package/lib/device/DeviceList.js

@@ -6,9 +6,9 @@ const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const Device_1 = require("./Device");
-const transportInfo_1 = require("../data/transportInfo");
 const types_1 = require("../types");
-const utils_2 = require("../types/utils");
+const TransportList_1 = require("./TransportList");
+const TransportManager_1 = require("./TransportManager");
 const debug_1 = require("../utils/debug");
 const createAuthPenaltyManager = (priority) => {
     const penalizedDevices = {};
@@ -67,100 +67,42 @@ const assertDeviceListConnected = deviceList => {
 };
 exports.assertDeviceListConnected = assertDeviceListConnected;
 class DeviceList extends utils_1.TypedEmitter {
-    transport = {};
+    transportManagers = {};
     transports = [];
     devices = createDeviceCollection();
     deviceCounter = Date.now();
     handshakeLock;
     authPenaltyManager;
-    transportCommonArgs;
+    updateTransports;
+    getConnectedTransports() {
+        return Object.values(this.transportManagers)
+            .map(manager => manager.get())
+            .filter(utils_1.isNotUndefined);
+    }
     isConnected() {
-        return !!Object.keys(this.transport).length;
+        return !!this.getConnectedTransports().length;
     }
     pendingConnection() {
-        const pending = Object.values(this.locks)
-            .map(({ promise }) => promise)
+        const pending = Object.values(this.transportManagers)
+            .map(manager => manager.pending())
             .filter(utils_1.isNotUndefined);
         if (pending.length)
             return Promise.all(pending).then(() => { });
     }
     getActiveTransports() {
-        return Object.values(this.transport).map(getTransportInfo);
-    }
-    locks = {};
-    async transportLock(apiType, abortMessage, action) {
-        const lock = this.locks[apiType] ?? (this.locks[apiType] = { sequence: 0 });
-        lock.abortMessage = abortMessage;
-        const sequence = ++lock.sequence;
-        while (lock.promise) {
-            lock.abort?.abort(new Error(abortMessage));
-            await lock.promise.catch(() => { });
-        }
-        if (sequence !== lock.sequence)
-            return Promise.reject(new Error(lock.abortMessage));
-        lock.abort = new AbortController();
-        lock.promise = action(lock.abort.signal).finally(() => {
-            delete lock.abort;
-            delete lock.promise;
-        });
-        return lock.promise;
+        return this.getConnectedTransports().map(getTransportInfo);
     }
-    scheduledUpgradeChecks = {};
     constructor({ messages, priority, debug, _sessionsBackgroundUrl, manifest, }) {
         super();
         const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
         this.handshakeLock = (0, utils_1.getSynchronize)();
         this.authPenaltyManager = createAuthPenaltyManager(priority);
-        this.transportCommonArgs = {
+        this.updateTransports = (0, TransportList_1.createTransportList)({
             messages,
             logger: transportLogger,
             sessionsBackgroundUrl: _sessionsBackgroundUrl,
             id: manifest?.appUrl || 'unknown app',
-        };
-    }
-    tryGetTransport(name) {
-        return this.transports.find(t => t.name === name);
-    }
-    getOrCreateTransport(transportType) {
-        const { transportCommonArgs } = this;
-        if (typeof transportType === 'string') {
-            const existing = this.tryGetTransport(transportType);
-            if (existing)
-                return existing;
-            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)) {
-                return this.tryGetTransport(transportInstance.name) ?? transportInstance;
-            }
-        }
-        else if ((0, transport_1.isTransportInstance)(transportType)) {
-            if (this.tryGetTransport(transportType.name)) {
-                return transportType;
-            }
-            if (!transportType.getMessage()) {
-                transportType.updateMessages(transportCommonArgs.messages);
-            }
-            return transportType;
-        }
-        throw constants_1.ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
-    }
-    createTransports(transports) {
-        const transportTypes = transports?.length ? transports : ['BridgeTransport'];
-        return transportTypes.map(this.getOrCreateTransport.bind(this));
+        });
     }
     onDeviceConnected(descriptor, transport) {
         const id = (this.deviceCounter++).toString(16).slice(-8);
@@ -190,103 +132,41 @@ class DeviceList extends utils_1.TypedEmitter {
         const device = this.devices.get(descriptor.path, transport);
         device?.usedElsewhere();
     }
-    async init(initParams = {}) {
-        this.transports = this.createTransports(initParams.transports);
+    getOrCreateTransportManager(apiType) {
+        if (!this.transportManagers[apiType]) {
+            const manager = new TransportManager_1.TransportManager({
+                startTransport: this.startTransport.bind(this),
+                stopTransport: this.stopTransport.bind(this),
+            });
+            manager.on(transport_1.TRANSPORT.START, transport => this.emit(transport_1.TRANSPORT.START, getTransportInfo(transport)));
+            manager.on(transport_1.TRANSPORT.ERROR, error => this.emit(transport_1.TRANSPORT.ERROR, { apiType, error }));
+            this.transportManagers[apiType] = manager;
+        }
+        return this.transportManagers[apiType];
+    }
+    async init({ transports, transportReconnect, pendingTransportEvent } = {}) {
+        this.transports = this.updateTransports(this.transports, transports);
         const promises = this.transports
             .map(t => t.apiType)
-            .concat((0, utils_2.typedObjectKeys)(this.transport))
-            .concat((0, utils_2.typedObjectKeys)(this.locks))
+            .concat((0, utils_1.typedObjectKeys)(this.transportManagers))
             .filter(utils_1.arrayDistinct)
-            .map(apiType => this.transportLock(apiType, 'New init', signal => this.createInitPromise(apiType, initParams, signal)));
+            .map(apiType => this.getOrCreateTransportManager(apiType).init({
+            transports: this.transports.filter(t => t.apiType === apiType),
+            transportReconnect,
+            pendingTransportEvent,
+        }));
         await Promise.all(promises);
     }
-    async createInitPromise(apiType, initParams, abortSignal) {
+    async startTransport(transport, pendingTransportEvent, signal) {
         try {
-            const transports = this.transports.filter(t => t.apiType === apiType);
-            const transport = transports.length
-                ? await this.selectTransport(transports, abortSignal)
-                : undefined;
-            const oldTransport = this.transport[apiType];
-            if (oldTransport !== transport) {
-                if (oldTransport) {
-                    delete this.transport[apiType];
-                    await this.stopTransport(oldTransport);
-                    if (!transport) {
-                        this.emit(transport_1.TRANSPORT.ERROR, { apiType, error: 'Transport disabled' });
-                    }
-                }
-                if (transport) {
-                    try {
-                        await this.initializeTransport(transport, initParams, abortSignal);
-                    }
-                    catch (error) {
-                        await this.stopTransport(transport);
-                        throw error;
-                    }
-                    transport.on(transport_1.TRANSPORT.ERROR, error => {
-                        this.emit(transport_1.TRANSPORT.ERROR, { apiType, error });
-                        this.transportLock(apiType, 'Transport error', async (signal) => {
-                            delete this.transport[apiType];
-                            await this.stopTransport(transport);
-                            if (initParams.transportReconnect) {
-                                await this.createReconnectDelay(signal);
-                                await this.createInitPromise(apiType, initParams, signal);
-                            }
-                        }).catch(() => { });
-                    });
-                    this.transport[apiType] = transport;
-                    this.emit(transport_1.TRANSPORT.START, getTransportInfo(transport));
-                }
-            }
-            if (transport && transport !== transports[0]) {
-                this.scheduleUpgradeCheck(apiType, initParams);
-            }
+            await this.initializeTransport(transport, pendingTransportEvent, signal);
         }
-        catch (error) {
-            this.emit(transport_1.TRANSPORT.ERROR, { apiType, error: error?.message });
-            if (initParams.transportReconnect && !abortSignal.aborted) {
-                this.transportLock(apiType, 'Reconnecting', async (signal) => {
-                    await this.createReconnectDelay(signal);
-                    await this.createInitPromise(apiType, initParams, signal);
-                }).catch(() => { });
-            }
+        catch (err) {
+            await this.stopTransport(transport);
+            throw err;
         }
     }
-    createReconnectDelay(signal) {
-        return (0, utils_1.resolveAfter)(1000, signal);
-    }
-    scheduleUpgradeCheck(apiType, initParams) {
-        clearTimeout(this.scheduledUpgradeChecks[apiType]);
-        this.scheduledUpgradeChecks[apiType] = setTimeout(async () => {
-            const transport = this.transport[apiType];
-            const transports = this.transports.filter(t => t.apiType === apiType);
-            if (!transport || transport === transports[0])
-                return;
-            for (const t of transports) {
-                if (t === transport)
-                    break;
-                if (await t.ping()) {
-                    this.transportLock(apiType, 'Upgrading', signal => this.createInitPromise(apiType, initParams, signal)).catch(() => { });
-                    return;
-                }
-            }
-            this.scheduleUpgradeCheck(apiType, initParams);
-        }, 1000);
-    }
-    async selectTransport([transport, ...rest], signal) {
-        if (signal.aborted)
-            throw new Error(signal.reason);
-        if (transport === this.transport[transport.apiType])
-            return transport;
-        const result = await transport.init({ signal });
-        if (result.success)
-            return transport;
-        else if (rest.length)
-            return this.selectTransport(rest, signal);
-        else
-            throw new Error(result.error);
-    }
-    async initializeTransport(transport, initParams, signal) {
+    async initializeTransport(transport, pendingTransportEvent, signal) {
         transport.on(transport_1.TRANSPORT.DEVICE_CONNECTED, d => this.onDeviceConnected(d, transport));
         transport.on(transport_1.TRANSPORT.DEVICE_DISCONNECTED, d => this.onDeviceDisconnected(d, transport));
         transport.on(transport_1.TRANSPORT.DEVICE_SESSION_CHANGED, d => this.onDeviceSessionChanged(d, transport));
@@ -296,7 +176,7 @@ class DeviceList extends utils_1.TypedEmitter {
             throw new Error(enumerateResult.error);
         }
         const descriptors = enumerateResult.payload;
-        const waitForDevicesPromise = initParams.pendingTransportEvent && descriptors.length
+        const waitForDevicesPromise = pendingTransportEvent && descriptors.length
             ? this.waitForDevices(transport, descriptors, signal)
             : Promise.resolve();
         transport.handleDescriptorsChange(descriptors);
@@ -348,20 +228,10 @@ class DeviceList extends utils_1.TypedEmitter {
     }
     async dispose() {
         this.removeAllListeners();
-        const promises = (0, utils_2.typedObjectKeys)(this.transport)
-            .concat((0, utils_2.typedObjectKeys)(this.locks))
-            .filter(utils_1.arrayDistinct)
-            .map(apiType => this.transportLock(apiType, 'Disposing', async () => {
-            const transport = this.transport[apiType];
-            if (transport) {
-                delete this.transport[apiType];
-                await this.stopTransport(transport);
-            }
-        }));
+        const promises = Object.values(this.transportManagers).map(manager => manager.dispose());
         await Promise.all(promises);
     }
     async stopTransport(transport) {
-        clearTimeout(this.scheduledUpgradeChecks[transport.apiType]);
         const devices = this.devices.clear(transport);
         devices.forEach(device => {
             this.emit(events_1.DEVICE.DISCONNECT, device);
@@ -373,7 +243,7 @@ class DeviceList extends utils_1.TypedEmitter {
         transport?.stop();
     }
     async enumerate() {
-        const promises = Object.values(this.transport).map(async (transport) => {
+        const promises = this.getConnectedTransports().map(async (transport) => {
             const res = await transport.enumerate();
             if (!res.success) {
                 return;