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

package/libESM/api/bitcoin/signtxLegacy.mjs

@@ -1,179 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-const requestPrevTxInfo = ({
-  txRequest: {
-    request_type,
-    details
-  },
-  refTxs
-}) => {
-  const {
-    tx_hash
-  } = details;
-  if (!tx_hash) {
-    throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: unknown details.tx_hash');
-  }
-  const tx = refTxs[tx_hash.toLowerCase()];
-  if (!tx) {
-    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Requested unknown tx: ${tx_hash}`);
-  }
-  if (!tx.bin_outputs) {
-    throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: bin_outputs not set tx: ${tx_hash}`);
-  }
-  if (request_type === 'TXINPUT') {
-    return {
-      inputs: [tx.inputs[details.request_index]]
-    };
-  }
-  if (request_type === 'TXOUTPUT') {
-    return {
-      bin_outputs: [tx.bin_outputs[details.request_index]]
-    };
-  }
-  if (request_type === 'TXEXTRADATA') {
-    if (typeof details.extra_data_len !== 'number') {
-      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_len');
-    }
-    if (typeof details.extra_data_offset !== 'number') {
-      throw ERRORS.TypedError('Runtime', 'requestPrevTxInfo: Missing extra_data_offset');
-    }
-    if (typeof tx.extra_data !== 'string') {
-      throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: No extra data for transaction ${tx.hash}`);
-    }
-    const data = tx.extra_data;
-    const dataLen = details.extra_data_len;
-    const dataOffset = details.extra_data_offset;
-    const extra_data = data.substring(dataOffset * 2, (dataOffset + dataLen) * 2);
-    return {
-      extra_data
-    };
-  }
-  if (request_type === 'TXMETA') {
-    const data = tx.extra_data;
-    const meta = {
-      version: tx.version,
-      lock_time: tx.lock_time,
-      inputs_cnt: tx.inputs.length,
-      outputs_cnt: tx.bin_outputs.length,
-      timestamp: tx.timestamp,
-      version_group_id: tx.version_group_id,
-      expiry: tx.expiry,
-      branch_id: tx.branch_id
-    };
-    if (typeof data === 'string' && data.length !== 0) {
-      return {
-        ...meta,
-        extra_data_len: data.length / 2
-      };
-    }
-    return meta;
-  }
-  throw ERRORS.TypedError('Runtime', `requestPrevTxInfo: Unknown request type: ${request_type}`);
-};
-const requestSignedTxInfo = ({
-  txRequest: {
-    request_type,
-    details
-  },
-  inputs,
-  outputs
-}) => {
-  if (request_type === 'TXINPUT') {
-    return {
-      inputs: [inputs[details.request_index]]
-    };
-  }
-  if (request_type === 'TXOUTPUT') {
-    return {
-      outputs: [outputs[details.request_index]]
-    };
-  }
-  if (request_type === 'TXMETA') {
-    throw ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXMETA from signed transaction');
-  }
-  if (request_type === 'TXEXTRADATA') {
-    throw ERRORS.TypedError('Runtime', 'requestSignedTxInfo: Cannot read TXEXTRADATA from signed transaction');
-  }
-  throw ERRORS.TypedError('Runtime', `requestSignedTxInfo: Unknown request type: ${request_type}`);
-};
-const requestTxAck = props => {
-  const {
-    tx_hash
-  } = props.txRequest.details;
-  if (tx_hash) {
-    return requestPrevTxInfo(props);
-  }
-  return requestSignedTxInfo(props);
-};
-const saveTxSignatures = (txRequest, serializedTx, signatures) => {
-  if (!txRequest) return;
-  const {
-    signature_index,
-    signature,
-    serialized_tx
-  } = txRequest;
-  if (serialized_tx) {
-    serializedTx.push(serialized_tx);
-  }
-  if (typeof signature_index === 'number') {
-    if (!signature) {
-      throw ERRORS.TypedError('Runtime', 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
-    }
-    signatures[signature_index] = signature;
-  }
-};
-const processTxRequest = async props => {
-  const {
-    typedCall,
-    txRequest,
-    serializedTx,
-    signatures
-  } = props;
-  if (txRequest.serialized) saveTxSignatures(txRequest.serialized, serializedTx, signatures);
-  if (txRequest.request_type === 'TXFINISHED') {
-    return Promise.resolve({
-      signatures,
-      serializedTx: serializedTx.join('')
-    });
-  }
-  const txAck = requestTxAck(props);
-  const {
-    message
-  } = await typedCall('TxAck', 'TxRequest', {
-    tx: txAck
-  });
-  return processTxRequest({
-    ...props,
-    txRequest: message
-  });
-};
-export const signTxLegacy = async ({
-  typedCall,
-  inputs,
-  outputs,
-  refTxs,
-  options,
-  coinInfo
-}) => {
-  const {
-    message
-  } = await typedCall('SignTx', 'TxRequest', {
-    ...options,
-    version: options.version === undefined && coinInfo.isBitcoin ? 1 : options.version,
-    inputs_count: inputs.length,
-    outputs_count: outputs.length,
-    coin_name: coinInfo.name
-  });
-  return processTxRequest({
-    typedCall,
-    txRequest: message,
-    refTxs: refTxs.reduce((record, tx) => ({
-      ...record,
-      [tx.hash.toLowerCase()]: tx
-    }), {}),
-    inputs,
-    outputs,
-    paymentRequests: [],
-    serializedTx: [],
-    signatures: []
-  });
-};

package/libESM/api/bitcoin/signtxVerify.d.mts

@@ -1,12 +0,0 @@
-import type { Network, PROTO } from '@trezor/connect-common';
-import { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-type GetHDNode = (address_n: number[]) => ReturnType<ReturnType<typeof DeviceCommands>['getHDNode']>;
-export declare const deriveOutputScript: (getHDNode: GetHDNode, output: PROTO.TxOutputType, network: Network) => Promise<Buffer<ArrayBufferLike> | undefined>;
-export declare const verifyTx: (serializedTx: string, params: {
-    inputs: PROTO.TxInputType[];
-    outputs: PROTO.TxOutputType[];
-    outputScripts: Awaited<ReturnType<typeof deriveOutputScript>>[];
-    network: Network;
-}) => BitcoinJsTransaction;
-export {};

package/libESM/api/bitcoin/signtxVerify.mjs

@@ -1,86 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { address as BitcoinJsAddress, payments as BitcoinJsPayments, Transaction as BitcoinJsTransaction, bip32 } from "@trezor/utxo-lib";
-const derivePubKeyHash = async (getHDNode, address_n, network) => {
-  if (address_n.length === 5) {
-    const response = await getHDNode(address_n.slice(0, 4));
-    const node = bip32.fromBase58(response.xpub, network);
-    return node.derive(address_n[address_n.length - 1]);
-  }
-  const response = await getHDNode(address_n);
-  return bip32.fromBase58(response.xpub, network);
-};
-export const deriveOutputScript = async (getHDNode, output, network) => {
-  if ('multisig' in output) return;
-  if ('op_return_data' in output) {
-    return BitcoinJsPayments.embed({
-      data: [Buffer.from(output.op_return_data, 'hex')]
-    }).output;
-  }
-  if (output.address) {
-    return BitcoinJsAddress.toOutputScript(output.address, network);
-  }
-  if (!output.address_n) {
-    throw ERRORS.TypedError('Runtime', 'deriveOutputScript: Neither address or address_n is set');
-  }
-  const node = await derivePubKeyHash(getHDNode, output.address_n, network);
-  const payment = {
-    hash: node.identifier,
-    network
-  };
-  if (output.script_type === 'PAYTOADDRESS') {
-    return BitcoinJsPayments.p2pkh(payment).output;
-  }
-  if (output.script_type === 'PAYTOSCRIPTHASH') {
-    return BitcoinJsPayments.p2sh(payment).output;
-  }
-  if (output.script_type === 'PAYTOP2SHWITNESS') {
-    return BitcoinJsPayments.p2sh({
-      redeem: BitcoinJsPayments.p2wpkh(payment)
-    }).output;
-  }
-  if (output.script_type === 'PAYTOWITNESS') {
-    return BitcoinJsPayments.p2wpkh(payment).output;
-  }
-  if (output.script_type === 'PAYTOTAPROOT') {
-    return BitcoinJsPayments.p2tr({
-      pubkey: node.publicKey,
-      network
-    }).output;
-  }
-  if (output.script_type === 'PAYTOMULTISIG') {
-    throw ERRORS.TypedError('Runtime', `deriveOutputScript: script_type PAYTOMULTISIG not expected without multisig defined`);
-  }
-  throw ERRORS.TypedError('Runtime', `deriveOutputScript: Unknown script type ${output.script_type}`);
-};
-export const verifyTx = (serializedTx, params) => {
-  const {
-    inputs,
-    outputs,
-    outputScripts,
-    network
-  } = params;
-  const bitcoinTx = BitcoinJsTransaction.fromHex(serializedTx, {
-    network
-  });
-  if (inputs.length !== bitcoinTx.ins.length) {
-    throw ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction inputs invalid length');
-  }
-  if (outputs.length !== bitcoinTx.outs.length) {
-    throw ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction outputs invalid length');
-  }
-  outputs.forEach((output, i) => {
-    if (output.amount) {
-      if (output.amount.toString() !== bitcoinTx.outs[i].value) {
-        throw ERRORS.TypedError('Runtime', `verifyTx: Wrong output amount at output ${i}. Requested: ${output.amount}, signed: ${bitcoinTx.outs[i].value}`);
-      }
-    }
-  });
-  for (let i = 0; i < outputs.length; i++) {
-    const scriptB = bitcoinTx.outs[i].script;
-    const scriptA = outputScripts[i];
-    if (scriptA && scriptA.compare(scriptB) !== 0) {
-      throw ERRORS.TypedError('Runtime', `verifyTx: Output ${i} scripts differ`);
-    }
-  }
-  return bitcoinTx;
-};

package/libESM/api/bitcoin/transactionBytes.d.mts

@@ -1,3 +0,0 @@
-import type { BitcoinNetworkInfo, PROTO } from '@trezor/connect-common';
-export declare function mapOutputScriptToKey(script_type: string): "p2tr" | "p2wpkh" | "p2sh" | "p2pkh" | undefined;
-export declare const getTransactionVbytes: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[], coinInfo: BitcoinNetworkInfo) => number | undefined;

package/libESM/api/bitcoin/transactionBytes.mjs

@@ -1,65 +0,0 @@
-import { TxWeightCalculator, address as baddress } from "@trezor/utxo-lib";
-import { getOutputScriptType, getScriptType } from "../../utils/pathUtils.mjs";
-export function mapOutputScriptToKey(script_type) {
-  switch (script_type) {
-    case 'PAYTOADDRESS':
-      return 'p2pkh';
-    case 'PAYTOSCRIPTHASH':
-      return 'p2sh';
-    case 'PAYTOWITNESS':
-      return 'p2wpkh';
-    case 'PAYTOP2SHWITNESS':
-      return 'p2sh';
-    case 'PAYTOTAPROOT':
-      return 'p2tr';
-    default:
-      return undefined;
-  }
-}
-export const getTransactionVbytes = (inputs, outputs, coinInfo) => {
-  const calc = new TxWeightCalculator();
-  let cannotProcess = false;
-  inputs.forEach(input => {
-    const script_type = input.script_type ?? getScriptType(input.address_n);
-    if (script_type && !input.witness) {
-      calc.addInput({
-        script_type,
-        multisig: input.multisig,
-        ownership_proof: input.ownership_proof
-      });
-    } else {
-      cannotProcess = true;
-    }
-  });
-  outputs.forEach(out => {
-    if (out.script_type === 'PAYTOOPRETURN') {
-      if (!out.op_return_data) {
-        cannotProcess = true;
-        return;
-      }
-      calc.addOutput({
-        length: 2 + out.op_return_data.length / 2
-      });
-      return;
-    } else if (out.address) {
-      calc.addOutput({
-        length: baddress.toOutputScript(out.address, coinInfo.network).length
-      });
-      return;
-    } else if (out.address_n || out.script_type) {
-      const script_type = out.script_type ?? getOutputScriptType(out.address_n);
-      if (script_type) {
-        const script_key = mapOutputScriptToKey(script_type);
-        if (script_key) {
-          calc.addOutputByKey(script_key);
-          return;
-        }
-      }
-    }
-    cannotProcess = true;
-  });
-  if (cannotProcess) {
-    return undefined;
-  }
-  return calc.getVirtualBytes();
-};

package/libESM/api/bleUnpair.d.mts

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

package/libESM/api/bleUnpair.mjs

@@ -1,35 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { TRANSPORT_ERROR } from "@trezor/transport";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-export default class BleUnpair extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.BleUnpair, payload);
-    const params = {
-      all: payload.all
-    };
-    super(message, params);
-    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    try {
-      const response = await cmd.typedCall('BleUnpair', 'Success', this.params);
-      return response.message;
-    } catch (error) {
-      if (this.getDevice().descriptor.apiType === 'bluetooth' && error.message === TRANSPORT_ERROR.INTERFACE_DATA_TRANSFER) {
-        throw ERRORS.TypedError('Device_Disconnected');
-      }
-      throw error;
-    }
-  }
-}

package/libESM/api/blockchainDisconnect.d.mts

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

package/libESM/api/blockchainDisconnect.mjs

@@ -1,39 +0,0 @@
-import { CoinObj } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { findBackend, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainDisconnect extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(CoinObj, payload);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity: payload.identity
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  get info() {
-    return '';
-  }
-  run() {
-    const backend = findBackend(this.params.coinInfo.shortcut, this.params.identity);
-    backend?.disconnect();
-    return Promise.resolve({
-      disconnected: true
-    });
-  }
-}

package/libESM/api/blockchainEstimateFee.d.mts

@@ -1,14 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, MethodReturnType, Payload } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Payload<'blockchainEstimateFee'>['request'];
-};
-export default class BlockchainEstimateFee extends AbstractMethod<'blockchainEstimateFee', Params> {
-    constructor(message: MethodMessage<'blockchainEstimateFee'>);
-    get requiredPermissions(): MethodPermission[];
-    run({ sendCoreMessage }: MethodContext): Promise<MethodReturnType<"blockchainEstimateFee">>;
-}
-export {};

package/libESM/api/blockchainEstimateFee.mjs

@@ -1,106 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { getOrInitFeeLevels } from "../backend/fees/index.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainEstimateFee extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'request',
-      type: 'object'
-    }]);
-    const {
-      request,
-      identity
-    } = payload;
-    if (request) {
-      validateParams(request, [{
-        name: 'blocks',
-        type: 'array'
-      }, {
-        name: 'specific',
-        type: 'object'
-      }, {
-        name: 'feeLevels',
-        type: 'string'
-      }]);
-      if (request.specific) {
-        validateParams(request.specific, [{
-          name: 'conservative',
-          type: 'boolean'
-        }, {
-          name: 'data',
-          type: 'string'
-        }, {
-          name: 'from',
-          type: 'string'
-        }, {
-          name: 'to',
-          type: 'string'
-        }, {
-          name: 'txsize',
-          type: 'number'
-        }, {
-          name: 'newAccountProgramName',
-          type: 'string'
-        }]);
-      }
-    }
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity,
-      request
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const {
-      coinInfo,
-      identity,
-      request
-    } = this.params;
-    const feeInfo = {
-      blockTime: coinInfo.blockTime,
-      minFee: coinInfo.minFee,
-      maxFee: coinInfo.maxFee,
-      minPriorityFee: coinInfo.minPriorityFee,
-      dustLimit: coinInfo.type === 'bitcoin' ? coinInfo.dustLimit : undefined,
-      levels: []
-    };
-    if (request?.feeLevels) {
-      const feeLevelsInstance = getOrInitFeeLevels(coinInfo);
-      if (request.feeLevels === 'smart') {
-        const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
-        await feeLevelsInstance.load(backend, request);
-      }
-      feeInfo.levels = feeLevelsInstance.levels;
-    } else {
-      const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
-      feeInfo.levels = await backend.estimateFee(request || {});
-    }
-    return feeInfo;
-  }
-}

package/libESM/api/blockchainEvmRpcCall.d.mts

@@ -1,17 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Omit<Payload<'blockchainEvmRpcCall'>, 'method' | 'coin'>;
-};
-export default class BlockchainEvmRpcCall extends AbstractMethod<'blockchainEvmRpcCall', Params> {
-    constructor(message: MethodMessage<'blockchainEvmRpcCall'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    run({ sendCoreMessage }: MethodContext): Promise<{
-        data: string;
-    }>;
-}
-export {};

package/libESM/api/blockchainEvmRpcCall.mjs

@@ -1,61 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainEvmRpcCall extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'from',
-      type: 'string'
-    }, {
-      name: 'to',
-      type: 'string',
-      required: true
-    }, {
-      name: 'data',
-      type: 'string',
-      required: true
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity: payload.identity,
-      request: {
-        from: payload.from,
-        to: payload.to,
-        data: payload.data
-      }
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  get info() {
-    return 'Blockchain Evm Rpc Call';
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    const response = await backend.rpcCall(this.params.request);
-    return response;
-  }
-}

package/libESM/api/blockchainGetAccountBalanceHistory.d.mts

@@ -1,14 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Omit<Payload<'blockchainGetAccountBalanceHistory'>, 'method' | 'coin'>;
-};
-export default class BlockchainGetAccountBalanceHistory extends AbstractMethod<'blockchainGetAccountBalanceHistory', Params> {
-    constructor(message: MethodMessage<'blockchainGetAccountBalanceHistory'>);
-    get requiredPermissions(): MethodPermission[];
-    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/blockchain-link-types").AccountBalanceHistory[]>;
-}
-export {};