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

package/lib/backend/Blockchain.js

@@ -0,0 +1,235 @@
+import { BlockchainLink } from "@trezor/blockchain-link";
+import { BLOCKCHAIN, createBlockchainMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { BlockbookWorker, BlockfrostWorker, ElectrumWorker, EvmRpcWorker, RippleWorker, SolanaWorker, StellarWorker } from "../workers/workers.js";
+const getWorker = type => {
+  switch (type) {
+    case 'blockbook':
+      return BlockbookWorker;
+    case 'ripple':
+      return RippleWorker;
+    case 'blockfrost':
+      return BlockfrostWorker;
+    case 'electrum':
+      return ElectrumWorker;
+    case 'solana':
+      return SolanaWorker;
+    case 'stellar':
+      return StellarWorker;
+    case 'evm-rpc':
+      return EvmRpcWorker;
+    default:
+      return null;
+  }
+};
+const getNormalizedTrezorShortcut = shortcut => {
+  if (shortcut === 'tXRP') {
+    return 'XRP';
+  }
+  return shortcut;
+};
+export class Blockchain {
+  link;
+  serverInfo;
+  identity;
+  coinInfo;
+  postMessage;
+  onDisconnected;
+  initPromise;
+  constructor(options) {
+    this.identity = options.identity;
+    this.coinInfo = options.coinInfo;
+    this.postMessage = options.postMessage;
+    this.onDisconnected = options.onDisconnected;
+    const {
+      blockchainLink
+    } = options.coinInfo;
+    if (!blockchainLink) {
+      throw ERRORS.TypedError('Backend_NotSupported');
+    }
+    const worker = getWorker(blockchainLink.type);
+    if (!worker) {
+      throw ERRORS.TypedError('Backend_WorkerMissing', `BlockchainLink worker not found ${blockchainLink.type}`);
+    }
+    const server = blockchainLink.url;
+    this.link = new BlockchainLink({
+      name: this.coinInfo.shortcut,
+      worker,
+      server,
+      debug: options.debug,
+      proxy: options.proxy,
+      ...(this.coinInfo.type === 'ethereum' ? {
+        throttleBlockEvent: 10 * 1000
+      } : {}),
+      ...(['ripple', 'stellar'].includes(blockchainLink.type) ? {
+        throttleBlockEvent: 60 * 1000
+      } : {})
+    });
+  }
+  onBackendDisconnected(pendingSubscriptions = false) {
+    this.postMessage(createBlockchainMessage(BLOCKCHAIN.ERROR, {
+      coin: this.coinInfo,
+      identity: this.identity,
+      error: ERRORS.ERROR_CODES.Backend_Disconnected,
+      code: 'Backend_Disconnected'
+    }));
+    this.onDisconnected?.(!!pendingSubscriptions);
+  }
+  async initLink() {
+    let info;
+    try {
+      await this.link.connect();
+      info = await this.link.getInfo();
+    } catch (error) {
+      throw ERRORS.TypedError('Backend_Error', error.message);
+    }
+    this.serverInfo = info;
+    const trezorNetworkShortcut = getNormalizedTrezorShortcut(this.coinInfo.shortcut);
+    const backendNetworkShortcut = this.serverInfo.network;
+    if (backendNetworkShortcut.toLowerCase() !== trezorNetworkShortcut.toLowerCase()) {
+      throw ERRORS.TypedError('Backend_Invalid');
+    }
+    this.link.on('disconnected', () => {
+      const pendingSubscriptions = this.link.listenerCount('block') || this.link.listenerCount('notification') || this.link.listenerCount('fiatRates');
+      this.link.dispose();
+      this.onBackendDisconnected(!!pendingSubscriptions);
+    });
+    return info;
+  }
+  init() {
+    if (!this.initPromise) {
+      this.initPromise = this.initLink().then(info => {
+        this.postMessage(createBlockchainMessage(BLOCKCHAIN.CONNECT, {
+          coin: this.coinInfo,
+          identity: this.identity,
+          ...info
+        }));
+        this.initPromise = Promise.resolve(info);
+        return info;
+      }).catch(error => {
+        this.postMessage(createBlockchainMessage(BLOCKCHAIN.ERROR, {
+          coin: this.coinInfo,
+          identity: this.identity,
+          error: error.message,
+          code: error.code
+        }));
+        this.initPromise = Promise.reject(error);
+        this.link.dispose();
+        return this.initPromise;
+      });
+    }
+    return this.initPromise;
+  }
+  getTransactions(txs, descriptor) {
+    return Promise.all(txs.map(txid => this.link.getTransaction({
+      txid,
+      descriptor
+    })));
+  }
+  getTransactionHexes(txids) {
+    return Promise.all(txids.map(id => this.link.getTransactionHex(id)));
+  }
+  getCurrentFiatRates(params) {
+    return this.link.getCurrentFiatRates(params);
+  }
+  getContractInfo(params) {
+    return this.link.getContractInfo(params);
+  }
+  getFiatRatesForTimestamps(params) {
+    return this.link.getFiatRatesForTimestamps(params);
+  }
+  getAccountBalanceHistory(params) {
+    return this.link.getAccountBalanceHistory(params);
+  }
+  getNetworkInfo() {
+    return this.link.getInfo();
+  }
+  getAccountInfo(request) {
+    return this.link.getAccountInfo(request);
+  }
+  getAccountUtxo(descriptor) {
+    return this.link.getAccountUtxo(descriptor);
+  }
+  rpcCall(params) {
+    return this.link.rpcCall(params);
+  }
+  estimateFee(request) {
+    return this.link.estimateFee(request);
+  }
+  subscribeBlocks() {
+    if (this.link.listenerCount('block') === 0) {
+      this.link.on('block', block => {
+        this.postMessage(createBlockchainMessage(BLOCKCHAIN.BLOCK, {
+          coin: this.coinInfo,
+          ...block
+        }));
+      });
+    }
+    return this.link.subscribe({
+      type: 'block'
+    });
+  }
+  subscribeAccounts(accounts) {
+    if (this.link.listenerCount('notification') === 0) {
+      this.link.on('notification', notification => {
+        this.postMessage(createBlockchainMessage(BLOCKCHAIN.NOTIFICATION, {
+          coin: this.coinInfo,
+          notification
+        }));
+      });
+    }
+    return this.link.subscribe({
+      type: 'accounts',
+      accounts
+    });
+  }
+  subscribeFiatRates(_currency) {
+    if (this.link.listenerCount('fiatRates') === 0) {
+      this.link.on('fiatRates', ({
+        rates
+      }) => {
+        this.postMessage(createBlockchainMessage(BLOCKCHAIN.FIAT_RATES_UPDATE, {
+          coin: this.coinInfo,
+          rates
+        }));
+      });
+    }
+    return this.link.subscribe({
+      type: 'fiatRates'
+    });
+  }
+  unsubscribeBlocks() {
+    this.link.removeAllListeners('block');
+    return this.link.unsubscribe({
+      type: 'block'
+    });
+  }
+  unsubscribeAccounts(accounts) {
+    return this.link.unsubscribe({
+      type: 'accounts',
+      accounts
+    });
+  }
+  unsubscribeFiatRates() {
+    this.link.removeAllListeners('fiatRates');
+    return this.link.unsubscribe({
+      type: 'fiatRates'
+    });
+  }
+  async unsubscribeAll() {
+    this.link.removeAllListeners('notification');
+    await this.unsubscribeFiatRates();
+    return this.unsubscribeBlocks();
+  }
+  pushTransaction(tx) {
+    const data = typeof tx === 'string' ? {
+      hex: tx
+    } : tx;
+    return this.link.pushTransaction(data);
+  }
+  disconnect() {
+    this.link.removeAllListeners();
+    this.link.disconnect().then(() => this.link.dispose());
+    this.onBackendDisconnected();
+  }
+}

package/lib/backend/BlockchainLink.d.ts

@@ -0,0 +1,10 @@
+import type { CoinInfo, Proxy } from '@trezor/connect-common';
+import type { BlockchainOptions as Options } from "./Blockchain.js";
+export { Blockchain } from "./Blockchain.js";
+export declare const findBackend: (coin: string, identity?: string) => import("./Blockchain").Blockchain | null;
+export declare const setCustomBackend: (coinInfo: CoinInfo, blockchainLink: CoinInfo["blockchainLink"]) => void;
+export declare const assertBackendSupported: (coinInfo: CoinInfo) => void;
+export declare const initBlockchain: (coinInfo: CoinInfo, postMessage: Options["postMessage"], identity?: string) => Promise<import("./Blockchain").Blockchain>;
+export declare const reconnectAllBackends: (coinInfo?: CoinInfo) => Promise<import("./Blockchain").Blockchain[]>;
+export declare const updateProxy: (proxy?: Proxy) => Promise<void>;
+export declare const dispose: () => void;

package/lib/backend/BlockchainLink.js

@@ -0,0 +1,19 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { BackendManager } from "./BackendManager.js";
+export { Blockchain } from "./Blockchain.js";
+const backends = new BackendManager();
+export const findBackend = (coin, identity) => backends.get(coin, identity);
+export const setCustomBackend = (coinInfo, blockchainLink) => backends.setCustom(coinInfo.shortcut, blockchainLink?.url.length ? blockchainLink : coinInfo.blockchainLink);
+export const assertBackendSupported = coinInfo => {
+  if (!backends.isSupported(coinInfo)) {
+    throw ERRORS.TypedError('Backend_NotSupported');
+  }
+};
+export const initBlockchain = (coinInfo, postMessage, identity) => backends.getOrConnect({
+  coinInfo,
+  identity,
+  postMessage
+});
+export const reconnectAllBackends = coinInfo => backends.reconnectAll(coinInfo);
+export const updateProxy = proxy => backends.updateProxy(proxy);
+export const dispose = () => backends.dispose();

package/lib/backend/fees/BitcoinFeeLevels.d.ts

@@ -0,0 +1,19 @@
+import type { BitcoinNetworkInfo } from '@trezor/connect-common';
+import type { Blockchain } from "../Blockchain.js";
+import { MiscFeeLevels } from "./MiscFeeLevels.js";
+export declare class BitcoinFeeLevels extends MiscFeeLevels {
+  coinInfo: BitcoinNetworkInfo;
+  longTermFeeRate: string;
+  constructor(coinInfo: BitcoinNetworkInfo);
+  load(blockchain: Blockchain): Promise<{
+    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;
+  }[]>;
+  updateBitcoinCustomFee(feePerUnit: string): void;
+}

package/lib/backend/fees/BitcoinFeeLevels.js

@@ -0,0 +1,44 @@
+import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
+import { clamp } from "@trezor/utils/lib/number.js";
+import { MiscFeeLevels } from "./MiscFeeLevels.js";
+import { DEFAULT_BITCOIN_LONGTERM_FEE_RATE } from "../../data/defaultFeeLevels.js";
+export class BitcoinFeeLevels extends MiscFeeLevels {
+  coinInfo;
+  longTermFeeRate;
+  constructor(coinInfo) {
+    super(coinInfo);
+    this.coinInfo = coinInfo;
+    this.longTermFeeRate = DEFAULT_BITCOIN_LONGTERM_FEE_RATE;
+  }
+  async load(blockchain) {
+    try {
+      const {
+        minFee,
+        maxFee
+      } = this.coinInfo;
+      const blocks = this.levels.map(level => level.blocks).filter(b => b > 0);
+      const response = await blockchain.estimateFee({
+        blocks
+      });
+      response.forEach(({
+        feePerUnit: feePerKB
+      }, index) => {
+        const feePerB = new BigNumber(feePerKB).div(1000).toNumber();
+        if (isNaN(feePerB) || feePerB < 0) return;
+        const trimmedFeePerUnit = clamp(feePerB, minFee, maxFee);
+        const level = this.levels[index];
+        level.feePerUnit = trimmedFeePerUnit.toString();
+      });
+      this.wasFetchedSuccessfully = true;
+    } catch {}
+    return this.levels;
+  }
+  updateBitcoinCustomFee(feePerUnit) {
+    this.levels = this.levels.filter(l => l.label !== 'custom');
+    this.levels.push({
+      label: 'custom',
+      feePerUnit,
+      blocks: -1
+    });
+  }
+}

package/lib/backend/fees/EthereumFeeLevels.d.ts

@@ -0,0 +1,17 @@
+import type { EthereumNetworkInfo } from '@trezor/connect-common';
+import type { Blockchain } from "../Blockchain.js";
+import { MiscFeeLevels } from "./MiscFeeLevels.js";
+export declare class EthereumFeeLevels extends MiscFeeLevels {
+  coinInfo: EthereumNetworkInfo;
+  constructor(coinInfo: EthereumNetworkInfo);
+  load(blockchain: Blockchain, request: Parameters<typeof blockchain.estimateFee>[0]): Promise<{
+    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;
+  }[]>;
+}

package/lib/backend/fees/EthereumFeeLevels.js

@@ -0,0 +1,63 @@
+import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
+import { clamp } from "@trezor/utils/lib/number.js";
+import { MiscFeeLevels } from "./MiscFeeLevels.js";
+export class EthereumFeeLevels extends MiscFeeLevels {
+  coinInfo;
+  constructor(coinInfo) {
+    super(coinInfo);
+    this.coinInfo = coinInfo;
+  }
+  async load(blockchain, request) {
+    try {
+      const estimateResult = await blockchain.estimateFee(request);
+      const response = estimateResult[0];
+      const maxFeeInWei = new BigNumber(this.coinInfo.maxFee).multipliedBy('1e+9').toNumber();
+      const minFeeInWei = new BigNumber(this.coinInfo.minFee).multipliedBy('1e+9').toNumber();
+      const feeInWei = new BigNumber(response.feePerUnit).toNumber();
+      const feePerUnit = new BigNumber(clamp(feeInWei, minFeeInWei, maxFeeInWei)).toFixed(0);
+      const {
+        eip1559
+      } = response;
+      if (eip1559?.baseFeePerGas) {
+        const minMaxPriorityFeePerGas = new BigNumber(this.coinInfo.minPriorityFee).multipliedBy('1e+9').toNumber();
+        const defaultBlocks = {
+          low: 4,
+          medium: 2,
+          high: 1
+        };
+        const levels = ['low', 'medium', 'high'].map(levelKey => {
+          const level = eip1559[levelKey];
+          const label = levelKey === 'medium' ? 'normal' : levelKey;
+          if (!level?.maxFeePerGas || !level?.maxPriorityFeePerGas) {
+            return null;
+          }
+          const maxFeePerGas = BigNumber.max(minFeeInWei, level.maxFeePerGas, minMaxPriorityFeePerGas).toFixed(0);
+          const maxPriorityFeePerGas = BigNumber.max(minMaxPriorityFeePerGas, BigNumber.min(maxFeePerGas, level.maxPriorityFeePerGas)).toFixed(0);
+          const blocksFromWaitTime = level.maxWaitTimeEstimate ? Math.ceil(level.maxWaitTimeEstimate / 1000 / this.coinInfo.blockTime) : 0;
+          return {
+            label,
+            feePerUnit,
+            feeLimit: response.feeLimit,
+            blocks: blocksFromWaitTime || defaultBlocks[levelKey],
+            baseFeePerGas: eip1559.baseFeePerGas,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+          };
+        });
+        this.levels = levels.filter(level => level);
+      } else {
+        const {
+          levels
+        } = this;
+        const currentLevel = levels[0];
+        this.levels[0] = {
+          ...currentLevel,
+          ...response,
+          feePerUnit
+        };
+      }
+      this.wasFetchedSuccessfully = true;
+    } catch {}
+    return this.levels;
+  }
+}

package/lib/backend/fees/MiscFeeLevels.d.ts

@@ -0,0 +1,18 @@
+import type { CoinInfo, FeeLevel } from '@trezor/connect-common';
+import type { Blockchain } from "../Blockchain.js";
+export declare class MiscFeeLevels {
+  coinInfo: CoinInfo;
+  levels: FeeLevel[];
+  wasFetchedSuccessfully: boolean;
+  constructor(coinInfo: CoinInfo);
+  load(blockchain: Blockchain, request: Parameters<typeof blockchain.estimateFee>[0]): Promise<{
+    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;
+  }[]>;
+}

package/lib/backend/fees/MiscFeeLevels.js

@@ -0,0 +1,30 @@
+import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
+import { cloneObject } from "@trezor/utils/lib/cloneObject.js";
+export class MiscFeeLevels {
+  coinInfo;
+  levels;
+  wasFetchedSuccessfully = false;
+  constructor(coinInfo) {
+    this.coinInfo = coinInfo;
+    this.levels = cloneObject(coinInfo.defaultFees);
+  }
+  async load(blockchain, request) {
+    try {
+      const estimateResult = await blockchain.estimateFee(request);
+      const response = estimateResult[0];
+      const fee = new BigNumber(response.feePerUnit).toNumber();
+      const feePerUnit = Math.min(this.coinInfo.maxFee, Math.max(this.coinInfo.minFee, fee)).toString();
+      const {
+        levels
+      } = this;
+      const currentLevel = levels[0];
+      this.levels[0] = {
+        ...currentLevel,
+        ...response,
+        feePerUnit
+      };
+      this.wasFetchedSuccessfully = true;
+    } catch {}
+    return this.levels;
+  }
+}

package/lib/backend/fees/index.d.ts

@@ -0,0 +1,5 @@
+import type { BitcoinNetworkInfo, CoinInfo } from '@trezor/connect-common';
+import { BitcoinFeeLevels } from "./BitcoinFeeLevels.js";
+import { MiscFeeLevels } from "./MiscFeeLevels.js";
+export declare const getOrInitFeeLevels: (coinInfo: CoinInfo) => MiscFeeLevels;
+export declare const getOrInitBitcoinFeeLevels: (coinInfo: BitcoinNetworkInfo) => BitcoinFeeLevels;

package/lib/backend/fees/index.js

@@ -0,0 +1,31 @@
+import { exhaustive } from "@trezor/type-utils";
+import { BitcoinFeeLevels } from "./BitcoinFeeLevels.js";
+import { EthereumFeeLevels } from "./EthereumFeeLevels.js";
+import { MiscFeeLevels } from "./MiscFeeLevels.js";
+const instancesPerCoin = {};
+const feeLevelsPerTypeFactory = coinInfo => {
+  const {
+    type
+  } = coinInfo;
+  switch (type) {
+    case 'bitcoin':
+      return new BitcoinFeeLevels(coinInfo);
+    case 'ethereum':
+      return new EthereumFeeLevels(coinInfo);
+    case 'misc':
+      return new MiscFeeLevels(coinInfo);
+    default:
+      return exhaustive(type);
+  }
+};
+export const getOrInitFeeLevels = coinInfo => {
+  const {
+    shortcut
+  } = coinInfo;
+  if (!Object.prototype.hasOwnProperty.call(instancesPerCoin, shortcut)) {
+    instancesPerCoin[shortcut] = feeLevelsPerTypeFactory(coinInfo);
+  }
+  const instance = instancesPerCoin[shortcut];
+  return instance;
+};
+export const getOrInitBitcoinFeeLevels = coinInfo => getOrInitFeeLevels(coinInfo);

package/lib/core/AbstractMethod.d.ts

@@ -0,0 +1,63 @@
+import { UI_REQUEST } from '@trezor/connect-common';
+import type { CallMethodPayload, CallMethodResponse, CoinInfo, CoreEventMessage, DeviceState, FirmwareCapability, MethodInfo, MethodPermission, PermissionRequest, PrecomposeResultFinal, UiRequestButtonData, UiRequestConfirmation } from '@trezor/connect-common';
+import type { Capability } from '@trezor/protobuf/lib/definitions';
+import { DEFAULT_FIRMWARE_RANGE } from "../api/common/paramsValidator.js";
+import type { Device } from "../device/Device.js";
+import type { UiPromiseCreator } from "../events/ui-promise.js";
+export { DEFAULT_FIRMWARE_RANGE };
+export type Payload<M> = Extract<CallMethodPayload, {
+  method: M;
+}> & {
+  override?: boolean;
+};
+export type MethodReturnType<M extends CallMethodPayload['method']> = CallMethodResponse<M>;
+export type DeviceMode = typeof UI_REQUEST.SEEDLESS | typeof UI_REQUEST.BOOTLOADER | typeof UI_REQUEST.INITIALIZE;
+export type MethodContext = {
+  sendCoreMessage: (message: CoreEventMessage) => void;
+  createUiPromise: UiPromiseCreator;
+};
+export type MethodMessage<Name extends CallMethodPayload['method']> = {
+  id?: string;
+  payload: Payload<Name>;
+};
+export declare abstract class AbstractMethod<Name extends CallMethodPayload['method'], Params = undefined> {
+  responseID: string;
+  callId?: string;
+  device: Device | undefined;
+  protected params: Params;
+  deviceState?: DeviceState;
+  keepSession: boolean;
+  skipFinalReload: boolean;
+  overridePreviousCall: boolean;
+  overridden: boolean;
+  readonly name: Name;
+  protected get info(): string;
+  protected get confirmation(): UiRequestConfirmation['payload'] | undefined;
+  useUi: boolean;
+  useDevice: boolean;
+  useDeviceState: boolean;
+  preauthorized?: boolean;
+  useEmptyPassphrase: boolean;
+  abstract get requiredPermissions(): PermissionRequest[];
+  private toCoinSymbol;
+  protected coinPerm(permission: MethodPermission, coin?: CoinInfo): PermissionRequest;
+  protected coinPerms(permission: MethodPermission, coins: (CoinInfo | undefined)[]): PermissionRequest[];
+  allowDeviceMode: DeviceMode[];
+  protected requiredDeviceCapabilities: Capability[];
+  protected requiredFirmwareCapabilities: FirmwareCapability[];
+  protected requiredFirmwareCoins: (CoinInfo | undefined)[];
+  useCardanoDerivation: boolean;
+  confirmMissingBackup: boolean;
+  getButtonRequestData?(code: string, name?: string): UiRequestButtonData | undefined;
+  initAsync?(): Promise<void>;
+  constructor(message: MethodMessage<Name>, params: Params);
+  resolveCardanoCapability(): void;
+  setDevice(device: Device): void;
+  getDevice(): Device;
+  checkFirmwareRange(): "ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined;
+  getMethodInfo(): MethodInfo;
+  payloadToPrecomposed(): Promise<PrecomposeResultFinal | undefined>;
+  checkDeviceCapability(): void;
+  abstract run(context: MethodContext): Promise<MethodReturnType<Name>>;
+  dispose(): void;
+}