@trezor/connect 10.0.0-beta.1 → 10.0.0-beta.2

package/lib/device/DeviceCurrentSession.js

@@ -1,239 +0,0 @@
-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'],
-  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 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;
-  logger;
-  disposed;
-  callPromise;
-  abortController;
-  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 = 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));
-    this.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;
-      this.logger.debug('Received', type, filterForLog(type, message));
-    } else {
-      this.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/lib/device/DeviceList.d.ts

@@ -1,75 +0,0 @@
-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 } 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;
-}
-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 = {
-  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 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 {};

package/lib/device/DeviceList.js

@@ -1,243 +0,0 @@
-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) => {
-    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 currentPenalty = penalizedDevices[deviceID];
-    const penalty = currentPenalty ? currentPenalty + 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
-});
-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;
-  createLogger;
-  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({
-    createLogger
-  }) {
-    super();
-    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({
-      id: asDeviceUniquePath(id),
-      transport,
-      descriptor,
-      createLogger: this.createLogger
-    });
-    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 = 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
-    }));
-    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/lib/device/TransportList.d.ts

@@ -1,3 +0,0 @@
-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[];

package/lib/device/TransportList.js

@@ -1,13 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { isTransportInstance } from "@trezor/transport-common";
-const reuseOrUse = (existing, candidate) => existing.find(t => t.name === candidate.name) ?? candidate;
-const resolveOne = (existing, arg) => {
-  if (!isTransportInstance(arg)) {
-    throw ERRORS.TypedError('Runtime', `init({ transports }) entry is not a valid Transport instance`);
-  }
-  return reuseOrUse(existing, arg);
-};
-export const createTransportList = (existing, transports) => {
-  if (!transports?.length) return [];
-  return transports.map(transport => resolveOne(existing, transport));
-};

package/lib/device/TransportManager.d.ts

@@ -1,33 +0,0 @@
-import { TRANSPORT, type Transport } from '@trezor/transport-common';
-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 {};