@yoroi/swap/lib/commonjs/adapters/api/dexhunter/api-maker.js

The Swap package of Yoroi SDK

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.dexhunterApiMaker = void 0;
var _common = require("@yoroi/common");
var _types = require("@yoroi/types");
var _immer = require("immer");
var _transformers = require("./transformers");
const dexhunterApiMaker = config => {
  const {
    address,
    partner,
    network,
    isPrimaryToken,
    request = _common.fetchData
  } = config;
  if (network !== _types.Chain.Network.Mainnet) return new Proxy({}, {
    get() {
      return () => (0, _immer.freeze)({
        tag: 'left',
        error: {
          status: -3,
          message: 'Dexhunter api only works on mainnet'
        }
      }, true);
    }
  });
  const baseUrl = baseUrls[network];
  const headers = {
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    ...(partner && {
      'X-Partner-Id': partner
    })
  };
  const transformers = (0, _transformers.transformersMaker)(config);
  return (0, _immer.freeze)({
    async tokens() {
      const response = await request({
        method: 'get',
        url: `${baseUrl}${apiPaths.tokens}`,
        headers
      });
      if ((0, _common.isLeft)(response)) return parseDhError(response);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: response.value.status,
          data: transformers.tokens.response(response.value.data)
        }
      }, true);
    },
    async orders() {
      const response = await request({
        method: 'get',
        url: `${baseUrl}${apiPaths.orders({
          address
        })}`,
        headers
      });
      if ((0, _common.isLeft)(response)) return parseDhError(response);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: response.value.status,
          data: transformers.orders.response(response.value.data).sort(({
            lastUpdate: A,
            placedAt: A2
          }, {
            lastUpdate: B,
            placedAt: B2
          }) => (B ?? B2 ?? 0) - (A ?? A2 ?? 0))
        }
      }, true);
    },
    /* istanbul ignore next */
    async limitOptions({
      tokenIn,
      tokenOut
    }) {
      const estimateResponse = await this.estimate({
        tokenIn,
        tokenOut,
        slippage: 0,
        amountIn: 50
      });
      if ((0, _common.isLeft)(estimateResponse)) return parseDhError(estimateResponse);
      const wantedPrice = estimateResponse.value.data.netPrice;
      const defaultProtocol = estimateResponse.value.data.splits[0]?.protocol;
      if (defaultProtocol === undefined) return (0, _immer.freeze)({
        tag: 'left',
        error: {
          status: -3,
          message: 'Invalid state',
          responseData: null
        }
      }, true);
      const options = (await Promise.all(_transformers.DexhunterProtocols.map(protocol => this.estimate({
        tokenIn,
        tokenOut,
        slippage: 0,
        amountIn: 50,
        wantedPrice,
        protocol
      })))).filter(_common.isRight).map(res => {
        const split = res.value.data.splits[0];
        if (split === undefined) return null;
        const {
          protocol,
          initialPrice,
          batcherFee
        } = split;
        return {
          protocol,
          initialPrice,
          batcherFee
        };
      }).filter(_common.isNonNullable);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: _types.Api.HttpStatusCode.Ok,
          data: {
            defaultProtocol,
            wantedPrice,
            options
          }
        }
      }, true);
    },
    async estimate(body) {
      const kind = body.wantedPrice !== undefined ? 'limitEstimate' : body.amountOut !== undefined ? 'reverseEstimate' : 'estimate';
      const response = await request({
        method: 'post',
        url: `${baseUrl}${apiPaths[kind]}`,
        headers,
        data: transformers[kind].request(body)
      });
      if ((0, _common.isLeft)(response)) return parseDhError(response);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: response.value.status,
          data: transformers[kind].response(response.value.data, isPrimaryToken(body.tokenIn))
        }
      }, true);
    },
    async create(body) {
      const kind = body.wantedPrice !== undefined ? 'limitBuild' : 'build';
      const response = await request({
        method: 'post',
        url: `${baseUrl}${apiPaths[kind]}`,
        headers,
        data: transformers[kind].request(body)
      });
      if ((0, _common.isLeft)(response)) return parseDhError(response);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: response.value.status,
          data: transformers[kind].response(response.value.data, isPrimaryToken(body.tokenIn))
        }
      }, true);
    },
    async cancel(body) {
      const response = await request({
        method: 'post',
        url: `${baseUrl}${apiPaths.cancel}`,
        headers,
        data: transformers.cancel.request(body)
      });
      if ((0, _common.isLeft)(response)) return parseDhError(response);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: response.value.status,
          data: transformers.cancel.response(response.value.data)
        }
      }, true);
    }
  }, true);
};
exports.dexhunterApiMaker = dexhunterApiMaker;
const parseDhError = ({
  tag,
  error
}) => (0, _immer.freeze)({
  tag,
  error: {
    ...error,
    message: JSON.stringify(error.responseData ?? 'Dexhunter API error', null, 2).replace(/^"/, '').replace(/"$/, '')
  }
}, true);
const baseUrls = (0, _immer.freeze)({
  [_types.Chain.Network.Mainnet]: 'https://api-us.dexhunterv3.app'
});
const apiPaths = (0, _immer.freeze)({
  tokens: '/swap/tokens',
  orders: ({
    address
  }) => `/swap/orders/${address}`,
  cancel: '/swap/cancel',
  estimate: '/swap/estimate',
  limitBuild: '/swap/limit/build',
  limitEstimate: '/swap/limit/estimate',
  reverseEstimate: '/swap/reverseEstimate',
  build: '/swap/build'
}, true);
//# sourceMappingURL=api-maker.js.map