@trezor/connect 9.3.0 → 9.3.1-beta.2

package/lib/device/DeviceCommands.js

@@ -230,7 +230,7 @@ class DeviceCommands {
             await this.transport.receive({
                 session: this.sessionId,
                 protocol: this.device.protocol,
-            });
+            }).promise;
             throw error;
         }
         return response;
@@ -260,9 +260,6 @@ class DeviceCommands {
         }
         if (res.type === 'ButtonRequest') {
             this._cancelableRequestBySend = true;
-            if (res.message.code === '_Deprecated_ButtonRequest_PassphraseType') {
-                res.message.code = 'ButtonRequest_PassphraseType';
-            }
             if (res.message.code === 'ButtonRequest_PassphraseEntry') {
                 this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
             }
@@ -285,25 +282,8 @@ class DeviceCommands {
             }), () => this._commonCall('Cancel', {}));
         }
         if (res.type === 'PassphraseRequest') {
-            const state = this.device.getInternalState();
-            const legacy = this.device.useLegacyPassphrase();
-            const legacyT1 = legacy && this.device.isT1();
-            if (legacyT1 && typeof state === 'string') {
-                return this._commonCall('PassphraseAck', { passphrase: state });
-            }
-            if (legacy && res.message._on_device) {
-                this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
-                return this._commonCall('PassphraseAck', { _state: state });
-            }
             return this._promptPassphrase().then(response => {
-                const { passphrase, passphraseOnDevice, cache } = response;
-                if (legacyT1) {
-                    this.device.setInternalState(cache ? passphrase : undefined);
-                    return this._commonCall('PassphraseAck', { passphrase });
-                }
-                if (legacy) {
-                    return this._commonCall('PassphraseAck', { passphrase, _state: state });
-                }
+                const { passphrase, passphraseOnDevice } = response;
                 return !passphraseOnDevice
                     ? this._commonCall('PassphraseAck', { passphrase })
                     : this._commonCall('PassphraseAck', { on_device: true });
@@ -311,11 +291,6 @@ class DeviceCommands {
                 throw err || e;
             }));
         }
-        if (res.type === 'Deprecated_PassphraseStateRequest') {
-            const { state } = res.message;
-            this.device.setInternalState(state);
-            return this._commonCall('Deprecated_PassphraseStateAck', {});
-        }
         if (res.type === 'WordRequest') {
             return this._promptWord(res.message.type).then(word => this._commonCall('WordAck', { word }), () => this._commonCall('Cancel', {}));
         }

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;