@trezor/connect 9.7.2 → 10.0.0-alpha.1

package/lib/api/composeTransaction.js

@@ -1,340 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const tslib_1 = require("tslib");
-const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const promiseAllSequence_1 = require("@trezor/utils/lib/promiseAllSequence");
-const resolveAfter_1 = require("@trezor/utils/lib/resolveAfter");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const constants_1 = require("../constants");
-const utxo_1 = require("../constants/utxo");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const bitcoin_1 = require("./bitcoin");
-const Discovery_1 = require("./common/Discovery");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const formatUtils_1 = require("../utils/formatUtils");
-const pathUtils = tslib_1.__importStar(require("../utils/pathUtils"));
-class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
-  discovery;
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    const {
-      payload
-    } = this;
-    (0, paramsValidator_1.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: 'skipPermutation',
-      type: 'boolean'
-    }, {
-      name: 'sortingStrategy',
-      type: 'string'
-    }]);
-    const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
-    const outputs = [];
-    let total = new bigNumber_1.BigNumber(0);
-    payload.outputs.forEach(out => {
-      const output = (0, bitcoin_1.validateHDOutput)(out, coinInfo);
-      if ('amount' in output && typeof output.amount === 'string') {
-        total = total.plus(output.amount);
-      }
-      outputs.push(output);
-    });
-    this.useDevice = !payload.account && !payload.feeLevels;
-    this.useUi = this.useDevice;
-    this.params = {
-      outputs,
-      coinInfo,
-      identity: payload.identity,
-      account: payload.account,
-      feeLevels: payload.feeLevels,
-      baseFee: payload.baseFee,
-      floorBaseFee: payload.floorBaseFee,
-      sequence: payload.sequence,
-      sortingStrategy: payload.skipPermutation === true ? 'none' : payload.sortingStrategy,
-      push: typeof payload.push === 'boolean' ? payload.push : false,
-      total
-    };
-    if (this.params.push) {
-      this.requiredPermissions.push('push_tx');
-    }
-  }
-  get info() {
-    const sendMax = this.params?.outputs.find(o => o.type === 'send-max') !== undefined;
-    if (sendMax) {
-      return 'Send maximum amount';
-    }
-    return `Send ${(0, formatUtils_1.formatAmount)(this.params.total.toString(), this.params.coinInfo)}`;
-  }
-  getBlockchain() {
-    return (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
-  }
-  async precompose(account, feeLevels) {
-    const {
-      coinInfo,
-      outputs,
-      baseFee,
-      sortingStrategy
-    } = this.params;
-    const address_n = pathUtils.validatePath(account.path);
-    const composer = new bitcoin_1.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 ?? utxo_1.DEFAULT_SORTING_STRATEGY
-    });
-    const blockchain = await this.getBlockchain();
-    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 => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence)),
-          outputs: tx.outputs.map(bitcoin_1.outputToTrezor)
-        };
-      }
-      if (tx.type === 'nonfinal') {
-        return {
-          ...tx,
-          inputs: tx.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence))
-        };
-      }
-      return tx;
-    });
-  }
-  async run() {
-    if (this.params.account && this.params.feeLevels) {
-      return this.precompose(this.params.account, this.params.feeLevels);
-    }
-    const {
-      account,
-      utxo
-    } = await this.selectAccount();
-    const response = await this.selectFee(account, utxo);
-    if (!this.discovery) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'ComposeTransaction: selectFee response received after dispose');
-    }
-    if (typeof response === 'string') {
-      return this.run();
-    }
-    return response;
-  }
-  async selectAccount() {
-    const {
-      coinInfo
-    } = this.params;
-    const blockchain = await this.getBlockchain();
-    const dfd = this.createUiPromise(events_1.UI.RECEIVE_ACCOUNT);
-    if (this.discovery && this.discovery.completed) {
-      const {
-        discovery
-      } = this;
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
-        type: 'end',
-        coinInfo,
-        accountTypes: discovery.types.map(t => t.type),
-        accounts: discovery.accounts
-      }));
-      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_1.Discovery({
-      blockchain,
-      getDescriptor: path => this.device.getCommands().getAccountDescriptor(this.params.coinInfo, path)
-    });
-    this.discovery = discovery;
-    discovery.on('progress', accounts => {
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
-        type: 'progress',
-        coinInfo,
-        accounts
-      }));
-    });
-    discovery.on('complete', () => {
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
-        type: 'end',
-        coinInfo
-      }));
-    });
-    discovery.start('tokens').catch(error => {
-      dfd.reject(error);
-    });
-    this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_ACCOUNT, {
-      type: 'start',
-      accountTypes: discovery.types.map(t => t.type),
-      coinInfo
-    }));
-    const uiResp = await dfd.promise;
-    discovery.removeAllListeners();
-    discovery.stop();
-    if (!discovery.completed) {
-      await (0, resolveAfter_1.resolveAfter)(501);
-    }
-    const account = discovery.accounts[uiResp.payload];
-    this.params.coinInfo = (0, coinInfo_1.fixCoinInfoNetwork)(this.params.coinInfo, account.address_n);
-    const utxo = await blockchain.getAccountUtxo(account.descriptor);
-    return {
-      account,
-      utxo
-    };
-  }
-  async selectFee(account, utxos) {
-    const {
-      coinInfo,
-      outputs,
-      sortingStrategy,
-      skipPermutation
-    } = this.params;
-    const blockchain = await this.getBlockchain();
-    const composer = new bitcoin_1.TransactionComposer({
-      account,
-      utxos,
-      coinInfo,
-      outputs,
-      sortingStrategy: skipPermutation === true ? 'none' : sortingStrategy ?? utxo_1.DEFAULT_SORTING_STRATEGY
-    });
-    await composer.init(blockchain);
-    const hasFunds = composer.composeAllFeeLevels();
-    if (!hasFunds) {
-      this.postMessage((0, events_1.createUiMessage)(events_1.UI.INSUFFICIENT_FUNDS));
-      await (0, resolveAfter_1.resolveAfter)(2000);
-      return 'change-account';
-    }
-    this.postMessage((0, events_1.createUiMessage)(events_1.UI.SELECT_FEE, {
-      feeLevels: composer.getFeeLevelList(),
-      coinInfo: this.params.coinInfo
-    }));
-    return this._selectFeeUiResponse(composer);
-  }
-  async _selectFeeUiResponse(composer) {
-    const resp = await this.createUiPromise(events_1.UI.RECEIVE_FEE).promise;
-    switch (resp.payload.type) {
-      case 'compose-custom':
-        composer.composeCustomFee(resp.payload.value);
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.UPDATE_CUSTOM_FEE, {
-          feeLevels: composer.getFeeLevelList(),
-          coinInfo: this.params.coinInfo
-        }));
-        return this._selectFeeUiResponse(composer);
-      case 'send':
-        return this._sign(composer.composed[resp.payload.value]);
-      default:
-        return 'change-account';
-    }
-  }
-  async _sign(tx) {
-    const {
-      device,
-      params
-    } = this;
-    if (tx.type !== 'final') throw constants_1.ERRORS.TypedError('Runtime', 'ComposeTransaction: Trying to sign unfinished tx');
-    const {
-      coinInfo
-    } = params;
-    const options = (0, bitcoin_1.enhanceSignTx)({}, coinInfo);
-    const inputs = tx.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, params.sequence));
-    const outputs = tx.outputs.map(bitcoin_1.outputToTrezor);
-    let refTxs = [];
-    const requiredRefTxs = (0, bitcoin_1.requireReferencedTransactions)(inputs, options, coinInfo);
-    const refTxsIds = (0, bitcoin_1.getReferencedTransactions)(inputs);
-    if (requiredRefTxs && refTxsIds.length > 0) {
-      refTxs = await this.getBlockchain().then(blockchain => blockchain.getTransactionHexes(refTxsIds)).then((0, bitcoin_1.parseTransactionHexes)(coinInfo.network)).then(bitcoin_1.transformReferencedTransactions);
-    }
-    const getHDNode = address_n => device.getCommands().getHDNode({
-      address_n
-    }, {
-      coinInfo: params.coinInfo
-    });
-    const outputScripts = await (0, promiseAllSequence_1.promiseAllSequence)(outputs.map(output => () => (0, bitcoin_1.deriveOutputScript)(getHDNode, output, coinInfo.network)));
-    const signTxMethod = !device.unavailableCapabilities.replaceTransaction ? bitcoin_1.signTx : bitcoin_1.signTxLegacy;
-    const cmd = device.getCommands();
-    const response = await signTxMethod({
-      typedCall: cmd.typedCall,
-      inputs,
-      outputs,
-      refTxs,
-      options,
-      coinInfo
-    });
-    (0, bitcoin_1.verifyTx)(response.serializedTx, {
-      inputs,
-      outputs,
-      outputScripts,
-      network: coinInfo.network
-    });
-    if (params.push) {
-      const blockchain = await this.getBlockchain();
-      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;
-    }
-  }
-}
-exports.default = ComposeTransaction;
-//# sourceMappingURL=composeTransaction.js.map

