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

package/libESM/backend/Blockchain.mjs

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

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

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

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

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

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

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

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

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

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

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

@@ -1,65 +0,0 @@
-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;
-}