@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/lib/device/DeviceCurrentSession.js

@@ -1,260 +0,0 @@
-"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");
-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'];
-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,
-  payload
-});
-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 {
-  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 = constants_1.ERRORS.TypedError(e.type === transport_1.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`);
-    }
-    (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.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 (0, utils_1.scheduleAction)(abort => this.transport.receive({
-        session: this.session,
-        protocol: this.device.protocol,
-        thpState: this.device.getThpState(),
-        signal: abort
-      }), {
-        timeout: 500
-      }).catch(() => {});
-      throw constants_1.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;
-    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) {
-        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', {});
-        }
-      }
-      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 constants_1.ERRORS.TrezorError(code || 'Failure_UnknownCode', err));
-          }
-        case 'ButtonRequest':
-          {
-            if (res.message.code === 'ButtonRequest_PassphraseEntry') {
-              this.device.emit(events_1.DEVICE.PASSPHRASE_ON_DEVICE);
-            } else {
-              this.device.emit(events_1.DEVICE.BUTTON, {
-                device: this.device,
-                payload: res.message
-              });
-            }
-            [name, data] = ['ButtonAck', {}];
-            break;
-          }
-        case 'PinMatrixRequest':
-          {
-            const promptRes = await Promise.race([this.device.prompt(events_1.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(events_1.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(events_1.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, result.message);
-    }
-    return result.success ? success(result.payload) : fail(result.message || result.error);
-  }
-  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.message || result.error);
-  }
-  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.message || result.error);
-  }
-  cancelCall() {
-    return this.call('Cancel', {});
-  }
-  async abort(reason) {
-    this.abortController?.abort(reason);
-    await this.callPromise;
-    this.disposed = reason;
-  }
-}
-exports.DeviceCurrentSession = DeviceCurrentSession;
-//# sourceMappingURL=DeviceCurrentSession.js.map

package/lib/device/DeviceList.d.ts

@@ -1,69 +0,0 @@
-import { TRANSPORT } from '@trezor/transport';
-import { TypedEmitter } from '@trezor/utils';
-import { DEVICE, DecodedTrezorPushNotification, TransportError, TransportInfo } from '../events';
-import { Device } from './Device';
-import { ConnectSettings, DeviceUniquePath, StaticSessionId } from '../types';
-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'> & {
-    messages: Record<string, any>;
-};
-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;
-}
-export {};
-//# sourceMappingURL=DeviceList.d.ts.map

package/lib/device/DeviceList.js

@@ -1,239 +0,0 @@
-"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 => {
-  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];
-  };
-  const clear = () => Object.keys(penalizedDevices).forEach(key => delete penalizedDevices[key]);
-  return {
-    get,
-    add,
-    remove,
-    clear
-  };
-};
-const getTransportInfo = transport => ({
-  apiType: transport.apiType,
-  type: transport.name,
-  version: transport.version,
-  outdated: transport.isOutdated
-});
-const assertDeviceListConnected = deviceList => {
-  if (!deviceList.isConnected()) {
-    throw constants_1.ERRORS.TypedError('Transport_Missing');
-  }
-};
-exports.assertDeviceListConnected = assertDeviceListConnected;
-class DeviceList extends utils_1.TypedEmitter {
-  transportManagers = {};
-  transports = [];
-  devices = [];
-  deviceCounter = Date.now();
-  handshakeLock;
-  authPenaltyManager;
-  updateTransports;
-  getConnectedTransports() {
-    return Object.values(this.transportManagers).map(manager => manager.get()).filter(utils_1.isNotUndefined);
-  }
-  isConnected() {
-    return !!this.getConnectedTransports().length;
-  }
-  pendingConnection() {
-    const pending = Object.values(this.transportManagers).map(manager => manager.pending()).filter(utils_1.isNotUndefined);
-    if (pending.length) return Promise.all(pending).then(() => {});
-  }
-  getActiveTransports() {
-    return this.getConnectedTransports().map(getTransportInfo);
-  }
-  constructor({
-    messages,
-    priority,
-    debug,
-    manifest
-  }) {
-    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'
-    });
-  }
-  async onDeviceConnected(descriptor, transport) {
-    const id = (this.deviceCounter++).toString(16).slice(-8);
-    const device = new Device_1.Device({
-      id: (0, types_1.asDeviceUniquePath)(id),
-      transport,
-      descriptor
-    });
-    const penalty = this.authPenaltyManager.get();
-    const stillConnected = await this.handshakeLock(() => (0, utils_1.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(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,
-        ...payload
-      });
-    });
-    device.lifecycle.on(events_1.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.isUnacquired() ? events_1.DEVICE.CONNECT_UNACQUIRED : events_1.DEVICE.CONNECT, device);
-  }
-  onPushNotification(event) {
-    const device = this.devices.find(d => d.descriptor.id === event.id);
-    if (device) {
-      (0, trezorPushNotification_1.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_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, {
-        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((0, utils_1.typedObjectKeys)(this.transportManagers)).filter(utils_1.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_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));
-    const enumerateResult = await transport.enumerate({
-      signal
-    });
-    if (!enumerateResult.success) {
-      throw new Error(enumerateResult.error);
-    }
-    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
-    } = (0, utils_1.createDeferred)();
-    const onAbort = () => reject(signal.reason);
-    signal.addEventListener('abort', onAbort);
-    const onError = error => reject(new Error(error));
-    transport.once(transport_1.TRANSPORT.ERROR, onError);
-    const autoResolveTransportEventTimeout = setTimeout(resolve, 10000);
-    this.handshakeLock(resolve);
-    return promise.finally(() => {
-      transport.off(transport_1.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() {
-    return this.devices.length === 1 ? this.devices[0] : undefined;
-  }
-  getDeviceByPath(path) {
-    return this.getPrioritizedDevices().find(d => d.getUniquePath() === path);
-  }
-  getDeviceByStaticState(state) {
-    const deviceId = state.split('@')[1].split(':')[0];
-    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);
-  }
-}
-exports.DeviceList = DeviceList;
-//# sourceMappingURL=DeviceList.js.map

package/lib/device/StateStorage.d.ts

@@ -1,15 +0,0 @@
-import { Device } from './Device';
-import { DeviceState } from '../types/device';
-export interface IStateStorage {
-    saveState(device: Device, state: DeviceState): void;
-    loadState(device: Device): DeviceState | undefined;
-}
-export declare class WebextensionStateStorage implements IStateStorage {
-    origin: string;
-    constructor(origin: string);
-    loadState(device: Device): {
-        sessionId: string;
-    } | undefined;
-    saveState(device: Device, state: DeviceState): void;
-}
-//# sourceMappingURL=StateStorage.d.ts.map

package/lib/device/StateStorage.js

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WebextensionStateStorage = void 0;
-const connect_common_1 = require("@trezor/connect-common");
-class WebextensionStateStorage {
-  origin;
-  constructor(origin) {
-    this.origin = origin;
-  }
-  loadState(device) {
-    if (!device.getState()?.sessionId) {
-      const {
-        preferredDevice
-      } = connect_common_1.storage.loadForOrigin(this.origin) || {};
-      if (preferredDevice?.internalState && preferredDevice?.internalStateExpiration && preferredDevice.internalStateExpiration > new Date().getTime()) {
-        return {
-          sessionId: preferredDevice.internalState
-        };
-      }
-    }
-    return undefined;
-  }
-  saveState(device, state) {
-    const expirationDelay = Math.max(1000 * 60 * 15, device.features.auto_lock_delay_ms ?? 0);
-    connect_common_1.storage.saveForOrigin(store => ({
-      ...store,
-      preferredDevice: store.preferredDevice ? {
-        ...store.preferredDevice,
-        state: state.staticSessionId,
-        internalState: state.sessionId,
-        internalStateExpiration: Date.now() + expirationDelay
-      } : undefined
-    }), this.origin);
-  }
-}
-exports.WebextensionStateStorage = WebextensionStateStorage;
-//# sourceMappingURL=StateStorage.js.map

package/lib/device/TransportList.d.ts

@@ -1,9 +0,0 @@
-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

package/lib/device/TransportList.js

@@ -1,52 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createTransportList = void 0;
-const transport_1 = require("@trezor/transport");
-const constants_1 = require("../constants");
-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 transport_1.BridgeTransport({
-      ...params,
-      port: 21328
-    }), new transport_1.BridgeTransport(params)];
-  }
-  if (typeof transportType === 'string') {
-    const existing = tryGetTransport(transports, transportType);
-    if (existing) return existing;
-    switch (transportType) {
-      case 'WebUsbTransport':
-        return new transport_1.WebUsbTransport(params);
-      case 'NodeUsbTransport':
-        return new transport_1.NodeUsbTransport(params);
-      case 'UdpTransport':
-        return new transport_1.UdpTransport(params);
-    }
-  } else if (typeof transportType === 'function' && 'prototype' in transportType) {
-    const transportInstance = new transportType(params);
-    if ((0, transport_1.isTransportInstance)(transportInstance)) {
-      return tryGetTransport(transports, transportInstance.name) ?? transportInstance;
-    }
-  } else if ((0, transport_1.isTransportInstance)(transportType)) {
-    const existing = tryGetTransport(transports, transportType.name);
-    if (existing) {
-      return existing;
-    }
-    if (!transportType.getMessage()) {
-      transportType.updateMessages(params.messages);
-    }
-    return transportType;
-  }
-  throw constants_1.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));
-};
-const createTransportList = params => (existing, transports) => createTransports(existing, transports, params);
-exports.createTransportList = createTransportList;
-//# sourceMappingURL=TransportList.js.map