package/lib/api/discoverAccounts.d.ts

@@ -1,33 +0,0 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { CoinInfo, FirmwareRange } from '../types';
-import { AccountTypeItem, AdditionalParams, CARDANO_DERIVATIONS } from '../types/api/discoverAccounts';
-type CardanoDerivation = (typeof CARDANO_DERIVATIONS)[keyof typeof CARDANO_DERIVATIONS];
-type Request = AdditionalParams & {
-    account: AccountTypeItem;
-    derivation?: CardanoDerivation;
-    firmwareRange: FirmwareRange;
-    coinInfo: CoinInfo;
-    offset: number;
-    skip: number;
-};
-export default class DiscoverAccounts extends AbstractMethod<'discoverAccounts', Request[]> {
-    disposed: boolean;
-    init(): void;
-    private progress;
-    private updateProgress;
-    private sendProgress;
-    run(): Promise<{
-        empty: number;
-        nonempty: number;
-        failed: number;
-    }>;
-    private filterUnsupportedAccounts;
-    private filterCardanoDerivations;
-    private readonly descriptorLock;
-    private readonly descriptorCache;
-    private getDescriptor;
-    private discoverAccount;
-    dispose(): void;
-}
-export {};
-//# sourceMappingURL=discoverAccounts.d.ts.map

