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

package/lib/device/workflow/trezorPushNotification.d.ts

@@ -0,0 +1,5 @@
+import type { TpnWorkflowContext } from "../../types/workflow.js";
+export declare const trezorPushNotificationHandler: ({
+  device,
+  message
+}: TpnWorkflowContext) => Promise<void>;

package/lib/device/workflow/trezorPushNotification.js

@@ -0,0 +1,73 @@
+import { DEVICE } from "@trezor/connect-common";
+import { TrezorPushNotificationMode, TrezorPushNotificationType, tpn } from "@trezor/protocol";
+import { resolveAfter } from "@trezor/utils";
+import { getThpChannel } from "../thp/index.js";
+const setupDeviceMode = async (device, mode) => {
+  if (mode === TrezorPushNotificationMode.BootloaderMode && !device.features) {
+    device.setBusy('rebooting');
+    await device.acquire();
+    await device.getFeatures();
+    await device.release();
+  }
+  if (mode === TrezorPushNotificationMode.NormalMode && (!device.features || !device.getThpState())) {
+    device.setBusy('rebooting');
+    device.setupThp();
+    await device.acquire();
+    await resolveAfter(1000);
+    await getThpChannel(device, false);
+    if (device.getThpState()?.phase === 'paired') {
+      await device.getFeatures();
+    } else {
+      device.setBusy('thp-locked');
+      device.emitDeviceChanged();
+    }
+    await device.release();
+  }
+};
+export const trezorPushNotificationHandler = async ({
+  device,
+  message
+}) => {
+  const decodedResult = tpn.decode(message);
+  if (!decodedResult.success) return;
+  const decoded = decodedResult.payload;
+  device.lifecycle.emit(DEVICE.TREZOR_PUSH_NOTIFICATION, decoded);
+  const {
+    type,
+    mode
+  } = decoded;
+  const modeChanged = mode === TrezorPushNotificationMode.BootloaderMode && (device.getThpState()?.properties || device.features && !device.features.bootloader_mode) || mode === TrezorPushNotificationMode.NormalMode && device.features?.bootloader_mode;
+  if (modeChanged) {
+    device.reset();
+    device.setBusy(mode === TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'rebooting');
+    device.emitDeviceChanged();
+  }
+  switch (type) {
+    case TrezorPushNotificationType.SETTING_CHANGE:
+    case TrezorPushNotificationType.PIN_CHANGE:
+    case TrezorPushNotificationType.NOTIFY_POWER_STATUS_CHANGE:
+      if (!device.isUsed()) {
+        await device.acquire();
+        await device.getFeatures();
+        await device.release();
+      }
+      break;
+    case TrezorPushNotificationType.LOCK:
+      device.setBusy(mode === TrezorPushNotificationMode.BootloaderMode ? 'bootloader-locked' : 'hard-locked');
+      device.emitDeviceChanged();
+      break;
+    case TrezorPushNotificationType.UNLOCK:
+      await setupDeviceMode(device, decoded.mode);
+      break;
+    case TrezorPushNotificationType.SOFTLOCK:
+      device.setBusy('pin-locked');
+      device.emitDeviceChanged();
+      break;
+    case TrezorPushNotificationType.SOFTUNLOCK:
+      device.setBusy(device.features ? undefined : 'thp-locked');
+      device.emitDeviceChanged();
+      break;
+    default:
+      break;
+  }
+};

package/lib/device/workflow/validateState.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowContext } from "../../types/workflow.js";
+export declare const validateState: (context: WorkflowContext) => Promise<undefined>;

package/lib/device/workflow/validateState.js

