@paraswap/dex-lib 2.21.0 → 2.21.1-chronos

package/src/dex/quickswap/camelot-v3.ts

@@ -1,15 +0,0 @@
-import { IDexHelper } from '../../dex-helper';
-import _ from 'lodash';
-import { QuickSwapConfig } from './config';
-import { QuickSwapV3 } from './quickswap-v3';
-
-const config = _.pick(QuickSwapConfig, ['CamelotV3']).CamelotV3;
-
-export class CamelotV3 extends QuickSwapV3 {
-  static dexKeys = ['camelotv3'];
-
-  // public static dexKeysWithNetwork
-  constructor(dexHelper: IDexHelper) {
-    super(dexHelper, 'camelotv3', config[dexHelper.config.data.network].router);
-  }
-}

package/src/dex/swaap-v2/config.ts

@@ -1,19 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap, AdapterMappings } from '../../types';
-import { Network, SwapSide } from '../../constants';
-
-export const SwaapV2Config: DexConfigMap<DexParams> = {
-  SwaapV2: {
-    // Mainnet and Arbitrum will be supported later
-    // [Network.MAINNET]: {},
-    // [Network.ARBITRUM]: {},
-    [Network.POLYGON]: {},
-  },
-};
-
-export const Adapters: Record<number, AdapterMappings> = {
-  [Network.POLYGON]: {
-    [SwapSide.SELL]: [{ name: 'PolygonAdapter02', index: 8 }],
-    [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 7 }],
-  },
-};

package/src/dex/swaap-v2/constants.ts

@@ -1,37 +0,0 @@
-export const SWAAP_RFQ_PRICES_CACHES_TTL_S = 3;
-
-export const SWAAP_RFQ_QUOTE_TIMEOUT_MS = 2000;
-
-export const SWAAP_RFQ_API_PRICES_POLLING_INTERVAL_MS = 1000;
-
-export const SWAAP_RFQ_API_TOKENS_POLLING_INTERVAL_MS = 1000 * 60 * 60; // 1 hour
-
-export const SWAAP_RFQ_TOKENS_CACHES_TTL_S = 7200; // 2 hours
-
-export const SWAAP_RFQ_API_URL = 'https://api.swaap.finance/v1/rfq';
-
-export const SWAAP_TOKENS_CACHE_KEY = 'tokens';
-
-export const SWAAP_PRICES_CACHE_KEY = 'prices';
-
-export const SWAAP_RFQ_PRICES_ENDPOINT = 'prices';
-
-export const SWAAP_RFQ_QUOTE_ENDPOINT = 'quote';
-
-export const SWAAP_RFQ_TOKENS_ENDPOINT = 'tokens';
-
-export const SWAAP_BLACKLIST_TTL_S = 60 * 60 * 24; // 24 hours
-
-export const SWAAP_RESTRICT_TTL_S = 60 * 30; // 30 minutes
-
-export const SWAAP_RESTRICTED_CACHE_KEY = 'restricted';
-
-export const GAS_COST_ESTIMATION = 170_000;
-
-export const BATCH_SWAP_SELECTOR = '0x945bcec9';
-
-export const CALLER_SLOT = 160;
-
-export const SWAAP_ORDER_TYPE_SELL = 1;
-
-export const SWAAP_ORDER_TYPE_BUY = 2;

package/src/dex/swaap-v2/rate-fetcher.ts

