@paraswap/dex-lib 3.9.7-fluid-dex.3 → 3.10.1

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

@@ -14,6 +14,8 @@ import {
 } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
 import ResolverABI from '../../abi/fluid-dex/resolver.abi.json';
+import { Contract } from 'ethers';
+import { Pool } from './types';
 
 /*
   README
@@ -33,14 +35,21 @@ import ResolverABI from '../../abi/fluid-dex/resolver.abi.json';
 function getReaderCalldata(
   exchangeAddress: string,
   readerIface: Interface,
+  poolAddress: string,
   amounts: bigint[],
   funcName: string,
+  pools: { address: string; token0: string; token1: string }[],
+  srcToken: string,
 ) {
+  const pool = pools.find(
+    item => item.address.toLowerCase() === poolAddress.toLowerCase(),
+  );
+
   return amounts.map(amount => ({
     target: exchangeAddress,
     callData: readerIface.encodeFunctionData(funcName, [
-      '0x0b1a513ee24972daef112bc777a5610d4325c9e7',
-      funcName == 'estimateSwapIn' ? true : false,
+      poolAddress,
+      pool!.token0.toLowerCase() === srcToken.toLowerCase() ? true : false,
       amount,
       funcName == 'estimateSwapIn' ? 0 : 2n * amount,
     ]),
@@ -60,20 +69,42 @@ function decodeReaderResult(
 async function checkOnChainPricing(
   fluidDex: FluidDex,
   funcName: string,
+  poolAddress: string,
   blockNumber: number,
   prices: bigint[],
   amounts: bigint[],
+  dexHelper: DummyDexHelper,
+  srcToken: string,
 ) {
   const resolverAddress = '0xE8a07a32489BD9d5a00f01A55749Cf5cB854Fd13';
 
   const readerIface = new Interface(ResolverABI);
 
+  const resolverContract = new Contract(
+    resolverAddress,
+    ResolverABI,
+    dexHelper.provider,
+  );
+  const rawResult = await resolverContract.callStatic.getAllPools({
+    blockTag: blockNumber,
+  });
+
+  const pools: Pool[] = rawResult.map((result: any) => ({
+    address: result[0],
+    token0: result[1],
+    token1: result[2],
+  }));
+
   const readerCallData = getReaderCalldata(
     resolverAddress,
     readerIface,
+    poolAddress,
     amounts.slice(1),
     funcName,
+    pools,
+    srcToken,
   );
+
   const readerResult = (
     await fluidDex.dexHelper.multiContract.methods
       .aggregate(readerCallData)
@@ -83,6 +114,8 @@ async function checkOnChainPricing(
   const expectedPrices = [0n].concat(
     decodeReaderResult(readerResult, readerIface, funcName),
   );
+
+  expect(prices).toEqual(expectedPrices);
 }
 
 async function testPricingOnNetwork(
@@ -95,6 +128,7 @@ async function testPricingOnNetwork(
   side: SwapSide,
   amounts: bigint[],
   funcNameToCheck: string,
+  dexHelper: DummyDexHelper,
 ) {
   const networkTokens = Tokens[network];
 
@@ -138,9 +172,12 @@ async function testPricingOnNetwork(
   await checkOnChainPricing(
     fluidDex,
     funcNameToCheck,
+    poolPrices![0].poolAddresses![0],
     blockNumber,
     poolPrices![0].prices,
     amounts,
+    dexHelper,
+    networkTokens[srcTokenSymbol].address,
   );
 }
 
@@ -153,8 +190,6 @@ describe('FluidDex', function () {
     const network = Network.MAINNET;
     const dexHelper = new DummyDexHelper(network);
 
-    const tokens = Tokens[network];
-
     beforeAll(async () => {
       blockNumber = await dexHelper.provider.getBlockNumber();
       fluidDex = new FluidDex(network, dexKey, dexHelper);
@@ -169,16 +204,16 @@ describe('FluidDex', function () {
 
       const amountsForSell = [
         0n,
-        1n * BI_POWS[8],
-        2n * BI_POWS[8],
-        3n * BI_POWS[8],
-        4n * BI_POWS[8],
-        5n * BI_POWS[8],
-        6n * BI_POWS[8],
-        7n * BI_POWS[8],
-        8n * BI_POWS[8],
-        9n * BI_POWS[8],
-        10n * BI_POWS[8],
+        1n * BI_POWS[18],
+        2n * BI_POWS[18],
+        3n * BI_POWS[18],
+        4n * BI_POWS[18],
+        5n * BI_POWS[18],
+        6n * BI_POWS[18],
+        7n * BI_POWS[18],
+        8n * BI_POWS[18],
+        9n * BI_POWS[18],
+        10n * BI_POWS[18],
       ];
 
       it('wstETH -> ETH, getPoolIdentifiers and getPricesVolume SELL', async function () {
@@ -192,6 +227,7 @@ describe('FluidDex', function () {
           SwapSide.SELL,
           amountsForSell,
           'estimateSwapIn',
+          dexHelper,
         );
       });
 
@@ -206,6 +242,7 @@ describe('FluidDex', function () {
           SwapSide.SELL,
           amountsForSell,
           'estimateSwapIn',
+          dexHelper,
         );
       });
     });
@@ -216,16 +253,16 @@ describe('FluidDex', function () {
 
       const amountsForSell = [
         0n,
-        1n * BI_POWS[6],
-        2n * BI_POWS[6],
-        3n * BI_POWS[6],
-        4n * BI_POWS[6],
-        5n * BI_POWS[6],
-        6n * BI_POWS[6],
-        7n * BI_POWS[6],
-        8n * BI_POWS[6],
-        9n * BI_POWS[6],
         10n * BI_POWS[6],
+        20n * BI_POWS[6],
+        30n * BI_POWS[6],
+        40n * BI_POWS[6],
+        50n * BI_POWS[6],
+        60n * BI_POWS[6],
+        70n * BI_POWS[6],
+        80n * BI_POWS[6],
+        90n * BI_POWS[6],
+        100n * BI_POWS[6],
       ];
 
       it('USDC -> USDT getPoolIdentifiers and getPricesVolume SELL', async function () {
@@ -239,6 +276,7 @@ describe('FluidDex', function () {
           SwapSide.SELL,
           amountsForSell,
           'estimateSwapIn',
+          dexHelper,
         );
       });
 
@@ -253,6 +291,7 @@ describe('FluidDex', function () {
           SwapSide.SELL,
           amountsForSell,
           'estimateSwapIn',
+          dexHelper,
         );
       });
     });

package/src/dex/fluid-dex/fluid-dex.ts

@@ -31,6 +31,8 @@ import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
 import { extractReturnAmountPosition } from '../../executor/utils';
 import { MultiResult } from '../../lib/multi-wrapper';
 import { generalDecoder } from '../../lib/decoders';
+import { BigNumber } from 'ethers';
+import { sqrt } from './utils';
 
 export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
   eventPools: { [id: string]: FluidDexEventPool } = {};
@@ -139,6 +141,8 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     side: SwapSide,
     blockNumber: number,
   ): Promise<string[]> {
+    if (side === SwapSide.BUY) return [];
+
     const pool = await this.getPoolByTokenPair(
       srcToken.address,
       destToken.address,
@@ -183,7 +187,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       if (srcToken.address.toLowerCase() === destToken.address.toLowerCase())
         return null;
 
-      if (side === SwapSide.BUY) throw new Error(`Buy not supported`);
+      if (side === SwapSide.BUY) return null;
       // Get the pool to use.
       const pool = await this.getPoolByTokenPair(
         srcToken.address,
@@ -358,15 +362,14 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
       return 0n;
     }
     const amountInAdjusted =
-      (((amountIn * (this.FEE_100_PERCENT - fee)) / this.FEE_100_PERCENT) *
-        BigInt(10 ** 12)) /
-      BigInt(10 ** inDecimals);
+      (amountIn * BigInt(10 ** 12)) / BigInt(10 ** inDecimals);
 
     const amountOut = this.swapInAdjusted(
       swap0To1,
       amountInAdjusted, // Convert back to number for internal calculations
       colReserves,
       debtReserves,
+      fee,
     );
     const result = (amountOut * BigInt(10 ** outDecimals)) / BigInt(10 ** 12);
     return result;
@@ -385,6 +388,7 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     amountToSwap: bigint,
     colReserves: CollateralReserves,
     debtReserves: DebtReserves,
+    fee: bigint,
   ): bigint {
     const {
       token0RealReserves,
@@ -466,22 +470,26 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     if (a <= BigInt(0)) {
       // Entire trade routes through debt pool
       amountOutDebt = this.getAmountOut(
-        amountToSwap,
+        this.applyFee(amountToSwap, fee),
         debtIReserveIn,
         debtIReserveOut,
       );
     } else if (a >= amountToSwap) {
       // Entire trade routes through collateral pool
       amountOutCollateral = this.getAmountOut(
-        amountToSwap,
+        this.applyFee(amountToSwap, fee),
         colIReserveIn,
         colIReserveOut,
       );
     } else {
       // Trade routes through both pools
-      amountOutCollateral = this.getAmountOut(a, colIReserveIn, colIReserveOut);
+      amountOutCollateral = this.getAmountOut(
+        this.applyFee(a, fee),
+        colIReserveIn,
+        colIReserveOut,
+      );
       amountOutDebt = this.getAmountOut(
-        amountToSwap - a,
+        this.applyFee(amountToSwap - a, fee),
         debtIReserveIn,
         debtIReserveOut,
       );
@@ -499,6 +507,10 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
     return totalAmountOut;
   }
 
+  applyFee(amount: bigint, fee: bigint): bigint {
+    return (amount * (this.FEE_100_PERCENT - fee)) / this.FEE_100_PERCENT;
+  }
+
   /**
    * Given an input amount of asset and pair reserves, returns the maximum output amount of the other asset.
    * @param amountIn - The amount of input asset.
@@ -599,18 +611,14 @@ export class FluidDex extends SimpleExchange implements IDex<FluidDexData> {
   ): bigint {
     // Adding 1e18 precision
 
-    const xyRoot = BigInt(Math.floor(Math.sqrt(Number(x * y * BigInt(1e18)))));
-    const x2y2Root = BigInt(
-      Math.floor(Math.sqrt(Number(x2 * y2 * BigInt(1e18)))),
-    );
+    const xyRoot = sqrt(BigNumber.from(x).mul(y).mul(BigInt(1e18))).toBigInt();
+    const x2y2Root = sqrt(
+      BigNumber.from(x2).mul(y2).mul(BigInt(1e18)),
+    ).toBigInt();
 
     // Calculating 'a' using the given formula
-    const a =
-      (Number(y2) * Number(xyRoot) +
-        Number(t) * Number(xyRoot) -
-        Number(y) * Number(x2y2Root)) /
-      (Number(xyRoot) + Number(x2y2Root));
-    return BigInt(Math.floor(a));
+    const a = (y2 * xyRoot + t * xyRoot - y * x2y2Root) / (xyRoot + x2y2Root);
+    return a;
   }
 
   /**

package/src/dex/fluid-dex/utils.ts

@@ -0,0 +1,15 @@
+import { BigNumber } from 'ethers';
+
+const ONE = BigNumber.from(1);
+const TWO = BigNumber.from(2);
+
+export function sqrt(value: BigNumber) {
+  let x = value;
+  let z = x.add(ONE).div(TWO);
+  let y = x;
+  while (z.sub(y).isNegative()) {
+    y = z;
+    z = x.div(z).add(z).div(TWO);
+  }
+  return y;
+}

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',