@trezor/connect 9.4.0 → 9.4.1-beta.1

package/lib/device/Device.js

@@ -28,14 +28,12 @@ class Device extends utils_1.TypedEmitter {
     constructor(transport, descriptor) {
         super();
         this.featuresNeedsReload = false;
-        this.acquirePromise = undefined;
-        this.releasePromise = undefined;
+        this.keepTransportSession = false;
         this.loaded = false;
         this.inconsistent = false;
-        this.keepSession = false;
         this.instance = 0;
-        this.internalState = [];
-        this.externalState = [];
+        this.state = [];
+        this.stateStorage = undefined;
         this.unavailableCapabilities = {};
         this.networkTypeState = [];
         this.name = 'Trezor';
@@ -43,12 +41,8 @@ class Device extends utils_1.TypedEmitter {
         this.authenticityChecks = {
             firmwareRevision: null,
         };
-        if (transport.name === 'BridgeTransport') {
-            this.protocol = protocol_1.bridge;
-        }
-        else {
-            this.protocol = protocol_1.v1;
-        }
+        this.useCardanoDerivation = false;
+        this.protocol = protocol_1.v1;
         this.transport = transport;
         this.originalDescriptor = descriptor;
         this.firstRunPromise = (0, utils_1.createDeferred)();
@@ -76,7 +70,7 @@ class Device extends utils_1.TypedEmitter {
                 previous: this.originalDescriptor.session,
             },
         });
-        const acquireResult = await this.acquirePromise.promise;
+        const acquireResult = await this.acquirePromise;
         this.acquirePromise = undefined;
         if (!acquireResult.success) {
             if (this.runPromise) {
@@ -85,34 +79,34 @@ class Device extends utils_1.TypedEmitter {
             }
             throw acquireResult.error;
         }
-        const sessionID = acquireResult.payload;
-        _log.debug('Expected session id:', sessionID);
-        this.activitySessionID = sessionID;
-        this.originalDescriptor.session = sessionID;
+        const transportSession = acquireResult.payload;
+        _log.debug('Expected workflow id:', transportSession);
+        this.transportSession = transportSession;
+        this.originalDescriptor.session = transportSession;
         if (this.commands) {
             this.commands.dispose();
         }
-        this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, sessionID);
+        this.commands = new DeviceCommands_1.DeviceCommands(this, this.transport, transportSession);
     }
     async release() {
         if (this.isUsedHere() &&
-            !this.keepSession &&
-            this.activitySessionID &&
+            this.transportSession &&
+            !this.keepTransportSession &&
             !this.releasePromise) {
             if (this.commands) {
                 this.commands.dispose();
                 if (this.commands.callPromise) {
-                    await this.commands.callPromise.promise;
+                    await this.commands.callPromise;
                 }
             }
             this.releasePromise = this.transport.release({
-                session: this.activitySessionID,
+                session: this.transportSession,
                 path: this.originalDescriptor.path,
             });
-            const releaseResponse = await this.releasePromise.promise;
+            const releaseResponse = await this.releasePromise;
             this.releasePromise = undefined;
             if (releaseResponse.success) {
-                this.activitySessionID = null;
+                this.transportSession = null;
                 this.originalDescriptor.session = null;
             }
         }
@@ -139,13 +133,13 @@ class Device extends utils_1.TypedEmitter {
     }
     async override(error) {
         if (this.acquirePromise) {
-            await this.acquirePromise.promise;
+            await this.acquirePromise;
         }
         if (this.runPromise) {
             await this.interruptionFromUser(error);
         }
         if (this.releasePromise) {
-            await this.releasePromise.promise;
+            await this.releasePromise;
         }
     }
     async interruptionFromUser(error) {
@@ -170,11 +164,14 @@ class Device extends utils_1.TypedEmitter {
         this.transport.releaseDevice(this.originalDescriptor.path);
     }
     async _runInner(fn, options) {
-        var _a;
+        var _a, _b;
         if (this.releasePromise) {
-            await this.releasePromise.promise;
+            await this.releasePromise;
         }
-        if (!this.isUsedHere() || ((_a = this.commands) === null || _a === void 0 ? void 0 : _a.disposed) || !this.getExternalState()) {
+        if (!this.isUsedHere() ||
+            ((_a = this.commands) === null || _a === void 0 ? void 0 : _a.disposed) ||
+            !((_b = this.getState()) === null || _b === void 0 ? void 0 : _b.staticSessionId) ||
+            this.useCardanoDerivation != !!options.useCardanoDerivation) {
             await this.acquire();
             try {
                 if (fn) {
@@ -205,7 +202,7 @@ class Device extends utils_1.TypedEmitter {
             }
         }
         if (options.keepSession) {
-            this.keepSession = true;
+            this.keepTransportSession = true;
         }
         if (this.listeners(events_1.DEVICE.ACQUIRED).length > 0) {
             this.emit(events_1.DEVICE.ACQUIRED);
@@ -216,9 +213,9 @@ class Device extends utils_1.TypedEmitter {
         if (this.loaded && this.features && !options.skipFinalReload) {
             await this.getFeatures();
         }
-        if ((!this.keepSession && typeof options.keepSession !== 'boolean') ||
+        if ((!this.keepTransportSession && typeof options.keepSession !== 'boolean') ||
             options.keepSession === false) {
-            this.keepSession = false;
+            this.keepTransportSession = false;
             await this.release();
         }
         if (this.runPromise) {
@@ -238,9 +235,9 @@ class Device extends utils_1.TypedEmitter {
     }
     setInstance(instance = 0) {
         if (this.instance !== instance) {
-            if (this.keepSession) {
-                this.activitySessionID = null;
-                this.keepSession = false;
+            if (this.keepTransportSession) {
+                this.transportSession = null;
+                this.keepTransportSession = false;
             }
         }
         this.instance = instance;
@@ -248,31 +245,26 @@ class Device extends utils_1.TypedEmitter {
     getInstance() {
         return this.instance;
     }
-    setInternalState(state) {
-        if (typeof state !== 'string') {
-            delete this.internalState[this.instance];
-        }
-        else if (state !== this.internalState[this.instance]) {
-            this.internalState[this.instance] = state;
-            this.emit(events_1.DEVICE.SAVE_STATE, state);
-        }
-    }
-    getInternalState() {
-        return this.internalState[this.instance];
+    getState() {
+        return this.state[this.instance];
     }
-    setExternalState(state) {
-        if (typeof state !== 'string') {
-            delete this.internalState[this.instance];
-            delete this.externalState[this.instance];
+    setState(state) {
+        var _a;
+        if (!state) {
+            delete this.state[this.instance];
         }
         else {
-            this.externalState[this.instance] = state;
+            const prevState = this.state[this.instance];
+            const newState = {
+                ...prevState,
+                ...state,
+            };
+            this.state[this.instance] = newState;
+            (_a = this.stateStorage) === null || _a === void 0 ? void 0 : _a.saveState(this, newState);
         }
     }
-    getExternalState() {
-        return this.externalState[this.instance];
-    }
     async validateState(preauthorized = false) {
+        var _a;
         if (!this.features)
             return;
         if (!this.features.unlocked && preauthorized) {
@@ -280,32 +272,38 @@ class Device extends utils_1.TypedEmitter {
                 return;
             }
         }
-        const expectedState = this.getExternalState();
+        const expectedState = (_a = this.getState()) === null || _a === void 0 ? void 0 : _a.staticSessionId;
         const state = await this.getCommands().getDeviceState();
-        const uniqueState = `${state}@${this.features.device_id || 'device_id'}:${this.instance}`;
+        const uniqueState = `${state}@${this.features.device_id}:${this.instance}`;
         if (this.features.session_id) {
-            this.setInternalState(this.features.session_id);
+            this.setState({ sessionId: this.features.session_id });
         }
         if (expectedState && expectedState !== uniqueState) {
             return uniqueState;
         }
         if (!expectedState) {
-            this.setExternalState(uniqueState);
+            this.setState({ staticSessionId: uniqueState });
         }
     }
     async initialize(useCardanoDerivation) {
+        var _a;
         let payload;
         if (this.features) {
-            const internalState = this.getInternalState();
+            const sessionId = (_a = this.getState()) === null || _a === void 0 ? void 0 : _a.sessionId;
             payload = {};
             payload.derive_cardano = useCardanoDerivation;
-            if (internalState) {
-                payload.session_id = internalState;
+            this.useCardanoDerivation = useCardanoDerivation;
+            if (sessionId) {
+                payload.session_id = sessionId;
             }
         }
         const { message } = await this.getCommands().typedCall('Initialize', 'Features', payload);
         this._updateFeatures(message);
     }
+    initStorage(storage) {
+        this.stateStorage = storage;
+        this.setState(storage.loadState(this));
+    }
     async getFeatures() {
         const { message } = await this.getCommands().typedCall('GetFeatures', 'Features', {});
         this._updateFeatures(message);
@@ -328,7 +326,7 @@ class Device extends utils_1.TypedEmitter {
     }
     async checkFirmwareRevision() {
         const firmwareVersion = this.getVersion();
-        if (firmwareVersion.length === 0 || !this.features) {
+        if (!firmwareVersion || !this.features) {
             return;
         }
         if (this.features.bootloader_mode === true) {
@@ -352,9 +350,13 @@ class Device extends utils_1.TypedEmitter {
         if (binary) {
             return this._uploadTranslationData(binary);
         }
+        const version = this.getVersion();
+        if (!version) {
+            throw constants_1.ERRORS.TypedError('Runtime', 'changeLanguage: device version unknown');
+        }
         const downloadedBinary = await (0, getLanguage_1.getLanguage)({
             language,
-            version: this.getVersion(),
+            version,
             internal_model: this.features.internal_model,
         });
         if (!downloadedBinary) {
@@ -398,12 +400,13 @@ class Device extends utils_1.TypedEmitter {
         if (!feat.internal_model) {
             feat.internal_model = (0, deviceFeaturesUtils_1.ensureInternalModelFeature)(feat.model);
         }
-        const version = [
+        const version = this.getVersion();
+        const newVersion = [
             feat.major_version,
             feat.minor_version,
             feat.patch_version,
         ];
-        if (!utils_1.versionUtils.isEqual(version, this.getVersion())) {
+        if (!version || !utils_1.versionUtils.isEqual(version, newVersion)) {
             this.unavailableCapabilities = (0, deviceFeaturesUtils_1.getUnavailableCapabilities)(feat, (0, coinInfo_1.getAllNetworks)());
             this.firmwareStatus = (0, firmwareInfo_1.getFirmwareStatus)(feat);
             this.firmwareRelease = (0, firmwareInfo_1.getRelease)(feat);
@@ -442,7 +445,7 @@ class Device extends utils_1.TypedEmitter {
     }
     disconnect() {
         _log.debug('Disconnect cleanup');
-        this.activitySessionID = null;
+        this.transportSession = null;
         this.interruptionFromUser(constants_1.ERRORS.TypedError('Device_Disconnected'));
         delete this.runPromise;
     }
@@ -460,7 +463,7 @@ class Device extends utils_1.TypedEmitter {
     }
     getVersion() {
         if (!this.features)
-            return [];
+            return;
         return [
             this.features.major_version,
             this.features.minor_version,
@@ -468,16 +471,17 @@ class Device extends utils_1.TypedEmitter {
         ];
     }
     atLeast(versions) {
-        if (!this.features)
+        const version = this.getVersion();
+        if (!this.features || !version)
             return false;
         const modelVersion = typeof versions === 'string' ? versions : versions[this.features.major_version - 1];
-        return utils_1.versionUtils.isNewerOrEqual(this.getVersion().join('.'), modelVersion);
+        return utils_1.versionUtils.isNewerOrEqual(version, modelVersion);
     }
     isUsed() {
         return typeof this.originalDescriptor.session === 'string';
     }
     isUsedHere() {
-        return this.isUsed() && this.originalDescriptor.session === this.activitySessionID;
+        return this.isUsed() && this.originalDescriptor.session === this.transportSession;
     }
     isUsedElsewhere() {
         return this.isUsed() && !this.isUsedHere();
@@ -514,15 +518,23 @@ class Device extends utils_1.TypedEmitter {
         }
         return null;
     }
+    updateDescriptor(descriptor) {
+        this.originalDescriptor = {
+            session: descriptor.session,
+            path: descriptor.path,
+            product: descriptor.product,
+            type: descriptor.type,
+        };
+    }
     async dispose() {
         this.removeAllListeners();
-        if (this.isUsedHere() && this.activitySessionID) {
+        if (this.isUsedHere() && this.transportSession) {
             try {
                 if (this.commands) {
                     await this.commands.cancel();
                 }
                 return this.transport.release({
-                    session: this.activitySessionID,
+                    session: this.transportSession,
                     path: this.originalDescriptor.path,
                     onClose: true,
                 });
@@ -541,6 +553,7 @@ class Device extends utils_1.TypedEmitter {
         return 'normal';
     }
     toMessageObject() {
+        var _a;
         if (this.unreadableError) {
             return {
                 type: 'unreadable',
@@ -565,10 +578,11 @@ class Device extends utils_1.TypedEmitter {
             status = 'used';
         return {
             type: 'acquired',
-            id: this.features.device_id || null,
+            id: this.features.device_id,
             path: this.originalDescriptor.path,
             label,
-            state: this.getExternalState(),
+            _state: this.getState(),
+            state: (_a = this.getState()) === null || _a === void 0 ? void 0 : _a.staticSessionId,
             status,
             mode: this.getMode(),
             name: this.name,

package/lib/device/DeviceCommands.d.ts

@@ -5,14 +5,14 @@ import type { CoinInfo, BitcoinNetworkInfo } from '../types';
 import type { HDNodeResponse } from '../types/api/getPublicKey';
 type MessageType = Messages.MessageType;
 type MessageKey = keyof MessageType;
-export type TypedResponseMessage<T extends MessageKey> = {
+type TypedPayload<T extends MessageKey> = {
     type: T;
     message: MessageType[T];
 };
 type TypedCallResponseMap = {
-    [K in keyof MessageType]: TypedResponseMessage<K>;
+    [K in keyof MessageType]: TypedPayload<K>;
 };
-type DefaultMessageResponse = TypedCallResponseMap[keyof MessageType];
+type DefaultPayloadMessage = TypedCallResponseMap[keyof MessageType];
 export type PassphrasePromptResponse = {
     passphrase?: string;
     passphraseOnDevice?: boolean;
@@ -21,15 +21,15 @@ export type PassphrasePromptResponse = {
 export declare class DeviceCommands {
     device: Device;
     transport: Transport;
-    sessionId: Session;
+    transportSession: Session;
     disposed: boolean;
     callPromise?: ReturnType<Transport['call']>;
     _cancelableRequest?: (error?: any) => void;
     _cancelableRequestBySend?: boolean;
-    constructor(device: Device, transport: Transport, sessionId: Session);
+    constructor(device: Device, transport: Transport, transportSession: Session);
     dispose(): void;
     isDisposed(): boolean;
-    unlockPath(params?: Messages.UnlockPath): Promise<TypedResponseMessage<"UnlockedPathRequest">>;
+    unlockPath(params?: Messages.UnlockPath): Promise<TypedPayload<"UnlockedPathRequest">>;
     getPublicKey(params: Messages.GetPublicKey, unlockPath?: Messages.UnlockPath): Promise<{
         descriptor?: string | undefined;
         root_fingerprint?: number | undefined;
@@ -74,9 +74,9 @@ export declare class DeviceCommands {
     getDeviceState(): Promise<string>;
     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>;
-    _filterCommonTypes(res: DefaultMessageResponse): Promise<DefaultMessageResponse>;
+    typedCall<T extends MessageKey, R extends MessageKey>(type: T, resType: R, msg?: MessageType[T]): Promise<TypedPayload<R>>;
+    _commonCall(type: MessageKey, msg?: DefaultPayloadMessage['message']): Promise<DefaultPayloadMessage>;
+    _filterCommonTypes(res: DefaultPayloadMessage): Promise<DefaultPayloadMessage>;
     private _getAddress;
     _promptPin(type?: Messages.PinMatrixRequestType): Promise<string>;
     _promptPassphrase(): Promise<PassphrasePromptResponse>;

package/lib/device/DeviceCommands.js

@@ -37,10 +37,10 @@ const filterForLog = (type, msg) => {
     return msg;
 };
 class DeviceCommands {
-    constructor(device, transport, sessionId) {
+    constructor(device, transport, transportSession) {
         this.device = device;
         this.transport = transport;
-        this.sessionId = sessionId;
+        this.transportSession = transportSession;
         this.disposed = false;
     }
     dispose() {
@@ -203,12 +203,12 @@ class DeviceCommands {
     async call(type, msg = {}) {
         logger.debug('Sending', type, filterForLog(type, msg));
         this.callPromise = this.transport.call({
-            session: this.sessionId,
+            session: this.transportSession,
             name: type,
             data: msg,
             protocol: this.device.protocol,
         });
-        const res = await this.callPromise.promise;
+        const res = await this.callPromise;
         this.callPromise = undefined;
         if (!res.success) {
             logger.warn('Received error', res.error);
@@ -228,9 +228,9 @@ class DeviceCommands {
         }
         catch (error) {
             await this.transport.receive({
-                session: this.sessionId,
+                session: this.transportSession,
                 protocol: this.device.protocol,
-            }).promise;
+            });
             throw error;
         }
         return response;
@@ -422,7 +422,7 @@ class DeviceCommands {
         this.dispose();
         if (!this._cancelableRequestBySend) {
             if (this.callPromise) {
-                await this.callPromise.promise;
+                await this.callPromise;
             }
             return;
         }
@@ -437,12 +437,12 @@ class DeviceCommands {
         else {
             await this.transport.send({
                 protocol: this.device.protocol,
-                session: this.sessionId,
+                session: this.transportSession,
                 name: 'Cancel',
                 data: {},
-            }).promise;
+            });
             if (this.callPromise) {
-                await this.callPromise.promise;
+                await this.callPromise;
             }
         }
     }

package/lib/device/DeviceList.js

@@ -97,82 +97,66 @@ class DeviceList extends utils_1.TypedEmitter {
         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());
-            }
-        });
-        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 (this.creatingDevicesDescriptors[path].session == null) {
-                await this._createAndSaveDevice(descriptor, transport);
-            }
-            else {
-                const device = this._createUnacquiredDevice(descriptor, transport);
-                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 => {
+        diff.forEach(async ({ descriptor, ...category }) => {
             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;
-            }
-        });
-        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,
-                };
+            this.creatingDevicesDescriptors[path] = descriptor;
+            switch (category.type) {
+                case 'disconnected':
+                    if (!device)
+                        break;
+                    device.disconnect();
+                    delete this.devices[path];
+                    this.emit(events_1.DEVICE.DISCONNECT, device.toMessageObject());
+                    break;
+                case 'connected':
+                    const penalty = this.authPenaltyManager.get();
+                    if (penalty) {
+                        await (0, promiseUtils_1.resolveAfter)(501 + penalty, null).promise;
+                    }
+                    if (this.creatingDevicesDescriptors[path].session == null) {
+                        await this._createAndSaveDevice(descriptor, transport);
+                    }
+                    else {
+                        const device = this._createUnacquiredDevice(descriptor, transport);
+                        this.devices[path] = device;
+                        this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
+                    }
+                    break;
+                case 'acquired':
+                    if (!device)
+                        break;
+                    if (category.subtype === 'elsewhere') {
+                        device.featuresNeedsReload = true;
+                        device.interruptionFromOutside();
+                    }
+                    _log.debug('Event', events_1.DEVICE.CHANGED, device.toMessageObject());
+                    this.emit(events_1.DEVICE.CHANGED, device.toMessageObject());
+                    _log.debug('Event', events_1.DEVICE.ACQUIRED, device.toMessageObject());
+                    this.emit(events_1.DEVICE.ACQUIRED, device.toMessageObject());
+                    break;
+                case 'released':
+                    if (!device)
+                        break;
+                    const methodStillRunning = !((_a = device.commands) === null || _a === void 0 ? void 0 : _a.isDisposed());
+                    if (methodStillRunning) {
+                        device.keepTransportSession = false;
+                    }
+                    _log.debug('Event', events_1.DEVICE.CHANGED, device.toMessageObject());
+                    this.emit(events_1.DEVICE.CHANGED, device.toMessageObject());
+                    _log.debug('Event', events_1.DEVICE.RELEASED, device.toMessageObject());
+                    this.emit(events_1.DEVICE.RELEASED, device.toMessageObject());
+                    if (category.subtype === 'elsewhere') {
+                        await (0, promiseUtils_1.resolveAfter)(1000, null).promise;
+                        if (!device.isUsed() && device.isUnacquired() && !device.isInconsistent()) {
+                            _log.debug('Create device from unacquired', device.toMessageObject());
+                            await this._createAndSaveDevice(descriptor, transport);
+                        }
+                    }
+                    break;
             }
+            device === null || device === void 0 ? void 0 : device.updateDescriptor(descriptor);
         });
     }
     init(initParams = {}) {
@@ -204,7 +188,7 @@ class DeviceList extends utils_1.TypedEmitter {
         return promise.then(this.createInitPromise.bind(this));
     }
     async selectTransport([transport, ...rest]) {
-        const result = await transport.init().promise;
+        const result = await transport.init();
         if (result.success)
             return transport;
         else if (rest.length)
@@ -221,7 +205,7 @@ class DeviceList extends utils_1.TypedEmitter {
                 this.initPromise = this.createReconnectPromise(initParams);
             }
         });
-        const enumerateResult = await transport.enumerate().promise;
+        const enumerateResult = await transport.enumerate();
         if (!enumerateResult.success) {
             throw new Error(enumerateResult.error);
         }
@@ -314,19 +298,13 @@ class DeviceList extends utils_1.TypedEmitter {
         transport === null || transport === void 0 ? void 0 : transport.stop();
     }
     async enumerate(transport = this.transport) {
-        const res = await transport.enumerate().promise;
+        const res = await transport.enumerate();
         if (!res.success) {
             return;
         }
         res.payload.forEach(d => {
             if (this.devices[d.path]) {
-                this.devices[d.path].originalDescriptor = {
-                    session: d.session,
-                    path: d.path,
-                    product: d.product,
-                    type: d.type,
-                };
-                this.devices[d.path].activitySessionID = d.session;
+                this.devices[d.path].updateDescriptor(d);
             }
         });
     }
@@ -371,7 +349,6 @@ class DeviceList extends utils_1.TypedEmitter {
                 await this.handle(descriptor, transport);
             }
         }
-        delete this.creatingDevicesDescriptors[path];
     }
     async _takeAndCreateDevice(descriptor, transport) {
         const device = Device_1.Device.fromDescriptor(transport, descriptor);