@@ -1,214 +0,0 @@
-import { IDexHelper } from '../../dex-helper';
-import { Fetcher } from '../../lib/fetcher/fetcher';
-import { validateAndCast } from '../../lib/validators';
-import { Logger, Token, Address } from '../../types';
-import {
-  SwaapV2RateFetcherConfig,
-  SwaapV2PriceLevelsResponse,
-  SwaapV2QuoteResponse,
-  SwaapV2PriceLevels,
-  SwaapV2QuoteRequest,
-  SwaapV2OrderType, SwaapV2TokensResponse, TokensMap,
-} from './types';
-import {
-  priceLevelsResponseValidator,
-  getQuoteResponseValidator, getTokensResponseValidator,
-} from './validators';
-import { normalizeTokenAddress } from './utils';
-import { SWAAP_RFQ_QUOTE_TIMEOUT_MS } from './constants';
-import { RequestConfig } from '../../dex-helper/irequest-wrapper';
-
-export class RateFetcher {
-  private rateFetcher: Fetcher<SwaapV2PriceLevelsResponse>;
-  private tokensFetcher: Fetcher<SwaapV2TokensResponse>;
-  private pricesCacheTTL: number;
-  private tokensCacheTTL: number;
-  private tokenCacheKey: string;
-  private pricesCacheKey: string;
-
-  constructor(
-    private dexHelper: IDexHelper,
-    private dexKey: string,
-    private logger: Logger,
-    config: SwaapV2RateFetcherConfig,
-  ) {
-    this.pricesCacheTTL = config.rateConfig.pricesCacheTTLSecs;
-    this.tokensCacheTTL = config.tokensConfig.tokensCacheTTLSecs;
-    this.pricesCacheKey = config.rateConfig.pricesCacheKey;
-    this.tokenCacheKey = config.tokensConfig.tokensCacheKey;
-
-    this.rateFetcher = new Fetcher<SwaapV2PriceLevelsResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.rateConfig.pricesReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<SwaapV2PriceLevelsResponse>(
-              data,
-              priceLevelsResponseValidator,
-            );
-          },
-        },
-        handler: this.handleRatesResponse.bind(this),
-      },
-      config.rateConfig.pricesIntervalMs,
-      logger,
-    );
-
-    this.tokensFetcher = new Fetcher<SwaapV2TokensResponse>(
-      dexHelper.httpRequest,
-      {
-        info: {
-          requestOptions: config.tokensConfig.tokensReqParams,
-          caster: (data: unknown) => {
-            return validateAndCast<SwaapV2TokensResponse>(
-              data,
-              getTokensResponseValidator,
-            );
-          },
-        },
-        handler: this.handleTokensResponse.bind(this),
-      },
-      config.tokensConfig.tokensIntervalMs,
-      logger,
-    )
-  }
-
-  start() {
-    this.rateFetcher.startPolling();
-    this.tokensFetcher.startPolling();
-  }
-
-  stop() {
-    this.rateFetcher.stopPolling();
-    this.tokensFetcher.startPolling();
-  }
-
-  private handleTokensResponse(resp: SwaapV2TokensResponse): void {
-    if (!resp.success) {
-      return;
-    }
-
-    const tokensMap = Object.keys(resp.tokens).reduce(
-      (acc, key: string) => {
-        acc[key.toLowerCase()] = resp.tokens[key];
-        return acc;
-      },
-      {} as TokensMap,
-    );
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.dexHelper.config.data.network,
-      this.tokenCacheKey,
-      this.tokensCacheTTL,
-      JSON.stringify(tokensMap),
-    );
-  }
-
-  private handleRatesResponse(resp: SwaapV2PriceLevelsResponse): void {
-    if (!resp.success) {
-      return;
-    }
-
-    const levels = Object.keys(resp.levels)
-      .map(pairName => {
-        const pair = resp.levels[pairName];
-        if (!pair) {
-          return;
-        }
-        const levels = resp.levels[pairName];
-
-        if (!levels.asks || !levels.bids) {
-          return;
-        }
-
-        const pairSplit = pairName.split('/');
-
-        const baseAddress = pairSplit[0];
-        const quoteAddress = pairSplit[1];
-        pair.base = normalizeTokenAddress(baseAddress);
-        pair.quote = normalizeTokenAddress(quoteAddress);
-        return pair;
-      })
-      .filter((p: SwaapV2PriceLevels | undefined) => p !== null);
-
-    this.dexHelper.cache.setex(
-      this.dexKey,
-      this.dexHelper.config.data.network,
-      this.pricesCacheKey,
-      this.pricesCacheTTL,
-      JSON.stringify(levels),
-    );
-  }
-
-  async getQuote(
-    networkId: number,
-    _srcToken: Token,
-    _destToken: Token,
-    srcAmount: string,
-    side: SwaapV2OrderType,
-    userAddress: Address,
-    aggregatorRecipient: Address,
-    tolerance: number,
-    requestParameters: RequestConfig,
-  ): Promise<SwaapV2QuoteResponse> {
-    const srcToken = this.dexHelper.config.wrapETH(_srcToken);
-    const destToken = this.dexHelper.config.wrapETH(_destToken);
-
-    if (BigInt(srcAmount) === 0n) {
-      throw new Error('geQuote failed with srcAmount == 0');
-    }
-
-    const _payload: SwaapV2QuoteRequest = {
-      network_id: networkId,
-      origin: userAddress,
-      sender: aggregatorRecipient,
-      recipient: aggregatorRecipient,
-      timestamp: Math.round(Date.now() / 1000),
-      order_type: side,
-      token_in: srcToken.address,
-      token_out: destToken.address,
-      amount: srcAmount,
-      tolerance: tolerance,
-    };
-
-    try {
-      let payload: RequestConfig = {
-        data: _payload,
-        ...requestParameters,
-        timeout: SWAAP_RFQ_QUOTE_TIMEOUT_MS,
-      };
-
-      this.logger.info(
-        'GetQuote Request:',
-        JSON.stringify(payload).replace(/(?:\r\n|\r|\n)/g, ' '),
-      );
-      const { data } = await this.dexHelper.httpRequest.request<unknown>(
-        payload,
-      );
-      this.logger.info(
-        'GetQuote Response: ',
-        JSON.stringify(data).replace(/(?:\r\n|\r|\n)/g, ' '),
-      );
-      const quoteResp = validateAndCast<SwaapV2QuoteResponse>(
-        data,
-        getQuoteResponseValidator,
-      );
-
-      return {
-        id: quoteResp.id,
-        calldata: quoteResp.calldata,
-        router: quoteResp.router,
-        expiration: quoteResp.expiration,
-        amount: quoteResp.amount,
-        guaranteed_price: quoteResp.guaranteed_price,
-        success: quoteResp.success,
-        recipient: quoteResp.recipient,
-      };
-    } catch (e) {
-      this.logger.error(e);
-      throw e;
-    }
-  }
-}

