@paraswap/dex-lib 2.36.2 → 2.36.3-dexalot.2

package/src/config.ts

@@ -30,6 +30,7 @@ type BaseConfig = {
   hashFlowAuthToken?: string;
   hashFlowDisabledMMs: string[];
   swaapV2AuthToken?: string;
+  dexalotAuthToken?: string;
   forceRpcFallbackDexs: string[];
 };
 
@@ -219,6 +220,7 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN || '',
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_43114`]?.split(',') || [],
+    dexalotAuthToken: process.env.API_KEY_DEXALOT_AUTH_TOKEN || '',
     adapterAddresses: {
       AvalancheAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
       AvalancheAdapter02: '0xFb8773AA4Fd02e54bbd352061D8Be1911FAa210a',
@@ -414,6 +416,7 @@ export function generateConfig(network: number): Config {
       baseConfig.rpcPollingBlocksBackToTriggerUpdate,
     hashFlowAuthToken: baseConfig.hashFlowAuthToken,
     swaapV2AuthToken: baseConfig.swaapV2AuthToken,
+    dexalotAuthToken: baseConfig.dexalotAuthToken,
     hashFlowDisabledMMs: baseConfig.hashFlowDisabledMMs,
     forceRpcFallbackDexs: baseConfig.forceRpcFallbackDexs,
   };

package/src/dex/dexalot/config.ts

@@ -0,0 +1,18 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network } 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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,192 @@
+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 = 5000;
+
+  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

@@ -0,0 +1,188 @@
+/* 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,
+        );
+      }
+    });
+  });
+});