@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/device/DeviceCurrentSession.js

@@ -1,17 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DeviceCurrentSession = void 0;
-const protobuf_1 = require("@trezor/protobuf");
-const schema_utils_1 = require("@trezor/schema-utils");
-const transport_1 = require("@trezor/transport");
-const errors_groups_1 = require("@trezor/transport/lib/errors-groups");
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../constants");
-const events_1 = require("../events");
-const debug_1 = require("../utils/debug");
+import { DEVICE } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as Messages } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { TRANSPORT, isErrorWithoutDeviceInteraction } from "@trezor/transport-common";
+import { scheduleAction } from "@trezor/utils";
 const blacklist = {
   PassphraseAck: ['passphrase'],
   CipheredKeyValue: ['value'],
@@ -20,12 +12,11 @@ const blacklist = {
   DecryptedMessage: ['message', 'address'],
   Features: true
 };
-const allowedCallsBeforeInitialize = ['Cancel', 'Initialize', 'GetFeatures', 'GetFirmwareHash', 'ChangeLanguage', 'DataChunkAck', 'RebootToBootloader', 'FirmwareErase', 'FirmwareUpload', 'RecoveryDevice'];
+const allowedCallsBeforeInitialize = ['Cancel', 'Initialize', 'GetFeatures', 'GetFirmwareHash', 'ChangeLanguage', 'DataChunkAck', 'RebootToBootloader', 'FirmwareErase', 'FirmwareUpload', 'RecoveryDevice', 'WipeDevice'];
 const filterForLog = (type, msg) => blacklist[type] === true ? '(redacted...)' : (blacklist[type] ?? []).reduce((prev, cur) => ({
   ...prev,
   [cur]: '(redacted...)'
 }), msg);
-const logger = (0, debug_1.initLog)('DeviceCommands');
 const isExpectedResponse = (response, expected) => (Array.isArray(expected) ? expected : expected.split('|')).includes(response.type);
 const success = payload => ({
   success: true,
@@ -35,22 +26,24 @@ const error = error => ({
   success: false,
   error
 });
-const nestedError = cause => error(constants_1.ERRORS.nestError(cause));
-const fail = msg => error((0, errors_groups_1.isErrorWithoutDeviceInteraction)(msg) ? new constants_1.ERRORS.TransportError(msg) : new Error(msg));
-class DeviceCurrentSession {
+const nestedError = cause => error(ERRORS.nestError(cause));
+const fail = msg => error(isErrorWithoutDeviceInteraction(msg) ? new ERRORS.TransportError(msg) : new Error(msg));
+export class DeviceCurrentSession {
   device;
   transport;
   session;
+  logger;
   disposed;
   callPromise;
   abortController;
-  constructor(device, transport, session) {
+  constructor(device, transport, session, logger) {
     this.device = device;
     this.transport = transport;
     this.session = session;
+    this.logger = logger;
     transport.deviceEvents.once(device.transportPath, e => {
       if (!this.disposed) {
-        this.disposed = constants_1.ERRORS.TypedError(e.type === transport_1.TRANSPORT.DEVICE_DISCONNECTED ? 'Device_Disconnected' : 'Device_UsedElsewhere');
+        this.disposed = ERRORS.TypedError(e.type === TRANSPORT.DEVICE_DISCONNECTED ? 'Device_Disconnected' : 'Device_UsedElsewhere');
         this.abortController?.abort(this.disposed);
       }
     });
@@ -63,7 +56,7 @@ class DeviceCurrentSession {
     if (!allowedCallsBeforeInitialize.includes(type) && !deviceSessionId) {
       console.error('Runtime', `typedCall: Device not initialized when calling ${type}. call Initialize first`);
     }
-    (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.MessageType.properties[type], msg);
+    Assert(Messages.MessageType.properties[type], msg);
     this.abortController = new AbortController();
     const {
       signal
@@ -82,7 +75,7 @@ class DeviceCurrentSession {
     if (isExpectedResponse(payload, expectedType)) {
       return payload;
     } else {
-      await (0, utils_1.scheduleAction)(abort => this.transport.receive({
+      await scheduleAction(abort => this.transport.receive({
         session: this.session,
         protocol: this.device.protocol,
         thpState: this.device.getThpState(),
@@ -90,12 +83,9 @@ class DeviceCurrentSession {
       }), {
         timeout: 500
       }).catch(() => {});
-      throw constants_1.ERRORS.TypedError('Runtime', `assertType: Response of unexpected type: ${receivedType}. Should be ${expectedType}`);
+      throw ERRORS.TypedError('Runtime', `assertType: Response of unexpected type: ${receivedType}. Should be ${expectedType}`);
     }
   }
-  needCancelWorkaround() {
-    return this.transport.name === 'BridgeTransport' && !utils_1.versionUtils.isNewer(this.transport.version, '2.0.28');
-  }
   async callLoop(type, msg, abortPromise) {
     let [name, data] = [type, msg];
     let pinUnlocked = false;
@@ -106,17 +96,8 @@ class DeviceCurrentSession {
       });
       const [abortedDuringCall, response] = await Promise.race([callPromise.then(res => [false, res]), abortPromise.then(res => [true, nestedError(res)])]);
       if (name === 'ButtonAck' && abortedDuringCall && !this.disposed) {
-        if (this.needCancelWorkaround()) {
-          try {
-            await (0, utils_1.resolveAfter)(1);
-            await this.device.acquire();
-            await this.device.getCurrentSession().cancelCall();
-            await this.device.release();
-          } catch {}
-        } else {
-          this.device.getThpState()?.sync('send', 'Cancel');
-          await this.send('Cancel', {});
-        }
+        this.device.getThpState()?.sync('send', 'Cancel');
+        await this.send('Cancel', {});
       }
       await callPromise;
       if (this.disposed) return nestedError(this.disposed);
@@ -134,14 +115,14 @@ class DeviceCurrentSession {
               break;
             }
             const err = message || code === 'Failure_FirmwareError' && 'Firmware installation failed' || code === 'Failure_ActionCancelled' && 'Action cancelled by user' || 'Failure_UnknownMessage';
-            return error(new constants_1.ERRORS.TrezorError(code || 'Failure_UnknownCode', err));
+            return error(new ERRORS.TrezorError(code || 'Failure_UnknownCode', err));
           }
         case 'ButtonRequest':
           {
             if (res.message.code === 'ButtonRequest_PassphraseEntry') {
-              this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
+              this.device.emit(DEVICE.PASSPHRASE_ON_DEVICE);
             } else {
-              this.device.emit(events_1.DEVICE.BUTTON, {
+              this.device.emit(DEVICE.BUTTON, {
                 device: this.device,
                 payload: res.message
               });
@@ -151,7 +132,7 @@ class DeviceCurrentSession {
           }
         case 'PinMatrixRequest':
           {
-            const promptRes = await Promise.race([this.device.prompt(events_1.DEVICE.PIN, {
+            const promptRes = await Promise.race([this.device.prompt(DEVICE.PIN, {
               type: res.message.type
             }), abortPromise.then(nestedError)]);
             if (!promptRes.success) {
@@ -166,7 +147,7 @@ class DeviceCurrentSession {
           }
         case 'PassphraseRequest':
           {
-            const promptRes = await Promise.race([this.device.prompt(events_1.DEVICE.PASSPHRASE, {}), abortPromise.then(nestedError)]);
+            const promptRes = await Promise.race([this.device.prompt(DEVICE.PASSPHRASE, {}), abortPromise.then(nestedError)]);
             if (!promptRes.success) {
               const cancelRes = await this.call('Cancel', {});
               return cancelRes.success ? promptRes : cancelRes;
@@ -181,7 +162,7 @@ class DeviceCurrentSession {
           }
         case 'WordRequest':
           {
-            const promptRes = await Promise.race([this.device.prompt(events_1.DEVICE.WORD, {
+            const promptRes = await Promise.race([this.device.prompt(DEVICE.WORD, {
               type: res.message.type
             }), abortPromise.then(nestedError)]);
             if (!promptRes.success) {
@@ -205,7 +186,7 @@ class DeviceCurrentSession {
   }
   async call(name, data, options = {}) {
     if (this.disposed) return Promise.resolve(nestedError(this.disposed));
-    logger.debug('Sending', name, filterForLog(name, data));
+    this.logger.debug('Sending', name, filterForLog(name, data));
     const result = await this.transport.call({
       name,
       data,
@@ -219,11 +200,11 @@ class DeviceCurrentSession {
         type,
         message
       } = result.payload;
-      logger.debug('Received', type, filterForLog(type, message));
+      this.logger.debug('Received', type, filterForLog(type, message));
     } else {
-      logger.warn('Received transport error', result.error, result.message);
+      this.logger.warn('Received transport error', result.error.code, result.error.message);
     }
-    return result.success ? success(result.payload) : fail(result.message || result.error);
+    return result.success ? success(result.payload) : fail(result.error.message || result.error.code);
   }
   async send(name, data, options = {}) {
     if (this.disposed) return Promise.resolve(nestedError(this.disposed));
@@ -235,7 +216,7 @@ class DeviceCurrentSession {
       thpState: this.device.getThpState(),
       ...options
     });
-    return result.success ? success(result.payload) : fail(result.message || result.error);
+    return result.success ? success(result.payload) : fail(result.error.message || result.error.code);
   }
   async receive(options = {}) {
     if (this.disposed) return Promise.resolve(nestedError(this.disposed));
@@ -245,7 +226,7 @@ class DeviceCurrentSession {
       thpState: this.device.getThpState(),
       ...options
     });
-    return result.success ? success(result.payload) : fail(result.message || result.error);
+    return result.success ? success(result.payload) : fail(result.error.message || result.error.code);
   }
   cancelCall() {
     return this.call('Cancel', {});
@@ -255,6 +236,4 @@ class DeviceCurrentSession {
     await this.callPromise;
     this.disposed = reason;
   }
-}
-exports.DeviceCurrentSession = DeviceCurrentSession;
-//# sourceMappingURL=DeviceCurrentSession.js.map
+}

package/lib/device/DeviceList.d.ts

@@ -1,69 +1,75 @@
-import { TRANSPORT } from '@trezor/transport';
+import { DEVICE } from '@trezor/connect-common';
+import type { ConnectSettings, DecodedTrezorPushNotification, DeviceUniquePath, StaticSessionId, TransportError, TransportInfo } from '@trezor/connect-common';
+import type { CreateLogger } from '@trezor/connect-common/lib/types/settings';
+import { type Descriptor, TRANSPORT } from '@trezor/transport-common';
 import { TypedEmitter } from '@trezor/utils';
-import { DEVICE, DecodedTrezorPushNotification, TransportError, TransportInfo } from '../events';
-import { Device } from './Device';
-import { ConnectSettings, DeviceUniquePath, StaticSessionId } from '../types';
+import { Device } from "./Device.js";
 interface DeviceListEvents {
-    [TRANSPORT.START]: TransportInfo;
-    [TRANSPORT.ERROR]: TransportError;
-    [DEVICE.CONNECT]: Device;
-    [DEVICE.CONNECT_UNACQUIRED]: Device;
-    [DEVICE.TREZOR_PUSH_NOTIFICATION]: DecodedTrezorPushNotification & {
-        device: Device;
-    };
-    [DEVICE.DISCONNECT]: Device;
-    [DEVICE.CHANGED]: Device;
+  [TRANSPORT.START]: TransportInfo;
+  [TRANSPORT.ERROR]: TransportError;
+  [DEVICE.CONNECT]: Device;
+  [DEVICE.CONNECT_UNACQUIRED]: Device;
+  [DEVICE.TREZOR_PUSH_NOTIFICATION]: DecodedTrezorPushNotification & {
+    device: Device;
+  };
+  [DEVICE.DISCONNECT]: Device;
+  [DEVICE.CHANGED]: Device;
 }
 export interface IDeviceList {
-    isConnected(): this is DeviceList;
-    pendingConnection(): Promise<void> | undefined;
-    addAuthPenalty: DeviceList['addAuthPenalty'];
-    removeAuthPenalty: DeviceList['removeAuthPenalty'];
-    on: DeviceList['on'];
-    once: DeviceList['once'];
-    init: DeviceList['init'];
-    dispose: DeviceList['dispose'];
+  isConnected(): this is DeviceList;
+  pendingConnection(): Promise<void> | undefined;
+  addAuthPenalty: DeviceList['addAuthPenalty'];
+  removeAuthPenalty: DeviceList['removeAuthPenalty'];
+  on: DeviceList['on'];
+  once: DeviceList['once'];
+  init: DeviceList['init'];
+  dispose: DeviceList['dispose'];
 }
 export declare const assertDeviceListConnected: (deviceList: IDeviceList) => asserts deviceList is DeviceList;
-type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | 'manifest'> & {
-    messages: Record<string, any>;
+type ConstructorParams = {
+  createLogger: CreateLogger;
 };
 type InitParams = Pick<ConnectSettings, 'transports' | 'pendingTransportEvent' | 'transportReconnect'>;
 export declare class DeviceList extends TypedEmitter<DeviceListEvents> implements IDeviceList {
-    private readonly transportManagers;
-    private transports;
-    private devices;
-    private deviceCounter;
-    private readonly handshakeLock;
-    private readonly authPenaltyManager;
-    private updateTransports;
-    private getConnectedTransports;
-    isConnected(): this is DeviceList;
-    pendingConnection(): Promise<void> | undefined;
-    getActiveTransports(): {
-        apiType: "usb" | "bluetooth" | "udp";
-        type: "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport" | "NativeUsbTransport" | "BluetoothTransport" | "NativeBluetoothTransport";
-        version: string;
-        outdated: boolean;
-    }[];
-    constructor({ messages, priority, debug, manifest }: ConstructorParams);
-    private onDeviceConnected;
-    private onPushNotification;
-    private onBatteryLevel;
-    private getOrCreateTransportManager;
-    init({ transports, transportReconnect, pendingTransportEvent }?: InitParams): Promise<void>;
-    private initializeTransport;
-    private waitForDevices;
-    getDeviceCount(): number;
-    getPrioritizedDevices(): Device[];
-    getAllDevices(): readonly Device[];
-    getOnlyDevice(): Device | undefined;
-    getDeviceByPath(path: DeviceUniquePath): Device | undefined;
-    getDeviceByStaticState(state: StaticSessionId): Device | undefined;
-    dispose(): Promise<void>;
-    enumerate(): Promise<void>;
-    addAuthPenalty(device: Device): void;
-    removeAuthPenalty(device: Device): void;
+  private readonly transportManagers;
+  private transports;
+  private devices;
+  private deviceCounter;
+  private readonly handshakeLock;
+  private readonly authPenaltyManager;
+  private readonly createLogger;
+  private getConnectedTransports;
+  isConnected(): this is DeviceList;
+  pendingConnection(): Promise<void> | undefined;
+  getActiveTransports(): {
+    apiType: "usb" | "bluetooth" | "udp";
+    type: "BridgeTransport" | "NodeUsbTransport" | "WebUsbTransport" | "UdpTransport" | "NativeUsbTransport" | "BluetoothTransport" | "NativeBluetoothTransport";
+    version: string;
+  }[];
+  constructor({
+    createLogger
+  }: ConstructorParams);
+  private getSimilarDevices;
+  private onDeviceConnected;
+  private onPushNotification;
+  private onBatteryLevel;
+  private getOrCreateTransportManager;
+  init({
+    transports,
+    transportReconnect,
+    pendingTransportEvent
+  }?: InitParams): Promise<void>;
+  private initializeTransport;
+  private waitForDevices;
+  getDeviceCount(): number;
+  getPrioritizedDevices(): Device[];
+  getAllDevices(): readonly Device[];
+  getOnlyDevice(apiType?: Descriptor['apiType']): Device | undefined;
+  getDeviceByPath(path: DeviceUniquePath): Device | undefined;
+  getDeviceByStaticState(state: StaticSessionId): Device | undefined;
+  dispose(): Promise<void>;
+  enumerate(): Promise<void>;
+  addAuthPenalty(device: Device): void;
+  removeAuthPenalty(device: Device): void;
 }
-export {};
-//# sourceMappingURL=DeviceList.d.ts.map
+export {};

package/lib/device/DeviceList.js

@@ -1,26 +1,23 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.DeviceList = exports.assertDeviceListConnected = void 0;
-const transport_1 = require("@trezor/transport");
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../constants");
-const events_1 = require("../events");
-const Device_1 = require("./Device");
-const types_1 = require("../types");
-const TransportList_1 = require("./TransportList");
-const TransportManager_1 = require("./TransportManager");
-const debug_1 = require("../utils/debug");
-const trezorPushNotification_1 = require("./workflow/trezorPushNotification");
-const createAuthPenaltyManager = priority => {
+import { DEVICE, asDeviceUniquePath } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { parseStaticSessionId } from "@trezor/device-utils";
+import { TRANSPORT } from "@trezor/transport-common";
+import { TypedEmitter, arrayDistinct, createDeferred, getSynchronize, isNotUndefined, resolveAfter, typedObjectKeys } from "@trezor/utils";
+import { Device } from "./Device.js";
+import { createTransportList } from "./TransportList.js";
+import { TransportManager } from "./TransportManager.js";
+import { trezorPushNotificationHandler } from "./workflow/trezorPushNotification.js";
+const createAuthPenaltyManager = (priority = 2) => {
   const penalizedDevices = {};
-  const get = () => 100 * priority + Object.keys(penalizedDevices).reduce((penalty, key) => Math.max(penalty, penalizedDevices[key]), 0);
+  const get = () => 100 * priority + Object.keys(penalizedDevices).reduce((penalty, key) => {
+    const devicePenalty = penalizedDevices[key];
+    return Math.max(penalty, devicePenalty);
+  }, 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;
+    const currentPenalty = penalizedDevices[deviceID];
+    const penalty = currentPenalty ? currentPenalty + 500 : 2000;
     penalizedDevices[deviceID] = Math.min(penalty, 5000);
   };
   const remove = device => {
@@ -28,74 +25,80 @@ const createAuthPenaltyManager = priority => {
     const deviceID = device.features.device_id;
     delete penalizedDevices[deviceID];
   };
-  const clear = () => Object.keys(penalizedDevices).forEach(key => delete penalizedDevices[key]);
   return {
     get,
     add,
-    remove,
-    clear
+    remove
   };
 };
 const getTransportInfo = transport => ({
   apiType: transport.apiType,
   type: transport.name,
-  version: transport.version,
-  outdated: transport.isOutdated
+  version: transport.version
 });
-const assertDeviceListConnected = deviceList => {
+export const assertDeviceListConnected = deviceList => {
   if (!deviceList.isConnected()) {
-    throw constants_1.ERRORS.TypedError('Transport_Missing');
+    throw ERRORS.TypedError('Transport_Missing');
   }
 };
-exports.assertDeviceListConnected = assertDeviceListConnected;
-class DeviceList extends utils_1.TypedEmitter {
+export class DeviceList extends TypedEmitter {
   transportManagers = {};
   transports = [];
   devices = [];
   deviceCounter = Date.now();
   handshakeLock;
   authPenaltyManager;
-  updateTransports;
+  createLogger;
   getConnectedTransports() {
-    return Object.values(this.transportManagers).map(manager => manager.get()).filter(utils_1.isNotUndefined);
+    return Object.values(this.transportManagers).map(manager => manager.get()).filter(isNotUndefined);
   }
   isConnected() {
     return !!this.getConnectedTransports().length;
   }
   pendingConnection() {
-    const pending = Object.values(this.transportManagers).map(manager => manager.pending()).filter(utils_1.isNotUndefined);
+    const pending = Object.values(this.transportManagers).map(manager => manager.pending()).filter(isNotUndefined);
     if (pending.length) return Promise.all(pending).then(() => {});
   }
   getActiveTransports() {
     return this.getConnectedTransports().map(getTransportInfo);
   }
   constructor({
-    messages,
-    priority,
-    debug,
-    manifest
+    createLogger
   }) {
     super();
-    const transportLogger = (0, debug_1.initLog)('@trezor/transport', debug);
-    this.handshakeLock = (0, utils_1.getSynchronize)();
-    this.authPenaltyManager = createAuthPenaltyManager(priority);
-    this.updateTransports = (0, TransportList_1.createTransportList)({
-      messages,
-      logger: transportLogger,
-      id: manifest?.appName || manifest?.appUrl || 'unknown app'
+    this.createLogger = createLogger;
+    this.handshakeLock = getSynchronize();
+    this.authPenaltyManager = createAuthPenaltyManager();
+  }
+  getSimilarDevices(device) {
+    return this.devices.filter(d => {
+      if (d.descriptor.apiType === device.transport.apiType) {
+        return false;
+      }
+      if (device.descriptor.id && d.features?.device_id === device.descriptor.id) {
+        return true;
+      }
+      if (device.descriptor.model && d.descriptor.model === device.descriptor.model) {
+        return true;
+      }
+      return false;
     });
   }
   async onDeviceConnected(descriptor, transport) {
     const id = (this.deviceCounter++).toString(16).slice(-8);
-    const device = new Device_1.Device({
-      id: (0, types_1.asDeviceUniquePath)(id),
+    const device = new Device({
+      id: asDeviceUniquePath(id),
       transport,
-      descriptor
+      descriptor,
+      createLogger: this.createLogger
     });
-    const penalty = this.authPenaltyManager.get();
-    const stillConnected = await this.handshakeLock(() => (0, utils_1.resolveAfter)(penalty && penalty + 501).then(() => device.handshake()));
-    if (!stillConnected) {
-      return;
+    const similarUsedDevices = this.getSimilarDevices(device).some(d => d.isUsed() || d.getBusy() === 'rebooting');
+    if (!similarUsedDevices) {
+      const penalty = this.authPenaltyManager.get();
+      const stillConnected = await this.handshakeLock(() => resolveAfter(penalty && penalty + 501).then(() => device.handshake()));
+      if (!stillConnected) {
+        return;
+      }
     }
     if (descriptor.id && descriptor.apiType === 'bluetooth') {
       transport.subscribe({
@@ -104,28 +107,28 @@ class DeviceList extends utils_1.TypedEmitter {
       });
     }
     this.devices.push(device);
-    device.lifecycle.on(events_1.DEVICE.CONNECT, () => this.emit(events_1.DEVICE.CONNECT, device));
-    device.lifecycle.on(events_1.DEVICE.CHANGED, () => this.emit(events_1.DEVICE.CHANGED, device));
-    device.lifecycle.on(events_1.DEVICE.CONNECT_UNACQUIRED, () => this.emit(events_1.DEVICE.CONNECT_UNACQUIRED, device));
-    device.lifecycle.on(events_1.DEVICE.TREZOR_PUSH_NOTIFICATION, payload => {
-      this.emit(events_1.DEVICE.TREZOR_PUSH_NOTIFICATION, {
+    device.lifecycle.on(DEVICE.CONNECT, () => this.emit(DEVICE.CONNECT, device));
+    device.lifecycle.on(DEVICE.CHANGED, () => this.emit(DEVICE.CHANGED, device));
+    device.lifecycle.on(DEVICE.CONNECT_UNACQUIRED, () => this.emit(DEVICE.CONNECT_UNACQUIRED, device));
+    device.lifecycle.on(DEVICE.TREZOR_PUSH_NOTIFICATION, payload => {
+      this.emit(DEVICE.TREZOR_PUSH_NOTIFICATION, {
         device,
         ...payload
       });
     });
-    device.lifecycle.on(events_1.DEVICE.DISCONNECT, () => {
+    device.lifecycle.on(DEVICE.DISCONNECT, () => {
       device.lifecycle.removeAllListeners();
       this.authPenaltyManager.remove(device);
       const index = this.devices.indexOf(device);
       if (index >= 0) this.devices.splice(index, 1);
-      this.emit(events_1.DEVICE.DISCONNECT, device);
+      this.emit(DEVICE.DISCONNECT, device);
     });
-    this.emit(device.isUnacquired() ? events_1.DEVICE.CONNECT_UNACQUIRED : events_1.DEVICE.CONNECT, device);
+    this.emit(device.isUnacquired() ? DEVICE.CONNECT_UNACQUIRED : DEVICE.CONNECT, device);
   }
   onPushNotification(event) {
     const device = this.devices.find(d => d.descriptor.id === event.id);
     if (device) {
-      (0, trezorPushNotification_1.trezorPushNotificationHandler)({
+      trezorPushNotificationHandler({
         device,
         message: event.data
       });
@@ -137,9 +140,9 @@ class DeviceList extends utils_1.TypedEmitter {
   }
   getOrCreateTransportManager(apiType) {
     if (!this.transportManagers[apiType]) {
-      const manager = new TransportManager_1.TransportManager(this.initializeTransport.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, {
+      const manager = new TransportManager(this.initializeTransport.bind(this));
+      manager.on(TRANSPORT.START, transport => this.emit(TRANSPORT.START, getTransportInfo(transport)));
+      manager.on(TRANSPORT.ERROR, error => this.emit(TRANSPORT.ERROR, {
         apiType,
         error
       }));
@@ -152,8 +155,8 @@ class DeviceList extends utils_1.TypedEmitter {
     transportReconnect,
     pendingTransportEvent
   } = {}) {
-    this.transports = this.updateTransports(this.transports, transports);
-    const promises = this.transports.map(t => t.apiType).concat((0, utils_1.typedObjectKeys)(this.transportManagers)).filter(utils_1.arrayDistinct).map(apiType => this.getOrCreateTransportManager(apiType).init({
+    this.transports = createTransportList(this.transports, transports);
+    const promises = this.transports.map(t => t.apiType).concat(typedObjectKeys(this.transportManagers)).filter(arrayDistinct).map(apiType => this.getOrCreateTransportManager(apiType).init({
       transports: this.transports.filter(t => t.apiType === apiType),
       transportReconnect,
       pendingTransportEvent
@@ -161,14 +164,14 @@ class DeviceList extends utils_1.TypedEmitter {
     await Promise.all(promises);
   }
   async initializeTransport(transport, pendingTransportEvent, signal) {
-    transport.on(transport_1.TRANSPORT.DEVICE_CONNECTED, d => this.onDeviceConnected(d, transport));
-    transport.on(transport_1.TRANSPORT.TREZOR_PUSH_NOTIFICATION, this.onPushNotification.bind(this));
-    transport.on(transport_1.TRANSPORT.BATTERY_LEVEL, this.onBatteryLevel.bind(this));
+    transport.on(TRANSPORT.DEVICE_CONNECTED, d => this.onDeviceConnected(d, transport));
+    transport.on(TRANSPORT.TREZOR_PUSH_NOTIFICATION, this.onPushNotification.bind(this));
+    transport.on(TRANSPORT.BATTERY_LEVEL, this.onBatteryLevel.bind(this));
     const enumerateResult = await transport.enumerate({
       signal
     });
     if (!enumerateResult.success) {
-      throw new Error(enumerateResult.error);
+      throw new Error(enumerateResult.error.message || enumerateResult.error.code);
     }
     const descriptors = enumerateResult.payload;
     transport.handleDescriptorsChange(descriptors);
@@ -182,15 +185,15 @@ class DeviceList extends utils_1.TypedEmitter {
       promise,
       reject,
       resolve
-    } = (0, utils_1.createDeferred)();
+    } = createDeferred();
     const onAbort = () => reject(signal.reason);
     signal.addEventListener('abort', onAbort);
     const onError = error => reject(new Error(error));
-    transport.once(transport_1.TRANSPORT.ERROR, onError);
+    transport.once(TRANSPORT.ERROR, onError);
     const autoResolveTransportEventTimeout = setTimeout(resolve, 10000);
     this.handshakeLock(resolve);
     return promise.finally(() => {
-      transport.off(transport_1.TRANSPORT.ERROR, onError);
+      transport.off(TRANSPORT.ERROR, onError);
       signal.removeEventListener('abort', onAbort);
       clearTimeout(autoResolveTransportEventTimeout);
     });
@@ -204,14 +207,17 @@ class DeviceList extends utils_1.TypedEmitter {
   getAllDevices() {
     return this.getPrioritizedDevices();
   }
-  getOnlyDevice() {
-    return this.devices.length === 1 ? this.devices[0] : undefined;
+  getOnlyDevice(apiType) {
+    const devices = apiType ? this.devices.filter(d => d.descriptor.apiType === apiType) : this.devices;
+    return devices.length === 1 ? devices[0] : undefined;
   }
   getDeviceByPath(path) {
     return this.getPrioritizedDevices().find(d => d.getUniquePath() === path);
   }
   getDeviceByStaticState(state) {
-    const deviceId = state.split('@')[1].split(':')[0];
+    const {
+      deviceId
+    } = parseStaticSessionId(state);
     return this.getPrioritizedDevices().find(d => d.features?.device_id === deviceId);
   }
   async dispose() {
@@ -234,6 +240,4 @@ class DeviceList extends utils_1.TypedEmitter {
   removeAuthPenalty(device) {
     return this.authPenaltyManager.remove(device);
   }
-}
-exports.DeviceList = DeviceList;
-//# sourceMappingURL=DeviceList.js.map
+}

package/lib/device/TransportList.d.ts

@@ -1,9 +1,3 @@
-import { NodeUsbTransport, Transport, UdpTransport } from '@trezor/transport';
-import type { AbstractTransportParams } from '@trezor/transport/lib/transports/abstract';
-import { ConnectSettingsTransport } from '../types';
-type Params = AbstractTransportParams & {
-    sessionsBackgroundUrl?: string | null;
-};
-export declare const createTransportList: (params: Params) => (existing: Transport[], transports?: ConnectSettingsTransport[]) => (Transport | NodeUsbTransport | UdpTransport)[];
-export {};
-//# sourceMappingURL=TransportList.d.ts.map
+import type { ConnectSettingsTransport } from '@trezor/connect-common/lib/types/settings';
+import { type Transport } from '@trezor/transport-common';
+export declare const createTransportList: (existing: Transport[], transports?: ConnectSettingsTransport[]) => Transport[];