@paraswap/dex-lib 2.33.1 → 2.33.3

package/src/dex/index.ts

@@ -51,6 +51,7 @@ import { SpiritSwapV2 } from './solidly/forks-override/spiritSwapV2';
 import { Synthetix } from './synthetix/synthetix';
 import { Cone } from './solidly/forks-override/cone';
 import { SoliSnek } from './solidly/forks-override/solisnek';
+import { Equalizer } from './solidly/forks-override/equalizer';
 import { BalancerV1 } from './balancer-v1/balancer-v1';
 import { balancerV1Merge } from './balancer-v1/optimizer';
 import { CurveV1 } from './curve-v1/curve-v1';
@@ -72,6 +73,7 @@ import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 import { Algebra } from './algebra/algebra';
+import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 
 const LegacyDexes = [
   CurveV2,
@@ -133,6 +135,7 @@ const Dexes = [
   VelodromeV2,
   Cone,
   SoliSnek,
+  Equalizer,
   Synthetix,
   CurveV1Factory,
   SwaapV1,
@@ -141,6 +144,7 @@ const Dexes = [
   MaverickV1,
   Camelot,
   SwaapV2,
+  NomiswapV2,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/solidly/config.ts

@@ -148,6 +148,16 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 0,
     },
   },
+  Equalizer: {
+    [Network.FANTOM]: {
+      factoryAddress: '0xc6366EFD0AF1d09171fe0EBF32c7943BB310832a',
+      router: '0x93d2611EB8b85bE4FDEa9D94Ce9913D90072eC0f',
+      initCode:
+        '0x02ada2a0163cd4f7e0f0c9805f5230716a95b174140e4c84c14883de216cc6a3',
+      feeCode: 0,
+      poolGasCost: 180 * 1000,
+    },
+  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {
@@ -155,7 +165,7 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'PolygonAdapter02', index: 3 }], // dystopia
   },
   [Network.FANTOM]: {
-    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly + spiritSwapV2
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly + spiritSwapV2 + Equalizer
   },
   [Network.OPTIMISM]: {
     [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 8 }], // velodrome

package/src/dex/solidly/forks-override/equalizer.ts

@@ -0,0 +1,58 @@
+import { Solidly } from '../solidly';
+import { SolidlyPair } from '../types';
+import { Network } from '../../../constants';
+import { IDexHelper } from '../../../dex-helper';
+import { Interface } from '@ethersproject/abi';
+import { getDexKeysWithNetwork } from '../../../utils';
+import { SolidlyConfig } from '../config';
+import _ from 'lodash';
+
+const EqualizerFactoryABI = [
+  {
+    inputs: [{ internalType: 'address', name: '_pair', type: 'address' }],
+    name: 'getRealFee',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+];
+
+const equalizerFactoryIface = new Interface(EqualizerFactoryABI);
+
+export class Equalizer extends Solidly {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['Equalizer']));
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      true, // dynamic fees
+    );
+  }
+
+  protected getFeesMultiCallData(pair: SolidlyPair) {
+    const callEntry = {
+      target: this.factoryAddress,
+      callData: equalizerFactoryIface.encodeFunctionData('getRealFee', [
+        pair.exchange,
+      ]),
+    };
+    const callDecoder = (values: any[]) =>
+      parseInt(
+        equalizerFactoryIface
+          .decodeFunctionResult('getRealFee', values)[0]
+          .toString(),
+      );
+
+    return {
+      callEntry,
+      callDecoder,
+    };
+  }
+}

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

@@ -2,7 +2,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders, NativeTokenSymbols } from '../../../tests/constants-e2e';
+import {
+  Tokens,
+  Holders,
+  NativeTokenSymbols,
+} from '../../../tests/constants-e2e';
 import { Network, ContractMethod, SwapSide } from '../../constants';
 import { StaticJsonRpcProvider } from '@ethersproject/providers';
 import { generateConfig } from '../../config';
@@ -389,6 +393,28 @@ describe('Solidly E2E', () => {
         });
       });
     });
