@swapper-finance/sdk/src/services/api.ts

JavaScript SDK form Swapper

import { HistoryEntry } from "@src/interfaces";
import swapperConfig from "../../swapper.config";
import {
  Chain,
  Ecosystem,
  GetPricesPayload,
  GenerateRoutePayload,
  GetTokenBalancesPayload,
  Route,
  Token,
  TokenPrices,
  TransactionStatus,
  Currency,
} from "@src/models";

interface ErrorResponse {
  status: number;
  statusText: string;
  message?: string;
}

interface SwapOrderStatusResonse {
  status: TransactionStatus;
  txHash: string;
  tokenOut: string;
  amountOut: string;
}

export async function _sendRequest<T>(
  urlPath: string,
  options?: RequestInit,
): Promise<T> {
  const response = await fetch(`${swapperConfig.apiUrl}${urlPath}`, {
    method: "GET",
    headers: {
      "Content-Type": "application/json",
      "Cache-Control": "no-cache",
      ...options?.headers,
    },
    ...options,
  });

  if (!response.ok) {
    const errorResponse: ErrorResponse = {
      status: response.status,
      statusText: response.statusText,
    };
    try {
      const errorBody = await response.json();
      if (errorBody?.message) {
        errorResponse.message = JSON.parse(errorBody.message);
      }
    } catch (e) {
      // ignore parsing error, fall back to status message
    }
    throw new Error(JSON.stringify(errorResponse));
  }

  return response.json();
}

/**
 * Get swap route based on provided criteria.
 * @param payload required
 * @param abortSignal
 */
export async function getRoute(
  payload: GenerateRoutePayload,
  abortSignal?: AbortSignal,
): Promise<Route> {
  return _sendRequest<Route>("/route", {
    method: "POST",
    body: JSON.stringify(payload),
    signal: abortSignal,
  });
}

/**
 * GET currencies.
 */
export async function getCurrencies(): Promise<Currency[]> {
  return _sendRequest<Currency[]>(`/currencies`);
}

/**
 * GET chains based on provided criteria.
 * @param ecosystem optional
 */
export async function getChains(
  integratorId: string,
  chainIds?: string[],
  ecosystem?: Ecosystem,
): Promise<Chain[]> {
  return _sendRequest<Chain[]>(`/chains?data=${JSON.stringify({
    integratorId,
    chainIds,
    ecosystem,
  })}
    `);
}

/**
 * GET chain data based on provided criteria.
 * @param chainId
 * @param ecosystem optional - Default: Ecosystem.EVM
 */
export async function getChainData(
  chainId?: string,
  ecosystem?: Ecosystem,
): Promise<Chain> {
  return _sendRequest<Chain>(
    `/chains?data=${JSON.stringify({
      chainId,
      ecosystem,
    })}`,
  );
}

/**
 * GET Tokens based on provided criteria
 * @param chainId required
 * @param address optional
 * @param ecosystem optional but Ecosystem.EVM will be considered
 */
export async function getTokens(
  chainId: string,
  address?: string,
  ecosystem?: Ecosystem,
): Promise<Token[]> {
  return _sendRequest<Token[]>(
    `/tokens?data=${JSON.stringify({
      chainId,
      address,
      ecosystem,
    })}`,
  );
}

export async function getHistory(payload: {
  walletAddress: string;
  chainIds: string[] | undefined;
}) {
  return await _sendRequest<HistoryEntry[]>(
    `/history?${new URLSearchParams({
      data: JSON.stringify(payload),
    })}`,
  );
}

export async function getPrices(payload: GetPricesPayload) {
  return await _sendRequest<TokenPrices>(
    `/tokenPrices?${new URLSearchParams({
      data: JSON.stringify(payload),
    })}`,
  );
}

export async function getBalances(payload: GetTokenBalancesPayload) {
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  return _sendRequest<any>(
    `/tokenBalances?${new URLSearchParams({
      data: JSON.stringify(payload),
    })}`,
  );
}

export async function getSwapOrderStatus(payload: {
  routeId: string;
  chainId: string;
}): Promise<SwapOrderStatusResonse> {
  return await _sendRequest<SwapOrderStatusResonse>(
    `/getSwapOrderStatus?${new URLSearchParams({
      data: JSON.stringify(payload), // todo remove once gcp starts working
    })}`,
  );
}