@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/device/DeviceCurrentSession.mjs

@@ -0,0 +1,240 @@
+import { DEVICE } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { initLog } from "@trezor/connect-common/libESM/utils/debug.mjs";
+import { MessagesSchema as Messages } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { TRANSPORT } from "@trezor/transport";
+import { isErrorWithoutDeviceInteraction } from "@trezor/transport/libESM/errors-groups.mjs";
+import { scheduleAction } from "@trezor/utils";
+const blacklist = {
+  PassphraseAck: ['passphrase'],
+  CipheredKeyValue: ['value'],
+  GetPublicKey: ['address_n'],
+  PublicKey: ['node', 'xpub'],
+  DecryptedMessage: ['message', 'address'],
+  Features: true
+};
+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 = initLog('DeviceCommands');
+const isExpectedResponse = (response, expected) => (Array.isArray(expected) ? expected : expected.split('|')).includes(response.type);
+const success = payload => ({
+  success: true,
+  payload
+});
+const error = error => ({
+  success: false,
+  error
+});
+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;
+  disposed;
+  callPromise;
+  abortController;
+  constructor(device, transport, session) {
+    this.device = device;
+    this.transport = transport;
+    this.session = session;
+    transport.deviceEvents.once(device.transportPath, e => {
+      if (!this.disposed) {
+        this.disposed = ERRORS.TypedError(e.type === TRANSPORT.DEVICE_DISCONNECTED ? 'Device_Disconnected' : 'Device_UsedElsewhere');
+        this.abortController?.abort(this.disposed);
+      }
+    });
+  }
+  isDisposed() {
+    return !!this.disposed;
+  }
+  async typedCall(type, expectedType, msg = {}) {
+    const deviceSessionId = this.device.getThpState()?.sessionId || this.device?.features?.session_id;
+    if (!allowedCallsBeforeInitialize.includes(type) && !deviceSessionId) {
+      console.error('Runtime', `typedCall: Device not initialized when calling ${type}. call Initialize first`);
+    }
+    Assert(Messages.MessageType.properties[type], msg);
+    this.abortController = new AbortController();
+    const {
+      signal
+    } = this.abortController;
+    const abortPromise = new Promise(resolve => signal.addEventListener('abort', () => resolve(signal.reason)));
+    const callPromise = this.callLoop(type, msg, abortPromise);
+    this.callPromise = callPromise;
+    const response = await callPromise;
+    this.callPromise = undefined;
+    this.abortController = undefined;
+    if (!response.success) throw response.error;
+    const {
+      payload
+    } = response;
+    const receivedType = payload.type;
+    if (isExpectedResponse(payload, expectedType)) {
+      return payload;
+    } else {
+      await scheduleAction(abort => this.transport.receive({
+        session: this.session,
+        protocol: this.device.protocol,
+        thpState: this.device.getThpState(),
+        signal: abort
+      }), {
+        timeout: 500
+      }).catch(() => {});
+      throw ERRORS.TypedError('Runtime', `assertType: Response of unexpected type: ${receivedType}. Should be ${expectedType}`);
+    }
+  }
+  async callLoop(type, msg, abortPromise) {
+    let [name, data] = [type, msg];
+    let pinUnlocked = false;
+    while (true) {
+      const timeout = this.device.possibleT1 && name === 'GetFeatures' ? 3_000 : undefined;
+      const callPromise = this.call(name, data, {
+        timeout
+      });
+      const [abortedDuringCall, response] = await Promise.race([callPromise.then(res => [false, res]), abortPromise.then(res => [true, nestedError(res)])]);
+      if (name === 'ButtonAck' && abortedDuringCall && !this.disposed) {
+        this.device.getThpState()?.sync('send', 'Cancel');
+        await this.send('Cancel', {});
+      }
+      await callPromise;
+      if (this.disposed) return nestedError(this.disposed);
+      if (!response.success) return response;
+      const res = response.payload;
+      switch (res.type) {
+        case 'Failure':
+          {
+            const {
+              code,
+              message
+            } = res.message;
+            if (name === 'GetFeatures' && code === 'Failure_UnexpectedMessage') {
+              [name, data] = ['Initialize', {}];
+              break;
+            }
+            const err = message || code === 'Failure_FirmwareError' && 'Firmware installation failed' || code === 'Failure_ActionCancelled' && 'Action cancelled by user' || 'Failure_UnknownMessage';
+            return error(new ERRORS.TrezorError(code || 'Failure_UnknownCode', err));
+          }
+        case 'ButtonRequest':
+          {
+            if (res.message.code === 'ButtonRequest_PassphraseEntry') {
+              this.device.emit(DEVICE.PASSPHRASE_ON_DEVICE);
+            } else {
+              this.device.emit(DEVICE.BUTTON, {
+                device: this.device,
+                payload: res.message
+              });
+            }
+            [name, data] = ['ButtonAck', {}];
+            break;
+          }
+        case 'PinMatrixRequest':
+          {
+            const promptRes = await Promise.race([this.device.prompt(DEVICE.PIN, {
+              type: res.message.type
+            }), abortPromise.then(nestedError)]);
+            if (!promptRes.success) {
+              const cancelRes = await this.call('Cancel', {});
+              return cancelRes.success ? promptRes : cancelRes;
+            }
+            pinUnlocked = true;
+            [name, data] = ['PinMatrixAck', {
+              pin: promptRes.payload
+            }];
+            break;
+          }
+        case 'PassphraseRequest':
+          {
+            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;
+            }
+            const payload = promptRes.payload.passphraseOnDevice ? {
+              on_device: true
+            } : {
+              passphrase: promptRes.payload.value.normalize('NFKD')
+            };
+            [name, data] = ['PassphraseAck', payload];
+            break;
+          }
+        case 'WordRequest':
+          {
+            const promptRes = await Promise.race([this.device.prompt(DEVICE.WORD, {
+              type: res.message.type
+            }), abortPromise.then(nestedError)]);
+            if (!promptRes.success) {
+              const cancelRes = await this.call('Cancel', {});
+              return cancelRes.success ? promptRes : cancelRes;
+            }
+            [name, data] = ['WordAck', {
+              word: promptRes.payload
+            }];
+            break;
+          }
+        default:
+          {
+            if (!this.disposed && pinUnlocked && !this.device.features.unlocked) {
+              await this.device.getFeatures().catch(() => {});
+            }
+            return success(res);
+          }
+      }
+    }
+  }
+  async call(name, data, options = {}) {
+    if (this.disposed) return Promise.resolve(nestedError(this.disposed));
+    logger.debug('Sending', name, filterForLog(name, data));
+    const result = await this.transport.call({
+      name,
+      data,
+      session: this.session,
+      protocol: this.device.protocol,
+      thpState: this.device.getThpState(),
+      ...options
+    });
+    if (result.success) {
+      const {
+        type,
+        message
+      } = result.payload;
+      logger.debug('Received', type, filterForLog(type, message));
+    } else {
+      logger.warn('Received transport error', result.error.code, result.error.message);
+    }
+    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));
+    const result = await this.transport.send({
+      name,
+      data,
+      session: this.session,
+      protocol: this.device.protocol,
+      thpState: this.device.getThpState(),
+      ...options
+    });
+    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));
+    const result = await this.transport.receive({
+      session: this.session,
+      protocol: this.device.protocol,
+      thpState: this.device.getThpState(),
+      ...options
+    });
+    return result.success ? success(result.payload) : fail(result.error.message || result.error.code);
+  }
+  cancelCall() {
+    return this.call('Cancel', {});
+  }
+  async abort(reason) {
+    this.abortController?.abort(reason);
+    await this.callPromise;
+    this.disposed = reason;
+  }
+}

