@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/tron/api/tronSignTransaction.mjs

@@ -0,0 +1,129 @@
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { TronSignTransaction as TronSignTransactionSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { validatePath } from "../../../utils/pathUtils.mjs";
+import { encodeTronContractRawData } from "../tronEncode.mjs";
+import { encodeBroadcastTransaction } from "../tronProtobuf.mjs";
+const transformContract = input => {
+  switch (input.type) {
+    case 'FreezeBalanceV2Contract':
+      {
+        const {
+          value
+        } = input.parameter;
+        return {
+          type: 'FreezeBalanceV2Contract',
+          parameter: {
+            value: {
+              owner_address: value.owner_address,
+              balance: 'frozen_balance' in value ? value.frozen_balance : value.balance,
+              resource: value.resource
+            }
+          }
+        };
+      }
+    case 'UnfreezeBalanceV2Contract':
+      {
+        const {
+          value
+        } = input.parameter;
+        return {
+          type: 'UnfreezeBalanceV2Contract',
+          parameter: {
+            value: {
+              owner_address: value.owner_address,
+              balance: 'unfreeze_balance' in value ? value.unfreeze_balance : value.balance,
+              resource: value.resource
+            }
+          }
+        };
+      }
+    case 'VoteWitnessContract':
+      {
+        const {
+          value
+        } = input.parameter;
+        return {
+          type: 'VoteWitnessContract',
+          parameter: {
+            value: {
+              owner_address: value.owner_address,
+              votes: value.votes.map(vote => ({
+                address: 'vote_address' in vote ? vote.vote_address : vote.address,
+                count: 'vote_count' in vote ? vote.vote_count : vote.count
+              }))
+            }
+          }
+        };
+      }
+    case 'TransferContract':
+    case 'TriggerSmartContract':
+    case 'WithdrawExpireUnfreezeContract':
+      return input;
+  }
+};
+const contractMapping = {
+  TransferContract: 'TronTransferContract',
+  TriggerSmartContract: 'TronTriggerSmartContract',
+  FreezeBalanceV2Contract: 'TronFreezeBalanceV2Contract',
+  UnfreezeBalanceV2Contract: 'TronUnfreezeBalanceV2Contract',
+  WithdrawExpireUnfreezeContract: 'TronWithdrawUnfreeze',
+  VoteWitnessContract: 'TronVoteWitnessContract'
+};
+export default class TronSignTransaction extends AbstractMethod {
+  hasBundle;
+  progress = 0;
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    const contractType = payload.contract?.[0]?.type;
+    if (!contractType || !(contractType in contractMapping)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Unsupported Tron contract type: ${contractType ?? 'undefined'}`);
+    }
+    Assert(TronSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 3);
+    const contract = transformContract(payload.contract[0]);
+    const params = {
+      tx: {
+        address_n: path,
+        ref_block_bytes: payload.ref_block_bytes,
+        ref_block_hash: payload.ref_block_hash,
+        expiration: payload.expiration,
+        timestamp: payload.timestamp,
+        fee_limit: payload.fee_limit,
+        data: payload.data
+      },
+      contract
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Tron'];
+  }
+  get requiredPermissions() {
+    return ['read', 'write'];
+  }
+  get info() {
+    return 'Sign Tron transaction';
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    await cmd.typedCall('TronSignTx', 'TronContractRequest', this.params.tx);
+    const {
+      message
+    } = await cmd.typedCall(contractMapping[this.params.contract.type], 'TronSignature', this.params.contract.parameter.value);
+    const {
+      signature
+    } = message;
+    let serializedTx;
+    try {
+      const rawData = encodeTronContractRawData(this.params.contract, this.params.tx);
+      serializedTx = encodeBroadcastTransaction(bytesToHex(rawData), signature);
+    } catch {}
+    return {
+      signature,
+      serializedTx
+    };
+  }
+}

package/libESM/api/tron/tronEncode.d.mts

@@ -0,0 +1,12 @@
+import type { TronContracts } from '@trezor/connect-common/libESM/types/api/tron';
+export declare const TRON_BANDWIDTH_FORMULA_OVERHEAD: number;
+type BlockParams = {
+    ref_block_bytes: string;
+    ref_block_hash: string;
+    expiration: number;
+    timestamp: number;
+    fee_limit?: number;
+    data?: string;
+};
+export declare const encodeTronContractRawData: (contract: TronContracts, blockParams: BlockParams) => Uint8Array;
+export {};

package/libESM/api/tron/tronEncode.mjs

@@ -0,0 +1,77 @@
+import { create, toBinary } from "@bufbuild/protobuf";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { protobufManager } from "@trezor/protobuf";
+import { TronRawContractType } from "@trezor/protobuf/libESM/definitions/messages-tron.mjs";
+export const TRON_BANDWIDTH_FORMULA_OVERHEAD = 3 + 64 + 67;
+const contractTypeUrl = name => `type.googleapis.com/protocol.${name}`;
+const getSchema = name => protobufManager.findSchema(name).schema;
+const encodeInnerContract = contract => {
+  switch (contract.type) {
+    case 'TransferContract':
+      {
+        const {
+          owner_address,
+          to_address,
+          amount
+        } = contract.parameter.value;
+        const schema = getSchema('TronTransferContract');
+        return {
+          type: TronRawContractType.TransferContract,
+          bytes: toBinary(schema, create(schema, {
+            ownerAddress: hexToBytes(owner_address ?? ''),
+            toAddress: hexToBytes(to_address ?? ''),
+            amount: BigInt(amount ?? 0)
+          }))
+        };
+      }
+    case 'TriggerSmartContract':
+      {
+        const {
+          owner_address,
+          contract_address,
+          data
+        } = contract.parameter.value;
+        const schema = getSchema('TronTriggerSmartContract');
+        return {
+          type: TronRawContractType.TriggerSmartContract,
+          bytes: toBinary(schema, create(schema, {
+            ownerAddress: hexToBytes(owner_address ?? ''),
+            contractAddress: hexToBytes(contract_address ?? ''),
+            data: hexToBytes(data ?? '')
+          }))
+        };
+      }
+    default:
+      throw new Error(`Unsupported contract type for encoding: ${contract.type}`);
+  }
+};
+export const encodeTronContractRawData = (contract, blockParams) => {
+  const {
+    type,
+    bytes
+  } = encodeInnerContract(contract);
+  const {
+    ref_block_bytes,
+    ref_block_hash,
+    expiration,
+    timestamp,
+    fee_limit,
+    data
+  } = blockParams;
+  const schema = getSchema('TronRawTransaction');
+  return toBinary(schema, create(schema, {
+    refBlockBytes: hexToBytes(ref_block_bytes),
+    refBlockHash: hexToBytes(ref_block_hash),
+    expiration: BigInt(expiration),
+    timestamp: BigInt(timestamp),
+    feeLimit: contract.type === 'TriggerSmartContract' ? BigInt(fee_limit ?? 0) : undefined,
+    data: data ? hexToBytes(data) : undefined,
+    contract: [{
+      type,
+      parameter: {
+        typeUrl: contractTypeUrl(contract.type),
+        value: bytes
+      }
+    }]
+  }));
+};

package/libESM/api/tron/tronProtobuf.d.mts

@@ -0,0 +1,5 @@
+export declare const encodeBroadcastTransaction: (rawDataHex: string, signatureHex: string) => string;
+export declare const decodeBroadcastTransaction: (hex: string) => {
+    rawData: Uint8Array<ArrayBufferLike>;
+    signature: Uint8Array<ArrayBufferLike>[];
+};

package/libESM/api/tron/tronProtobuf.mjs

@@ -0,0 +1,28 @@
+import { BinaryReader, BinaryWriter, WireType } from "@bufbuild/protobuf/wire";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+export const encodeBroadcastTransaction = (rawDataHex, signatureHex) => {
+  const writer = new BinaryWriter();
+  writer.tag(1, WireType.LengthDelimited).bytes(hexToBytes(rawDataHex));
+  writer.tag(2, WireType.LengthDelimited).bytes(hexToBytes(signatureHex));
+  return bytesToHex(writer.finish());
+};
+export const decodeBroadcastTransaction = hex => {
+  const reader = new BinaryReader(hexToBytes(hex));
+  let rawData;
+  const signature = [];
+  while (reader.pos < reader.len) {
+    const [fieldNo] = reader.tag();
+    if (fieldNo === 1) {
+      rawData = reader.bytes();
+    } else if (fieldNo === 2) {
+      signature.push(reader.bytes());
+    } else {
+      throw new Error(`Unexpected field ${fieldNo} in broadcast transaction`);
+    }
+  }
+  if (!rawData) throw new Error('Missing rawData in broadcast transaction');
+  return {
+    rawData,
+    signature
+  };
+};

package/libESM/api/unlockPath.d.mts

@@ -0,0 +1,12 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class UnlockPath extends AbstractMethod<'unlockPath', PROTO.UnlockPath> {
+    constructor(message: MethodMessage<'unlockPath'>);
+    get requiredPermissions(): MethodPermission[];
+    run(): Promise<{
+        address_n: number[];
+        mac: string;
+    }>;
+}

package/libESM/api/unlockPath.mjs

@@ -0,0 +1,31 @@
+import { UnlockPathParams } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { validatePath } from "../utils/pathUtils.mjs";
+export default class UnlockPath extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(UnlockPathParams, payload);
+    const path = validatePath(payload.path, 1);
+    const params = {
+      address_n: path,
+      mac: payload.mac
+    };
+    super(message, params);
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    const {
+      message
+    } = await cmd.unlockPath(this.params);
+    return {
+      address_n: this.params.address_n,
+      mac: message.mac
+    };
+  }
+}

package/libESM/api/verifyMessage.d.mts

@@ -0,0 +1,16 @@
+import type { CoinInfo, MethodPermission, PROTO } from '@trezor/connect-common';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type Params = {
+    proto: PROTO.VerifyMessage;
+    coinInfo: CoinInfo;
+};
+export default class VerifyMessage extends AbstractMethod<'verifyMessage', Params> {
+    constructor(message: MethodMessage<'verifyMessage'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    run(): Promise<{
+        message: string;
+    }>;
+}
+export {};

package/libESM/api/verifyMessage.mjs

@@ -0,0 +1,46 @@
+import { VerifyMessage as VerifyMessageSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { getBitcoinNetwork } from "../data/coinInfo.mjs";
+import { validateModelOneMessageSize } from "../device/validateMessageSize.mjs";
+import { messageToHex } from "../utils/formatUtils.mjs";
+import { getLabel } from "../utils/pathUtils.mjs";
+export default class VerifyMessage extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(VerifyMessageSchema, payload);
+    const coinInfo = getBitcoinNetwork(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
+    const signatureHex = Buffer.from(payload.signature, 'base64').toString('hex');
+    const proto = {
+      address: payload.address,
+      signature: signatureHex,
+      message: messageHex,
+      coin_name: coinInfo.name
+    };
+    const params = {
+      proto,
+      coinInfo
+    };
+    super(message, params);
+    this.requiredFirmwareCoins = [coinInfo];
+  }
+  get requiredPermissions() {
+    return ['read', 'write'];
+  }
+  get info() {
+    return getLabel('Verify #NETWORK message', this.params.coinInfo);
+  }
+  async run() {
+    validateModelOneMessageSize(this.getDevice(), this.params.proto.message);
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('VerifyMessage', 'Success', this.params.proto);
+    return response.message;
+  }
+}

package/libESM/api/wipeDevice.d.mts

@@ -0,0 +1,21 @@
+import { type MethodPermission } from '@trezor/connect-common';
+import type { MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { Device } from '../device/Device';
+export default class WipeDevice extends AbstractMethod<'wipeDevice'> {
+    constructor(message: MethodMessage<'wipeDevice'>);
+    get requiredPermissions(): MethodPermission[];
+    get confirmation(): {
+        view: "device-management";
+        customConfirmButton: {
+            className: string;
+            label: string;
+        };
+        label: string;
+    };
+    get info(): string;
+    setDevice(device: Device): void;
+    run(): Promise<{
+        message: string;
+    }>;
+}

package/libESM/api/wipeDevice.mjs

@@ -0,0 +1,47 @@
+import { DEVICE, UI_REQUEST } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+export default class WipeDevice extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS, UI_REQUEST.BOOTLOADER];
+    this.useDeviceState = false;
+    this.skipFinalReload = false;
+  }
+  get requiredPermissions() {
+    return ['management'];
+  }
+  get confirmation() {
+    return {
+      view: 'device-management',
+      customConfirmButton: {
+        className: 'wipe',
+        label: `Wipe`
+      },
+      label: 'Are you sure you want to wipe your device?'
+    };
+  }
+  get info() {
+    return 'Wipe device';
+  }
+  setDevice(device) {
+    super.setDevice(device);
+    this.skipFinalReload = device.features?.bootloader_mode || !!device.getThpState();
+  }
+  async run() {
+    const cmd = this.getDevice().getCommands();
+    if (this.getDevice().isBootloader()) {
+      this.getDevice().emit(DEVICE.BUTTON, {
+        device: this.getDevice(),
+        payload: {
+          code: 'ButtonRequest_WipeDevice'
+        }
+      });
+    }
+    const response = await cmd.typedCall('WipeDevice', 'Success');
+    const thpState = this.getDevice().getThpState();
+    if (thpState) {
+      thpState.resetState();
+    }
+    return response.message;
+  }
+}

package/libESM/backend/BackendManager.d.mts

@@ -0,0 +1,24 @@
+import type { BlockchainLink, CoinInfo } from '@trezor/connect-common';
+import type { BlockchainOptions } from './Blockchain';
+import { Blockchain } from './Blockchain';
+type CoinShortcut = CoinInfo['shortcut'];
+type BackendParams = Pick<BlockchainOptions, 'coinInfo' | 'postMessage' | 'identity'>;
+export declare class BackendManager {
+    private readonly instances;
+    private readonly reconnect;
+    private readonly custom;
+    private readonly preferred;
+    get(shortcut: CoinShortcut, identity?: string): Blockchain | null;
+    getOrConnect({ coinInfo, postMessage, identity }: BackendParams): Promise<Blockchain>;
+    dispose(): void;
+    reconnectAll(coin?: CoinInfo): Promise<Blockchain[]>;
+    isSupported(coinInfo: CoinInfo): void;
+    setCustom(shortcut: CoinShortcut, blockchainLink?: BlockchainLink): void;
+    private setInstance;
+    private setPreferred;
+    private onDisconnect;
+    private clearReconnect;
+    private patchCoinInfo;
+    private getReconnectFilter;
+}
+export {};

package/libESM/backend/BackendManager.mjs

@@ -0,0 +1,137 @@
+import { BLOCKCHAIN, createBlockchainMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { Blockchain } from "./Blockchain.mjs";
+import * as settingsStore from "../data/settingsStore.mjs";
+const DEFAULT_IDENTITY = 'default';
+export class BackendManager {
+  instances = {};
+  reconnect = {};
+  custom = {};
+  preferred = {};
+  get(shortcut, identity = DEFAULT_IDENTITY) {
+    return this.instances[`${shortcut}/${identity}`] ?? null;
+  }
+  async getOrConnect({
+    coinInfo,
+    postMessage,
+    identity
+  }) {
+    const coinIdentity = `${coinInfo.shortcut}/${identity ?? DEFAULT_IDENTITY}`;
+    let backend = this.instances[coinIdentity];
+    if (!backend) {
+      backend = new Blockchain({
+        coinInfo: this.patchCoinInfo(coinInfo),
+        identity,
+        debug: settingsStore.get('debug'),
+        proxy: settingsStore.get('proxy'),
+        postMessage,
+        onDisconnected: pendingSubscriptions => {
+          const reconnectAttempts = pendingSubscriptions ? 0 : undefined;
+          this.onDisconnect({
+            coinInfo,
+            postMessage,
+            identity
+          }, reconnectAttempts);
+        }
+      });
+      this.setInstance(coinIdentity, backend);
+    }
+    const reconnect = this.clearReconnect(coinIdentity);
+    try {
+      const info = await backend.init();
+      this.setPreferred(coinInfo.shortcut, info.url);
+      return backend;
+    } catch (error) {
+      this.onDisconnect({
+        coinInfo,
+        postMessage,
+        identity
+      }, reconnect?.attempts);
+      throw error;
+    }
+  }
+  dispose() {
+    Object.keys(this.reconnect).filter(this.getReconnectFilter()).forEach(this.clearReconnect, this);
+    Object.values(this.instances).forEach(i => i.disconnect());
+  }
+  reconnectAll(coin) {
+    const backends = Object.values(this.instances).filter(backend => !coin || coin.shortcut === backend.coinInfo.shortcut);
+    backends.forEach(i => i.disconnect());
+    return Promise.all(backends.map(this.getOrConnect, this));
+  }
+  isSupported(coinInfo) {
+    const info = this.custom[coinInfo.shortcut] || coinInfo.blockchainLink;
+    if (!info) {
+      throw ERRORS.TypedError('Backend_NotSupported');
+    }
+  }
+  setCustom(shortcut, blockchainLink) {
+    this.setPreferred(shortcut, undefined);
+    if (blockchainLink) {
+      this.custom[shortcut] = blockchainLink;
+    } else {
+      delete this.custom[shortcut];
+    }
+  }
+  setInstance(coinIdentity, instance) {
+    if (!instance) delete this.instances[coinIdentity];else this.instances[coinIdentity] = instance;
+  }
+  setPreferred(shortcut, url) {
+    if (!url) delete this.preferred[shortcut];else this.preferred[shortcut] = url;
+  }
+  onDisconnect({
+    coinInfo,
+    postMessage,
+    identity
+  }, reconnectAttempt) {
+    const coinIdentity = `${coinInfo.shortcut}/${identity ?? DEFAULT_IDENTITY}`;
+    this.setInstance(coinIdentity, undefined);
+    if (reconnectAttempt === undefined || reconnectAttempt === 4) {
+      this.setPreferred(coinInfo.shortcut, undefined);
+    }
+    if (reconnectAttempt === undefined) {
+      return;
+    }
+    const timeout = Math.min(2500 * reconnectAttempt, 20000);
+    const time = Date.now() + timeout;
+    const handle = setTimeout(() => {
+      this.getOrConnect({
+        coinInfo,
+        postMessage,
+        identity
+      }).catch(() => {});
+    }, timeout);
+    clearTimeout(this.reconnect[coinIdentity]?.handle);
+    this.reconnect[coinIdentity] = {
+      attempts: reconnectAttempt + 1,
+      handle
+    };
+    postMessage(createBlockchainMessage(BLOCKCHAIN.RECONNECTING, {
+      coin: coinInfo,
+      identity,
+      time
+    }));
+  }
+  clearReconnect(coinIdentity) {
+    const reconnect = this.reconnect[coinIdentity];
+    clearTimeout(reconnect?.handle);
+    delete this.reconnect[coinIdentity];
+    return reconnect;
+  }
+  patchCoinInfo(coinInfo) {
+    const custom = this.custom[coinInfo.shortcut];
+    const preferred = this.preferred[coinInfo.shortcut];
+    const url = preferred ? [preferred] : custom?.url ?? coinInfo.blockchainLink?.url;
+    return {
+      ...coinInfo,
+      blockchainLink: {
+        ...coinInfo.blockchainLink,
+        ...custom,
+        url
+      }
+    };
+  }
+  getReconnectFilter(coinInfo) {
+    return key => !coinInfo || key.startsWith(`${coinInfo.shortcut}/`);
+  }
+}

package/libESM/backend/Blockchain.d.mts

@@ -0,0 +1,81 @@
+import type { BlockchainLinkParams, ServerInfo, SubscriptionAccountInfo } from '@trezor/blockchain-link';
+import { BlockchainLink } from '@trezor/blockchain-link';
+import type { CoinInfo, CoreEventMessage, Proxy, PushTransaction } from '@trezor/connect-common';
+export type BlockchainOptions = {
+    coinInfo: CoinInfo;
+    postMessage: (message: CoreEventMessage) => void;
+    proxy?: Proxy;
+    debug?: boolean;
+    identity?: string;
+    onDisconnected?: (pendingSubscriptions?: boolean) => void;
+};
+export declare class Blockchain {
+    readonly link: BlockchainLink;
+    serverInfo?: ServerInfo;
+    readonly identity?: string;
+    readonly coinInfo: BlockchainOptions['coinInfo'];
+    readonly postMessage: BlockchainOptions['postMessage'];
+    private onDisconnected;
+    private initPromise?;
+    constructor(options: BlockchainOptions);
+    private onBackendDisconnected;
+    private initLink;
+    init(): Promise<ServerInfo>;
+    getTransactions(txs: string[]): Promise<import("@trezor/blockchain-link-types").Transaction[]>;
+    getTransactionHexes(txids: string[]): Promise<string[]>;
+    getCurrentFiatRates(params: {
+        currencies?: string[];
+        token?: string;
+    }): Promise<{
+        ts: number;
+        rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
+    }>;
+    getContractInfo(params: BlockchainLinkParams<'getContractInfo'>): Promise<import("@trezor/blockchain-link-types/libESM/blockbook-api").ContractInfoResult>;
+    getFiatRatesForTimestamps(params: {
+        currencies?: string[];
+        timestamps: number[];
+        token?: string;
+    }): Promise<{
+        tickers: {
+            ts: number;
+            rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
+        }[];
+    }>;
+    getAccountBalanceHistory(params: BlockchainLinkParams<'getAccountBalanceHistory'>): Promise<import("@trezor/blockchain-link-types").AccountBalanceHistory[]>;
+    getNetworkInfo(): Promise<ServerInfo>;
+    getAccountInfo(request: BlockchainLinkParams<'getAccountInfo'>): Promise<import("@trezor/blockchain-link-types").AccountInfo>;
+    getAccountUtxo(descriptor: string): Promise<import("@trezor/blockchain-link-types").Utxo[]>;
+    rpcCall(params: BlockchainLinkParams<'rpcCall'>): Promise<{
+        data: string;
+    }>;
+    estimateFee(request: Parameters<typeof this.link.estimateFee>[0]): Promise<{
+        feePerUnit: string;
+        feePerTx?: string;
+        feePayer?: string;
+        feeLimit?: string;
+        eip1559?: import("@trezor/blockchain-link-types").Eip1559Fees;
+    }[]>;
+    subscribeBlocks(): Promise<{
+        subscribed: boolean;
+    }>;
+    subscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
+        subscribed: boolean;
+    }>;
+    subscribeFiatRates(_currency?: string): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribeBlocks(): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribeFiatRates(): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribeAll(): Promise<{
+        subscribed: boolean;
+    }>;
+    pushTransaction(tx: PushTransaction['tx']): Promise<string>;
+    disconnect(): void;
+}