@paraswap/dex-lib 2.37.8-dexalot → 2.38.0

package/src/dex/dexalot/config.ts

@@ -1,18 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap, AdapterMappings } from '../../types';
-import { Network, SwapSide } from '../../constants';
-
-export const DexalotConfig: DexConfigMap<DexParams> = {
-  Dexalot: {
-    [Network.AVALANCHE]: {
-      mainnetRFQAddress: '0xEed3c159F3A96aB8d41c8B9cA49EE1e5071A7cdD',
-    },
-  },
-};
-
-export const Adapters: Record<number, AdapterMappings> = {
-  [Network.AVALANCHE]: {
-    [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 6 }],
-    [SwapSide.BUY]: [{ name: 'AvalancheBuyAdapter', index: 8 }],
-  },
-};

package/src/dex/dexalot/constants.ts

@@ -1,29 +0,0 @@
-import BigNumber from 'bignumber.js';
-
-export const DEXALOT_PRICES_CACHES_TTL_S = 3;
-
-export const DEXALOT_PAIRS_CACHES_TTL_S = 21 * 60; // 21 mins
-
-export const DEXALOT_TOKENS_CACHES_TTL_S = 21 * 60; // 21 mins
-
-export const DEXALOT_BLACKLIST_CACHES_TTL_S = 180 * 60; // 3 hours
-
-export const DEXALOT_API_PRICES_POLLING_INTERVAL_MS = 1000;
-
-export const DEXALOT_API_PAIRS_POLLING_INTERVAL_MS = 1000 * 60 * 10; // 10 mins
-
-export const DEXALOT_API_BLACKLIST_POLLING_INTERVAL_MS = 1000 * 60 * 60; // 1 hour
-
-export const DEXALOT_API_URL = 'https://api.dexalot.com';
-
-export const DEXALOT_GAS_COST = 120_000;
-
-export const DEXALOT_RATE_LIMITED_TTL_S = 60 * 60; // 1 hour
-
-export const DEXALOT_RATELIMIT_CACHE_VALUE = 'limited';
-
-export const DEXALOT_RESTRICT_TTL_S = 60 * 30; // 30 minutes
-
-export const DEXALOT_RESTRICTED_CACHE_KEY = 'restricted';
-
-export const DEXALOT_MIN_SLIPPAGE_FACTOR_THRESHOLD_FOR_RESTRICTION = new BigNumber('0.001');

package/src/dex/dexalot/dexalot-e2e.test.ts