@@ -0,0 +1,152 @@
+import { UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { toHardenedPathPart } from "@trezor/crypto-utils";
+import { createStaticSessionId, parseStaticSessionId } from "@trezor/device-utils";
+import { createThpSession } from "../thp/index.js";
+const getStaticSessionId = device => device.getCurrentSession().typedCall('GetAddress', 'Address', {
+  address_n: [toHardenedPathPart(44), toHardenedPathPart(1), toHardenedPathPart(0), 0, 0],
+  coin_name: 'Testnet',
+  script_type: 'SPENDADDRESS'
+}).then(({
+  message
+}) => createStaticSessionId({
+  walletDescriptor: message.address,
+  deviceId: device.features.device_id,
+  instance: device.getInstance()
+}));
+const preauthorizeState = ({
+  device,
+  method
+}) => {
+  if (!device.features.unlocked && method.preauthorized) {
+    return device.getCommands().preauthorize(false);
+  }
+};
+const isUnexpectedState = (expected, current) => {
+  if (!expected || !current) return false;
+  const parsedExpected = parseStaticSessionId(expected);
+  const parsedCurrent = parseStaticSessionId(current);
+  return parsedExpected.walletDescriptor !== parsedCurrent.walletDescriptor || parsedExpected.deviceId !== parsedCurrent.deviceId;
+};
+const validate = async context => {
+  const {
+    device
+  } = context;
+  if (!device.features) return;
+  if (await preauthorizeState(context)) {
+    return;
+  }
+  const expectedState = device.getState()?.staticSessionId;
+  const uniqueState = await getStaticSessionId(device);
+  if (device.features.session_id) {
+    device.setState({
+      sessionId: device.features.session_id
+    });
+  }
+  if (isUnexpectedState(expectedState, uniqueState)) {
+    throw ERRORS.TypedError('Device_InvalidState');
+  }
+  if (!expectedState || expectedState !== uniqueState) {
+    device.setState({
+      staticSessionId: uniqueState
+    });
+  }
+};
+const MAX_PIN_TRIES = 3;
+const validateDeviceState = async context => {
+  for (let i = 0; i < MAX_PIN_TRIES - 1; ++i) {
+    try {
+      return await validate(context);
+    } catch (error) {
+      if (error.message.includes('PIN invalid')) {
+        context.sendCoreMessage(createUiMessage(UI_REQUEST.INVALID_PIN, {
+          device: context.device.toMessageObject()
+        }));
+      } else {
+        throw error;
+      }
+    }
+  }
+  return validate(context).catch(error => {
+    if (error.message.includes('PIN invalid')) {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.INVALID_PIN_ATTEMPTS_DEPLETED, {
+        device: context.device.toMessageObject()
+      }));
+    }
+    throw error;
+  });
+};
+const validateThpDeviceState = async context => {
+  const {
+    device,
+    method
+  } = context;
+  const currentState = device.getState();
+  const expectedState = currentState?.staticSessionId;
+  const expectedSessionId = currentState?.sessionId ? Buffer.from(currentState.sessionId, 'hex') : undefined;
+  if (await preauthorizeState(context)) {
+    return;
+  }
+  let uniqueState;
+  const thpState = device.getThpState();
+  if (expectedSessionId) {
+    thpState.setSessionId(expectedSessionId);
+    uniqueState = await getStaticSessionId(device).catch(e => {
+      switch (e.code) {
+        case 'Failure_PinCancelled':
+          throw e;
+        case 'Failure_InvalidSession':
+        default:
+          return undefined;
+      }
+    });
+    if (isUnexpectedState(expectedState, uniqueState)) {
+      uniqueState = undefined;
+    }
+    if (!uniqueState) {
+      device.setState({
+        sessionId: undefined,
+        deriveCardano: undefined
+      });
+      thpState?.setSessionId(Buffer.alloc(1));
+    }
+  }
+  if (!uniqueState || !currentState?.deriveCardano && method.useCardanoDerivation) {
+    const newSessionId = thpState.createNewSessionId();
+    await createThpSession(device, method.useCardanoDerivation);
+    uniqueState = await getStaticSessionId(device);
+    device.setState({
+      sessionId: newSessionId.toString('hex'),
+      deriveCardano: method.useCardanoDerivation
+    });
+  }
+  if (isUnexpectedState(expectedState, uniqueState)) {
+    throw ERRORS.TypedError('Device_InvalidState');
+  }
+  if (!expectedState) {
+    device.setState({
+      staticSessionId: uniqueState
+    });
+  }
+};
+export const validateState = async context => {
+  const {
+    device
+  } = context;
+  const isDeviceUnlocked = device.features.unlocked;
+  try {
+    if (device.protocol.name === 'v2') {
+      await validateThpDeviceState(context);
+    } else {
+      await validateDeviceState(context);
+    }
+  } catch (error) {
+    device.setState({
+      sessionId: undefined
+    });
+    return Promise.reject(error);
+  }
+  if (!isDeviceUnlocked && device.features.unlocked) {
+    device.emitDeviceChanged();
+  }
+};

package/lib/events/ui-promise.d.ts

