@paraswap/dex-lib 3.9.7-fluid-dex.2 → 3.10.0

package/src/dex/curve-v1-factory/constants.ts

@@ -29,6 +29,7 @@ export const NETWORK_ID_TO_NAME: Record<number, string> = {
   [Network.ARBITRUM]: 'arbitrum',
   [Network.OPTIMISM]: 'optimism',
   [Network.BASE]: 'base',
+  [Network.GNOSIS]: 'xdai',
 };
 
 // They are hardcoded in factory contract. If factory is changing, must be

package/src/dex/curve-v1-factory/curve-v1-factory.ts

@@ -605,7 +605,8 @@ export class CurveV1Factory
           const allResultsFromFactory = (
             await this.dexHelper.multiWrapper.tryAggregate<
               string[] | number[] | string
-            >(true, callDataFromFactoryPools)
+              // decrease batch size to 450 to avoid 'out-of-limit' error on gnosis
+            >(true, callDataFromFactoryPools, undefined, 450)
           ).map(r => r.returnData);
 
           const resultsFromFactory = allResultsFromFactory.slice(

package/src/dex/curve-v1-stable-ng/config.ts

@@ -192,6 +192,34 @@ const CurveV1StableNgConfig: DexConfigMap<DexParams> = {
       },
       customPools: {},
     },
+    [Network.GNOSIS]: {
+      factories: [
+        {
+          address: '0xbc0797015fcfc47d9c1856639cae50d0e69fbee8',
+          isStableNg: true,
+        },
+      ],
+      router: '0x0dcded3545d565ba3b19e683431381007245d983', // https://github.com/curvefi/curve-router-ng
+      stateUpdatePeriodMs: 5 * 1000,
+      disabledPools: new Set([]),
+      disabledImplementations: new Set([]),
+      factoryPoolImplementations: {
+        // TODO-gnosis: check if there's no missing implementations
+        '0x3d6cb2f6dcf47cdd9c13e4e3beae9af041d8796a': {
+          name: ImplementationNames.FACTORY_STABLE_NG,
+          address: '0x3d6cb2f6dcf47cdd9c13e4e3beae9af041d8796a',
+          liquidityApiSlug: '/factory-stable-ng',
+          isStoreRateSupported: true,
+        },
+        '0xc1b393efef38140662b91441c6710aa704973228': {
+          name: ImplementationNames.FACTORY_STABLE_NG,
+          address: '0xc1b393efef38140662b91441c6710aa704973228',
+          liquidityApiSlug: '/factory-stable-ng',
+          isStoreRateSupported: true,
+        },
+      },
+      customPools: {},
+    },
   },
 };
 

package/src/dex/curve-v1-stable-ng/curve-v1-stable-ng-e2e.test.ts

@@ -196,4 +196,24 @@ describe('CurveV1StableNG E2E', () => {
       sidesToContractMethods,
     );
   });
+
+  describe('Gnosis', () => {
+    const network = Network.GNOSIS;
+
+    const tokenASymbol: string = 'sDAI';
+    const tokenBSymbol: string = 'crvUSD';
+
+    const tokenAAmount: string = '1000000000000000000';
+    const tokenBAmount: string = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+      sidesToContractMethods,
+    );
+  });
 });

package/src/dex/index.ts

@@ -86,7 +86,6 @@ import { Spark } from './spark/spark';
 import { VelodromeSlipstream } from './uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream';
 import { AaveV3Stata } from './aave-v3-stata/aave-v3-stata';
 import { OSwap } from './oswap/oswap';
-import { FluidDex } from './fluid-dex/fluid-dex';
 import { ConcentratorArusd } from './concentrator-arusd/concentrator-arusd';
 import { FxProtocolRusd } from './fx-protocol-rusd/fx-protocol-rusd';
 import { AaveGsm } from './aave-gsm/aave-gsm';