+
+    describe('Equalizer', () => {
+      const dexKey = 'Equalizer';
+      const network = Network.FANTOM;
+
+      const tokenASymbol: string = 'FUSDT';
+      const tokenBSymbol: string = 'USDC';
+
+      const tokenAAmount: string = '111110';
+      const tokenBAmount: string = '100000';
+      const nativeTokenAmount = '11000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
   });
 
   describe('Mainnet', () => {
@@ -1378,5 +1404,4 @@ describe('Solidly E2E', () => {
       );
     });
   });
-
 });

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

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 import dotenv from 'dotenv';
 dotenv.config();
 
@@ -15,6 +16,7 @@ import { Chronos } from './forks-override/chronos';
 import { Ramses } from './forks-override/ramses';
 import * as util from 'util';
 import { VelodromeV2 } from './forks-override/velodromeV2';
+import { Equalizer } from './forks-override/equalizer';
 
 const amounts18 = [0n, BI_POWS[18], 2000000000000000000n];
 const amounts6 = [0n, BI_POWS[6], 2000000n];
@@ -46,7 +48,7 @@ function decodeReaderResult(
 const constructCheckOnChainPricing =
   (dexHelper: DummyDexHelper) =>
   async (
-    soldily: Solidly,
+    solidly: Solidly,
     funcName: string,
     blockNumber: number,
     prices: bigint[],
@@ -88,7 +90,7 @@ describe('Solidly integration tests', () => {
 
     describe('Solidly', function () {
       const dexKey = 'Solidly';
-      const soldily = new Solidly(network, dexKey, dexHelper);
+      const solidly = new Solidly(network, dexKey, dexHelper);
 
       describe('UniswapV2 like pool', function () {
         const TokenASymbol = 'WFTM';
@@ -100,7 +102,7 @@ describe('Solidly integration tests', () => {
 
         it('getPoolIdentifiers and getPricesVolume', async function () {
           const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-          const pools = await soldily.getPoolIdentifiers(
+          const pools = await solidly.getPoolIdentifiers(
             tokenA,
             tokenB,
             SwapSide.SELL,
@@ -113,7 +115,7 @@ describe('Solidly integration tests', () => {
 
           expect(pools.length).toBeGreaterThan(0);
 
-          const poolPrices = await soldily.getPricesVolume(
+          const poolPrices = await solidly.getPricesVolume(
             tokenA,
             tokenB,
             amounts,
@@ -131,13 +133,13 @@ describe('Solidly integration tests', () => {
 
           // Check if onchain pricing equals to calculated ones
 
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
-              soldily,
+              solidly,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -145,7 +147,7 @@ describe('Solidly integration tests', () => {
         });
 
         it('getTopPoolsForToken', async function () {
-          const poolLiquidity = await soldily.getTopPoolsForToken(
+          const poolLiquidity = await solidly.getTopPoolsForToken(
             tokenA.address,
             10,
           );
@@ -165,7 +167,7 @@ describe('Solidly integration tests', () => {
 
         it('getPoolIdentifiers and getPricesVolume', async function () {
           const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-          const pools = await soldily.getPoolIdentifiers(
+          const pools = await solidly.getPoolIdentifiers(
             tokenA,
             tokenB,
             SwapSide.SELL,
@@ -178,7 +180,7 @@ describe('Solidly integration tests', () => {
 
           expect(pools.length).toBeGreaterThan(0);
 
-          const poolPrices = await soldily.getPricesVolume(
+          const poolPrices = await solidly.getPricesVolume(
             tokenA,
             tokenB,
             amounts,
@@ -195,13 +197,13 @@ describe('Solidly integration tests', () => {
           checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
           // Check if onchain pricing equals to calculated ones
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
-              soldily,
+              solidly,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -209,7 +211,7 @@ describe('Solidly integration tests', () => {
         });
 
         it('getTopPoolsForToken', async function () {
-          const poolLiquidity = await soldily.getTopPoolsForToken(
+          const poolLiquidity = await solidly.getTopPoolsForToken(
             tokenA.address,
             10,
           );
@@ -265,13 +267,13 @@ describe('Solidly integration tests', () => {
 
           // Check if onchain pricing equals to calculated ones
 
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               spiritSwapV2,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -329,13 +331,13 @@ describe('Solidly integration tests', () => {
           checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
           // Check if onchain pricing equals to calculated ones
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               spiritSwapV2,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -353,6 +355,176 @@ describe('Solidly integration tests', () => {
         });
       });
     });
+
+    describe('Equalizer', () => {
+      const dexKey = 'Equalizer';
+      const equalizer = new Equalizer(network, dexKey, dexHelper);
+
+      describe('UniswapV2 like pool', function () {
+        const TokenASymbol = 'WFTM';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'FUSDT';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts18;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await equalizer.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await equalizer.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              equalizer,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+      });
+
+      describe('Curve like stable pool', function () {
+        const TokenASymbol = 'FUSDT';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'USDC';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts6; // amounts6;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await equalizer.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await equalizer.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              equalizer,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+      });
+
+      describe('FTM -> EQUAL', () => {
+        const TokenASymbol = 'WFTM';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'EQUAL';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = [0n, 10000000n];
+
+        console.log('AMOUNTS: ', amounts);
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          // const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const blocknumber = 67666611;
+          const pools = await equalizer.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await equalizer.getPricesVolume(
+            tokenA,
+            tokenB,
+            amounts,
+            SwapSide.SELL,
+            blocknumber,
+            pools,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
+            poolPrices,
+          );
+
+          expect(poolPrices).not.toBeNull();
+          checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+          // Check if onchain pricing equals to calculated ones
+          for (const poolPrice of poolPrices || []) {
+            await checkOnChainPricing(
+              equalizer,
+              'getAmountOut',
+              blocknumber,
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+      });
+    });
   });
 
   describe('Polygon', () => {
@@ -405,13 +577,13 @@ describe('Solidly integration tests', () => {
 
           // Check if onchain pricing equals to calculated ones
 
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               dystopia,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -469,13 +641,13 @@ describe('Solidly integration tests', () => {
           checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
           // Check if onchain pricing equals to calculated ones
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               dystopia,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -545,13 +717,13 @@ describe('Solidly integration tests', () => {
 
           // Check if onchain pricing equals to calculated ones
 
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               cone,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -609,13 +781,13 @@ describe('Solidly integration tests', () => {
           checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
           // Check if onchain pricing equals to calculated ones
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               cone,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -685,13 +857,13 @@ describe('Solidly integration tests', () => {
 
           // Check if onchain pricing equals to calculated ones
 
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               chronos,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -749,13 +921,13 @@ describe('Solidly integration tests', () => {
           checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
           // Check if onchain pricing equals to calculated ones
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               chronos,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -821,13 +993,13 @@ describe('Solidly integration tests', () => {
 
           // Check if onchain pricing equals to calculated ones
 
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               ramses,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -885,13 +1057,13 @@ describe('Solidly integration tests', () => {
           checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
           // Check if onchain pricing equals to calculated ones
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               ramses,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -961,13 +1133,13 @@ describe('Solidly integration tests', () => {
 
           // Check if onchain pricing equals to calculated ones
 
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               velodromeV2,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );
@@ -1015,13 +1187,13 @@ describe('Solidly integration tests', () => {
           checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
 
           // Check if onchain pricing equals to calculated ones
-          for (const i in poolPrices || []) {
+          for (const poolPrice of poolPrices || []) {
             await checkOnChainPricing(
               velodromeV2,
               'getAmountOut',
               blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
+              poolPrice.prices,
+              poolPrice.poolAddresses![0],
               tokenA.address,
               amounts,
             );

package/src/dex/solidly/solidly.ts

@@ -74,6 +74,7 @@ export class Solidly extends UniswapV2 {
         'SoliSnek',
         'Chronos',
         'Ramses',
+        'Equalizer',
       ]),
     );