@@ -0,0 +1,20 @@
+import type { DEVICE, UiResponseEvent } from '@trezor/connect-common';
+import type { Deferred } from '@trezor/utils';
+import type { IDevice } from "../types/idevice.js";
+export type UiPromiseResponse = (UiResponseEvent & {
+  requestId?: string;
+}) | {
+  type: typeof DEVICE.DISCONNECT;
+  payload?: undefined;
+  requestId?: string;
+};
+export type UiPromise<T extends UiPromiseResponse['type']> = Deferred<Extract<UiPromiseResponse, {
+  type: T;
+}>, T> & {
+  device?: IDevice;
+  requestId: string;
+};
+type UiPromiseMap = { [T in UiPromiseResponse['type']]: UiPromise<T> };
+export type AnyUiPromise = UiPromiseMap[UiPromiseResponse['type']];
+export type UiPromiseCreator = <T extends UiPromiseResponse['type']>(type: T, device?: IDevice) => UiPromise<T>;
+export {};

package/lib/exports.d.ts

@@ -0,0 +1,3 @@
+export * from '@trezor/connect-common';
+export { MessagesSchema as PROTO } from '@trezor/protobuf';
+export { TRANSPORT } from '@trezor/transport-common';

package/lib/exports.js

@@ -0,0 +1,3 @@
+export * from "@trezor/connect-common";
+export { MessagesSchema as PROTO } from "@trezor/protobuf";
+export { TRANSPORT } from "@trezor/transport-common";

package/lib/impl/core-in-module.d.ts

@@ -0,0 +1,33 @@
+import type { CallMethodPayload, ConnectSettings, CoreRequestMessage, MethodResponseMessage, TrezorConnectCore, UiResponseEvent, UpdateConnectSettings } from '@trezor/connect-common';
+import { ERRORS } from '@trezor/connect-common/lib/constants';
+import { ConnectEmitter } from '@trezor/connect-common/lib/types/emitter';
+import { type CancelParams } from '@trezor/connect-common/lib/utils/cancelParams';
+import { type AbstractTransportParams, type Transport } from '@trezor/transport-common';
+export declare abstract class CoreInModule implements TrezorConnectCore<ConnectSettings> {
+  private readonly eventEmitter;
+  on: ConnectEmitter['on'];
+  off: ConnectEmitter['removeListener'];
+  removeAllListeners: ConnectEmitter['removeAllListeners'];
+  protected settings: ConnectSettings;
+  private coreManager;
+  private log;
+  private messagePromises;
+  private readonly boundOnCoreEvent;
+  protected abstract defaultTransports(params: AbstractTransportParams): Transport[];
+  private buildDefaultTransports;
+  constructor();
+  protected handleCoreMessage(message: CoreRequestMessage): void;
+  private onCoreEvent;
+  init(settings: Partial<ConnectSettings>): Promise<void>;
+  protected abstract updateProxy(proxy: UpdateConnectSettings['proxy']): Promise<void>;
+  updateConnectSettings(params: UpdateConnectSettings): Promise<import("@trezor/type-utils").Err<ERRORS.SerializedError> | {
+    readonly success: true;
+    readonly payload: {
+      readonly message: "success";
+    };
+  }>;
+  call(params: CallMethodPayload): Promise<import("@trezor/type-utils").Err<ERRORS.SerializedError> | Omit<MethodResponseMessage, "type" | "event">>;
+  uiResponse(response: UiResponseEvent): void;
+  cancel(params?: CancelParams): void;
+  dispose(): void;
+}

package/lib/impl/core-in-module.js