package/src/dex/swaap-v2/swaap-v2-e2e.test.ts

@@ -1,172 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { testE2E } from '../../../tests/utils-e2e';
-import {
-  Tokens,
-  Holders,
-} from '../../../tests/constants-e2e';
-import { Network, ContractMethod, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-import { generateConfig } from '../../config';
-
-const sleepMs: number = 5000;
-
-describe('SwaapV2 E2E', () => {
-  const dexKey = 'SwaapV2';
-
-  const sideToContractMethods = new Map([
-    [
-      SwapSide.SELL,
-      [
-        ContractMethod.simpleSwap,
-        ContractMethod.multiSwap,
-        ContractMethod.megaSwap,
-      ],
-    ],
-    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-  ]);
-
-  describe('Polygon', () => {
-    const network = Network.POLYGON;
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-
-    const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
-      [
-        {
-          name: 'USDC',
-          sellAmount: '45410357',
-          buyAmount: '1000000000000000000',
-        },
-        {
-          name: 'WETH',
-          sellAmount: '1000000000000000000',
-          buyAmount: '100000000',
-        },
-      ],
-      [
-        {
-          name: 'MATIC',
-          sellAmount: '45000000000000000000',
-          buyAmount: '100000000',
-        },
-        {
-          name: 'USDC',
-          sellAmount: '100000000',
-          buyAmount: '150000000000000000000',
-        },
-      ],
-      [
-        {
-          name: 'WMATIC',
-          sellAmount: '150000000000000000000',
-          buyAmount: '100000000',
-        },
-        {
-          name: 'USDC',
-          sellAmount: '100000000',
-          buyAmount: '150000000000000000000',
-        },
-      ],
-    ];
-
-    sideToContractMethods.forEach((contractMethods, side) =>
-      describe(`${side}`, () => {
-        contractMethods.forEach((contractMethod: ContractMethod) => {
-          pairs.forEach(pair => {
-            describe(`${contractMethod}`, () => {
-              it(`${pair[0].name} -> ${pair[1].name}`, async () => {
-                await testE2E(
-                  tokens[pair[0].name],
-                  tokens[pair[1].name],
-                  holders[pair[0].name],
-                  side === SwapSide.SELL
-                    ? pair[0].sellAmount
-                    : pair[0].buyAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-              it(`${pair[1].name} -> ${pair[0].name}`, async () => {
-                await testE2E(
-                  tokens[pair[1].name],
-                  tokens[pair[0].name],
-                  holders[pair[1].name],
-                  side === SwapSide.SELL
-                    ? pair[1].sellAmount
-                    : pair[1].buyAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-            });
-          });
-        });
-      }),
-    );
-  });
-
-  // Arbitrum will be supported later
-  // describe('Arbitrum', () => {
-  //   const network = Network.ARBITRUM;
-  //
-  //   const tokenASymbol: string = 'ETH';
-  //   const tokenBSymbol: string = 'DAI';
-  //
-  //   const tokenAAmount: string = '100000000';
-  //   const tokenBAmount: string = '1000000000000000000';
-  //   const nativeTokenAmount = '1000000000000000000';
-  //
-  //   testForNetwork(
-  //     network,
-  //     dexKey,
-  //     tokenASymbol,
-  //     tokenBSymbol,
-  //     tokenAAmount,
-  //     tokenBAmount,
-  //     nativeTokenAmount,
-  //   );
-  // });
-
-  // Mainnet will be supported later
-  // describe('Mainnet', () => {
-  //   const network = Network.MAINNET;
-  //   const tokenASymbol: string = 'USDC';
-  //   const tokenBSymbol: string = 'USDT';
-  //
-  //   const tokenAAmount: string = '100000000';
-  //   const tokenBAmount: string = '1000000000000000000';
-  //   const nativeTokenAmount = '1000000000000000000';
-  //
-  //   testForNetwork(
-  //     network,
-  //     dexKey,
-  //     tokenASymbol,
-  //     tokenBSymbol,
-  //     tokenAAmount,
-  //     tokenBAmount,
-  //     nativeTokenAmount,
-  //   );
-  // });
-});

package/src/dex/swaap-v2/swaap-v2-integration.test.ts

@@ -1,142 +0,0 @@
-/* eslint-disable no-console */
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { DummyDexHelper } from '../../dex-helper/index';
-import { Network, SwapSide } from '../../constants';
-import { BI_POWS } from '../../bigint-constants';
-import { SwaapV2 } from './swaap-v2';
-import {
-  checkPoolPrices,
-  checkPoolsLiquidity,
-  checkConstantPoolPrices,
-  sleep,
-} from '../../../tests/utils';
-import { Tokens } from '../../../tests/constants-e2e';
-
-async function testPricingOnNetwork(
-  swaapV2: SwaapV2,
-  network: Network,
-  dexKey: string,
-  blockNumber: number,
-  srcTokenSymbol: string,
-  destTokenSymbol: string,
-  side: SwapSide,
-  amounts: bigint[],
-) {
-  const networkTokens = Tokens[network];
-
-  const pools = await swaapV2.getPoolIdentifiers(
-    networkTokens[srcTokenSymbol],
-    networkTokens[destTokenSymbol],
-    side,
-    blockNumber,
-  );
-  console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
-    pools,
-  );
-
-  expect(pools.length).toBeGreaterThan(0);
-
-  const poolPrices = await swaapV2.getPricesVolume(
-    networkTokens[srcTokenSymbol],
-    networkTokens[destTokenSymbol],
-    amounts,
-    side,
-    blockNumber,
-    pools,
-  );
-  console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
-    poolPrices,
-  );
-
-  expect(poolPrices).not.toBeNull();
-  if (swaapV2.hasConstantPriceLargeAmounts) {
-    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
-  } else {
-    checkPoolPrices(poolPrices!, amounts, side, dexKey);
-  }
-}
-
-describe('Swaap V2', function () {
-  const dexKey = 'SwaapV2';
-  let blockNumber: number;
-  let swaapV2: SwaapV2;
-
-  describe('Polygon', () => {
-    const network = Network.POLYGON;
-    const dexHelper = new DummyDexHelper(network);
-
-    const tokens = Tokens[network];
-
-    const srcTokenSymbol = 'WETH';
-    const destTokenSymbol = 'USDC';
-
-    const amountsForSell = [
-      0n,
-      1n * BI_POWS[tokens[srcTokenSymbol].decimals],
-      2n * BI_POWS[tokens[srcTokenSymbol].decimals],
-    ];
-
-    const amountsForBuy = [
-      0n,
-      10n * BI_POWS[tokens[destTokenSymbol].decimals],
-      20n * BI_POWS[tokens[destTokenSymbol].decimals],
-    ];
-
-    beforeAll(async () => {
-      swaapV2 = new SwaapV2(network, dexKey, dexHelper);
-      if (swaapV2.initializePricing) {
-        await swaapV2.initializePricing(0);
-        await sleep(5000);
-      }
-    });
-
-    it('getPoolIdentifiers and getPricesVolume SELL', async function () {
-      await testPricingOnNetwork(
-        swaapV2,
-        network,
-        dexKey,
-        blockNumber,
-        srcTokenSymbol,
-        destTokenSymbol,
-        SwapSide.SELL,
-        amountsForSell,
-      );
-    });
-
-    it('getPoolIdentifiers and getPricesVolume BUY', async function () {
-      await testPricingOnNetwork(
-        swaapV2,
-        network,
-        dexKey,
-        blockNumber,
-        srcTokenSymbol,
-        destTokenSymbol,
-        SwapSide.BUY,
-        amountsForBuy,
-      );
-    });
-
-    it('getTopPoolsForToken', async function () {
-      // We have to check without calling initializePricing, because
-      // pool-tracker is not calling that function
-      const swaapV2 = new SwaapV2(network, dexKey, dexHelper);
-      const poolLiquidity = await swaapV2.getTopPoolsForToken(
-        tokens[srcTokenSymbol].address,
-        10,
-      );
-      console.log(`${srcTokenSymbol} Top Pools:`, poolLiquidity);
-
-      if (!swaapV2.hasConstantPriceLargeAmounts) {
-        checkPoolsLiquidity(
-          poolLiquidity,
-          Tokens[network][srcTokenSymbol].address,
-          dexKey,
-        );
-      }
-    });
-  });
-});