@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/common/paramsValidator.mjs

@@ -0,0 +1,134 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { typedObjectTransformValues, versionUtils } from "@trezor/utils";
+import { config } from "../../data/config.mjs";
+import { fromHardened } from "../../utils/pathUtils.mjs";
+const invalidParameter = message => ERRORS.TypedError('Method_InvalidParameter', message);
+export const bundlify = payload => ({
+  hasBundle: !!payload.bundle,
+  payload: {
+    ...payload,
+    bundle: payload.bundle ?? [payload]
+  }
+});
+export function validateParams(params, schema) {
+  schema.forEach(field => {
+    const value = params[field.name];
+    if (field.required && value == null) {
+      throw invalidParameter(`Parameter "${field.name}" is missing.`);
+    }
+    if (!field.type || value == null) return;
+    const {
+      name,
+      type
+    } = field;
+    if (Array.isArray(type)) {
+      const p = {};
+      p[name] = value;
+      const success = type.reduce((count, t) => {
+        try {
+          validateParams(p, [{
+            name: field.name,
+            type: t
+          }]);
+          return count + 1;
+        } catch {
+          return count;
+        }
+      }, 0);
+      if (!success) {
+        throw invalidParameter(`Parameter "${name}" has invalid type. Union of "${type.join('|')}" expected.`);
+      }
+      return;
+    }
+    if (type === 'array') {
+      if (!Array.isArray(value)) {
+        throw invalidParameter(`Parameter "${name}" has invalid type. "${type}" expected.`);
+      }
+      if (!field.allowEmpty && value.length < 1) {
+        throw invalidParameter(`Parameter "${name}" is empty.`);
+      }
+    } else if (type === 'uint') {
+      if (typeof value !== 'string' && typeof value !== 'number') {
+        throw invalidParameter(`Parameter "${name}" has invalid type. "string|number" expected.`);
+      }
+      if (typeof value === 'number' && !Number.isSafeInteger(value) || !/^(?:[1-9]\d*|\d)$/.test(value.toString().replace(/^-/, field.allowNegative ? '' : '-'))) {
+        throw invalidParameter(`Parameter "${name}" has invalid value "${value}". Integer representation expected.`);
+      }
+    } else if (type === 'array-buffer') {
+      if (!(value instanceof ArrayBuffer)) {
+        throw invalidParameter(`Parameter "${name}" has invalid type. "ArrayBuffer" expected.`);
+      }
+    } else if (typeof value !== type) {
+      throw invalidParameter(`Parameter "${name}" has invalid type. "${type}" expected.`);
+    }
+  });
+  return params;
+}
+export const validateCoinPath = (path, coinInfo) => {
+  if (coinInfo && coinInfo.slip44 !== fromHardened(path[1])) {
+    throw invalidParameter('Parameters "path" and "coin" do not match.');
+  }
+};
+export const DEFAULT_FIRMWARE_RANGE = {
+  UNKNOWN: {
+    min: '1.0.0',
+    max: '0'
+  },
+  T1B1: {
+    min: '1.0.0',
+    max: '0'
+  },
+  T2T1: {
+    min: '2.0.0',
+    max: '0'
+  },
+  T2B1: {
+    min: '2.6.1',
+    max: '0'
+  },
+  T3B1: {
+    min: '2.8.1',
+    max: '0'
+  },
+  T3T1: {
+    min: '2.7.1',
+    max: '0'
+  },
+  T3W1: {
+    min: '2.7.1',
+    max: '0'
+  }
+};
+const intersectMin = (a, b) => a === '0' || b !== '0' && versionUtils.isNewer(a, b) ? a : b;
+const intersectMax = (a, b) => a === '0' || b !== '0' && versionUtils.isNewer(a, b) ? b : a;
+const intersectRange = (a, b) => typedObjectTransformValues(a, (value, model) => ({
+  min: intersectMin(value.min, b[model].min),
+  max: intersectMax(value.max, b[model].max)
+}));
+const ensureArray = (item = []) => Array.isArray(item) ? item : [item];
+const filterByCoins = coins => {
+  const coinSet = new Set(coins.map(coin => coin.shortcut.toLowerCase()));
+  const coinTypeSet = new Set(coins.map(coin => coin.type));
+  return rule => !rule.coin && !rule.coinType || ensureArray(rule.coin).some(coinSet.has.bind(coinSet)) || ensureArray(rule.coinType).some(coinTypeSet.has.bind(coinTypeSet));
+};
+const filterByMethods = methodsOrCapabilities => {
+  const methodSet = new Set(methodsOrCapabilities);
+  return rule => !rule.methods && !rule.capabilities || ensureArray(rule.methods).some(methodSet.has.bind(methodSet)) || ensureArray(rule.capabilities).some(methodSet.has.bind(methodSet));
+};
+const getCoinRules = (coins, currentRange) => coins.map(({
+  support = typedObjectTransformValues(DEFAULT_FIRMWARE_RANGE, () => false)
+}) => ({
+  ...currentRange,
+  ...typedObjectTransformValues(support, value => ({
+    min: value || '0',
+    max: '0'
+  }))
+}));
+const getConfigRules = (methodsOrCapabilities, coins, currentRange) => config.supportedFirmware.filter(filterByCoins(coins)).filter(filterByMethods(methodsOrCapabilities)).map(({
+  min,
+  max
+}) => typedObjectTransformValues(currentRange, (value, key) => ({
+  min: min?.[key] ?? value.min,
+  max: max?.[key] ?? value.max
+})));
+export const getFirmwareRange = (methodsOrCapabilities, coins, currentRange = DEFAULT_FIRMWARE_RANGE) => getCoinRules(coins, currentRange).concat(getConfigRules(methodsOrCapabilities, coins, currentRange)).reduce(intersectRange, currentRange);

