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

package/libESM/api/common/paramsValidator.mjs

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

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

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

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

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

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