@@ -182,7 +181,6 @@ const Dexes = [
   UsualBond,
   StkGHO,
   SkyConverter,
-  FluidDex,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

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

@@ -427,6 +427,22 @@ export const UniswapV2Config: DexConfigMap<DexParams> = {
         '0xe18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303',
       feeCode: 30,
     },
+    [Network.GNOSIS]: {
+      subgraphURL: '7czeiia7ZXvsW45szX2w8EK1ZNgZWZET83zYCwE6JT9x',
+      factoryAddress: '0xc35dadb65012ec5796536bd9864ed8773abc74c4',
+      initCode:
+        '0xe18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303',
+      feeCode: 30,
+    },
+  },
+  HoneySwap: {
+    [Network.GNOSIS]: {
+      subgraphURL: '7vjh6q6gj6M1bhRNgkKZmWqd5jot79kV84BiQtUDQSdV',
+      factoryAddress: '0xa818b4f111ccac7aa31d0bcc0806d64f2e0737d7',
+      initCode:
+        '0xdbd265d4828759db2a0351a7b97180bcc41449a038bcd08a45afe937147f6267',
+      feeCode: 30,
+    },
   },
   Zyberswap: {
     [Network.ARBITRUM]: {

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

@@ -18,6 +18,17 @@ export const NomiswapV2Config: DexConfigMap<DexParams> = {
       subgraphURL: '5CBKsDihF7KeBrNX4bgtb4tVFqy41PguVm88zBGpd4Hi',
     },
   },
+  // not exactly the same, but swapFee logic works in the same way
+  SwaprV2: {
+    [Network.GNOSIS]: {
+      factoryAddress: '0x5D48C95AdfFD4B40c1AAADc4e08fc44117E02179',
+      initCode:
+        '0xfcee8e246628cf9708fcb9d6f5d4aa0d96b62bb50f1af012a75a3292849e2dca',
+      poolGasCost: 120 * 1000,
+      feeCode: 25, // this is ignored as SwaprV2 uses dynamic fees,
+      subgraphURL: 'EWoa3JwNntAWtaLsLixTU25smp4R5tzGvs9rFXx9NHKZ',
+    },
+  },
 };
 
 export class NomiswapV2 extends UniswapV2 {

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

@@ -0,0 +1,283 @@
+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';
+
+describe('UniswapV2 E2E Gnosis', () => {
+  const network = Network.GNOSIS;
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+
+  describe('SushiSwap', () => {
+    const dexKey = 'SushiSwap';
+
+    describe('swapExactAmountIn', () => {
+      it('SushiSwap ETH -> TOKEN', async () => {
+        await testE2E(
+          tokens.XDAI,
+          tokens.USDC,
+          holders.XDAI,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> ETH', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.XDAI,
+          holders.WETH,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> TOKEN', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.USDC,
+          holders.WETH,
+          '7000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+    });
+
+    describe('swapExactAmountOut', () => {
+      it('SushiSwap ETH -> TOKEN', async () => {
+        await testE2E(
+          tokens.XDAI,
+          tokens.USDC,
+          holders.XDAI,
+          '700000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> ETH', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.XDAI,
+          holders.USDC,
+          '7000000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> TOKEN', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.WETH,
+          holders.USDC,
+          '7000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+    });
+  });
+
+  describe('HoneySwap', () => {
+    const dexKey = 'HoneySwap';
+
+    describe('swapExactAmountIn', () => {
+      it('SushiSwap ETH -> TOKEN', async () => {
+        await testE2E(
+          tokens.XDAI,
+          tokens.USDC,
+          holders.XDAI,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> ETH', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.XDAI,
+          holders.WETH,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> TOKEN', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.USDC,
+          holders.WETH,
+          '7000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+    });
+
+    describe('swapExactAmountOut', () => {
+      it('SushiSwap ETH -> TOKEN', async () => {
+        await testE2E(
+          tokens.XDAI,
+          tokens.USDC,
+          holders.XDAI,
+          '700000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> ETH', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.XDAI,
+          holders.USDC,
+          '7000000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('SushiSwap TOKEN -> TOKEN', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.WETH,
+          holders.USDC,
+          '700000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+    });
+  });
+
+  describe('SwaprV2', () => {
+    const dexKey = 'SwaprV2';
+
+    describe('swapExactAmountIn', () => {
+      it('SushiSwap ETH -> TOKEN', async () => {
+        await testE2E(
+          tokens.XDAI,
+          tokens.USDC,
+          holders.XDAI,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('SwaprV2 TOKEN -> ETH', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.XDAI,
+          holders.WETH,
+          '700000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+      it('SwaprV2 TOKEN -> TOKEN', async () => {
+        await testE2E(
+          tokens.WETH,
+          tokens.USDC,
+          holders.WETH,
+          '7000000000000000',
+          SwapSide.SELL,
+          dexKey,
+          ContractMethod.swapExactAmountIn,
+          network,
+          provider,
+        );
+      });
+    });
+
+    describe('swapExactAmountOut', () => {
+      it('SwaprV2 ETH -> TOKEN', async () => {
+        await testE2E(
+          tokens.XDAI,
+          // SWPR/WXDAI pool has non-standard feeCode - 100
+          tokens.SWPR,
+          holders.XDAI,
+          '7000000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('SwaprV2 TOKEN -> ETH', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.XDAI,
+          holders.USDC,
+          '7000000000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+      it('SwaprV2 TOKEN -> TOKEN', async () => {
+        await testE2E(
+          tokens.USDC,
+          tokens.WETH,
+          holders.USDC,
+          '700000000000000',
+          SwapSide.BUY,
+          dexKey,
+          ContractMethod.swapExactAmountOut,
+          network,
+          provider,
+        );
+      });
+    });
+  });
+});

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

@@ -681,7 +681,7 @@ export class UniswapV2
   }
 
   getAdapters(side: SwapSide): { name: string; index: number }[] | null {
-    return this.adapters[side];
+    return this.adapters?.[side] ?? null;
   }
 
   async getTopPoolsForToken(

package/src/dex/uniswap-v3/config.ts

@@ -346,6 +346,20 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       subgraphURL: 'https://api.studio.thegraph.com/query/59130/v3alb/0.3',
     },
   },
+  OkuTradeV3: {
+    [Network.GNOSIS]: {
+      factory: '0xe32f7dd7e3f098d518ff19a22d5f028e076489b1',
+      quoter: '0x7E9cB3499A6cee3baBe5c8a3D328EA7FD36578f4',
+      router: '0xB5253c895361678FF5D0fFDdA81Dd02f1F7a81D6',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x35Db9Ac2ff3C5A86fde165Bd26D43d303417942E',
+      uniswapMulticall: '0x4dfa9a980efE4802E969AC33968E3d6E59B8a19e',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash: `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`,
+      subgraphURL: 'Dimv1udMsJu1DqirVM4G2vNRvH8CWzWTn7GffQQCGAaq',
+    },
+  },
   VelodromeSlipstream: {
     [Network.OPTIMISM]: {
       factory: '0x548118C7E0B865C2CfA94D15EC86B666468ac758',

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

@@ -1364,4 +1364,28 @@ describe('UniswapV3 E2E', () => {
       });
     });
   });
+
+  describe('OkuTradeV3 E2E', () => {
+    const dexKey = 'OkuTradeV3';
+    describe('Gnosis', () => {
+      const network = Network.GNOSIS;
+
+      const tokenASymbol: string = 'WETH';
+      const tokenBSymbol: string = 'sDAI';
+
+      const tokenAAmount: string = '1000000000000000000';
+      const tokenBAmount: string = '1000000000000000000';
+      const nativeTokenAmount = '1000000000000000000';
+
+      testForNetwork(
+        network,
+        dexKey,
+        tokenASymbol,
+        tokenBSymbol,
+        tokenAAmount,
+        tokenBAmount,
+        nativeTokenAmount,
+      );
+    });
+  });
 });

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

@@ -115,6 +115,7 @@ export class UniswapV3
         'BaseswapV3',
         'PharaohV2',
         'AlienBaseV3',
+        'OkuTradeV3',
       ]),
     );
 

package/src/dex/weth/config.ts

@@ -46,6 +46,11 @@ export const WethConfig: DexConfigMap<DexParams> = {
       poolGasCost: WethGasCost,
     },
   },
+  Wxdai: {
+    [Network.GNOSIS]: {
+      poolGasCost: WethGasCost,
+    },
+  },
 };
 
 export const Adapters: {

package/src/dex/wusdm/config.ts

@@ -25,4 +25,12 @@ export const WUSDMConfig: DexConfigMap<WusdmParams> = {
       USDMAddress: '0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C',
     },
   },
+  // not really wUSDM, but works in the same way
+  // might give 1wei difference on BUY
+  sDAI: {
+    [Network.GNOSIS]: {
+      wUSDMAddress: '0xaf204776c7245bF4147c2612BF6e5972Ee483701', // sDAI
+      USDMAddress: '0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d', // WXDAI
+    },
+  },
 };

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

@@ -163,4 +163,42 @@ describe('MountainProtocol E2E', () => {
       tokenBAmount,
     );
   });
+
+  describe('Gnosis', () => {
+    const network = Network.GNOSIS;
+
+    const tokenASymbol: string = 'sDAI';
+    const tokenBSymbol: string = 'WXDAI';
+
+    const tokenAAmount: string = '500000000000000000';
+    const tokenBAmount: string = '500000000000000000';
+
+    testForNetwork(
+      network,
+      'sDAI',
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+
+  describe('Gnosis with Native', () => {
+    const network = Network.GNOSIS;
+
+    const tokenASymbol: string = 'sDAI';
+    const tokenBSymbol: string = 'XDAI';
+
+    const tokenAAmount: string = '500000000000000000';
+    const tokenBAmount: string = '500000000000000000';
+
+    testForNetwork(
+      network,
+      'sDAI',
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
 });

package/src/dex/wusdm/wusdm.ts

@@ -38,6 +38,7 @@ export class WUSDM
 {
   readonly hasConstantPriceLargeAmounts = true;
   readonly isFeeOnTransferSupported = false;
+  readonly needWrapNative: boolean = true;
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(WUSDMConfig);
@@ -89,7 +90,10 @@ export class WUSDM
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
-    return this.isAppropriatePair(srcToken, destToken)
+    const _srcToken = this.dexHelper.config.wrapETH(srcToken);
+    const _destToken = this.dexHelper.config.wrapETH(destToken);
+
+    return this.isAppropriatePair(_srcToken, _destToken)
       ? [`${this.dexKey}_${this.wUSDMAddress}`]
       : [];
   }
@@ -121,13 +125,16 @@ export class WUSDM
     blockNumber: number,
     limitPools?: string[],
   ): Promise<null | ExchangePrices<WUSDMData>> {
-    if (!this.isAppropriatePair(srcToken, destToken)) return null;
+    const _srcToken = this.dexHelper.config.wrapETH(srcToken);
+    const _destToken = this.dexHelper.config.wrapETH(destToken);
+
+    if (!this.isAppropriatePair(_srcToken, _destToken)) return null;
     const state = this.eventPool.getState(blockNumber);
     if (!state) return null;
 
-    const isSrcAsset = this.isUSDM(srcToken.address);
+    const isSrcAsset = this.isUSDM(_srcToken.address);
 
-    const isWrap = this.isWrap(srcToken, destToken, side);
+    const isWrap = this.isWrap(_srcToken, _destToken, side);
 
     let calcFunction: Function;
 

package/src/executor/WETHBytecodeBuilder.ts

@@ -1,9 +1,9 @@
 import { DexExchangeBuildParam } from '../types';
-import { OptimalRate, SwapSide } from '@paraswap/core';
+import { OptimalRate } from '@paraswap/core';
 import { isETHAddress } from '../utils';
 import { DepositWithdrawReturn } from '../dex/weth/types';
 import { WethConfig } from '../dex/weth/config';
-import { Executors, Flag, SpecialDex } from './types';
+import { Executors } from './types';
 import { ExecutorBytecodeBuilder } from './ExecutorBytecodeBuilder';
 import { Network } from '../constants';
 
@@ -15,6 +15,7 @@ const SUPPORTED_NETWORKS = [
   Network.POLYGON,
   Network.OPTIMISM,
   Network.ZKEVM,
+  Network.GNOSIS,
 ];
 const SUPPORTED_EXCHANGES = Object.keys(WethConfig);