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

package/libESM/core/method.d.mts

@@ -1,3 +0,0 @@
-import type { CoreCallMessage } from '@trezor/connect-common';
-import type { AbstractMethod } from './AbstractMethod';
-export declare const getMethod: (message: CoreCallMessage) => Promise<AbstractMethod<any>>;

package/libESM/core/method.mjs

@@ -1,19 +0,0 @@
-import { TypedError } from "@trezor/connect-common/libESM/constants/errors.mjs";
-import { MODULES } from "@trezor/connect-common/libESM/constants/network.mjs";
-import * as Methods from "../api/index.mjs";
-const getMethodModule = method => MODULES.find(module => method.startsWith(module));
-export const getMethod = async message => {
-  const {
-    method
-  } = message.payload;
-  if (typeof method !== 'string') {
-    throw TypedError('Method_InvalidParameter', 'Message method is not set');
-  }
-  const methodModule = getMethodModule(method);
-  const methods = methodModule ? await import(`../api/${methodModule}/api/index.js`) : Methods;
-  const MethodConstructor = methods[method];
-  if (MethodConstructor) {
-    return new MethodConstructor(message);
-  }
-  throw TypedError('Method_InvalidParameter', `Method ${method} not found`);
-};

package/libESM/core/method.native.d.mts

@@ -1,2 +0,0 @@
-import type { CoreCallMessage } from '@trezor/connect-common';
-export declare const getMethod: (message: CoreCallMessage) => Promise<any>;

package/libESM/core/method.native.mjs

@@ -1,29 +0,0 @@
-import { TypedError } from "@trezor/connect-common/libESM/constants/errors.mjs";
-import { MODULES } from "@trezor/connect-common/libESM/constants/network.mjs";
-import * as Methods from "../api/index.mjs";
-const moduleMethods = {
-  cardano: require('../api/cardano/api'),
-  ethereum: require('../api/ethereum/api'),
-  monero: require('../api/monero/api'),
-  ripple: require('../api/ripple/api'),
-  solana: require('../api/solana/api'),
-  stellar: require('../api/stellar/api'),
-  tezos: require('../api/tezos/api'),
-  tron: require('../api/tron/api')
-};
-const getMethodModule = method => MODULES.find(module => method.startsWith(module));
-export const getMethod = async message => {
-  const {
-    method
-  } = message.payload;
-  if (typeof method !== 'string') {
-    throw TypedError('Method_InvalidParameter', 'Message method is not set');
-  }
-  const methodModule = getMethodModule(method);
-  const methods = methodModule ? moduleMethods[methodModule] : Methods;
-  const MethodConstructor = methods[method];
-  if (MethodConstructor) {
-    return new MethodConstructor(message);
-  }
-  throw TypedError('Method_InvalidParameter', `Method ${method} not found`);
-};

package/libESM/core/onCallFirmwareUpdate.d.mts

@@ -1,39 +0,0 @@
-import type { CommonParams, CoreEventMessage, DeviceUniquePath, FirmwareUpdateResponse } from '@trezor/connect-common';
-import type { Log } from '@trezor/connect-common/libESM/utils/debug';
-import type { Device } from '../device/Device';
-import type { DeviceList } from '../device/DeviceList';
-import type { UiPromiseCreator } from '../events/ui-promise';
-type PostMessage = (message: CoreEventMessage) => void;
-type ReconnectContext = {
-    deviceList: DeviceList;
-    device: Device;
-    registerEvents: (device: Device) => void;
-    postMessage: PostMessage;
-    log: Log;
-    abortSignal: AbortSignal;
-    uiPromises: {
-        create: UiPromiseCreator;
-        rejectAll: (e: Error) => void;
-    };
-};
-export type Params = {
-    language?: string;
-    baseUrl?: string;
-    btcOnly?: boolean;
-    binary?: ArrayBuffer;
-} & CommonParams;
-type Context = {
-    deviceList: DeviceList;
-    registerEvents: (device: Device) => void;
-    postMessage: PostMessage;
-    selectDevice: (path?: DeviceUniquePath) => Device;
-    log: Log;
-    abortSignal: AbortSignal;
-    uiPromises: ReconnectContext['uiPromises'];
-};
-type OnCallFirmwareUpdateParams = {
-    params: Params;
-    context: Context;
-};
-export declare const onCallFirmwareUpdate: ({ params, context, }: OnCallFirmwareUpdateParams) => Promise<FirmwareUpdateResponse>;
-export {};

