@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/backend/Blockchain.mjs

@@ -0,0 +1,232 @@
+import { BlockchainLink } from "@trezor/blockchain-link";
+import { BLOCKCHAIN, createBlockchainMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { BlockbookWorker, BlockfrostWorker, ElectrumWorker, EvmRpcWorker, RippleWorker, SolanaWorker, StellarWorker } from "../workers/workers.mjs";
+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) {
+    return Promise.all(txs.map(id => this.link.getTransaction(id)));
+  }
+  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/libESM/backend/BlockchainLink.d.mts

@@ -0,0 +1,9 @@
+import type { CoinInfo } from '@trezor/connect-common';
+import type { BlockchainOptions as Options } from './Blockchain';
+export { Blockchain } from './Blockchain';
+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 isBackendSupported: (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 dispose: () => void;

package/libESM/backend/BlockchainLink.mjs

@@ -0,0 +1,13 @@
+import { BackendManager } from "./BackendManager.mjs";
+export { Blockchain } from "./Blockchain.mjs";
+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 isBackendSupported = coinInfo => backends.isSupported(coinInfo);
+export const initBlockchain = (coinInfo, postMessage, identity) => backends.getOrConnect({
+  coinInfo,
+  identity,
+  postMessage
+});
+export const reconnectAllBackends = coinInfo => backends.reconnectAll(coinInfo);
+export const dispose = () => backends.dispose();

package/libESM/backend/fees/BitcoinFeeLevels.d.mts

@@ -0,0 +1,19 @@
+import type { BitcoinNetworkInfo } from '@trezor/connect-common';
+import type { Blockchain } from '../Blockchain';
+import { MiscFeeLevels } from './MiscFeeLevels';
+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/libESM/backend/fees/BitcoinFeeLevels.mjs

@@ -0,0 +1,43 @@
+import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
+import { clamp } from "@trezor/utils/libESM/number.mjs";
+import { MiscFeeLevels } from "./MiscFeeLevels.mjs";
+import { DEFAULT_BITCOIN_LONGTERM_FEE_RATE } from "../../data/defaultFeeLevels.mjs";
+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);
+        this.levels[index].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/libESM/backend/fees/EthereumFeeLevels.d.mts

@@ -0,0 +1,17 @@
+import type { EthereumNetworkInfo } from '@trezor/connect-common';
+import type { Blockchain } from '../Blockchain';
+import { MiscFeeLevels } from './MiscFeeLevels';
+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/libESM/backend/fees/EthereumFeeLevels.mjs

@@ -0,0 +1,52 @@
+import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
+import { clamp } from "@trezor/utils/libESM/number.mjs";
+import { MiscFeeLevels } from "./MiscFeeLevels.mjs";
+export class EthereumFeeLevels extends MiscFeeLevels {
+  coinInfo;
+  constructor(coinInfo) {
+    super(coinInfo);
+    this.coinInfo = coinInfo;
+  }
+  async load(blockchain, request) {
+    try {
+      const [response] = await blockchain.estimateFee(request);
+      const {
+        eip1559
+      } = response;
+      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);
+      if (eip1559?.baseFeePerGas) {
+        const minMaxPriorityFeePerGas = new BigNumber(this.coinInfo.minPriorityFee).multipliedBy('1e+9').toNumber();
+        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);
+          return {
+            label,
+            feePerUnit,
+            feeLimit: response.feeLimit,
+            blocks: Math.ceil(Math.max(1, (level?.maxWaitTimeEstimate || 0) / 1000 / this.coinInfo.blockTime)),
+            baseFeePerGas: eip1559.baseFeePerGas,
+            maxFeePerGas,
+            maxPriorityFeePerGas
+          };
+        });
+        this.levels = levels.filter(level => level);
+      } else {
+        this.levels[0] = {
+          ...this.levels[0],
+          ...response,
+          feePerUnit
+        };
+      }
+      this.wasFetchedSuccessfully = true;
+    } catch {}
+    return this.levels;
+  }
+}

package/libESM/backend/fees/MiscFeeLevels.d.mts

@@ -0,0 +1,18 @@
+import type { CoinInfo, FeeLevel } from '@trezor/connect-common';
+import type { Blockchain } from '../Blockchain';
+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/libESM/backend/fees/MiscFeeLevels.mjs

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

package/libESM/backend/fees/index.d.mts

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

package/libESM/backend/fees/index.mjs

@@ -0,0 +1,30 @@
+import { exhaustive } from "@trezor/type-utils";
+import { BitcoinFeeLevels } from "./BitcoinFeeLevels.mjs";
+import { EthereumFeeLevels } from "./EthereumFeeLevels.mjs";
+import { MiscFeeLevels } from "./MiscFeeLevels.mjs";
+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);
+  }
+  return instancesPerCoin[shortcut];
+};
+export const getOrInitBitcoinFeeLevels = coinInfo => getOrInitFeeLevels(coinInfo);

package/libESM/core/AbstractMethod.d.mts

@@ -0,0 +1,65 @@
+import { UI_REQUEST } from '@trezor/connect-common';
+import type { CallMethodPayload, CallMethodResponse, CoinInfo, CoreEventMessage, DeviceState, FirmwareCapability, MethodInfo, MethodPermission, PrecomposeResultFinal, UiRequestButtonData, UiRequestConfirmation } from '@trezor/connect-common';
+import type { Capability } from '@trezor/protobuf/libESM/definitions';
+import { DEFAULT_FIRMWARE_RANGE } from '../api/common/paramsValidator';
+import type { Device } from '../device/Device';
+import type { UiPromiseCreator } from '../events/ui-promise';
+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(): MethodPermission[];
+    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);
+    protected getUseUi(params: {
+        address?: string;
+        proto: {
+            show_display?: boolean;
+        };
+    }[], useEventListener: boolean | undefined): boolean;
+    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;
+}