@yoroi/portfolio/lib/module/adapters/dullahan-api/transformers.js

The Portfolio package of Yoroi SDK

import { Api } from '@yoroi/types';
import { BigNumber } from 'bignumber.js';
import { freeze } from 'immer';
import { parseSecondaryTokenInfoWithCacheRecord } from '../../validators/token-info';
import { z } from 'zod';
export const toSecondaryTokenInfos = apiTokenInfosResponse => {
  const apiCachedTokenInfos = {};
  return Object.entries(apiTokenInfosResponse).reduce((acc, _ref) => {
    let [id, tokenInfoWithCache] = _ref;
    const castedId = id;
    const castedTokenInfoWithCache = tokenInfoWithCache;
    if (!parseSecondaryTokenInfoWithCacheRecord(castedTokenInfoWithCache)) {
      console.warn('Failed to transform token info ', id);
      return acc;
    }
    const [statusCode] = castedTokenInfoWithCache;
    if (statusCode === Api.HttpStatusCode.NotModified) {
      return {
        ...acc,
        [castedId]: castedTokenInfoWithCache
      };
    }
    if (statusCode === Api.HttpStatusCode.InternalServerError) {
      return acc;
    }
    const [, tokenInfo, hash, maxAge] = castedTokenInfoWithCache;
    acc[castedId] = [statusCode, tokenInfo, hash, maxAge];
    return acc;
  }, apiCachedTokenInfos);
};
export const toTokenActivity = apiTokenActivityResponse => {
  const tokenActivity = {};
  return freeze(Object.entries(apiTokenActivityResponse).reduce((acc, _ref2) => {
    let [id, response] = _ref2;
    if (!Array.isArray(response)) return acc;
    const castedId = id;
    const [statusCode, tokenActivityData] = response;
    if (statusCode !== Api.HttpStatusCode.Ok) return acc;
    if (!TokenActivityResponseSchema.safeParse(tokenActivityData).success) return acc;
    const parsedTokenActivity = {
      price: {
        ts: tokenActivityData.price.ts,
        open: new BigNumber(tokenActivityData.price.open),
        close: new BigNumber(tokenActivityData.price.close),
        low: new BigNumber(tokenActivityData.price.low),
        high: new BigNumber(tokenActivityData.price.high),
        change: tokenActivityData.price.change
      }
    };
    acc[castedId] = parsedTokenActivity;
    return acc;
  }, tokenActivity), true);
};
export const toTokenHistory = apiTokenHistoryResponse => {
  if (!TokenHistoryResponseSchema.safeParse(apiTokenHistoryResponse).success) return undefined;
  return freeze({
    prices: apiTokenHistoryResponse.prices.map(tokenHistoryRecord => ({
      ts: tokenHistoryRecord.ts,
      open: new BigNumber(tokenHistoryRecord.open),
      close: new BigNumber(tokenHistoryRecord.close),
      low: new BigNumber(tokenHistoryRecord.low),
      high: new BigNumber(tokenHistoryRecord.high),
      change: tokenHistoryRecord.change
    }))
  });
};
export const toDullahanRequest = request => request.map(_ref3 => {
  let [tokenId, hash] = _ref3;
  return `${tokenId}:${hash}`;
});
const TokenActivityResponseSchema = z.object({
  price: z.object({
    ts: z.number(),
    open: z.string(),
    close: z.string(),
    low: z.string(),
    high: z.string(),
    change: z.number()
  })
});
const TokenHistoryResponseSchema = z.object({
  prices: z.array(z.object({
    ts: z.number(),
    open: z.string(),
    close: z.string(),
    low: z.string(),
    high: z.string(),
    change: z.number()
  }))
});
export const toProcessedMediaRequest = request => {
  const [policy, name] = request.split('.');
  return {
    policy,
    name
  };
};
//# sourceMappingURL=transformers.js.map