@@ -1,192 +0,0 @@
-import dotenv from 'dotenv';
-dotenv.config();
-
-import { testE2E } from '../../../tests/utils-e2e';
-import {
-  Tokens,
-  NativeTokenSymbols,
-  Holders,
-} from '../../../tests/constants-e2e';
-import { Network, ContractMethod, SwapSide } from '../../constants';
-import { StaticJsonRpcProvider } from '@ethersproject/providers';
-import { generateConfig } from '../../config';
-
-function testForNetwork(
-  network: Network,
-  dexKey: string,
-  tokenASymbol: string,
-  tokenBSymbol: string,
-  tokenAAmount: string,
-  tokenBAmount: string,
-  nativeTokenAmount: string,
-  excludeNativeTokenTests: boolean = false,
-) {
-  const config = generateConfig(network);
-  const provider = new StaticJsonRpcProvider(
-    config.privateHttpProvider,
-    network,
-  );
-  const tokens = Tokens[network];
-  const holders = Holders[network];
-  const nativeTokenSymbol = NativeTokenSymbols[network];
-  const sleepMs = 20000;
-
-  const sideToContractMethods = new Map([
-    [SwapSide.SELL, [
-      ContractMethod.simpleSwap,
-      ContractMethod.megaSwap,
-      ContractMethod.multiSwap
-    ]],
-    [SwapSide.BUY, [
-      ContractMethod.simpleBuy,
-      ContractMethod.buy
-    ]],
-  ]);
-
-  describe(`${network}`, () => {
-    sideToContractMethods.forEach((contractMethods, side) =>
-      describe(`${side}`, () => {
-        contractMethods.forEach((contractMethod: ContractMethod) => {
-          describe(`${contractMethod}`, () => {
-            if (excludeNativeTokenTests) {
-              it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
-                await testE2E(
-                  tokens[tokenASymbol],
-                  tokens[tokenBSymbol],
-                  holders[tokenASymbol],
-                  side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-              it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
-                await testE2E(
-                  tokens[tokenBSymbol],
-                  tokens[tokenASymbol],
-                  holders[tokenBSymbol],
-                  side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-            } else {
-              it(`${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
-                await testE2E(
-                  tokens[nativeTokenSymbol],
-                  tokens[tokenASymbol],
-                  holders[nativeTokenSymbol],
-                  side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-              it(`${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
-                await testE2E(
-                  tokens[tokenASymbol],
-                  tokens[nativeTokenSymbol],
-                  holders[tokenASymbol],
-                  side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-              it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
-                await testE2E(
-                  tokens[tokenASymbol],
-                  tokens[tokenBSymbol],
-                  holders[tokenASymbol],
-                  side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-              it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
-                await testE2E(
-                  tokens[tokenBSymbol],
-                  tokens[tokenASymbol],
-                  holders[tokenBSymbol],
-                  side === SwapSide.SELL ? tokenBAmount : tokenAAmount,
-                  side,
-                  dexKey,
-                  contractMethod,
-                  network,
-                  provider,
-                  undefined,
-                  undefined,
-                  undefined,
-                  undefined,
-                  sleepMs,
-                );
-              });
-            }
-          });
-        });
-      }),
-    );
-  });
-}
-
-describe('Dexalot E2E', () => {
-  const dexKey = 'Dexalot';
-
-  describe('Avalanche', () => {
-    const network = Network.AVALANCHE;
-
-    const tokenASymbol: string = 'USDC';
-    const tokenBSymbol: string = 'USDT';
-
-    const tokenAAmount: string = '1000000';
-    const tokenBAmount: string = '1000000';
-    const nativeTokenAmount = '1000000000000000000';
-
-    testForNetwork(
-      network,
-      dexKey,
-      tokenASymbol,
-      tokenBSymbol,
-      tokenAAmount,
-      tokenBAmount,
-      nativeTokenAmount,
-    );
-  });
-});

package/src/dex/dexalot/dexalot-integration.test.ts

@@ -1,188 +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 { Dexalot } from './dexalot';
-import {
-  checkPoolPrices,
-  checkPoolsLiquidity,
-  checkConstantPoolPrices,
-  sleep,
-} from '../../../tests/utils';
-import { Tokens } from '../../../tests/constants-e2e';
-
-async function testPricingOnNetwork(
-  dexalot: Dexalot,
-  network: Network,
-  dexKey: string,
-  blockNumber: number,
-  srcTokenSymbol: string,
-  destTokenSymbol: string,
-  side: SwapSide,
-  amounts: bigint[],
-) {
-  const networkTokens = Tokens[network];
-
-  const pools = await dexalot.getPoolIdentifiers(
-    networkTokens[srcTokenSymbol],
-    networkTokens[destTokenSymbol],
-    side,
-    blockNumber,
-  );
-  console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
-    pools,
-  );
-
-  expect(pools.length).toBeGreaterThan(0);
-
-  const poolPrices = await dexalot.getPricesVolume(
-    networkTokens[srcTokenSymbol],
-    networkTokens[destTokenSymbol],
-    amounts,
-    side,
-    blockNumber,
-    pools,
-  );
-  console.log(
-    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
-    poolPrices,
-  );
-
-  expect(poolPrices).not.toBeNull();
-  if (dexalot.hasConstantPriceLargeAmounts) {
-    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
-  } else {
-    checkPoolPrices(poolPrices!, amounts, side, dexKey);
-  }
-}
-
-describe('Dexalot', function () {
-  const dexKey = 'Dexalot';
-  let blockNumber: number;
-  let dexalot: Dexalot;
-
-  describe('Avalanche', () => {
-    const network = Network.AVALANCHE;
-    const dexHelper = new DummyDexHelper(network);
-
-    const tokens = Tokens[network];
-
-    const tokenASymbol = 'AVAX';
-    const tokenBSymbol = 'USDC';
-
-    const amountsForTokenA = [
-      0n,
-      1n * BI_POWS[tokens[tokenASymbol].decimals],
-      2n * BI_POWS[tokens[tokenASymbol].decimals],
-      3n * BI_POWS[tokens[tokenASymbol].decimals],
-      4n * BI_POWS[tokens[tokenASymbol].decimals],
-      5n * BI_POWS[tokens[tokenASymbol].decimals],
-      6n * BI_POWS[tokens[tokenASymbol].decimals],
-      7n * BI_POWS[tokens[tokenASymbol].decimals],
-      8n * BI_POWS[tokens[tokenASymbol].decimals],
-      9n * BI_POWS[tokens[tokenASymbol].decimals],
-      10n * BI_POWS[tokens[tokenASymbol].decimals],
-    ];
-
-    const amountsForTokenB = [
-      0n,
-      1n * BI_POWS[tokens[tokenBSymbol].decimals],
-      2n * BI_POWS[tokens[tokenBSymbol].decimals],
-      3n * BI_POWS[tokens[tokenBSymbol].decimals],
-      4n * BI_POWS[tokens[tokenBSymbol].decimals],
-      5n * BI_POWS[tokens[tokenBSymbol].decimals],
-      6n * BI_POWS[tokens[tokenBSymbol].decimals],
-      7n * BI_POWS[tokens[tokenBSymbol].decimals],
-      8n * BI_POWS[tokens[tokenBSymbol].decimals],
-      9n * BI_POWS[tokens[tokenBSymbol].decimals],
-      10n * BI_POWS[tokens[tokenBSymbol].decimals],
-    ];
-
-    beforeEach(async () => {
-      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
-      dexalot = new Dexalot(network, dexKey, dexHelper);
-      await dexalot.initializePricing(blockNumber);
-      await sleep(5000);
-    });
-
-    afterEach(async () => {
-      dexalot.releaseResources();
-      await sleep(5000);
-    });
-
-    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenASymbol} ${tokenBSymbol}`, async function () {
-      await testPricingOnNetwork(
-        dexalot,
-        network,
-        dexKey,
-        blockNumber,
-        tokenASymbol,
-        tokenBSymbol,
-        SwapSide.SELL,
-        amountsForTokenA,
-      );
-    });
-
-    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenASymbol} ${tokenBSymbol}`, async function () {
-      await testPricingOnNetwork(
-        dexalot,
-        network,
-        dexKey,
-        blockNumber,
-        tokenASymbol,
-        tokenBSymbol,
-        SwapSide.BUY,
-        amountsForTokenB,
-      );
-    });
-
-    it(`getPoolIdentifiers and getPricesVolume SELL ${tokenBSymbol} ${tokenASymbol}`, async function () {
-      await testPricingOnNetwork(
-        dexalot,
-        network,
-        dexKey,
-        blockNumber,
-        tokenBSymbol,
-        tokenASymbol,
-        SwapSide.SELL,
-        amountsForTokenB,
-      );
-    });
-
-    it(`getPoolIdentifiers and getPricesVolume BUY ${tokenBSymbol} ${tokenASymbol}`, async function () {
-      await testPricingOnNetwork(
-        dexalot,
-        network,
-        dexKey,
-        blockNumber,
-        tokenBSymbol,
-        tokenASymbol,
-        SwapSide.BUY,
-        amountsForTokenA,
-      );
-    });
-
-    it('getTopPoolsForToken', async function () {
-      // We have to check without calling initializePricing, because
-      // pool-tracker is not calling that function
-      const dexalot = new Dexalot(network, dexKey, dexHelper);
-      const poolLiquidity = await dexalot.getTopPoolsForToken(
-        tokens[tokenASymbol].address,
-        10,
-      );
-      console.log(`${tokenASymbol} Top Pools:`, poolLiquidity);
-
-      if (!dexalot.hasConstantPriceLargeAmounts) {
-        checkPoolsLiquidity(
-          poolLiquidity,
-          Tokens[network][tokenASymbol].address,
-          dexKey,
-        );
-      }
-    });
-  });
-});