@paraswap/dex-lib 2.33.1-equalizer → 2.33.1-nomiswap-v2

package/src/dex/index.ts

@@ -51,7 +51,6 @@ 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';
@@ -73,6 +72,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,
@@ -134,7 +134,6 @@ const Dexes = [
   VelodromeV2,
   Cone,
   SoliSnek,
-  Equalizer,
   Synthetix,
   CurveV1Factory,
   SwaapV1,
@@ -143,6 +142,7 @@ const Dexes = [
   MaverickV1,
   Camelot,
   SwaapV2,
+  NomiswapV2,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/solidly/config.ts

@@ -148,16 +148,6 @@ 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> = {
@@ -165,7 +155,7 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'PolygonAdapter02', index: 3 }], // dystopia
   },
   [Network.FANTOM]: {
-    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly + spiritSwapV2 + Equalizer
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly + spiritSwapV2
   },
   [Network.OPTIMISM]: {
     [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 8 }], // velodrome

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

@@ -389,29 +389,6 @@ 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', () => {

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

@@ -15,7 +15,6 @@ 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];
@@ -354,120 +353,6 @@ 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 i in poolPrices || []) {
-            await checkOnChainPricing(
-              equalizer,
-              'getAmountOut',
-              blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].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 i in poolPrices || []) {
-            await checkOnChainPricing(
-              equalizer,
-              'getAmountOut',
-              blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
-              tokenA.address,
-              amounts,
-            );
-          }
-        });
-      });
-    });
   });
 
   describe('Polygon', () => {

package/src/dex/solidly/solidly.ts

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

package/src/dex/uniswap-v2/nomiswap-v2.ts

@@ -0,0 +1,62 @@
+import { Network } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { UniswapV2, UniswapV2Pair } from '../uniswap-v2/uniswap-v2';
+import { Interface } from '@ethersproject/abi';
+import NomiswapPoolABI from '../../abi/nomiswap-v2/nomiswap-v2-pool.json';
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+
+export const NomiswapV2Config: DexConfigMap<DexParams> = {
+  NomiswapV2: {
+    [Network.BSC]: {
+      factoryAddress: '0xd6715A8be3944ec72738F0BFDC739d48C3c29349',
+      initCode:
+        '0x83eb759f5ea0525124f03d4ac741bb4af0bb1c703d5f694bd42a8bd72e495a01',
+      poolGasCost: 120 * 1000,
+      feeCode: 0, // this is ignored as Nomiswap uses dynamic fees,
+      subgraphURL: 'https://api.thegraph.com/subgraphs/name/nominex/nomiswap-exchange-subgraph',
+    },
+  },
+};
+
+export class NomiswapV2 extends UniswapV2 {
+  nomiswapPool: Interface;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(NomiswapV2Config);
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      true,
+      NomiswapV2Config[dexKey][network].factoryAddress,
+      NomiswapV2Config[dexKey][network].subgraphURL,
+      NomiswapV2Config[dexKey][network].initCode,
+      NomiswapV2Config[dexKey][network].feeCode,
+      NomiswapV2Config[dexKey][network].poolGasCost,
+    );
+    this.nomiswapPool = new Interface(NomiswapPoolABI);
+  }
+
+  protected getFeesMultiCallData(pair: UniswapV2Pair) {
+    const callEntry = {
+      target: pair.exchange!,
+      callData: this.nomiswapPool.encodeFunctionData('swapFee', []),
+    };
+    const callDecoder = (values: any[]) =>
+      parseInt(
+        this.nomiswapPool.decodeFunctionResult('swapFee', values)[0].toString(),
+      ) * 10;
+    return {
+      callEntry,
+      callDecoder,
+    };
+  }
+}

package/src/dex/uniswap-v2/uniswap-v2-e2e-bsc.test.ts

@@ -2,11 +2,110 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { testE2E } from '../../../tests/utils-e2e';
-import { Tokens, Holders } 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';
 
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+  nativeTokenAmount: string,
+  slippage?: number | undefined,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const nativeTokenSymbol = NativeTokenSymbols[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+    [
+      SwapSide.BUY,
+      [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ],
+    ],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            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,
+                slippage,
+              );
+            });
+            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,
+                slippage,
+              );
+            });
+            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,
+                slippage,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
 describe('UniswapV2 E2E BSC', () => {
   const network = Network.BSC;
   const tokens = Tokens[network];
@@ -1407,6 +1506,28 @@ describe('UniswapV2 E2E BSC', () => {
     });
   });
 
+  describe('NomiswapV2', () => {
+    const dexKey = 'NomiswapV2';
+    const network = Network.BSC;
+
+    const tokenASymbol: string = 'USDC';
+    const tokenBSymbol: string = 'USDT';
+
+    const tokenAAmount: string = '1111100000';
+    const tokenBAmount: string = '1000000000';
+    const nativeTokenAmount = '11000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      nativeTokenAmount,
+    );
+  });
+
   describe(`Swapsicle`, () => {
     const dexKey = 'Swapsicle';
 

package/src/dex/uniswap-v3/uniswap-v3-e2e.test.ts

@@ -112,7 +112,6 @@ function testForNetwork(
   });
 }
 
-
 describe('UniswapV3 E2E', () => {
 
   describe('UniswapV3', () => {

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

@@ -1,58 +0,0 @@
-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: 'bool', name: '_stable', type: 'bool' }],
-    name: 'getFee',
-    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('getFee', [
-        pair.stable,
-      ]),
-    };
-    const callDecoder = (values: any[]) =>
-      parseInt(
-        equalizerFactoryIface
-          .decodeFunctionResult('getFee', values)[0]
-          .toString(),
-      );
-
-    return {
-      callEntry,
-      callDecoder,
-    };
-  }
-}