@yoroi/resolver/lib/module/adapters/api.js

Yoroi domain resolver

import { Resolver } from '@yoroi/types';
import { handleApiGetCryptoAddress } from './handle/api';
import { unstoppableApiGetCryptoAddress } from './unstoppable/api';
import { cnsCryptoAddress } from './cns/api';
import { fetchData } from '@yoroi/common';
const initialDeps = {
  unstoppableApi: {
    getCryptoAddress: unstoppableApiGetCryptoAddress
  },
  handleApi: {
    getCryptoAddress: handleApiGetCryptoAddress
  },
  cnsApi: {
    getCryptoAddress: cnsCryptoAddress
  }
};
export const resolverApiMaker = function (_ref) {
  let {
    apiConfig,
    cslFactory,
    isMainnet = true
  } = _ref;
  let {
    unstoppableApi,
    handleApi,
    cnsApi
  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : initialDeps;
  const getHandleCryptoAddress = handleApi.getCryptoAddress({
    request: fetchData,
    isMainnet
  });
  const getUnstoppableCryptoAddress = unstoppableApi.getCryptoAddress(apiConfig[Resolver.NameServer.Unstoppable]);
  const getCnsCryptoAddress = cnsApi.getCryptoAddress(cslFactory, isMainnet);
  const operationsGetCryptoAddress = [[Resolver.NameServer.Handle, getHandleCryptoAddress], [Resolver.NameServer.Unstoppable, getUnstoppableCryptoAddress], [Resolver.NameServer.Cns, getCnsCryptoAddress]];

  // facade to the different name servers
  const getCardanoAddresses = async (_ref2, fetcherConfig) => {
    let {
      resolve,
      strategy = 'all'
    } = _ref2;
    if (strategy === 'all') return resolveAll(operationsGetCryptoAddress, resolve, fetcherConfig);
    return resolveFirst(operationsGetCryptoAddress, resolve, fetcherConfig);
  };
  return {
    getCardanoAddresses
  };
};
const safelyExecuteOperation = async (operationFn, nameServer, resolve, fetcherConfig) => {
  try {
    const address = await operationFn(resolve, fetcherConfig);
    return {
      error: null,
      address,
      nameServer
    };
  } catch (error) {
    return {
      error,
      address: null,
      nameServer
    };
  }
};
const resolveAll = async (operations, resolve, fetcherConfig) => {
  const promises = operations.map(_ref3 => {
    let [nameServer, operationFn] = _ref3;
    return safelyExecuteOperation(operationFn, nameServer, resolve, fetcherConfig);
  });
  const result = await Promise.all(promises);
  return result;
};
const resolveFirst = async (operations, resolve, fetcherConfig) => {
  const promises = operations.map(async _ref4 => {
    let [nameServer, operationFn] = _ref4;
    const address = await operationFn(resolve, fetcherConfig);
    return {
      error: null,
      address,
      nameServer
    };
  });
  try {
    const result = await Promise.any(promises);
    return [result];
  } catch {
    return [{
      address: null,
      error: new Resolver.Errors.NotFound(),
      nameServer: null
    }];
  }
};
//# sourceMappingURL=api.js.map