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

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

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

package/lib/device/workflow/trezorPushNotification.js

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

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

package/lib/device/workflow/validateState.js

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

@@ -1,20 +0,0 @@
-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/events/ui-promise.js

@@ -1 +0,0 @@
-export {};

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

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

@@ -1,194 +0,0 @@
-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/types/idevice.d.ts

@@ -1,110 +0,0 @@
-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>;
-}

package/lib/types/idevice.js

@@ -1 +0,0 @@
-export {};

package/lib/types/typed-call-provider.d.ts

@@ -1,29 +0,0 @@
-import type { MessagesSchema as Messages } from '@trezor/protobuf';
-import type { MessageResponse } from '@trezor/transport-common';
-type AbortableOptions = {
-  timeout?: number;
-  signal?: AbortSignal;
-};
-type CallResult = {
-  success: true;
-  payload: MessageResponse;
-} | {
-  success: false;
-  error: Error;
-};
-type SendResult = {
-  success: true;
-  payload: undefined;
-} | {
-  success: false;
-  error: Error;
-};
-export interface TypedCallProvider {
-  typedCall: Messages.TypedCall;
-  isDisposed: () => boolean;
-  cancelCall: () => Promise<CallResult>;
-  call: (name: string, data: Record<string, unknown>, options?: AbortableOptions) => Promise<CallResult>;
-  send: (name: string, data: Record<string, unknown>, options?: AbortableOptions) => Promise<SendResult>;
-  receive: (options?: AbortableOptions) => Promise<CallResult>;
-}
-export {};

package/lib/types/typed-call-provider.js

@@ -1 +0,0 @@
-export {};

package/lib/types/workflow.d.ts

@@ -1,16 +0,0 @@
-import type { CoreEventMessage } from '@trezor/connect-common';
-import type { IDevice } from "./idevice.js";
-export interface WorkflowMethod {
-  preauthorized?: boolean;
-  useCardanoDerivation: boolean;
-}
-export type WorkflowContext = {
-  device: IDevice;
-  method: WorkflowMethod;
-  signal: AbortSignal;
-  sendCoreMessage: (message: CoreEventMessage) => void;
-};
-export type TpnWorkflowContext = {
-  device: IDevice;
-  message: number[];
-};

package/lib/types/workflow.js

@@ -1 +0,0 @@
-export {};

package/lib/utils/accountUtils.d.ts

@@ -1,10 +0,0 @@
-import type { BitcoinNetworkInfo, CoinInfo } from '@trezor/connect-common';
-type Bip44Options = {
-  purpose?: number;
-  coinType?: number;
-};
-export declare const getAccountAddressN: (coinInfo: CoinInfo, accountIndex: number, bip44?: Bip44Options) => number[];
-export declare const getAccountLabel: (path: number[], coinInfo: CoinInfo) => string;
-export declare const getPublicKeyLabel: (path: number[], coinInfo?: BitcoinNetworkInfo) => string;
-export declare const isUtxoBased: (coinInfo: CoinInfo) => boolean;
-export {};