@yoroi/portfolio/lib/commonjs/adapters/dullahan-api/api-maker.js

The Portfolio package of Yoroi SDK

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.portfolioApiMaker = exports.apiConfig = void 0;
var _common = require("@yoroi/common");
var _types = require("@yoroi/types");
var _immer = require("immer");
var _transformers = require("./transformers");
var _tokenDiscovery = require("../../validators/token-discovery");
var _tokenTraits = require("../../validators/token-traits");
var _tokenInfo = require("../../validators/token-info");
const portfolioApiMaker = _ref => {
  let {
    network,
    maxIdsPerRequest,
    maxConcurrentRequests,
    request = _common.fetchData
  } = _ref;
  const config = apiConfig[network];
  return (0, _immer.freeze)({
    async tokenDiscovery(id) {
      const response = await request({
        method: 'get',
        url: `${config.tokenDiscovery}/${id}`,
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      });
      if ((0, _common.isRight)(response)) {
        const discovery = (0, _tokenDiscovery.parseTokenDiscovery)(response.value.data);
        if (!discovery) {
          return (0, _immer.freeze)({
            tag: 'left',
            error: {
              status: -3,
              message: 'Failed to transform token discovery response',
              responseData: response.value.data
            }
          }, true);
        }
        return (0, _immer.freeze)({
          tag: 'right',
          value: {
            status: response.value.status,
            data: discovery
          }
        }, true);
      }
      return response;
    },
    async tokenInfos(idsWithCache) {
      const chunks = [];
      for (let i = 0; i < idsWithCache.length; i += maxIdsPerRequest) chunks.push(idsWithCache.slice(i, i + maxIdsPerRequest));
      const tasks = chunks.map(ids => () => request({
        method: 'post',
        url: config.tokenInfos,
        data: (0, _transformers.toDullahanRequest)(ids),
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      }));
      const responses = await (0, _common.PromiseAllLimited)(tasks, maxConcurrentRequests);
      const infos = responses.filter(_common.isRight).reduce((acc, _ref2) => {
        let {
          value: {
            data
          }
        } = _ref2;
        return Object.assign(acc, data);
      }, {});

      // return with the first error only if none of responses were successful
      const firstError = responses.find(_common.isLeft);
      if (Object.keys(infos).length === 0 && firstError) return firstError;
      const transformedResponseData = (0, _transformers.toSecondaryTokenInfos)(infos);
      const transformedResponse = (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: _types.Api.HttpStatusCode.Ok,
          data: transformedResponseData
        }
      }, true);
      return transformedResponse;
    },
    async tokenInfo(id) {
      const response = await request({
        method: 'get',
        url: `${config.tokenInfo}/${id}`,
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      });
      if ((0, _common.isRight)(response)) {
        const tokenInfo = (0, _tokenInfo.parseTokenInfo)(response.value.data);
        if (!tokenInfo) {
          return (0, _immer.freeze)({
            tag: 'left',
            error: {
              status: -3,
              message: 'Failed to transform token info response',
              responseData: response.value.data
            }
          }, true);
        }
        return (0, _immer.freeze)({
          tag: 'right',
          value: {
            status: response.value.status,
            data: tokenInfo
          }
        }, true);
      }
      return response;
    },
    async tokenTraits(id) {
      const response = await request({
        method: 'get',
        url: `${config.tokenTraits}/${id}`,
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      });
      if ((0, _common.isRight)(response)) {
        const traits = (0, _tokenTraits.parseTokenTraits)(response.value.data);
        if (!traits) {
          return (0, _immer.freeze)({
            tag: 'left',
            error: {
              status: -3,
              message: 'Failed to transform token traits response',
              responseData: response.value.data
            }
          }, true);
        }
        return (0, _immer.freeze)({
          tag: 'right',
          value: {
            status: response.value.status,
            data: traits
          }
        }, true);
      }
      return response;
    },
    async tokenActivity(requestedIds, window) {
      const chunks = [];
      for (let i = 0; i < requestedIds.length; i += maxIdsPerRequest) chunks.push(requestedIds.slice(i, i + maxIdsPerRequest));
      const tasks = chunks.map(ids => () => request({
        method: 'post',
        url: `${config.tokenActivity}/${window}`,
        data: ids,
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      }));
      const responses = await (0, _common.PromiseAllLimited)(tasks, maxConcurrentRequests);
      const activities = responses.filter(_common.isRight).reduce((acc, _ref3) => {
        let {
          value: {
            data
          }
        } = _ref3;
        return Object.assign(acc, data);
      }, {});

      // return with the first error only if none of responses were successful
      const firstError = responses.find(_common.isLeft);
      if (Object.keys(activities).length === 0 && firstError) return firstError;
      const transformedResponseData = (0, _transformers.toTokenActivity)(activities);
      const transformedResponse = (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: _types.Api.HttpStatusCode.Ok,
          data: transformedResponseData
        }
      }, true);
      return transformedResponse;
    },
    async tokenHistory(tokenId, period) {
      const response = await request({
        method: 'post',
        url: config.tokenHistory,
        data: {
          tokenId,
          period
        },
        headers: {
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        }
      });
      if ((0, _common.isRight)(response)) {
        const history = (0, _transformers.toTokenHistory)(response.value.data);
        if (!history) {
          return (0, _immer.freeze)({
            tag: 'left',
            error: {
              status: -3,
              message: 'Failed to transform token history response',
              responseData: response.value.data
            }
          }, true);
        }
        return (0, _immer.freeze)({
          tag: 'right',
          value: {
            status: response.value.status,
            data: history
          }
        }, true);
      }
      return response;
    },
    async tokenImageInvalidate(ids) {
      const tasks = ids.map(id => () => request({
        method: 'post',
        url: config.tokenImageInvalidate,
        data: (0, _transformers.toProcessedMediaRequest)(id),
        headers: {
          'Content-Type': 'application/json'
        }
      }));
      await (0, _common.PromiseAllLimited)(tasks, maxConcurrentRequests);
    }
  }, true);
};
exports.portfolioApiMaker = portfolioApiMaker;
const apiConfig = (0, _immer.freeze)({
  [_types.Chain.Network.Mainnet]: {
    tokenDiscovery: 'https://zero.yoroiwallet.com/tokens/discovery',
    tokenInfo: 'https://zero.yoroiwallet.com/tokens/info',
    tokenInfos: 'https://zero.yoroiwallet.com/tokens/info/multi',
    tokenTraits: 'https://zero.yoroiwallet.com/tokens/nft/traits',
    tokenActivity: 'https://zero.yoroiwallet.com/tokens/activity/multi',
    tokenHistory: 'https://zero.yoroiwallet.com/tokens/history/price',
    tokenImageInvalidate: 'https://mainnet.processed-media.yoroiwallet.com/invalidate'
  },
  [_types.Chain.Network.Preprod]: {
    tokenDiscovery: 'https://yoroi-backend-zero-preprod.emurgornd.com/tokens/discovery',
    tokenInfo: 'https://yoroi-backend-zero-preprod.emurgornd.com/tokens/info',
    tokenInfos: 'https://yoroi-backend-zero-preprod.emurgornd.com/tokens/info/multi',
    tokenTraits: 'https://yoroi-backend-zero-preprod.emurgornd.com/tokens/nft/traits',
    tokenActivity: 'https://yoroi-backend-zero-preprod.emurgornd.com/tokens/activity/multi',
    tokenHistory: 'https://yoroi-backend-zero-preprod.emurgornd.com/tokens/history/price',
    tokenImageInvalidate: 'https://preprod.processed-media.yoroiwallet.com/invalidate'
  },
  [_types.Chain.Network.Preview]: {
    tokenDiscovery: 'https://yoroi-backend-zero-preview.emurgornd.com/tokens/discovery',
    tokenInfo: 'https://yoroi-backend-zero-preview.emurgornd.com/tokens/info',
    tokenInfos: 'https://yoroi-backend-zero-preview.emurgornd.com/tokens/info/multi',
    tokenTraits: 'https://yoroi-backend-zero-preview.emurgornd.com/tokens/nft/traits',
    tokenActivity: 'https://yoroi-backend-zero-preview.emurgornd.com/tokens/activity/multi',
    tokenHistory: 'https://yoroi-backend-zero-preview.emurgornd.com/tokens/history/price',
    tokenImageInvalidate: 'https://preview.processed-media.yoroiwallet.com/invalidate'
  }
}, true);
exports.apiConfig = apiConfig;
//# sourceMappingURL=api-maker.js.map