package/libESM/device/DeviceList.d.mts

@@ -0,0 +1,68 @@
+import { DEVICE } from '@trezor/connect-common';
+import type { ConnectSettings, DecodedTrezorPushNotification, DeviceUniquePath, StaticSessionId, TransportError, TransportInfo } from '@trezor/connect-common';
+import { TRANSPORT } from '@trezor/transport';
+import type { Descriptor } from '@trezor/transport/libESM/types';
+import { TypedEmitter } from '@trezor/utils';
+import { Device } from './Device';
+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;
+}
+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'];
+}
+export declare const assertDeviceListConnected: (deviceList: IDeviceList) => asserts deviceList is DeviceList;
+type ConstructorParams = Pick<ConnectSettings, 'priority' | 'debug' | 'manifest'>;
+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({ priority, debug, manifest }: 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 {};

package/libESM/device/DeviceList.mjs

@@ -0,0 +1,246 @@
+import { DEVICE, asDeviceUniquePath } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { initLog } from "@trezor/connect-common/libESM/utils/debug.mjs";
+import { parseStaticSessionId } from "@trezor/device-utils";
+import { TRANSPORT } from "@trezor/transport";
+import { TypedEmitter, arrayDistinct, createDeferred, getSynchronize, isNotUndefined, resolveAfter, typedObjectKeys } from "@trezor/utils";
+import { Device } from "./Device.mjs";
+import { createTransportList } from "./TransportList.mjs";
+import { TransportManager } from "./TransportManager.mjs";
+import { trezorPushNotificationHandler } from "./workflow/trezorPushNotification.mjs";
+const createAuthPenaltyManager = priority => {
+  const penalizedDevices = {};
+  const get = () => 100 * priority + Object.keys(penalizedDevices).reduce((penalty, key) => Math.max(penalty, penalizedDevices[key]), 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;
+    penalizedDevices[deviceID] = Math.min(penalty, 5000);
+  };
+  const remove = device => {
+    if (!device.isInitialized() || device.isBootloader() || !device.features.device_id) return;
+    const deviceID = device.features.device_id;
+    delete penalizedDevices[deviceID];
+  };
+  return {
+    get,
+    add,
+    remove
+  };
+};
+const getTransportInfo = transport => ({
+  apiType: transport.apiType,
+  type: transport.name,
+  version: transport.version,
+  outdated: transport.isOutdated
+});
+export const assertDeviceListConnected = deviceList => {
+  if (!deviceList.isConnected()) {
+    throw ERRORS.TypedError('Transport_Missing');
+  }
+};
+export class DeviceList extends TypedEmitter {
+  transportManagers = {};
+  transports = [];
+  devices = [];
+  deviceCounter = Date.now();
+  handshakeLock;
+  authPenaltyManager;
+  updateTransports;
+  getConnectedTransports() {
+    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(isNotUndefined);
+    if (pending.length) return Promise.all(pending).then(() => {});
+  }
+  getActiveTransports() {
+    return this.getConnectedTransports().map(getTransportInfo);
+  }
+  constructor({
+    priority,
+    debug,
+    manifest
+  }) {
+    super();
+    const transportLogger = initLog('@trezor/transport', debug);
+    this.handshakeLock = getSynchronize();
+    this.authPenaltyManager = createAuthPenaltyManager(priority);
+    this.updateTransports = createTransportList({
+      logger: transportLogger,
+      id: manifest?.appName || manifest?.appUrl || 'unknown app'
+    });
+  }
+  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({
+      id: asDeviceUniquePath(id),
+      transport,
+      descriptor
+    });
+    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({
+        path: device.descriptor.id,
+        channels: ['battery-level', 'trezor-push-notification']
+      });
+    }
+    this.devices.push(device);
+    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(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(DEVICE.DISCONNECT, 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) {
+      trezorPushNotificationHandler({
+        device,
+        message: event.data
+      });
+    }
+  }
+  onBatteryLevel(event) {
+    const device = this.devices.find(d => d.descriptor.id === event.id);
+    device?.updateFeature('soc', event.data[0]);
+  }
+  getOrCreateTransportManager(apiType) {
+    if (!this.transportManagers[apiType]) {
+      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
+      }));
+      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(typedObjectKeys(this.transportManagers)).filter(arrayDistinct).map(apiType => this.getOrCreateTransportManager(apiType).init({
+      transports: this.transports.filter(t => t.apiType === apiType),
+      transportReconnect,
+      pendingTransportEvent
+    }));
+    await Promise.all(promises);
+  }
+  async initializeTransport(transport, pendingTransportEvent, signal) {
+    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.message || enumerateResult.error.code);
+    }
+    const descriptors = enumerateResult.payload;
+    transport.handleDescriptorsChange(descriptors);
+    transport.listen();
+    if (pendingTransportEvent && descriptors.length) {
+      await this.waitForDevices(transport, signal);
+    }
+  }
+  waitForDevices(transport, signal) {
+    const {
+      promise,
+      reject,
+      resolve
+    } = createDeferred();
+    const onAbort = () => reject(signal.reason);
+    signal.addEventListener('abort', onAbort);
+    const onError = error => reject(new Error(error));
+    transport.once(TRANSPORT.ERROR, onError);
+    const autoResolveTransportEventTimeout = setTimeout(resolve, 10000);
+    this.handshakeLock(resolve);
+    return promise.finally(() => {
+      transport.off(TRANSPORT.ERROR, onError);
+      signal.removeEventListener('abort', onAbort);
+      clearTimeout(autoResolveTransportEventTimeout);
+    });
+  }
+  getDeviceCount() {
+    return this.devices.length;
+  }
+  getPrioritizedDevices() {
+    return [...this.devices].sort((a, b) => (a.descriptor.apiType === 'bluetooth' ? 1 : 0) - (b.descriptor.apiType === 'bluetooth' ? 1 : 0));
+  }
+  getAllDevices() {
+    return this.getPrioritizedDevices();
+  }
+  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
+    } = parseStaticSessionId(state);
+    return this.getPrioritizedDevices().find(d => d.features?.device_id === deviceId);
+  }
+  async dispose() {
+    this.removeAllListeners();
+    const promises = Object.values(this.transportManagers).map(manager => manager.dispose());
+    await Promise.all(promises);
+  }
+  async enumerate() {
+    const promises = this.getConnectedTransports().map(async transport => {
+      const res = await transport.enumerate();
+      if (res.success) {
+        transport.handleDescriptorsChange(res.payload);
+      }
+    });
+    await Promise.all(promises);
+  }
+  addAuthPenalty(device) {
+    return this.authPenaltyManager.add(device);
+  }
+  removeAuthPenalty(device) {
+    return this.authPenaltyManager.remove(device);
+  }
+}