package/libESM/core/onCallFirmwareUpdate.mjs

@@ -1,436 +0,0 @@
-import { FirmwareType, UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { getFirmwareOrBootloaderVersionArray } from "@trezor/device-utils";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { resolveAfter } from "@trezor/utils";
-import { isEqual, isNewer } from "@trezor/utils/libESM/versionUtils.mjs";
-import { getBinary, parseFirmwareHeaders, shouldStripFwHeaders, stripFwHeaders, uploadFirmware } from "../api/firmware/index.mjs";
-import { getFirmwareLocation, getReleaseByVersion } from "../data/firmwareInfo.mjs";
-import * as settingsStore from "../data/settingsStore.mjs";
-import { isFirmwareCacheUsedForSelectedSource } from "../utils/firmwareUtils.mjs";
-const waitForThpPairingConfirmation = async ({
-  uiPromises,
-  postMessage,
-  device,
-  deviceList,
-  abortSignal,
-  thpPairingError
-}) => {
-  const uiPromise = uiPromises.create(UI_RESPONSE.RECEIVE_CONFIRMATION, device);
-  postMessage(createUiMessage(UI_REQUEST.REQUEST_CONFIRMATION, {
-    view: thpPairingError ? 'thp-pairing-failed' : 'thp-pairing-start'
-  }, {
-    requestId: uiPromise.requestId
-  }));
-  const devicePath = device.getUniquePath();
-  const disconnectListener = event => {
-    if (event.getUniquePath() === devicePath) {
-      uiPromise.reject(ERRORS.TypedError('Device_Disconnected'));
-    }
-  };
-  const abortListener = () => {
-    uiPromise.reject(ERRORS.TypedError('Method_Interrupted'));
-  };
-  try {
-    abortSignal.addEventListener('abort', abortListener);
-    deviceList.on('device-disconnect', disconnectListener);
-    const uiResp = await uiPromise.promise;
-    if (!uiResp.payload) {
-      throw ERRORS.TypedError('Method_PermissionsNotGranted');
-    }
-  } finally {
-    abortSignal.removeEventListener('abort', abortListener);
-    deviceList.off('device-disconnect', disconnectListener);
-  }
-};
-const WAIT_FOR_RECONNECT_TIME = 2000;
-const waitForReconnectedDevice = async ({
-  bootloader,
-  method,
-  intermediary
-}, {
-  deviceList,
-  device,
-  registerEvents,
-  postMessage,
-  log,
-  abortSignal,
-  uiPromises
-}) => {
-  const target = intermediary || !bootloader ? 'normal' : 'bootloader';
-  let i = 0;
-  if (method !== 'auto') {
-    log.debug('onCallFirmwareUpdate', 'waiting for device to disconnect');
-    postMessage(createUiMessage(UI_REQUEST.FIRMWARE_RECONNECT, {
-      device: device.toMessageObject(),
-      disconnected: false,
-      method,
-      target,
-      i
-    }));
-    await new Promise(resolve => {
-      deviceList.once('device-disconnect', resolve);
-    });
-  }
-  log.debug('onCallFirmwareUpdate', `waiting for device to reconnect in ${bootloader ? 'bootloader' : 'normal'} mode`);
-  let reconnectedDevice;
-  let thpPairingError = false;
-  let skipWaitTime = false;
-  do {
-    postMessage(createUiMessage(UI_REQUEST.FIRMWARE_RECONNECT, {
-      device: device.toMessageObject(),
-      disconnected: true,
-      method,
-      target,
-      i
-    }));
-    await resolveAfter(skipWaitTime ? 0 : WAIT_FOR_RECONNECT_TIME);
-    skipWaitTime = false;
-    try {
-      reconnectedDevice = deviceList.getOnlyDevice(device.descriptor.apiType);
-    } catch {}
-    if (reconnectedDevice && !reconnectedDevice.features) {
-      log.debug('onCallFirmwareUpdate', 'we were unable to read device.features on the first interaction after seeing it, retrying...');
-      let runFn;
-      if (reconnectedDevice.getThpState()?.properties) {
-        try {
-          await waitForThpPairingConfirmation({
-            uiPromises,
-            postMessage,
-            device: reconnectedDevice,
-            deviceList,
-            thpPairingError,
-            abortSignal
-          });
-        } catch (e) {
-          if (e.code === 'Device_Disconnected') {
-            continue;
-          }
-          throw e;
-        }
-        runFn = () => Promise.resolve();
-      }
-      try {
-        registerEvents(reconnectedDevice);
-        await reconnectedDevice.run(runFn, {
-          skipFirmwareChecks: true,
-          skipLanguageChecks: true
-        });
-      } catch (error) {
-        uiPromises.rejectAll(error);
-        thpPairingError = error.code === 'Device_ThpPairingTagInvalid';
-        if (thpPairingError || error.code === 'Failure_ActionCancelled') {
-          skipWaitTime = true;
-        }
-      }
-    }
-    i++;
-    log.debug('onCallFirmwareUpdate', '...still waiting for device to reconnect', i);
-  } while (!abortSignal.aborted && (!reconnectedDevice?.features || bootloader === !reconnectedDevice.features.bootloader_mode || intermediary && !isNewer(getFirmwareOrBootloaderVersionArray(reconnectedDevice.features), getFirmwareOrBootloaderVersionArray(device.features))));
-  if (!reconnectedDevice) {
-    throw ERRORS.TypedError('Method_Interrupted');
-  }
-  registerEvents(reconnectedDevice);
-  await reconnectedDevice.currentRun;
-  if (!reconnectedDevice.isUsedHere()) {
-    await reconnectedDevice.acquire();
-  }
-  return reconnectedDevice;
-};
-const waitForBluetoothReboot = ({
-  device,
-  target,
-  postMessage
-}) => new Promise(resolve => {
-  postMessage(createUiMessage(UI_REQUEST.FIRMWARE_RECONNECT, {
-    device: device.toMessageObject(),
-    disconnected: false,
-    method: 'auto',
-    target,
-    i: 0
-  }));
-  const handler = () => {
-    const deviceIsReady = target === 'bootloader' && device.features?.bootloader_mode || target === 'normal' && device.getThpState()?.properties;
-    if (deviceIsReady) {
-      device.lifecycle.off('device-changed', handler);
-      resolve();
-    }
-  };
-  device.lifecycle.on('device-changed', handler);
-});
-const getInstallationParams = (device, params) => {
-  const btcOnly = params.btcOnly ?? device.firmwareType === FirmwareType.BitcoinOnly;
-  if (!device.features.bootloader_mode) {
-    const version = params.binary ? parseFirmwareHeaders(Buffer.from(params.binary)).version : undefined;
-    const isUpdatingToNewerVersion = !version ? device.firmwareReleaseConfigInfo?.isNewer : isNewer(version, getFirmwareOrBootloaderVersionArray(device.features));
-    const isUpdatingToEqualFirmwareType = device.firmwareType === FirmwareType.BitcoinOnly === btcOnly;
-    const upgrade = device.atLeast('2.6.3') && isUpdatingToNewerVersion && isUpdatingToEqualFirmwareType;
-    const manual = !device.atLeast(['1.10.0', '2.6.0']) && !upgrade;
-    const getUpdateFlowType = () => {
-      if (manual) return 'manual';
-      return upgrade ? 'reboot_and_upgrade' : 'reboot_and_wait';
-    };
-    return {
-      manual,
-      upgrade,
-      updateFlowType: getUpdateFlowType(),
-      btcOnly
-    };
-  } else {
-    return {
-      manual: false,
-      upgrade: false,
-      updateFlowType: 'unknown_flow',
-      btcOnly
-    };
-  }
-};
-const getFwHeader = binary => Buffer.from(binary.slice(0, 6000)).toString('hex');
-const getBinaryHelper = async ({
-  device,
-  params,
-  firmwareType,
-  isIntermediary,
-  log
-}) => {
-  if (params.binary) {
-    return Promise.resolve({
-      binary: params.binary,
-      binaryVersion: parseFirmwareHeaders(Buffer.from(params.binary)).version,
-      release: undefined
-    });
-  }
-  if (!device.firmwareReleaseConfigInfo) {
-    throw ERRORS.TypedError('Runtime', 'device.firmwareReleaseConfigInfo is not set');
-  }
-  const deviceModel = device.features?.internal_model;
-  const {
-    release: {
-      version
-    },
-    intermediary
-  } = device.firmwareReleaseConfigInfo;
-  log.debug('onCallFirmwareUpdate loading binary', 'isIntermediary', isIntermediary, 'version', version, 'firmwareType', firmwareType, 'deviceModel', deviceModel);
-  const release = await getReleaseByVersion(device.features, version, firmwareType);
-  if (!release) {
-    throw new Error('Missing Firmware release for device');
-  }
-  const {
-    baseUrl,
-    path
-  } = getFirmwareLocation({
-    firmwareVersion: version,
-    remotePath: release.url,
-    deviceModel,
-    firmwareType,
-    intermediaryVersion: isIntermediary && intermediary ? intermediary.version : undefined
-  });
-  return getBinary({
-    baseUrl,
-    path,
-    release
-  });
-};
-export const onCallFirmwareUpdate = async ({
-  params,
-  context
-}) => {
-  const {
-    deviceList,
-    registerEvents,
-    postMessage,
-    selectDevice,
-    log
-  } = context;
-  log.debug('onCallFirmwareUpdate with params: ', params);
-  const firmwareType = params.btcOnly ? FirmwareType.BitcoinOnly : FirmwareType.Universal;
-  const device = selectDevice(params?.device?.path);
-  if (!device.features) {
-    throw ERRORS.TypedError('Device_NotFound', 'Device missing features');
-  }
-  if (deviceList.getDeviceCount() > 1 && !deviceList.getOnlyDevice(device.descriptor.apiType)) {
-    throw ERRORS.TypedError('Device_MultipleNotSupported', 'Firmware update allowed with only 1 device connected');
-  }
-  log.debug('onCallFirmwareUpdate', 'device', device);
-  registerEvents(device);
-  const {
-    manual,
-    upgrade,
-    updateFlowType,
-    btcOnly
-  } = getInstallationParams(device, params);
-  log.debug('onCallFirmwareUpdate', 'installation params', {
-    manual,
-    upgrade,
-    updateFlowType,
-    btcOnly
-  });
-  const intermediary = !params.binary && device?.firmwareReleaseConfigInfo?.intermediary;
-  postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-    device: device.toMessageObject(),
-    operation: 'downloading',
-    progress: 0
-  }));
-  let intermediaryBinaryInfo;
-  let finalBinaryInfo;
-  const fwFetchPromises = [];
-  if (intermediary) {
-    fwFetchPromises.push(getBinaryHelper({
-      device,
-      params,
-      firmwareType,
-      isIntermediary: true,
-      log
-    }));
-  }
-  fwFetchPromises.push(getBinaryHelper({
-    device,
-    params,
-    firmwareType,
-    isIntermediary: false,
-    log
-  }));
-  const [firstResult, finalResult] = await Promise.all(fwFetchPromises);
-  if (intermediary) {
-    intermediaryBinaryInfo = firstResult;
-    finalBinaryInfo = finalResult;
-  } else {
-    finalBinaryInfo = firstResult;
-  }
-  const firstBinaryInfo = intermediary ? intermediaryBinaryInfo : finalBinaryInfo;
-  if (!firstBinaryInfo) {
-    throw new Error('Missing binary, something went wrong.');
-  }
-  postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
-    device: device.toMessageObject(),
-    operation: 'downloading',
-    progress: 100
-  }));
-  if (isFirmwareCacheUsedForSelectedSource(settingsStore.get('firmwareChannel')) && finalBinaryInfo.release) {
-    const message = createUiMessage(UI_REQUEST.FIRMWARE_DOWNLOADED, {
-      binary: finalBinaryInfo.binary,
-      binaryVersion: finalBinaryInfo.binaryVersion,
-      releaseVersion: finalBinaryInfo.release?.version,
-      firmwareType,
-      release: finalBinaryInfo.release,
-      internalModel: device.features.internal_model
-    });
-    postMessage(message);
-  }
-  const deviceInitiallyConnectedInBootloader = device.features.bootloader_mode;
-  let reconnectedDevice = device;
-  if (deviceInitiallyConnectedInBootloader) {
-    log.warn('onCallFirmwareUpdate', 'device is already in bootloader mode.');
-    await device.acquire();
-  } else if (manual) {
-    reconnectedDevice = await waitForReconnectedDevice({
-      bootloader: true,
-      method: 'manual'
-    }, {
-      ...context,
-      device
-    });
-  } else {
-    const rebootParams = upgrade ? {
-      boot_command: PROTO.BootCommand.INSTALL_UPGRADE,
-      firmware_header: getFwHeader(firstBinaryInfo.binary)
-    } : {};
-    await device.acquire();
-    const disconnectedPromise = new Promise(resolve => {
-      deviceList.once('device-disconnect', resolve);
-    });
-    await device.getCommands().typedCall('RebootToBootloader', 'Success', rebootParams);
-    log.info('onCallFirmwareUpdate', 'waiting for disconnected event after rebootToBootloader...');
-    if (device.descriptor.apiType === 'bluetooth') {
-      await device.release();
-      await waitForBluetoothReboot({
-        device,
-        target: 'bootloader',
-        postMessage
-      });
-    } else {
-      await disconnectedPromise;
-      if (device.features.major_version === 1) {
-        await resolveAfter(2000);
-      }
-    }
-    reconnectedDevice = await waitForReconnectedDevice({
-      bootloader: true,
-      method: 'auto'
-    }, {
-      ...context,
-      device
-    });
-  }
-  const bootloaderVersion = reconnectedDevice.getVersion();
-  await reconnectedDevice.initialize(false);
-  let stripped = stripFwHeaders(firstBinaryInfo.binary);
-  const payload = !intermediary && shouldStripFwHeaders(device.features) ? stripped : firstBinaryInfo.binary;
-  await uploadFirmware({
-    typedCall: reconnectedDevice.getCommands().typedCall,
-    postMessage,
-    device: reconnectedDevice,
-    firmwareUploadRequest: {
-      payload
-    },
-    updateFlowType
-  });
-  log.info('onCallFirmwareUpdate', 'firmware uploaded');
-  if (intermediary) {
-    log.info('onCallFirmwareUpdate', '...but it was the intermediary firmware, so one more go');
-    reconnectedDevice = await waitForReconnectedDevice({
-      bootloader: true,
-      method: 'manual',
-      intermediary: true
-    }, {
-      ...context,
-      device: reconnectedDevice
-    });
-    stripped = stripFwHeaders(finalBinaryInfo.binary);
-    await reconnectedDevice.initialize(false);
-    await uploadFirmware({
-      typedCall: reconnectedDevice.getCommands().typedCall,
-      postMessage,
-      device: reconnectedDevice,
-      firmwareUploadRequest: {
-        payload: stripped
-      },
-      updateFlowType
-    });
-  }
-  let method = 'wait';
-  if (device.descriptor.apiType === 'bluetooth') {
-    await waitForBluetoothReboot({
-      device,
-      target: 'normal',
-      postMessage
-    });
-    method = 'auto';
-  }
-  reconnectedDevice = await waitForReconnectedDevice({
-    bootloader: false,
-    method
-  }, {
-    ...context,
-    device: reconnectedDevice
-  });
-  const installedVersion = reconnectedDevice.getVersion();
-  if (!bootloaderVersion || !installedVersion) {
-    throw ERRORS.TypedError('Runtime', 'reconnectedDevice.installedVersion is not set');
-  }
-  const {
-    binaryVersion,
-    release
-  } = finalBinaryInfo;
-  const assertBinaryVersion = isEqual(installedVersion, binaryVersion);
-  const assertReleaseVersion = release?.version ? isEqual(installedVersion, release?.version) : true;
-  await reconnectedDevice.release();
-  log.info('onCallFirmwareUpdate', `firmware updated to version ${installedVersion}`);
-  return {
-    versionCheck: assertBinaryVersion && assertReleaseVersion,
-    bootloaderVersion,
-    installedVersion,
-    binaryVersion,
-    releaseVersion: release?.version
-  };
-};