package/libESM/api/common/requestExistingAccounts.d.mts

@@ -0,0 +1,9 @@
+import { type CoinInfo, type CoreEventMessage, type DiscoveryAccount } from '@trezor/connect-common';
+import type { UiPromiseCreator } from '../../events/ui-promise';
+import type { IDevice } from '../../types/idevice';
+export declare const requestExistingAccounts: ({ postMessage, createUiPromise, device, coinInfo, }: {
+    postMessage: (message: CoreEventMessage) => void;
+    createUiPromise: UiPromiseCreator;
+    device: IDevice;
+    coinInfo: CoinInfo;
+}) => Promise<DiscoveryAccount[] | null>;

package/libESM/api/common/requestExistingAccounts.mjs

@@ -0,0 +1,20 @@
+import { UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
+import { resolveAfter } from "@trezor/utils/libESM/resolveAfter.mjs";
+const REQUEST_TIMEOUT_MS = 200;
+export const requestExistingAccounts = async ({
+  postMessage,
+  createUiPromise,
+  device,
+  coinInfo
+}) => {
+  const dfd = createUiPromise(UI_RESPONSE.RECEIVE_DISCOVERY_ACCOUNTS, device);
+  postMessage(createUiMessage(UI_REQUEST.REQUEST_DISCOVERY_ACCOUNTS, {
+    coinInfo
+  }));
+  const result = await Promise.race([dfd.promise.then(response => response.payload), resolveAfter(REQUEST_TIMEOUT_MS).then(() => null)]);
+  if (result === null) {
+    dfd.reject(new Error('No discovery accounts handler'));
+    return null;
+  }
+  return result.accounts.length > 0 ? result.accounts : null;
+};

package/libESM/api/composeTransaction.d.mts

@@ -0,0 +1,36 @@
+import { type BitcoinNetworkInfo, type MethodPermission, type PrecomposeParams, type PrecomposedResult, type SignedTransaction } from '@trezor/connect-common';
+import { BigNumber } from '@trezor/utils/libESM/bigNumber';
+import type { ComposeOutput, TransactionInputOutputSortingStrategy } from '@trezor/utxo-lib';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+import { Discovery } from './common/Discovery';
+type Params = {
+    outputs: ComposeOutput[];
+    coinInfo: BitcoinNetworkInfo;
+    identity?: string;
+    push: boolean;
+    account?: PrecomposeParams['account'];
+    feeLevels?: PrecomposeParams['feeLevels'];
+    baseFee?: PrecomposeParams['baseFee'];
+    floorBaseFee?: PrecomposeParams['floorBaseFee'];
+    sequence?: PrecomposeParams['sequence'];
+    total: BigNumber;
+    sortingStrategy?: TransactionInputOutputSortingStrategy;
+};
+export default class ComposeTransaction extends AbstractMethod<'composeTransaction', Params> {
+    constructor(message: MethodMessage<'composeTransaction'>);
+    discovery?: Discovery;
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    private getBlockchain;
+    private precompose;
+    run(context: MethodContext): Promise<SignedTransaction | PrecomposedResult[]>;
+    private selectAccount;
+    private selectFromExistingAccounts;
+    private selectFromDiscovery;
+    private selectFee;
+    private _selectFeeUiResponse;
+    private _sign;
+    dispose(): void;
+}
+export {};

package/libESM/api/composeTransaction.mjs

@@ -0,0 +1,386 @@
+import { DEFAULT_SORTING_STRATEGY, ERRORS, UI_REQUEST, UI_RESPONSE, createUiMessage } from "@trezor/connect-common";
+import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
+import { promiseAllSequence } from "@trezor/utils/libESM/promiseAllSequence.mjs";
+import { resolveAfter } from "@trezor/utils/libESM/resolveAfter.mjs";
+import { unique } from "@trezor/utils/libESM/unique.mjs";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { requestExistingAccounts } from "./common/requestExistingAccounts.mjs";
+import { fixCoinInfoNetwork, getBitcoinNetwork } from "../data/coinInfo.mjs";
+import { formatAmount } from "../utils/formatUtils.mjs";
+import * as pathUtils from "../utils/pathUtils.mjs";
+import { TransactionComposer } from "./bitcoin/TransactionComposer.mjs";
+import { enhanceSignTx } from "./bitcoin/enhanceSignTx.mjs";
+import { inputToTrezor } from "./bitcoin/inputs.mjs";
+import { outputToTrezor, validateHDOutput } from "./bitcoin/outputs.mjs";
+import { getReferencedTransactions, parseTransactionHexes, requireReferencedTransactions, transformReferencedTransactions } from "./bitcoin/refTx.mjs";
+import { signTx } from "./bitcoin/signtx.mjs";
+import { signTxLegacy } from "./bitcoin/signtxLegacy.mjs";
+import { deriveOutputScript, verifyTx } from "./bitcoin/signtxVerify.mjs";
+import { Discovery } from "./common/Discovery.mjs";
+import { validateParams } from "./common/paramsValidator.mjs";
+export default class ComposeTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'outputs',
+      type: 'array',
+      required: true
+    }, {
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'identity',
+      type: 'string'
+    }, {
+      name: 'push',
+      type: 'boolean'
+    }, {
+      name: 'account',
+      type: 'object'
+    }, {
+      name: 'feeLevels',
+      type: 'array'
+    }, {
+      name: 'baseFee',
+      type: 'number'
+    }, {
+      name: 'floorBaseFee',
+      type: 'boolean'
+    }, {
+      name: 'sequence',
+      type: 'number'
+    }, {
+      name: 'sortingStrategy',
+      type: 'string'
+    }]);
+    const coinInfo = getBitcoinNetwork(payload.coin);
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    isBackendSupported(coinInfo);
+    const outputs = [];
+    let total = new BigNumber(0);
+    payload.outputs.forEach(out => {
+      const output = validateHDOutput(out, coinInfo);
+      if ('amount' in output && typeof output.amount === 'string') {
+        total = total.plus(output.amount);
+      }
+      outputs.push(output);
+    });
+    const params = {
+      outputs,
+      coinInfo,
+      identity: payload.identity,
+      account: payload.account,
+      feeLevels: payload.feeLevels,
+      baseFee: payload.baseFee,
+      floorBaseFee: payload.floorBaseFee,
+      sequence: payload.sequence,
+      sortingStrategy: payload.sortingStrategy,
+      push: typeof payload.push === 'boolean' ? payload.push : false,
+      total
+    };
+    super(message, params);
+    this.useDevice = !payload.account && !payload.feeLevels;
+    this.useUi = this.useDevice;
+    this.requiredFirmwareCoins = [coinInfo];
+  }
+  discovery;
+  get requiredPermissions() {
+    const permissions = ['read', 'write'];
+    if (this.params.push) {
+      permissions.push('push_tx');
+    }
+    return permissions;
+  }
+  get info() {
+    const sendMax = this.params?.outputs.find(o => o.type === 'send-max') !== undefined;
+    if (sendMax) {
+      return 'Send maximum amount';
+    }
+    return `Send ${formatAmount(this.params.total.toString(), this.params.coinInfo)}`;
+  }
+  getBlockchain(sendCoreMessage) {
+    return initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
+  }
+  async precompose(account, feeLevels, sendCoreMessage) {
+    const {
+      coinInfo,
+      outputs,
+      baseFee,
+      sortingStrategy
+    } = this.params;
+    const address_n = pathUtils.validatePath(account.path);
+    const composer = new TransactionComposer({
+      account: {
+        type: pathUtils.getAccountType(address_n),
+        label: 'Account',
+        descriptor: account.path,
+        address_n,
+        addresses: account.addresses
+      },
+      utxos: account.utxo,
+      coinInfo,
+      outputs,
+      baseFee,
+      sortingStrategy: sortingStrategy ?? DEFAULT_SORTING_STRATEGY
+    });
+    const blockchain = await this.getBlockchain(sendCoreMessage);
+    await composer.init(blockchain);
+    return feeLevels.map(level => {
+      composer.composeCustomFee(level.feePerUnit);
+      const tx = {
+        ...composer.composed.custom
+      };
+      if (tx.type === 'final') {
+        return {
+          ...tx,
+          inputs: tx.inputs.map(inp => inputToTrezor(inp, this.params.sequence)),
+          outputs: tx.outputs.map(outputToTrezor)
+        };
+      }
+      if (tx.type === 'nonfinal') {
+        return {
+          ...tx,
+          inputs: tx.inputs.map(inp => inputToTrezor(inp, this.params.sequence))
+        };
+      }
+      return tx;
+    });
+  }
+  async run(context) {
+    if (this.params.account && this.params.feeLevels) {
+      return this.precompose(this.params.account, this.params.feeLevels, context.sendCoreMessage);
+    }
+    const {
+      account,
+      utxo
+    } = await this.selectAccount(context);
+    const response = await this.selectFee(account, utxo, context);
+    if (!this.discovery) {
+      throw ERRORS.TypedError('Runtime', 'ComposeTransaction: selectFee response received after dispose');
+    }
+    if (typeof response === 'string') {
+      return this.run(context);
+    }
+    return response;
+  }
+  async selectAccount(context) {
+    const {
+      coinInfo
+    } = this.params;
+    const blockchain = await this.getBlockchain(context.sendCoreMessage);
+    if (!this.discovery) {
+      const existingAccounts = await requestExistingAccounts({
+        postMessage: context.sendCoreMessage,
+        createUiPromise: context.createUiPromise,
+        device: this.getDevice(),
+        coinInfo
+      });
+      if (existingAccounts) {
+        return this.selectFromExistingAccounts(existingAccounts, blockchain, context);
+      }
+    }
+    return this.selectFromDiscovery(blockchain, context);
+  }
+  async selectFromExistingAccounts(accounts, blockchain, context) {
+    const {
+      coinInfo
+    } = this.params;
+    const dfd = context.createUiPromise(UI_RESPONSE.RECEIVE_ACCOUNT, this.getDevice());
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+      type: 'complete',
+      accountTypes: unique(accounts.map(a => a.type)),
+      coinInfo,
+      accounts
+    }));
+    const uiResp = await dfd.promise;
+    const account = accounts[uiResp.payload];
+    this.params.coinInfo = fixCoinInfoNetwork(this.params.coinInfo, account.address_n);
+    const utxo = await blockchain.getAccountUtxo(account.descriptor);
+    return {
+      account,
+      utxo
+    };
+  }
+  async selectFromDiscovery(blockchain, context) {
+    const {
+      coinInfo
+    } = this.params;
+    const dfd = context.createUiPromise(UI_RESPONSE.RECEIVE_ACCOUNT, this.getDevice());
+    if (this.discovery && this.discovery.completed) {
+      const {
+        discovery
+      } = this;
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+        type: 'end',
+        coinInfo,
+        accountTypes: discovery.types.map(t => t.type),
+        accounts: discovery.accounts
+      }, {
+        requestId: dfd.requestId
+      }));
+      const uiResp = await dfd.promise;
+      const account = discovery.accounts[uiResp.payload];
+      const utxo = await blockchain.getAccountUtxo(account.descriptor);
+      return {
+        account,
+        utxo
+      };
+    }
+    const discovery = this.discovery || new Discovery({
+      blockchain,
+      getDescriptor: path => this.getDevice().getCommands().getAccountDescriptor(this.params.coinInfo, path)
+    });
+    this.discovery = discovery;
+    discovery.on('progress', accounts => {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+        type: 'progress',
+        coinInfo,
+        accounts
+      }, {
+        requestId: dfd.requestId
+      }));
+    });
+    discovery.on('complete', () => {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+        type: 'end',
+        coinInfo
+      }, {
+        requestId: dfd.requestId
+      }));
+    });
+    discovery.start('tokens').catch(error => {
+      dfd.reject(error);
+    });
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_ACCOUNT, {
+      type: 'start',
+      accountTypes: discovery.types.map(t => t.type),
+      coinInfo
+    }, {
+      requestId: dfd.requestId
+    }));
+    const uiResp = await dfd.promise;
+    discovery.removeAllListeners();
+    discovery.stop();
+    if (!discovery.completed) {
+      await resolveAfter(501);
+    }
+    const account = discovery.accounts[uiResp.payload];
+    this.params.coinInfo = fixCoinInfoNetwork(this.params.coinInfo, account.address_n);
+    const utxo = await blockchain.getAccountUtxo(account.descriptor);
+    return {
+      account,
+      utxo
+    };
+  }
+  async selectFee(account, utxos, context) {
+    const {
+      coinInfo,
+      outputs,
+      sortingStrategy
+    } = this.params;
+    const blockchain = await this.getBlockchain(context.sendCoreMessage);
+    const composer = new TransactionComposer({
+      account,
+      utxos,
+      coinInfo,
+      outputs,
+      sortingStrategy: sortingStrategy ?? DEFAULT_SORTING_STRATEGY
+    });
+    await composer.init(blockchain);
+    const hasFunds = composer.composeAllFeeLevels();
+    if (!hasFunds) {
+      context.sendCoreMessage(createUiMessage(UI_REQUEST.INSUFFICIENT_FUNDS));
+      await resolveAfter(2000);
+      return 'change-account';
+    }
+    context.sendCoreMessage(createUiMessage(UI_REQUEST.SELECT_FEE, {
+      feeLevels: composer.getFeeLevelList(),
+      coinInfo: this.params.coinInfo
+    }));
+    return this._selectFeeUiResponse(composer, context);
+  }
+  async _selectFeeUiResponse(composer, context) {
+    const resp = await context.createUiPromise(UI_RESPONSE.RECEIVE_FEE, this.getDevice()).promise;
+    switch (resp.payload.type) {
+      case 'compose-custom':
+        composer.composeCustomFee(resp.payload.value);
+        context.sendCoreMessage(createUiMessage(UI_REQUEST.UPDATE_CUSTOM_FEE, {
+          feeLevels: composer.getFeeLevelList(),
+          coinInfo: this.params.coinInfo
+        }, {
+          requestId: resp.requestId
+        }));
+        return this._selectFeeUiResponse(composer, context);
+      case 'send':
+        return this._sign(composer.composed[resp.payload.value], context.sendCoreMessage);
+      default:
+        return 'change-account';
+    }
+  }
+  async _sign(tx, sendCoreMessage) {
+    const device = this.getDevice();
+    const {
+      params
+    } = this;
+    if (tx.type !== 'final') throw ERRORS.TypedError('Runtime', 'ComposeTransaction: Trying to sign unfinished tx');
+    const {
+      coinInfo
+    } = params;
+    const options = enhanceSignTx({}, coinInfo);
+    const inputs = tx.inputs.map(inp => inputToTrezor(inp, params.sequence));
+    const outputs = tx.outputs.map(outputToTrezor);
+    let refTxs = [];
+    const requiredRefTxs = requireReferencedTransactions(inputs, options, coinInfo);
+    const refTxsIds = getReferencedTransactions(inputs);
+    if (requiredRefTxs && refTxsIds.length > 0) {
+      refTxs = await this.getBlockchain(sendCoreMessage).then(blockchain => blockchain.getTransactionHexes(refTxsIds)).then(parseTransactionHexes(coinInfo.network)).then(transformReferencedTransactions);
+    }
+    const getHDNode = address_n => device.getCommands().getHDNode({
+      address_n
+    }, {
+      coinInfo: params.coinInfo
+    });
+    const outputScripts = await promiseAllSequence(outputs.map(output => () => deriveOutputScript(getHDNode, output, coinInfo.network)));
+    const signTxMethod = !device.unavailableCapabilities.replaceTransaction ? signTx : signTxLegacy;
+    const cmd = device.getCommands();
+    const response = await signTxMethod({
+      typedCall: cmd.typedCall,
+      inputs,
+      outputs,
+      refTxs,
+      options,
+      coinInfo
+    });
+    verifyTx(response.serializedTx, {
+      inputs,
+      outputs,
+      outputScripts,
+      network: coinInfo.network
+    });
+    if (params.push) {
+      const blockchain = await this.getBlockchain(sendCoreMessage);
+      const txid = await blockchain.pushTransaction(response.serializedTx);
+      return {
+        ...response,
+        txid
+      };
+    }
+    return response;
+  }
+  dispose() {
+    const {
+      discovery
+    } = this;
+    if (discovery) {
+      discovery.stop();
+      discovery.removeAllListeners();
+      this.discovery = undefined;
+    }
+  }
+}

