@trezor/connect 9.0.11 → 9.1.2

package/lib/device/Device.d.ts

@@ -3,8 +3,8 @@ 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 { Device as DeviceTyped, DeviceFirmwareStatus, Features, ReleaseInfo, UnavailableCapabilities } from '../types';
+import type { Transport, Descriptor } from '@trezor/transport';
+import { Device as DeviceTyped, DeviceFirmwareStatus, Features, ReleaseInfo, UnavailableCapabilities, FirmwareType } from '../types';
 export type RunOptions = {
     skipFinalReload?: boolean;
     waiting?: 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;
@@ -45,10 +44,10 @@ export declare class Device extends TypedEmitter<DeviceEvents> {
     externalState: string[];
     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;
+    firmwareType?: FirmwareType;
+    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

@@ -11,6 +11,7 @@ const deviceFeaturesUtils_1 = require("../utils/deviceFeaturesUtils");
 const versionUtils_1 = require("../utils/versionUtils");
 const deferred_1 = require("../utils/deferred");
 const debug_1 = require("../utils/debug");
+const types_1 = require("../types");
 const _log = (0, debug_1.initLog)('Device');
 const parseRunOptions = (options) => {
     if (!options)
@@ -21,7 +22,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;
@@ -30,7 +32,6 @@ class Device extends typedEventEmitter_1.TypedEmitter {
         this.externalState = [];
         this.unavailableCapabilities = {};
         this.networkTypeState = [];
-        this.firmwareType = 'regular';
         this.transport = transport;
         this.originalDescriptor = descriptor;
         this.firstRunPromise = (0, deferred_1.create)();
@@ -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,67 +319,26 @@ 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 =
-            feat.capabilities &&
-                feat.capabilities.length > 0 &&
-                !feat.capabilities.includes('Capability_Bitcoin_like')
-                ? 'bitcoin-only'
-                : 'regular';
+        if (this.getMode() !== 'bootloader') {
+            this.firmwareType =
+                feat.capabilities &&
+                    feat.capabilities.length > 0 &&
+                    !feat.capabilities.includes('Capability_Bitcoin_like')
+                    ? types_1.FirmwareType.BitcoinOnly
+                    : types_1.FirmwareType.Regular;
+        }
     }
     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 +417,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';
             }
@@ -306,7 +311,12 @@ class DeviceCommands {
             });
         }
         if (res.type === 'PinMatrixRequest') {
-            return this._promptPin(res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }), () => this._commonCall('Cancel', {}));
+            return this._promptPin(res.message.type).then(pin => this._commonCall('PinMatrixAck', { pin }).then(response => {
+                if (!this.device.features.unlocked) {
+                    return this.device.getFeatures().then(() => response);
+                }
+                return response;
+            }), () => this._commonCall('Cancel', {}));
         }
         if (res.type === 'PassphraseRequest') {
             const state = this.device.getInternalState();
@@ -475,13 +485,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