package/libESM/device/TransportList.d.mts

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

package/libESM/device/TransportList.mjs

@@ -0,0 +1,41 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { BridgeTransport, NodeUsbTransport, UdpTransport, WebUsbTransport, isTransportInstance } from "@trezor/transport";
+const tryGetTransport = (transports, name) => transports.find(t => t.name === name);
+const getOrCreateTransport = (transports, transportType, params) => {
+  if (transportType === 'BridgeTransport') {
+    const existing = transports.filter(t => t.name === transportType);
+    return existing.length ? existing : [new BridgeTransport({
+      ...params,
+      port: 21328
+    }), new BridgeTransport(params)];
+  }
+  if (typeof transportType === 'string') {
+    const existing = tryGetTransport(transports, transportType);
+    if (existing) return existing;
+    switch (transportType) {
+      case 'WebUsbTransport':
+        return new WebUsbTransport(params);
+      case 'NodeUsbTransport':
+        return new NodeUsbTransport(params);
+      case 'UdpTransport':
+        return new UdpTransport(params);
+    }
+  } else if (typeof transportType === 'function' && 'prototype' in transportType) {
+    const transportInstance = new transportType(params);
+    if (isTransportInstance(transportInstance)) {
+      return tryGetTransport(transports, transportInstance.name) ?? transportInstance;
+    }
+  } else if (isTransportInstance(transportType)) {
+    const existing = tryGetTransport(transports, transportType.name);
+    if (existing) {
+      return existing;
+    }
+    return transportType;
+  }
+  throw ERRORS.TypedError('Runtime', `DeviceList.init: transports[] of unexpected type: ${transportType}`);
+};
+const createTransports = (existing, transports = [], params) => {
+  const transportTypes = transports?.length ? transports : ['BridgeTransport'];
+  return transportTypes.flatMap(type => getOrCreateTransport(existing, type, params));
+};
+export const createTransportList = params => (existing, transports) => createTransports(existing, transports, params);

package/libESM/device/TransportManager.d.mts

@@ -0,0 +1,30 @@
+import type { Transport } from '@trezor/transport';
+import { TRANSPORT } from '@trezor/transport';
+import { TypedEmitter } from '@trezor/utils';
+type TransportManagerEvents = {
+    [TRANSPORT.START]: Transport;
+    [TRANSPORT.ERROR]: string;
+};
+type StartTransport = (transport: Transport, pendingTransportEvent: boolean, signal: AbortSignal) => Promise<void>;
+type InitParams = {
+    transports: Transport[];
+    transportReconnect?: boolean;
+    pendingTransportEvent?: boolean;
+};
+export declare class TransportManager extends TypedEmitter<TransportManagerEvents> {
+    private lock;
+    private transports;
+    private activeTransport?;
+    private transportReconnect;
+    private upgradeTimeout?;
+    private readonly startTransport;
+    constructor(startTransport: StartTransport);
+    pending(): Promise<void> | undefined;
+    get(): Transport | undefined;
+    init({ transports, transportReconnect, pendingTransportEvent }: InitParams): Promise<void>;
+    dispose(): Promise<void>;
+    private selectTransport;
+    private scheduleUpgradeCheck;
+    private createInitPromise;
+}
+export {};