@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/device/workflow/trezorPushNotification.mjs

@@ -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.mjs";
+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.lifecycle.emit(DEVICE.CHANGED);
+    }
+    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.lifecycle.emit(DEVICE.CHANGED);
+  }
+  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.lifecycle.emit(DEVICE.CHANGED);
+      break;
+    case TrezorPushNotificationType.UNLOCK:
+      await setupDeviceMode(device, decoded.mode);
+      break;
+    case TrezorPushNotificationType.SOFTLOCK:
+      device.setBusy('pin-locked');
+      device.lifecycle.emit(DEVICE.CHANGED);
+      break;
+    case TrezorPushNotificationType.SOFTUNLOCK:
+      device.setBusy(device.features ? undefined : 'thp-locked');
+      device.lifecycle.emit(DEVICE.CHANGED);
+      break;
+    default:
+      break;
+  }
+};

package/libESM/device/workflow/validateState.d.mts

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

package/libESM/device/workflow/validateState.mjs

@@ -0,0 +1,153 @@
+import { DEVICE, UI_REQUEST, createDeviceMessage, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { createStaticSessionId, parseStaticSessionId } from "@trezor/device-utils";
+import { toHardened } from "../../utils/pathUtils.mjs";
+import { createThpSession } from "../thp/index.mjs";
+const getStaticSessionId = device => device.getCurrentSession().typedCall('GetAddress', 'Address', {
+  address_n: [toHardened(44), toHardened(1), toHardened(0), 0, 0],
+  coin_name: 'Testnet',
+  script_type: 'SPENDADDRESS'
+}).then(({
+  message
+}) => createStaticSessionId({
+  firstTestnetAddress: 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.firstTestnetAddress !== parsedCurrent.firstTestnetAddress || 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,
+    sendCoreMessage
+  } = 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) {
+    sendCoreMessage(createDeviceMessage(DEVICE.CHANGED, device.toMessageObject()));
+  }
+};

package/libESM/events/ui-promise.d.mts

@@ -0,0 +1,22 @@
+import type { DEVICE, UiResponseEvent } from '@trezor/connect-common';
+import type { Deferred } from '@trezor/utils';
+import type { IDevice } from '../types/idevice';
+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/libESM/events/ui-promise.mjs

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

package/libESM/exports.d.mts

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

package/libESM/exports.mjs

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

package/libESM/impl/core-in-module.d.mts

@@ -0,0 +1,27 @@
+import type { CallMethodPayload, ConnectFactoryDependencies, ConnectSettings, ConnectSettingsPublic, ConnectSettingsTransport, CoreRequestMessage, MethodResponseMessage, UiResponseEvent, UpdateConnectSettings } from '@trezor/connect-common';
+import { ERRORS } from '@trezor/connect-common/libESM/constants';
+import { ConnectEmitter } from '@trezor/connect-common/libESM/types/emitter';
+export declare abstract class CoreInModule implements ConnectFactoryDependencies<ConnectSettingsPublic> {
+    readonly eventEmitter: ConnectEmitter;
+    private settings;
+    private coreManager;
+    private log;
+    private messagePromises;
+    private readonly boundOnCoreEvent;
+    protected abstract get defaultTransports(): ConnectSettingsTransport[];
+    constructor();
+    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(reason?: string): void;
+    dispose(): void;
+}

package/libESM/impl/core-in-module.mjs

@@ -0,0 +1,173 @@
+import { BLOCKCHAIN_EVENT, CORE_CALL, CORE_CALL_CANCEL, DEVICE_EVENT, RESPONSE_EVENT, TRANSPORT_EVENT, UI_EVENT, createErrorMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { parseConnectSettings } from "@trezor/connect-common/libESM/data/connectSettings.mjs";
+import { ConnectEmitter } from "@trezor/connect-common/libESM/types/emitter.mjs";
+import { initLog } from "@trezor/connect-common/libESM/utils/debug.mjs";
+import { TRANSPORT } from "@trezor/transport";
+import { cloneObject, createDeferredManager } from "@trezor/utils";
+import { initCoreState } from "../core/index.mjs";
+export class CoreInModule {
+  eventEmitter = new ConnectEmitter();
+  settings;
+  coreManager;
+  log;
+  messagePromises;
+  boundOnCoreEvent = this.onCoreEvent.bind(this);
+  constructor() {
+    this.settings = parseConnectSettings();
+    this.log = initLog('@trezor/connect');
+    this.coreManager = initCoreState();
+    this.messagePromises = createDeferredManager({
+      generateId: () => crypto.randomUUID()
+    });
+  }
+  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');
+    }
+    if (!this.settings.transports?.length) {
+      this.settings.transports = this.defaultTransports;
+    }
+    this.log.enabled = !!this.settings.debug;
+    await this.coreManager.getOrInit(this.settings, this.boundOnCoreEvent);
+  }
+  async updateConnectSettings(params) {
+    const {
+      proxy,
+      transports: newTransports
+    } = params;
+    try {
+      await this.updateProxy(proxy);
+    } catch (err) {
+      return Promise.resolve(createErrorMessage(err));
+    }
+    if (newTransports !== undefined) {
+      const transports = newTransports?.length ? newTransports : this.defaultTransports;
+      this.settings = parseConnectSettings({
+        ...this.settings,
+        transports
+      });
+      this.handleCoreMessage({
+        type: TRANSPORT.SET_TRANSPORTS,
+        payload: {
+          transports
+        }
+      });
+    }
+    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(reason) {
+    this.handleCoreMessage({
+      type: CORE_CALL_CANCEL,
+      payload: reason ? {
+        reason
+      } : null
+    });
+  }
+  dispose() {
+    this.eventEmitter.removeAllListeners();
+    this.settings = parseConnectSettings();
+    if (this.coreManager.get()) {
+      this.coreManager.dispose();
+    }
+  }
+}

package/libESM/index.browser.d.mts

@@ -0,0 +1,9 @@
+declare const TrezorConnect: import("@trezor/connect-common").TrezorConnect & {
+    init: import("@trezor/connect-common").InitType<Partial<import("@trezor/connect-common").ConnectSettings>>;
+    call: import("@trezor/connect-common").CallMethod;
+} & {
+    disableWebUSB: () => void;
+    requestWebUSBDevice: () => Promise<void>;
+};
+export default TrezorConnect;
+export * from './exports';

package/libESM/index.browser.mjs

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

package/libESM/index.d.mts

@@ -0,0 +1,6 @@
+declare const TrezorConnect: import("@trezor/connect-common").TrezorConnect & {
+    init: import("@trezor/connect-common").InitType<Partial<import("@trezor/connect-common").ConnectSettings>>;
+    call: import("@trezor/connect-common").CallMethod;
+};
+export default TrezorConnect;
+export * from './exports';

package/libESM/index.mjs

@@ -0,0 +1,32 @@
+import { factory } from "@trezor/connect-common";
+import { deepEqual } from "@trezor/utils";
+import { reconnectAllBackends } from "./backend/BlockchainLink.mjs";
+import * as settingsStore from "./data/settingsStore.mjs";
+import { CoreInModule } from "./impl/core-in-module.mjs";
+class CoreInModuleNode extends CoreInModule {
+  get defaultTransports() {
+    return ['BridgeTransport'];
+  }
+  async updateProxy(proxy) {
+    if (!settingsStore.isLoaded()) return;
+    const settings = settingsStore.get();
+    if (proxy !== undefined && !deepEqual(settings.proxy, proxy)) {
+      settingsStore.update({
+        proxy
+      });
+      await reconnectAllBackends();
+    }
+  }
+}
+const impl = new CoreInModuleNode();
+const TrezorConnect = factory({
+  eventEmitter: impl.eventEmitter,
+  init: impl.init.bind(impl),
+  call: impl.call.bind(impl),
+  updateConnectSettings: impl.updateConnectSettings.bind(impl),
+  uiResponse: impl.uiResponse.bind(impl),
+  cancel: impl.cancel.bind(impl),
+  dispose: impl.dispose.bind(impl)
+}, {});
+export default TrezorConnect;
+export * from "./exports.mjs";

package/libESM/index.renderer.d.mts

@@ -0,0 +1,6 @@
+declare const TrezorConnect: import("@trezor/connect-common").TrezorConnect & {
+    init: import("@trezor/connect-common").InitType<Record<string, any>>;
+    call: import("@trezor/connect-common").CallMethod;
+} & Record<string, any>;
+export default TrezorConnect;
+export * from './exports';

package/libESM/index.renderer.mjs

@@ -0,0 +1,19 @@
+import { factory } from "@trezor/connect-common";
+const dummy = method => () => {
+  throw new Error(`TrezorConnect.${method} should never be called from electron renderer without using ipcProxy`);
+};
+const TrezorConnect = factory({
+  eventEmitter: {
+    on: dummy('eventEmitter.on'),
+    removeListener: dummy('eventEmitter.removeListener'),
+    removeAllListeners: dummy('eventEmitter.removeAllListeners')
+  },
+  init: dummy('init'),
+  call: dummy('call'),
+  updateConnectSettings: dummy('updateConnectSettings'),
+  uiResponse: dummy('uiResponse'),
+  cancel: dummy('cancel'),
+  dispose: dummy('dispose')
+});
+export default TrezorConnect;
+export * from "./exports.mjs";

package/libESM/tsconfig.libESM.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/exports.ts","../src/index.browser.ts","../src/index.renderer.ts","../src/index.ts","../src/api/applyFlags.ts","../src/api/applySettings.ts","../src/api/authenticateDevice.ts","../src/api/authorizeCoinjoin.ts","../src/api/backupDevice.ts","../src/api/bleUnpair.ts","../src/api/blockchainDisconnect.ts","../src/api/blockchainEstimateFee.ts","../src/api/blockchainEvmRpcCall.ts","../src/api/blockchainGetAccountBalanceHistory.ts","../src/api/blockchainGetContractInfo.ts","../src/api/blockchainGetCurrentFiatRates.ts","../src/api/blockchainGetFiatRatesForTimestamps.ts","../src/api/blockchainGetInfo.ts","../src/api/blockchainGetTransactions.ts","../src/api/blockchainSetCustomBackend.ts","../src/api/blockchainSubscribe.ts","../src/api/blockchainSubscribeFiatRates.ts","../src/api/blockchainUnsubscribe.ts","../src/api/blockchainUnsubscribeFiatRates.ts","../src/api/blockchainValidateEvmRpcUrl.ts","../src/api/cancelCoinjoinAuthorization.ts","../src/api/changeLanguage.ts","../src/api/changePin.ts","../src/api/changeWipeCode.ts","../src/api/cipherKeyValue.ts","../src/api/composeTransaction.ts","../src/api/discoverAccounts.ts","../src/api/evoluGetDelegatedIdentityKey.ts","../src/api/evoluGetNode.ts","../src/api/evoluSignRegistrationRequest.ts","../src/api/getAccountInfo.ts","../src/api/getAddress.ts","../src/api/getCoinInfo.ts","../src/api/getDeviceState.ts","../src/api/getFeatures.ts","../src/api/getFirmwareHash.ts","../src/api/getNonce.ts","../src/api/getOwnershipId.ts","../src/api/getOwnershipProof.ts","../src/api/getPublicKey.ts","../src/api/getSettings.ts","../src/api/index.ts","../src/api/loadDevice.ts","../src/api/pingDevice.ts","../src/api/pushTransaction.ts","../src/api/recoveryDevice.ts","../src/api/requestLogin.ts","../src/api/resetDevice.ts","../src/api/setBrightness.ts","../src/api/setBusy.ts","../src/api/showDeviceTutorial.ts","../src/api/signMessage.ts","../src/api/signTransaction.ts","../src/api/telemetryGet.ts","../src/api/thpGetCredentials.ts","../src/api/thpRemoveCredentials.ts","../src/api/unlockPath.ts","../src/api/verifyMessage.ts","../src/api/wipeDevice.ts","../src/api/bitcoin/TransactionComposer.ts","../src/api/bitcoin/createPendingTx.ts","../src/api/bitcoin/enhanceSignTx.ts","../src/api/bitcoin/index.ts","../src/api/bitcoin/inputs.ts","../src/api/bitcoin/outputs.ts","../src/api/bitcoin/refTx.ts","../src/api/bitcoin/signtx.ts","../src/api/bitcoin/signtxLegacy.ts","../src/api/bitcoin/signtxVerify.ts","../src/api/bitcoin/transactionBytes.ts","../src/api/cardano/cardanoAddressParameters.ts","../src/api/cardano/cardanoAuxiliaryData.ts","../src/api/cardano/cardanoCertificate.ts","../src/api/cardano/cardanoInputs.ts","../src/api/cardano/cardanoOutputs.ts","../src/api/cardano/cardanoTokenBundle.ts","../src/api/cardano/cardanoUtils.ts","../src/api/cardano/cardanoWitnesses.ts","../src/api/cardano/api/cardanoComposeTransaction.ts","../src/api/cardano/api/cardanoGetAddress.ts","../src/api/cardano/api/cardanoGetNativeScriptHash.ts","../src/api/cardano/api/cardanoGetPublicKey.ts","../src/api/cardano/api/cardanoSignMessage.ts","../src/api/cardano/api/cardanoSignTransaction.ts","../src/api/cardano/api/index.ts","../src/api/common/AbstractMiscGetAddress.ts","../src/api/common/Discovery.ts","../src/api/common/paramsValidator.ts","../src/api/common/requestExistingAccounts.ts","../src/api/ethereum/ethereumDefinitions.ts","../src/api/ethereum/ethereumSignTx.ts","../src/api/ethereum/ethereumSignTypedData.ts","../src/api/ethereum/api/ethereumGetAddress.ts","../src/api/ethereum/api/ethereumGetPublicKey.ts","../src/api/ethereum/api/ethereumSignMessage.ts","../src/api/ethereum/api/ethereumSignTransaction.ts","../src/api/ethereum/api/ethereumSignTypedData.ts","../src/api/ethereum/api/ethereumVerifyMessage.ts","../src/api/ethereum/api/index.ts","../src/api/firmware/calculateFirmwareHash.ts","../src/api/firmware/calculateXPubHash.ts","../src/api/firmware/getBinary.ts","../src/api/firmware/index.ts","../src/api/firmware/modifyFirmware.ts","../src/api/firmware/parseFirmwareHeaders.ts","../src/api/firmware/uploadFirmware.ts","../src/api/firmware/verifyEntropy.ts","../src/api/monero/api/index.ts","../src/api/monero/api/moneroGetAddress.ts","../src/api/monero/api/moneroGetWatchKey.ts","../src/api/monero/api/moneroKeyImageSync.ts","../src/api/monero/api/moneroSignTransaction.ts","../src/api/ripple/api/index.ts","../src/api/ripple/api/rippleGetAddress.ts","../src/api/ripple/api/rippleSignTransaction.ts","../src/api/solana/solanaDefinitions.ts","../src/api/solana/api/index.ts","../src/api/solana/api/solanaComposeTransaction.ts","../src/api/solana/api/solanaGetAddress.ts","../src/api/solana/api/solanaGetPublicKey.ts","../src/api/solana/api/solanaSignTransaction.ts","../src/api/stellar/stellarSignTx.ts","../src/api/stellar/api/index.ts","../src/api/stellar/api/stellarGetAddress.ts","../src/api/stellar/api/stellarSignTransaction.ts","../src/api/tezos/tezosSignTx.ts","../src/api/tezos/api/index.ts","../src/api/tezos/api/tezosGetAddress.ts","../src/api/tezos/api/tezosGetPublicKey.ts","../src/api/tezos/api/tezosSignTransaction.ts","../src/api/tron/tronEncode.ts","../src/api/tron/tronProtobuf.ts","../src/api/tron/api/index.ts","../src/api/tron/api/tronComposeTransaction.ts","../src/api/tron/api/tronGetAddress.ts","../src/api/tron/api/tronSignTransaction.ts","../src/backend/BackendManager.ts","../src/backend/Blockchain.ts","../src/backend/BlockchainLink.ts","../src/backend/fees/BitcoinFeeLevels.ts","../src/backend/fees/EthereumFeeLevels.ts","../src/backend/fees/MiscFeeLevels.ts","../src/backend/fees/index.ts","../src/core/AbstractMethod.ts","../src/core/index.ts","../src/core/method.native.ts","../src/core/method.ts","../src/core/onCallFirmwareUpdate.ts","../src/data/coinInfo.ts","../src/data/config.ts","../src/data/defaultFeeLevels.ts","../src/data/firmwareInfo.ts","../src/data/firmwareReleaseStore.ts","../src/data/localFirmwareStore.ts","../src/data/protobufLoader.ts","../src/data/settingsStore.ts","../src/device/Device.ts","../src/device/DeviceCommands.ts","../src/device/DeviceCurrentSession.ts","../src/device/DeviceList.ts","../src/device/TransportList.ts","../src/device/TransportManager.ts","../src/device/calculateRevisionForDevice.ts","../src/device/checkFirmwareRevision.ts","../src/device/resolveDescriptorForTaproot.ts","../src/device/validateMessageSize.ts","../src/device/thp/handshake.ts","../src/device/thp/index.ts","../src/device/thp/pairing.ts","../src/device/thp/session.ts","../src/device/thp/thpCall.ts","../src/device/workflow/changeLanguage.ts","../src/device/workflow/checkFirmwareHash.ts","../src/device/workflow/checkFirmwareHashWithRetries.ts","../src/device/workflow/handshake.ts","../src/device/workflow/trezorPushNotification.ts","../src/device/workflow/validateState.ts","../src/events/ui-promise.ts","../src/impl/core-in-module.ts","../src/types/idevice.ts","../src/types/typed-call-provider.ts","../src/types/workflow.ts","../src/utils/accountUtils.ts","../src/utils/addressUtils.ts","../src/utils/assetUtils.ts","../src/utils/assets.browser.ts","../src/utils/assets.native.ts","../src/utils/assets.ts","../src/utils/assetsTypes.ts","../src/utils/buildOutputDescriptor.ts","../src/utils/deviceFeaturesUtils.ts","../src/utils/ethereumUtils.ts","../src/utils/firmwareReleaseConfigUtils.ts","../src/utils/firmwareUtils.ts","../src/utils/formatUtils.ts","../src/utils/hdnodeUtils.ts","../src/utils/pathUtils.ts","../src/utils/paymentRequest.ts","../src/utils/uiPromiseManager.ts","../src/workers/workers.browser.ts","../src/workers/workers.native.ts","../src/workers/workers.ts"],"version":"5.9.3"}