package/libESM/api/discoverAccounts.d.mts

@@ -0,0 +1,38 @@
+import { type AccountTypeItem, type AdditionalParams, CARDANO_DERIVATIONS, type CoinInfo, type EntropyCheckResult, type FirmwareRange, type MethodPermission } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+type CardanoDerivation = (typeof CARDANO_DERIVATIONS)[keyof typeof CARDANO_DERIVATIONS];
+type Request = AdditionalParams & {
+    account: AccountTypeItem;
+    derivation?: CardanoDerivation;
+    firmwareRange: FirmwareRange;
+    coinInfo: CoinInfo;
+    offset: number;
+    skip: number;
+};
+type DiscoverAccountsLocalParams = {
+    coins: Request[];
+    entropyCheckResult?: EntropyCheckResult;
+};
+export declare const getTxsPerPage: (account: AccountTypeItem) => 8 | 25;
+export default class DiscoverAccounts extends AbstractMethod<'discoverAccounts', DiscoverAccountsLocalParams> {
+    disposed: boolean;
+    constructor(message: MethodMessage<'discoverAccounts'>);
+    get requiredPermissions(): MethodPermission[];
+    private progress;
+    private updateProgress;
+    private sendProgress;
+    run({ sendCoreMessage }: MethodContext): Promise<{
+        empty: number;
+        nonempty: number;
+        failed: number;
+    }>;
+    private filterUnsupportedAccounts;
+    private filterCardanoDerivations;
+    private readonly descriptorLock;
+    private readonly descriptorCache;
+    private getDescriptor;
+    private discoverAccount;
+    dispose(): void;
+}
+export {};