OnePolloWeb3 Academy

  public static swapCallParameters(
    inputCurrency: Currency,
    outputCurrency: Currency,
    trade: Trade<Currency, Currency, TradeType>,
    options: TradeOptions | TradeOptionsDeadline,
  ): SwapParameters {
    const etherIn = inputCurrency.isNative;
    const etherOut = outputCurrency.isNative;
    // the router does not support both ether in and out
    invariant(!(etherIn && etherOut), "ETHER_IN_OUT");
    invariant(!("ttl" in options) || options.ttl > 0, "TTL");

    const to: string = validateAndParseAddress(options.recipient);
    const amountIn: string = toHex(trade.maximumAmountIn(options.allowedSlippage));
    const amountOut: string = toHex(trade.minimumAmountOut(options.allowedSlippage));

    const path: string[] = trade.route.path.map((token: Token) => token.address);
    const deadline =
      "ttl" in options
        ? `0x${(Math.floor(new Date().getTime() / 1000) + options.ttl).toString(16)}`
        : `0x${options.deadline.toString(16)}`;

    const useFeeOnTransfer = Boolean(options.feeOnTransfer);

    let methodName: string;
    let args: (string | string[])[];
    let value: string;
    switch (trade.tradeType) {
      case TradeType.EXACT_INPUT:
        if (etherIn) {
          if (outputCurrency.equals(USDB[outputCurrency.chainId])) {
            methodName = useFeeOnTransfer ? "swapExactETHForUSDBSupportingFeeOnTransferTokens" : "swapExactETHForUSDB";
          } else {
            methodName = useFeeOnTransfer
              ? "swapExactETHForTokensSupportingFeeOnTransferTokens"
              : "swapExactETHForTokens";
          }

          // (uint amountOutMin, address[] calldata path, address to, uint deadline)
          args = [amountOut, path, to, deadline];
          value = amountIn;
        } else if (etherOut) {
          if (inputCurrency.equals(USDB[inputCurrency.chainId])) {
            methodName = useFeeOnTransfer ? "swapExactUSDBForETHSupportingFeeOnTransferTokens" : "swapExactUSDBForETH";
          } else {
            methodName = useFeeOnTransfer
              ? "swapExactTokensForETHSupportingFeeOnTransferTokens"
              : "swapExactTokensForETH";
          }

          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
          args = [amountIn, amountOut, path, to, deadline];
          value = ZERO_HEX;
        } else if (inputCurrency.equals(USDB[inputCurrency.chainId])) {
          methodName = useFeeOnTransfer
            ? "swapExactUSDBForTokensSupportingFeeOnTransferTokens"
            : "swapExactUSDBForTokens";
          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
          args = [amountIn, amountOut, path, to, deadline];
          value = ZERO_HEX;
        } else if (outputCurrency.equals(USDB[outputCurrency.chainId])) {
          methodName = useFeeOnTransfer
            ? "swapExactTokensForUSDBSupportingFeeOnTransferTokens"
            : "swapExactTokensForUSDB";
          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
          args = [amountIn, amountOut, path, to, deadline];
          value = ZERO_HEX;
        } else {
          methodName = useFeeOnTransfer
            ? "swapExactTokensForTokensSupportingFeeOnTransferTokens"
            : "swapExactTokensForTokens";
          // (uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
          args = [amountIn, amountOut, path, to, deadline];
          value = ZERO_HEX;
        }

import { ArrowLeft, Search } from "lucide-react";

export abstract class Fetcher {
  /**
   * Cannot be constructed.
   */
  private constructor() {}

  /**
   * Fetch information for a given token on the given chain, using the given viem provider.
   * @param chainId chain of the token
   * @param address address of the token on the chain
   * @param provider provider used to fetch the token
   * @param symbol symbol of the token
   * @param name optional name of the token
   */
  public static async fetchTokenData(
    chainId: ChainId,
    address: Address,
    publicClient: PublicClient,
    symbol?: string,
    name?: string,
  ): Promise<Token> {
    const erc20 = getContract({
      abi: erc20ABI,
      address,
      client: publicClient,
    });
    const parsedDecimals =
      typeof TOKEN_DECIMALS_CACHE?.[chainId]?.[address] === "number"
        ? TOKEN_DECIMALS_CACHE[chainId][address]
        : await erc20.read.decimals([]).then((decimals: any) => {
            // @ts-ignore
            TOKEN_DECIMALS_CACHE = {
              ...TOKEN_DECIMALS_CACHE,
              [chainId]: {
                ...TOKEN_DECIMALS_CACHE?.[chainId],
                [address]: decimals,
              },
            };
            // @ts-ignore
            return decimals;
          });
    let _symbol = "";
    if (!symbol) {
      _symbol = (await erc20.read.symbol().catch(() => address)) as string;
    }
    return new Token(chainId, address, parsedDecimals, symbol || _symbol, name);
  }

  /**
   * Fetches information about a pair and constructs a pair from the given two tokens.
   * @param tokenA first token
   * @param tokenB second token
   * @param provider the provider to use to fetch the data
   */
  public static async fetchPairData(tokenA: Token, tokenB: Token, publicClient: PublicClient): Promise<Pair> {
    invariant(tokenA.chainId === tokenB.chainId, "CHAIN_ID");
    const address = Pair.getAddress(tokenA, tokenB) as Address;
    // console.log(address);

    const pairContract = getContract({
      abi: PairABI,
      address,
      client: publicClient,
    });
    const [reserves0, reserves1] = await pairContract.read.getReserves();
    const balances = tokenA.sortsBefore(tokenB) ? [reserves0, reserves1] : [reserves1, reserves0];
    return new Pair(
      CurrencyAmount.fromRawAmount(tokenA, balances[0].toString()),
      CurrencyAmount.fromRawAmount(tokenB, balances[1].toString()),
    );
  }
}