@paraswap/dex-lib 3.9.4 → 3.9.5-gnosis.0

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

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

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/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);
 

package/src/types.ts

@@ -294,7 +294,7 @@ export type Config = {
   wrappedNativeTokenAddress: Address;
   hasEIP1559: boolean;
   augustusAddress: Address;
-  augustusV6Address?: Address;
+  augustusV6Address: Address;
   augustusRFQAddress: Address;
   tokenTransferProxyAddress: Address;
   multicallV2Address: Address;

package/tests/constants-e2e.ts

@@ -7,6 +7,7 @@ import {
   allowedFn,
   _balancesFn,
   _allowancesFn,
+  balanceAndBlacklistStatesFn,
 } from '../tests/smart-tokens';
 import { Address } from '../src/types';
 import { ETHER_ADDRESS, Network } from '../src/constants';
@@ -1177,6 +1178,12 @@ export const Tokens: {
       address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
       decimals: 6,
       symbol: 'USDC',
+      addBalance: balanceAndBlacklistStatesFn,
+      addAllowance: allowedFn,
+    },
+    SUSHI: {
+      address: '0xd4d42F0b6DEF4CE0383636770eF773390d85c61A',
+      decimals: 18,
     },
     crvUSD: {
       address: '0x498bf2b1e120fed3ad3d42ea2165e9b73f99c1e5',
@@ -1319,6 +1326,8 @@ export const Tokens: {
     WETH: {
       address: '0x4200000000000000000000000000000000000006',
       decimals: 18,
+      addBalance: balanceOfFn,
+      addAllowance: allowanceFn,
     },
     ETH: { address: ETHER_ADDRESS, decimals: 18 },
     USDCe: {
@@ -1450,6 +1459,60 @@ export const Tokens: {
       decimals: 6,
     },
   },
+  [Network.GNOSIS]: {
+    XDAI: {
+      address: ETHER_ADDRESS,
+      decimals: 18,
+    },
+    WETH: {
+      address: '0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1',
+      decimals: 18,
+    },
+    WBTC: {
+      address: '0x8e5bBbb09Ed1ebdE8674Cda39A0c169401db4252',
+      decimals: 8,
+    },
+    USDC: {
+      address: '0xDDAfbb505ad214D7b80b1f830fcCc89B60fb7A83',
+      decimals: 6,
+    },
+    USDT: {
+      address: '0x4ECaBa5870353805a9F068101A40E0f32ed605C6',
+      decimals: 6,
+    },
+    WXDAI: {
+      address: '0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d',
+      decimals: 18,
+    },
+    aGnoWETH: {
+      address: '0xa818f1b57c201e092c4a2017a91815034326efd1',
+      decimals: 18,
+    },
+    aGnowstETH: {
+      address: '0x23e4e76d01b2002be436ce8d6044b0aa2f68b68a',
+      decimals: 18,
+    },
+    aGnoUSDC: {
+      address: '0xc6b7aca6de8a6044e0e32d0c841a89244a10d284',
+      decimals: 6,
+    },
+    wstETH: {
+      address: '0x6C76971f98945AE98dD7d4DFcA8711ebea946eA6',
+      decimals: 18,
+    },
+    aGnoWXDAI: {
+      address: '0xd0dd6cef72143e22cced4867eb0d5f2328715533',
+      decimals: 18,
+    },
+    sDAI: {
+      address: '0xaf204776c7245bF4147c2612BF6e5972Ee483701',
+      decimals: 18,
+    },
+    crvUSD: {
+      address: '0xaBEf652195F98A91E490f047A5006B71c85f058d',
+      decimals: 18,
+    },
+  },
   [Network.BASE]: {
     wstETH: {
       address: `0xc1cba3fcea344f92d9239c08c0568f6f2f0ee452`,
@@ -1887,6 +1950,20 @@ export const Holders: {
     WBTC: '0x99b31498b0a1dae01fc3433e3cb60f095340935c',
     USDC: '0x99b31498b0a1dae01fc3433e3cb60f095340935c',
   },
+  [Network.GNOSIS]: {
+    XDAI: '0x9fc062032d4F2Fe7dAA601bd8B06C45F9c8f17Be',
+    WXDAI: '0xBA12222222228d8Ba445958a75a0704d566BF2C8',
+    WETH: '0x800e12aF6c96790EDDdc5B3f3302899e27B2A918',
+    USDT: '0x1098503a90c3224F0e6BE7c124a337888C0BA564',
+    WBTC: '0x8e5bBbb09Ed1ebdE8674Cda39A0c169401db4252',
+    USDC: '0xd4A39d219ADB43aB00739DC5D876D98Fdf0121Bf',
+    aGnoWXDAI: '0x458cD345B4C05e8DF39d0A07220feb4Ec19F5e6f',
+    aGnoUSDC: '0x458cD345B4C05e8DF39d0A07220feb4Ec19F5e6f',
+    wstETH: '0x458cD345B4C05e8DF39d0A07220feb4Ec19F5e6f',
+    aGnowstETH: '0x458cD345B4C05e8DF39d0A07220feb4Ec19F5e6f',
+    sDAI: '0x79f08F2e75A8C99428DE4A2e6456c07C99E55da5',
+    crvUSD: '0xE4A982fa1f1E8AD1AF238A7b1226b13b56bf5CcD',
+  },
   [Network.BASE]: {
     WETH: '0x4bb6b2efe7036020ba6f02a05602546c9f25bf28',
     PRIME: '0xe3879b7359695f802d6FD56Bb76fD82C362Dafd6',
@@ -1938,6 +2015,7 @@ export const NativeTokenSymbols: { [network: number]: string } = {
   [Network.ARBITRUM]: 'ETH',
   [Network.OPTIMISM]: 'ETH',
   [Network.BASE]: 'ETH',
+  [Network.GNOSIS]: 'XDAI',
 };
 
 export const WrappedNativeTokenSymbols: { [network: number]: string } = {
@@ -1949,4 +2027,5 @@ export const WrappedNativeTokenSymbols: { [network: number]: string } = {
   [Network.ARBITRUM]: 'WETH',
   [Network.OPTIMISM]: 'WETH',
   [Network.BASE]: 'WETH',
+  [Network.GNOSIS]: 'WXDAI',
 };

package/tests/smart-tokens.ts

@@ -43,6 +43,9 @@ const constructAddBAllowanceFn = (varName: string): AddAllowanceFn => {
 
 export const balanceOfFn = constructAddBalanceFn('balanceOf');
 export const balancesFn = constructAddBalanceFn('balances');
+export const balanceAndBlacklistStatesFn = constructAddBalanceFn(
+  'balanceAndBlacklistStates',
+);
 export const _balancesFn = constructAddBalanceFn('_balances');
 export const allowanceFn = constructAddBAllowanceFn('allowance');
 export const _allowancesFn = constructAddBAllowanceFn('_allowances');

package/tests/utils-e2e.ts

@@ -777,7 +777,9 @@ export async function newTestE2E({
           .addBalance(senderAddress, twiceAmount.toString())
           .addAllowance(
             senderAddress,
-            config.tokenTransferProxyAddress,
+            priceRoute.version === ParaSwapVersion.V5
+              ? config.tokenTransferProxyAddress
+              : config.augustusV6Address,
             amount.toString(),
           );
       } else {
@@ -785,7 +787,9 @@ export async function newTestE2E({
           .addBalance(senderAddress, MAX_UINT)
           .addAllowance(
             senderAddress,
-            config.tokenTransferProxyAddress,
+            priceRoute.version === ParaSwapVersion.V5
+              ? config.tokenTransferProxyAddress
+              : config.augustusV6Address,
             (BigInt(MAX_UINT) / 8n).toString(),
           );
       }