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

The Swap package of Yoroi SDK

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.parseMuesliError = exports.muesliswapApiMaker = void 0;
var _common = require("@yoroi/common");
var _types = require("@yoroi/types");
var _immer = require("immer");
var _transformers = require("./transformers");
const muesliswapApiMaker = config => {
  const {
    address,
    network,
    request = _common.fetchData
  } = config;
  if (network !== _types.Chain.Network.Mainnet) return new Proxy({}, {
    get() {
      return () => (0, _immer.freeze)({
        tag: 'left',
        error: {
          status: -3,
          message: 'Muesliswap api only works on mainnet'
        }
      }, true);
    }
  });
  const headers = {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  };
  const baseUrl = baseUrls[network];
  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 parseMuesliError(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.orderHistory}`,
        headers
      }, {
        params: {
          user_address: address,
          numbers_have_decimals: true
        }
      });
      if ((0, _common.isLeft)(response)) return parseMuesliError(response);
      try {
        return (0, _immer.freeze)({
          tag: 'right',
          value: {
            status: 200,
            data: transformers.ordersHistory.response(response.value.data).sort(({
              lastUpdate: A,
              placedAt: A2
            }, {
              lastUpdate: B,
              placedAt: B2
            }) => (B ?? B2 ?? 0) - (A ?? A2 ?? 0))
          }
        }, true);
      } catch (e) {
        return (0, _immer.freeze)({
          tag: 'left',
          error: {
            status: -3,
            message: 'Failed to transform orderHistory',
            responseData: response.value.data
          }
        }, 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 parseMuesliError(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.MuesliswapProtocols.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 ? 'limitQuote' : 'quote';
      const response = await request({
        method: 'post',
        url: `${baseUrl}${apiPaths[kind]}`,
        headers,
        data: transformers[kind].request(body)
      });
      if ((0, _common.isLeft)(response)) return parseMuesliError(response);
      try {
        return (0, _immer.freeze)({
          tag: 'right',
          value: {
            status: response.value.status,
            data: transformers.quote.response(response.value.data)
          }
        }, true);
      } catch (e) {
        /* istanbul ignore next */
        return (0, _immer.freeze)({
          tag: 'left',
          error: {
            status: -3,
            message: 'No liquidity pools satisfy the estimate requirements',
            responseData: response.value.data
          }
        }, true);
      }
    },
    async create(body) {
      const kind = body.wantedPrice !== undefined ? 'createLimit' : 'create';
      const response = await request({
        method: 'post',
        url: `${baseUrl}${apiPaths[kind]}`,
        headers,
        data: transformers[kind].request(body)
      });
      if ((0, _common.isLeft)(response)) return parseMuesliError(response);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: response.value.status,
          data: transformers[kind].response(response.value.data)
        }
      }, 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 parseMuesliError(response);
      return (0, _immer.freeze)({
        tag: 'right',
        value: {
          status: response.value.status,
          data: transformers.cancel.response(response.value.data)
        }
      }, true);
    }
  }, true);
};
exports.muesliswapApiMaker = muesliswapApiMaker;
const parseMuesliError = ({
  tag,
  error
}) => (0, _immer.freeze)({
  tag,
  error: {
    ...error,
    message: JSON.stringify(error.responseData?.detail ?? 'Muesliswap API error', null, 2).replace(/^"/, '').replace(/"$/, '')
  }
}, true);
exports.parseMuesliError = parseMuesliError;
const baseUrls = (0, _immer.freeze)({
  [_types.Chain.Network.Mainnet]: 'https://aggregator-v2.muesliswap.com'
});
const apiPaths = (0, _immer.freeze)({
  tokens: '/tokens',
  orderHistory: '/order_history',
  openOrders: '/open_orders',
  quote: '/quote',
  limitQuote: '/limit_order_quote',
  create: '/order',
  createLimit: '/limit_order',
  cancel: '/cancel',
  pools: '/pools',
  providers: '/providers'
});
//# sourceMappingURL=api-maker.js.map