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

package/lib/core/method.d.ts

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

package/lib/core/method.js

@@ -1,19 +0,0 @@
-import { TypedError } from "@trezor/connect-common/lib/constants/errors.js";
-import { MODULES } from "@trezor/connect-common/lib/constants/network.js";
-import * as Methods from "../api/index.js";
-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/lib/core/method.native.d.ts

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

package/lib/core/method.native.js

@@ -1,29 +0,0 @@
-import { TypedError } from "@trezor/connect-common/lib/constants/errors.js";
-import { MODULES } from "@trezor/connect-common/lib/constants/network.js";
-import * as Methods from "../api/index.js";
-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/lib/core/onCallFirmwareUpdate.d.ts

@@ -1,42 +0,0 @@
-import type { CommonParams, CoreEventMessage, DeviceUniquePath, FirmwareUpdateResponse } from '@trezor/connect-common';
-import { type Logger } from '@trezor/utils';
-import type { Device } from "../device/Device.js";
-import type { DeviceList } from "../device/DeviceList.js";
-import type { UiPromiseCreator } from "../events/ui-promise.js";
-type PostMessage = (message: CoreEventMessage) => void;
-type ReconnectContext = {
-  deviceList: DeviceList;
-  device: Device;
-  registerEvents: (device: Device) => void;
-  postMessage: PostMessage;
-  log: Logger;
-  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: Logger;
-  abortSignal: AbortSignal;
-  uiPromises: ReconnectContext['uiPromises'];
-};
-type OnCallFirmwareUpdateParams = {
-  params: Params;
-  context: Context;
-};
-export declare const onCallFirmwareUpdate: ({
-  params,
-  context
-}: OnCallFirmwareUpdateParams) => Promise<FirmwareUpdateResponse>;
-export {};

package/lib/core/onCallFirmwareUpdate.js

@@ -1,436 +0,0 @@
-import { FirmwareType, UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { getFirmwareOrBootloaderVersionArray } from "@trezor/device-utils";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { resolveAfter } from "@trezor/utils";
-import { isEqual, isNewer } from "@trezor/utils/lib/versionUtils.js";
-import { getBinary, parseFirmwareHeaders, shouldStripFwHeaders, stripFwHeaders, uploadFirmware } from "../api/firmware/index.js";
-import { getFirmwareLocation, getReleaseByVersion } from "../data/firmwareInfo.js";
-import * as settingsStore from "../data/settingsStore.js";
-import { isFirmwareCacheUsedForSelectedSource } from "../utils/firmwareUtils.js";
-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
-  };
-};

package/lib/data/coinInfo.d.ts

@@ -1,101 +0,0 @@
-import type { BitcoinNetworkInfo, CoinInfo, CoinSymbol, EthereumNetworkInfo, MiscNetworkInfo } from '@trezor/connect-common/lib/types/coinInfo';
-export declare const getBitcoinNetwork: (symbolOrPath: CoinSymbol | number[]) => Readonly<BitcoinNetworkInfo> | undefined;
-export declare const getEthereumNetwork: (symbolOrPath: CoinSymbol | number[]) => Readonly<EthereumNetworkInfo> | undefined;
-export declare const getMiscNetwork: (symbolOrPath: CoinSymbol | number[]) => Readonly<MiscNetworkInfo> | undefined;
-export declare const getSegwitNetwork: (coin: BitcoinNetworkInfo) => {
-  bip32: {
-    public: number;
-    private: number;
-  };
-  forkId?: number | undefined;
-  messagePrefix: string;
-  bech32: string;
-  pubKeyHash: number;
-  scriptHash: number;
-  wif: number;
-} | null;
-export declare const getBech32Network: (coin: BitcoinNetworkInfo) => {
-  bip32: {
-    public: number;
-    private: number;
-  };
-  forkId?: number | undefined;
-  messagePrefix: string;
-  bech32: string;
-  pubKeyHash: number;
-  scriptHash: number;
-  wif: number;
-} | null;
-export declare const fixCoinInfoNetwork: (ci: BitcoinNetworkInfo, path: number[]) => {
-  blockchainLink?: {
-    type: string;
-    url: string[];
-  } | undefined;
-  label: string;
-  name: string;
-  shortcut: string;
-  slip44: number;
-  support: {
-    T1B1: string | false;
-    T2T1: string | false;
-    T3T1: string | false;
-    T2B1: string | false;
-    T3B1: string | false;
-    T3W1: string | false;
-    UNKNOWN: string | false;
-  };
-  decimals: number;
-  blockTime: number;
-  minFee: number;
-  maxFee: number;
-  minPriorityFee: number;
-  defaultFees: {
-    feePerTx?: string | undefined;
-    feeLimit?: string | undefined;
-    baseFeePerGas?: string | undefined;
-    maxFeePerGas?: string | undefined;
-    maxPriorityFeePerGas?: string | undefined;
-    label: "high" | "normal" | "economy" | "low" | "custom";
-    blocks: number;
-    feePerUnit: string;
-  }[];
-} & {
-  taproot?: boolean | undefined;
-  cashAddrPrefix?: string | undefined;
-  xPubMagicSegwitNative?: number | undefined;
-  xPubMagicSegwit?: number | undefined;
-  type: "bitcoin";
-  curveName: string;
-  dustLimit: number;
-  forceBip143: boolean;
-  hashGenesisBlock: string;
-  maxAddressLength: number;
-  maxFeeSatoshiKb: number;
-  minAddressLength: number;
-  minFeeSatoshiKb: number;
-  segwit: boolean;
-  xPubMagic: number;
-  network: {
-    forkId?: number | undefined;
-    messagePrefix: string;
-    bech32: string;
-    bip32: {
-      public: number;
-      private: number;
-    };
-    pubKeyHash: number;
-    scriptHash: number;
-    wif: number;
-  };
-  isBitcoin: boolean;
-};
-export declare const getCoinInfoOrThrow: (coin: string) => Readonly<CoinInfo>;
-export declare const getCoinName: (path: number[]) => string;
-export declare const ethereumNetworkInfoBase: {
-  type: "ethereum";
-  decimals: number;
-};
-export declare const getUniqueNetworks: <T extends {
-  shortcut: string;
-}>(networks: (T | undefined)[]) => T[];
-export declare const getAllNetworks: () => CoinInfo[];