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

package/lib/core/method.d.ts

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

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

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

package/lib/core/method.native.js

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

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

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

@@ -0,0 +1,101 @@
+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[];