package/lib/api/discoverAccounts.js

@@ -1,316 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const utils_1 = require("@trezor/utils");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const coinInfo_1 = require("../data/coinInfo");
-const events_1 = require("../events");
-const paramsValidator_1 = require("./common/paramsValidator");
-const discoverAccounts_1 = require("../types/api/discoverAccounts");
-const accountUtils_1 = require("../utils/accountUtils");
-const pathUtils_1 = require("../utils/pathUtils");
-const ACCOUNT_LIMIT = 10;
-const TXS_PER_PAGE = 25;
-const DETAILS = 'txs';
-const isCardano = account => account.symbol === 'ada' || account.symbol === 'tada';
-const isCardanoRequest = request => isCardano(request.account);
-const isEvmLedger = (account, coinInfo) => coinInfo.type === 'ethereum' && account.type === 'ledger';
-const getAccountTypeKey = ({
-  symbol,
-  type
-}) => `${symbol}-${type}`;
-const substituteBip43Path = (path, index) => path.replace('i', String(index));
-class DiscoverAccounts extends AbstractMethod_1.AbstractMethod {
-  disposed = false;
-  init() {
-    this.requiredPermissions = ['read'];
-    this.useDevice = true;
-    this.useDeviceState = true;
-    this.useUi = false;
-    const {
-      payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
-      name: 'coins',
-      type: 'array',
-      required: true,
-      allowEmpty: true
-    }]);
-    this.params = payload.coins.flatMap(coin => {
-      (0, paramsValidator_1.validateParams)(coin, [{
-        name: 'symbol',
-        type: 'string',
-        required: true
-      }, {
-        name: 'known',
-        type: 'array',
-        allowEmpty: true
-      }, {
-        name: 'knownOnly',
-        type: 'boolean'
-      }, {
-        name: 'identity',
-        type: 'string'
-      }, {
-        name: 'details',
-        type: 'string'
-      }, {
-        name: 'pageSize',
-        type: 'number'
-      }]);
-      const {
-        symbol,
-        known: knownAccs,
-        knownOnly,
-        ...rest
-      } = coin;
-      const coinInfo = (0, coinInfo_1.getCoinInfo)(symbol);
-      if (!coinInfo) {
-        throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-      }
-      (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-      const firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, AbstractMethod_1.DEFAULT_FIRMWARE_RANGE);
-      const symbolAccounts = discoverAccounts_1.ACCOUNT_TYPES.filter(a => a.symbol === symbol);
-      knownAccs?.forEach(account => {
-        (0, paramsValidator_1.validateParams)(account, [{
-          name: 'type',
-          type: 'string',
-          required: true
-        }, {
-          name: 'skip',
-          type: 'number'
-        }]);
-        if (!symbolAccounts.some(a => a.type === account.type)) {
-          throw new Error(`Unknown account type: ${symbol}/${account.type}`);
-        }
-      });
-      return symbolAccounts.map(account => [account, knownAccs?.find(t => t.type === account.type)]).filter(([_, known]) => known ? typeof known.skip === 'number' : !knownOnly).map(([account, known]) => ({
-        pageSize: isCardano(account) ? 8 : TXS_PER_PAGE,
-        details: DETAILS,
-        coinInfo,
-        firmwareRange,
-        skip: known?.skip ?? 0,
-        account,
-        ...rest,
-        offset: isEvmLedger(account, coinInfo) ? 1 : 0,
-        derivation: isCardano(account) ? discoverAccounts_1.CARDANO_DERIVATIONS[account.type] : undefined
-      }));
-    });
-  }
-  progress = {};
-  updateProgress(account, done, last = false) {
-    const progress = last ? 1 : done / Math.max(ACCOUNT_LIMIT, done + 1);
-    const key = getAccountTypeKey(account);
-    this.progress[key] = progress;
-  }
-  sendProgress(response) {
-    const progress = Object.values(this.progress).reduce((sum, typeProgress) => sum + typeProgress, 0) / (Object.keys(this.progress).length || 1);
-    this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
-      total: 100,
-      progress: 100 * progress,
-      response
-    }));
-  }
-  async run() {
-    const [unsupported, supported] = this.filterUnsupportedAccounts(this.params);
-    unsupported.forEach(({
-      account: {
-        path: bip43,
-        ...rest
-      },
-      error,
-      coinInfo,
-      skip,
-      offset
-    }) => {
-      const path = substituteBip43Path(bip43, skip + offset);
-      const backendType = coinInfo.blockchainLink?.type;
-      this.sendProgress({
-        ...rest,
-        index: skip,
-        failed: true,
-        error,
-        path,
-        backendType
-      });
-    });
-    const [cardanoAccounts, otherAccounts] = (0, utils_1.arrayPartition)(supported, isCardanoRequest);
-    const [_, filteredCardanoAccounts] = await this.filterCardanoDerivations(cardanoAccounts);
-    const accounts = [...otherAccounts, ...filteredCardanoAccounts];
-    accounts.forEach(({
-      account,
-      skip
-    }) => this.updateProgress(account, skip));
-    const counts = await Promise.all(accounts.map(account => this.discoverAccount(account)));
-    const nonempty = counts.reduce((sum, acc) => sum + acc.nonempty, 0);
-    const failed = counts.filter(acc => acc.error).length;
-    const empty = counts.length - failed;
-    return {
-      empty,
-      nonempty,
-      failed
-    };
-  }
-  filterUnsupportedAccounts(accounts) {
-    const version = this.device.getVersion();
-    const model = this.device.features?.internal_model;
-    if (!version || !model) return [[], accounts];
-    return (0, utils_1.arrayPartition)(accounts.map(item => {
-      const {
-        min,
-        max
-      } = item.firmwareRange[model];
-      let error;
-      if (min === '0') {
-        error = events_1.UI.FIRMWARE_NOT_SUPPORTED;
-      } else if (!utils_1.versionUtils.isNewerOrEqual(version, min)) {
-        error = events_1.UI.FIRMWARE_OLD;
-      } else if (max !== '0' && utils_1.versionUtils.isNewer(version, max)) {
-        error = events_1.UI.FIRMWARE_NOT_COMPATIBLE;
-      }
-      return error ? {
-        ...item,
-        error
-      } : item;
-    }), item => 'error' in item);
-  }
-  async filterCardanoDerivations(accounts) {
-    const legacyRequest = accounts.find(a => a.account.type === 'legacy');
-    const ledgerRequest = accounts.find(a => a.account.type === 'ledger');
-    const filterableRequest = legacyRequest ?? ledgerRequest;
-    const getDescriptor = derivation => filterableRequest && this.getDescriptor(filterableRequest.coinInfo, filterableRequest.account.path, discoverAccounts_1.CARDANO_DERIVATIONS[derivation], 0).then(({
-      descriptor
-    }) => descriptor);
-    const normalDescriptor = await getDescriptor('normal');
-    const omitLegacy = legacyRequest && (await getDescriptor('legacy')) === normalDescriptor;
-    const omitLedger = ledgerRequest && (!legacyRequest || omitLegacy) && (await getDescriptor('ledger')) === normalDescriptor;
-    return (0, utils_1.arrayPartition)(accounts.map(item => item.account.type === 'legacy' && omitLegacy || item.account.type === 'ledger' && omitLedger ? {
-      ...item,
-      error: 'ignored cardano derivation'
-    } : item), item => 'error' in item);
-  }
-  descriptorLock = (0, utils_1.getSynchronize)();
-  descriptorCache = {};
-  async getDescriptor(coinInfo, bip43PathTemplate, derivationType, index) {
-    const path = substituteBip43Path(bip43PathTemplate, index);
-    const {
-      address_n: _,
-      ...descriptorRest
-    } = await this.descriptorLock(async () => {
-      const key = `${path}-${derivationType}`;
-      if (!this.descriptorCache[key]) {
-        const address_n = (0, pathUtils_1.validatePath)(path, 3);
-        this.descriptorCache[key] = await this.device.getCommands().getAccountDescriptor(coinInfo, address_n, derivationType);
-      }
-      return this.descriptorCache[key];
-    });
-    return {
-      path,
-      ...descriptorRest
-    };
-  }
-  async discoverAccount(request) {
-    const {
-      details,
-      identity,
-      pageSize,
-      coinInfo,
-      derivation,
-      offset,
-      skip
-    } = request;
-    const {
-      path: bip43,
-      ...accountKey
-    } = request.account;
-    const backendType = coinInfo.blockchainLink?.type;
-    const utxoRequired = (0, accountUtils_1.isUtxoBased)(coinInfo) && details && details !== 'basic';
-    let index = skip;
-    let blockchain;
-    try {
-      blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
-    } catch (err) {
-      const path = substituteBip43Path(bip43, offset + index);
-      this.updateProgress(accountKey, index + 1, true);
-      const error = err.message;
-      this.sendProgress({
-        ...accountKey,
-        index,
-        failed: true,
-        error,
-        path,
-        backendType
-      });
-      return {
-        nonempty: 0,
-        error
-      };
-    }
-    let descPromise = this.getDescriptor(coinInfo, bip43, derivation, offset + index);
-    descPromise.catch(() => {});
-    while (true) {
-      try {
-        const {
-          descriptor,
-          ...descRest
-        } = await descPromise;
-        descPromise = this.getDescriptor(coinInfo, bip43, derivation, offset + index + 1);
-        descPromise.catch(() => {});
-        const info = await blockchain.getAccountInfo({
-          descriptor,
-          details,
-          pageSize
-        });
-        const utxo = !utxoRequired ? undefined : info.empty ? [] : await blockchain.getAccountUtxo(descriptor);
-        this.updateProgress(accountKey, index + 1, info.empty);
-        this.sendProgress({
-          ...info,
-          descriptor,
-          ...descRest,
-          utxo,
-          ...accountKey,
-          index,
-          backendType,
-          failed: false
-        });
-        if (info.empty) {
-          await descPromise.catch(() => {});
-          return {
-            nonempty: index - skip
-          };
-        }
-      } catch (err) {
-        const path = substituteBip43Path(bip43, offset + index);
-        const {
-          message: error,
-          code
-        } = err;
-        const failed = true;
-        this.updateProgress(accountKey, index + 1, true);
-        this.sendProgress({
-          ...accountKey,
-          index,
-          failed,
-          error,
-          code,
-          path,
-          backendType
-        });
-        return {
-          nonempty: index - skip,
-          error
-        };
-      }
-      index++;
-    }
-  }
-  dispose() {
-    this.disposed = true;
-  }
-}
-exports.default = DiscoverAccounts;
-//# sourceMappingURL=discoverAccounts.js.map