@@ -0,0 +1,194 @@
+import { BLOCKCHAIN_EVENT, CORE_CALL, DEVICE_EVENT, RESPONSE_EVENT, SET_ENABLED_NETWORKS, TRANSPORT_EVENT, UI_EVENT, createErrorMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { parseConnectSettings } from "@trezor/connect-common/lib/data/connectSettings.js";
+import { ConnectEmitter } from "@trezor/connect-common/lib/types/emitter.js";
+import { createCoreCallCancelMessage } from "@trezor/connect-common/lib/utils/cancelParams.js";
+import { noopLogger } from "@trezor/connect-common/lib/utils/debug.js";
+import { createUUIDDeferredManager } from "@trezor/connect-common/lib/utils/deferred.js";
+import { TRANSPORT } from "@trezor/transport-common";
+import { cloneObject } from "@trezor/utils";
+import { initCoreState } from "../core/index.js";
+export class CoreInModule {
+  eventEmitter = new ConnectEmitter();
+  on = this.eventEmitter.on.bind(this.eventEmitter);
+  off = this.eventEmitter.removeListener.bind(this.eventEmitter);
+  removeAllListeners = this.eventEmitter.removeAllListeners.bind(this.eventEmitter);
+  settings;
+  coreManager;
+  log;
+  messagePromises;
+  boundOnCoreEvent = this.onCoreEvent.bind(this);
+  buildDefaultTransports() {
+    return this.defaultTransports({
+      logger: this.settings.createLogger?.('@trezor/transport'),
+      id: this.settings.manifest?.appName || this.settings.manifest?.appUrl || 'unknown app'
+    });
+  }
+  constructor() {
+    this.settings = parseConnectSettings();
+    this.log = noopLogger;
+    this.coreManager = initCoreState();
+    this.messagePromises = createUUIDDeferredManager();
+  }
+  handleCoreMessage(message) {
+    const core = this.coreManager.get();
+    if (!core) {
+      throw ERRORS.TypedError('Runtime', 'postMessage: _core not found');
+    }
+    core.handleMessage(message);
+  }
+  onCoreEvent(rawMessage) {
+    const message = cloneObject(rawMessage);
+    const {
+      event,
+      type,
+      payload
+    } = message;
+    switch (event) {
+      case RESPONSE_EVENT:
+        {
+          const {
+            id = '',
+            success,
+            device
+          } = message;
+          const resolved = this.messagePromises.resolve(id, success ? {
+            id,
+            success,
+            payload: message.payload,
+            device
+          } : {
+            id,
+            success,
+            error: message.error,
+            device
+          });
+          if (!resolved) this.log.warn(`Unknown message id ${id}`);
+          break;
+        }
+      case DEVICE_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      case TRANSPORT_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      case BLOCKCHAIN_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      case UI_EVENT:
+        this.eventEmitter.emit(event, message);
+        this.eventEmitter.emit(type, payload);
+        break;
+      default:
+        this.log.warn('Undefined message', event, message);
+    }
+  }
+  async init(settings) {
+    if (this.coreManager.get() || this.coreManager.getPending()) {
+      throw ERRORS.TypedError('Init_AlreadyInitialized');
+    }
+    this.settings = parseConnectSettings({
+      ...this.settings,
+      ...settings
+    });
+    if (!this.settings.manifest) {
+      throw ERRORS.TypedError('Init_ManifestMissing');
+    }
+    this.log = this.settings.createLogger?.('@trezor/connect') ?? noopLogger;
+    if (!this.settings.transports?.length) {
+      this.settings.transports = this.buildDefaultTransports();
+    }
+    await this.coreManager.getOrInit(this.settings, this.boundOnCoreEvent);
+  }
+  async updateConnectSettings(params) {
+    const {
+      proxy,
+      transports: newTransports,
+      enabledNetworks
+    } = params;
+    try {
+      await this.updateProxy(proxy);
+    } catch (err) {
+      return Promise.resolve(createErrorMessage(err));
+    }
+    if (!this.coreManager.get()) {
+      const pending = this.coreManager.getPending();
+      if (pending) {
+        await pending;
+      }
+    }
+    try {
+      if (newTransports !== undefined) {
+        const transports = newTransports?.length ? newTransports : this.buildDefaultTransports();
+        this.settings = parseConnectSettings({
+          ...this.settings,
+          transports
+        });
+        this.handleCoreMessage({
+          type: TRANSPORT.SET_TRANSPORTS,
+          payload: {
+            transports
+          }
+        });
+      }
+      if (enabledNetworks !== undefined) {
+        this.handleCoreMessage({
+          type: SET_ENABLED_NETWORKS,
+          payload: enabledNetworks
+        });
+      }
+    } catch (err) {
+      return Promise.resolve(createErrorMessage(err));
+    }
+    return {
+      success: true,
+      payload: {
+        message: 'success'
+      }
+    };
+  }
+  async call(params) {
+    try {
+      if (!this.settings.manifest) {
+        throw ERRORS.TypedError('Init_ManifestMissing');
+      }
+      if (!this.coreManager.get()) {
+        const pending = this.coreManager.getPending();
+        if (pending) {
+          await pending;
+        }
+      }
+      const {
+        promiseId,
+        promise
+      } = this.messagePromises.create();
+      const payload = cloneObject(params);
+      this.handleCoreMessage({
+        type: CORE_CALL,
+        id: promiseId,
+        payload
+      });
+      const response = cloneObject(await promise);
+      return response ?? createErrorMessage(ERRORS.TypedError('Method_NoResponse'));
+    } catch (error) {
+      this.log.error('call', error);
+      return createErrorMessage(error);
+    }
+  }
+  uiResponse(response) {
+    this.handleCoreMessage(response);
+  }
+  cancel(params) {
+    this.handleCoreMessage(createCoreCallCancelMessage(params));
+  }
+  dispose() {
+    this.eventEmitter.removeAllListeners();
+    this.settings = parseConnectSettings();
+    if (this.coreManager.get()) {
+      this.coreManager.dispose();
+    }
+  }
+}

package/lib/index.browser.d.ts

@@ -0,0 +1,7 @@
+import { type TrezorConnectPrivilegedAPI } from '@trezor/connect-common';
+type TrezorConnectBrowserAPI = TrezorConnectPrivilegedAPI & {
+  requestWebUSBDevice: () => Promise<void>;
+};
+declare const TrezorConnect: TrezorConnectBrowserAPI;
+export default TrezorConnect;
+export * from "./exports.js";

package/lib/index.browser.js

@@ -0,0 +1,34 @@
+import { ERRORS, factoryPrivileged } from "@trezor/connect-common";
+import { BridgeTransport, TRANSPORT } from "@trezor/transport-common";
+import { WebUsbTransport } from "@trezor/transport-web";
+import { config } from "./data/config.js";
+import { CoreInModule } from "./impl/core-in-module.js";
+class CoreInModuleWeb extends CoreInModule {
+  defaultTransports(params) {
+    return [new BridgeTransport(params), new WebUsbTransport(params)];
+  }
+  updateProxy(proxy) {
+    if (proxy !== undefined) {
+      throw ERRORS.TypedError('Method_InvalidPackage', 'proxy setting is not supported in web environment');
+    }
+    return Promise.resolve();
+  }
+  async requestWebUSBDevice() {
+    try {
+      await window.navigator.usb.requestDevice({
+        filters: config.webusb
+      });
+      this.handleCoreMessage({
+        type: TRANSPORT.REQUEST_DEVICE
+      });
+    } catch {}
+  }
+}
+const TrezorConnect = factoryPrivileged(new CoreInModuleWeb());
+export default TrezorConnect;
+export * from "./exports.js";
+if (typeof window !== 'undefined') {
+  window.addEventListener('beforeunload', () => {
+    TrezorConnect.dispose();
+  });
+}

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+import { type TrezorConnectPrivilegedAPI } from '@trezor/connect-common';
+declare const TrezorConnect: TrezorConnectPrivilegedAPI;
+export default TrezorConnect;
+export * from "./exports.js";

package/lib/index.js

@@ -0,0 +1,15 @@
+import { factoryPrivileged } from "@trezor/connect-common";
+import { BridgeTransport } from "@trezor/transport-common";
+import { updateProxy } from "./backend/BlockchainLink.js";
+import { CoreInModule } from "./impl/core-in-module.js";
+class CoreInModuleNode extends CoreInModule {
+  defaultTransports(params) {
+    return [new BridgeTransport(params)];
+  }
+  async updateProxy(proxy) {
+    await updateProxy(proxy);
+  }
+}
+const TrezorConnect = factoryPrivileged(new CoreInModuleNode());
+export default TrezorConnect;
+export * from "./exports.js";

package/lib/types/idevice.d.ts

@@ -0,0 +1,110 @@
+import type { Device, DeviceBusyStatus, DeviceButtonRequestPayload, DeviceFirmwareStatus, DeviceState, DeviceThpCredentialsChangedPayload, DeviceThpPairingPayload, DeviceThpPairingStatus, DeviceUniquePath, DeviceVersionChanged, Features, FirmwareHashCheckResult, KnownDevice, UiResponsePassphrase, UiResponsePin, UiResponseThpPairingTag, UiResponseWord, UnavailableCapabilities } from '@trezor/connect-common';
+import type { FirmwareReleaseConfigInfo } from '@trezor/connect-common/lib/types/firmware';
+import type { FirmwareRelease, FirmwareType } from '@trezor/device-utils';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { DecodedTrezorPushNotification, TransportProtocol, thp as protocolThp } from '@trezor/protocol';
+import type { Descriptor, Transport } from '@trezor/transport-common';
+import type { TypedEmitter, VersionArray } from '@trezor/utils';
+import type { TypedCallProvider } from "./typed-call-provider.js";
+import type { DeviceCommands } from "../device/DeviceCommands.js";
+export interface DeviceLifecycleEvents {
+  'device-connect': void;
+  'device-connect_unacquired': void;
+  'device-changed': void;
+  'device-disconnect': void;
+  'device-trezor_push_notification': DecodedTrezorPushNotification;
+}
+export type PromptResult<T> = {
+  success: true;
+  payload: T;
+} | {
+  success: false;
+  error: Error;
+};
+export interface DeviceEvents {
+  pin: {
+    type: PROTO.PinMatrixRequestType | undefined;
+    callback: (response: PromptResult<UiResponsePin['payload']>) => void;
+  };
+  word: {
+    type: PROTO.WordRequestType;
+    callback: (response: PromptResult<UiResponseWord['payload']>) => void;
+  };
+  passphrase: {
+    callback: (response: PromptResult<UiResponsePassphrase['payload']>) => void;
+  };
+  passphrase_on_device: void;
+  button: {
+    device: IDevice;
+    payload: DeviceButtonRequestPayload;
+  };
+  'device-firmware_version_changed': DeviceVersionChanged['payload'];
+  'device-trezor_push_notification': {
+    device: Device;
+    payload: DecodedTrezorPushNotification;
+  };
+  thp_pairing: {
+    payload: DeviceThpPairingPayload;
+    callback: (response: PromptResult<UiResponseThpPairingTag['payload']>) => void;
+  };
+  'device-thp_credentials_changed': DeviceThpCredentialsChangedPayload;
+  'device-thp_pairing_status_changed': DeviceThpPairingStatus;
+}
+export type RunOptions = {
+  skipFinalReload?: boolean;
+  keepSession?: boolean;
+  useCardanoDerivation?: boolean;
+  skipFirmwareChecks?: boolean;
+  skipLanguageChecks?: boolean;
+};
+export interface IDevice {
+  readonly transport: Transport;
+  readonly descriptor: Pick<Descriptor, 'apiType' | 'id' | 'type' | 'path' | 'model'>;
+  readonly protocol: TransportProtocol;
+  readonly transportPath: Descriptor['path'];
+  readonly lifecycle: TypedEmitter<DeviceLifecycleEvents>;
+  readonly possibleT1: boolean;
+  readonly firmwareStatus: DeviceFirmwareStatus;
+  readonly currentRelease: FirmwareRelease | undefined;
+  readonly firmwareReleaseConfigInfo: FirmwareReleaseConfigInfo | undefined;
+  readonly features: Features;
+  readonly unavailableCapabilities: Readonly<UnavailableCapabilities>;
+  readonly firmwareType: FirmwareType | undefined;
+  readonly currentRun: Promise<void> | undefined;
+  acquire(): ReturnType<Transport['acquire']>;
+  release(): ReturnType<Transport['release']> | undefined;
+  run(fn?: () => Promise<void>, options?: RunOptions): Promise<void>;
+  interrupt(reason: Error): Promise<void>;
+  reset(): void;
+  setBusy(value?: DeviceBusyStatus): void;
+  setupThp(): void;
+  handshake(): Promise<boolean>;
+  setInstance(instance?: number): void;
+  getThpState(): protocolThp.ThpState | undefined;
+  getUniquePath(): DeviceUniquePath;
+  getInstance(): number;
+  getState(): DeviceState | undefined;
+  setState(state?: Partial<DeviceState>): void;
+  getVersion(): VersionArray | undefined;
+  getBusy(): DeviceBusyStatus | undefined;
+  getAuthenticityChecks(): KnownDevice['authenticityChecks'];
+  setAuthenticityChecks(firmwareHash: FirmwareHashCheckResult | null): void;
+  getCurrentSession(): TypedCallProvider;
+  getCommands(): ReturnType<typeof DeviceCommands>;
+  startPiggybackAck(): void;
+  stopPiggybackAck(): Promise<void>;
+  isUnacquired(): boolean;
+  isBootloader(): boolean;
+  isInitialized(): boolean;
+  isSeedless(): boolean;
+  isUsed(): boolean;
+  isUsedHere(): boolean;
+  isUsedElsewhere(): boolean;
+  atLeast(versions: string[] | string): boolean;
+  hasUnexpectedMode(allow: string[]): string | null;
+  toMessageObject(): Device;
+  emit: TypedEmitter<DeviceEvents>['emit'];
+  emitDeviceChanged(): void;
+  prompt<T extends 'pin' | 'passphrase' | 'word' | 'thp_pairing'>(type: T, args: Omit<DeviceEvents[T], 'callback'>): Promise<Parameters<DeviceEvents[T]['callback']>[0]>;
+  getFeatures(): Promise<void>;
+}