@paraswap/dex-lib 2.20.3 → 2.21.1-chronos

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

@@ -905,38 +905,39 @@ describe('Solidly E2E', () => {
         ],
       ]);
 
-      const pairs: { name: string; sellAmount: string }[][] = [
+      const pairs: { name: string; sellAmount: string; }[][] =
         [
-          {
-            name: 'BNB',
-            sellAmount: '1000000000000000000',
-          },
-          {
-            name: 'USDT',
-            sellAmount: '10000000000000000000',
-          },
-        ],
-        [
-          {
-            name: 'USDT',
-            sellAmount: '10000000000000000000',
-          },
-          {
-            name: 'USDC',
-            sellAmount: '10000000000000000000',
-          },
-        ],
-        [
-          {
-            name: 'ETH',
-            sellAmount: '5000000000000000000',
-          },
-          {
-            name: 'BNB',
-            sellAmount: '1000000000000000000',
-          },
-        ],
-      ];
+          [
+            {
+              name: 'BNB',
+              sellAmount: '1000000000000000000',
+            },
+            {
+              name: 'USDT',
+              sellAmount: '10000000000000000000',
+            },
+          ],
+          [
+            {
+              name: 'USDT',
+              sellAmount: '10000000000000000000',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '10000000000000000000',
+            },
+          ],
+          [
+            {
+              name: 'ETH',
+              sellAmount: '5000000000000000000',
+            },
+            {
+              name: 'BNB',
+              sellAmount: '1000000000000000000',
+            },
+          ]
+        ];
 
       sideToContractMethods.forEach((contractMethods, side) =>
         describe(`${side}`, () => {
@@ -1075,4 +1076,177 @@ describe('Solidly E2E', () => {
       });
     });
   });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const tokens = Tokens[network];
+    const holders = Holders[network];
+    const provider = new StaticJsonRpcProvider(
+      generateConfig(network).privateHttpProvider,
+      network,
+    );
+
+    describe(`Chronos`, () => {
+      const dexKey = 'Chronos';
+
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            ContractMethod.simpleSwap,
+            ContractMethod.multiSwap,
+            ContractMethod.megaSwap,
+          ],
+        ],
+      ]);
+
+      const pairs: { name: string; sellAmount: string; }[][] =
+        [
+          [
+            {
+              name: 'ETH',
+              sellAmount: '1000000000000000000',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '100000000',
+            },
+          ],
+          [
+            {
+              name: 'USDT',
+              sellAmount: '100000000',
+            },
+            {
+              name: 'USDC',
+              sellAmount: '100000000',
+            },
+          ],
+          [
+            {
+              name: 'USDC',
+              sellAmount: '100000000',
+            },
+            {
+              name: 'DAI',
+              sellAmount: '100000000000000000000',
+            },
+          ],
+          [
+            {
+              name: 'ARB',
+              sellAmount: '100000000',
+            },
+            {
+              name: 'ETH',
+              sellAmount: '100000000000000000000',
+            },
+          ]
+        ];
+
+      sideToContractMethods.forEach((contractMethods, side) =>
+        describe(`${side}`, () => {
+          contractMethods.forEach((contractMethod: ContractMethod) => {
+            pairs.forEach(pair => {
+              describe(`${contractMethod}`, () => {
+                it(`${pair[0].name} -> ${pair[1].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[0].name],
+                    tokens[pair[1].name],
+                    holders[pair[0].name],
+                    pair[0].sellAmount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+                it(`${pair[1].name} -> ${pair[0].name}`, async () => {
+                  await testE2E(
+                    tokens[pair[1].name],
+                    tokens[pair[0].name],
+                    holders[pair[1].name],
+                    pair[1].sellAmount,
+                    side,
+                    dexKey,
+                    contractMethod,
+                    network,
+                    provider,
+                  );
+                });
+              });
+            });
+          });
+        }),
+      );
+    });
+
+  //     describe(`simpleSwap`, () => {
+  //       describe(`Volatile`, () => {
+  //         it('ETH -> USDC', async () => {
+  //           await testE2E(
+  //             tokens.ETH,
+  //             tokens.USDC,
+  //             holders.ETH,
+  //             '1000000000000000000',
+  //             SwapSide.SELL,
+  //             dexKey,
+  //             ContractMethod.simpleSwap,
+  //             network,
+  //             provider,
+  //           );
+  //         });
+  //       });
+  //       describe(`Stable`, () => {
+  //         it('USDC -> USDT', async () => {
+  //           await testE2E(
+  //             tokens.USDC,
+  //             tokens.USDT,
+  //             holders.USDC,
+  //             '10000000',
+  //             SwapSide.SELL,
+  //             dexKey,
+  //             ContractMethod.simpleSwap,
+  //             network,
+  //             provider,
+  //           );
+  //         });
+  //       });
+  //     });
+  //
+  //     describe(`multiSwap`, () => {
+  //       describe(`Volatile`, () => {
+  //         it('ETH -> USDC', async () => {
+  //           await testE2E(
+  //             tokens.ETH,
+  //             tokens.USDC,
+  //             holders.ETH,
+  //             '1000000000000000000',
+  //             SwapSide.SELL,
+  //             dexKey,
+  //             ContractMethod.multiSwap,
+  //             network,
+  //             provider,
+  //           );
+  //         });
+  //       });
+  //       describe(`Stable`, () => {
+  //         it('USDC -> USDT', async () => {
+  //           await testE2E(
+  //             tokens.USDC,
+  //             tokens.USDT,
+  //             holders.USDC,
+  //             '10000000',
+  //             SwapSide.SELL,
+  //             dexKey,
+  //             ContractMethod.multiSwap,
+  //             network,
+  //             provider,
+  //           );
+  //         });
+  //       });
+  //     });
+  //   });
+  });
 });

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

@@ -11,6 +11,7 @@ import { Interface, Result } from '@ethersproject/abi';
 import solidlyPairABI from '../../abi/solidly/SolidlyPair.json';
 import { SpiritSwapV2 } from './forks-override/spiritSwapV2';
 import { Cone } from './forks-override/cone';
+import { Chronos } from './forks-override/chronos';
 
 const amounts18 = [0n, BI_POWS[18], 2000000000000000000n];
 const amounts6 = [0n, BI_POWS[6], 2000000n];
@@ -628,4 +629,144 @@ describe('Solidly integration tests', () => {
       });
     });
   });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+    const dexHelper = new DummyDexHelper(network);
+    const checkOnChainPricing = constructCheckOnChainPricing(dexHelper);
+
+    describe('Chronos', function () {
+      const dexKey = 'Chronos';
+      const chronos = new Chronos(network, dexKey, dexHelper);
+
+      describe('UniswapV2 like pool', function () {
+        const TokenASymbol = 'USDC';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'WETH';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts18;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await chronos.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await chronos.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(
+              chronos,
+              'getAmountOut',
+              blocknumber,
+              poolPrices![i].prices,
+              poolPrices![i].poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await chronos.getTopPoolsForToken(
+            tokenA.address,
+            10,
+          );
+          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+        });
+      });
+
+      describe('Curve like stable pool', function () {
+        const TokenASymbol = 'USDT';
+        const tokenA = Tokens[network][TokenASymbol];
+        const TokenBSymbol = 'USDC';
+        const tokenB = Tokens[network][TokenBSymbol];
+
+        const amounts = amounts6;
+
+        it('getPoolIdentifiers and getPricesVolume', async function () {
+          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
+          const pools = await chronos.getPoolIdentifiers(
+            tokenA,
+            tokenB,
+            SwapSide.SELL,
+            blocknumber,
+          );
+          console.log(
+            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
+            pools,
+          );
+
+          expect(pools.length).toBeGreaterThan(0);
+
+          const poolPrices = await chronos.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(
+              chronos,
+              'getAmountOut',
+              blocknumber,
+              poolPrices![i].prices,
+              poolPrices![i].poolAddresses![0],
+              tokenA.address,
+              amounts,
+            );
+          }
+        });
+
+        it('getTopPoolsForToken', async function () {
+          const poolLiquidity = await chronos.getTopPoolsForToken(
+            tokenA.address,
+            10,
+          );
+          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
+        });
+      });
+    });
+  });
 });

package/src/dex/solidly/solidly.ts

@@ -71,6 +71,7 @@ export class Solidly extends UniswapV2 {
         'SolidlyV2',
         'Thena',
         'SoliSnek',
+        'Chronos',
       ]),
     );
 

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

@@ -788,15 +788,9 @@ export class UniswapV2
     destToken: Address,
     srcAmount: NumberAsString,
     destAmount: NumberAsString,
-    expectedAmount: NumberAsString,
     _data: UniswapData,
     side: SwapSide,
     permit: string,
-    uuid: string,
-    feePercent: NumberAsString,
-    deadline: NumberAsString,
-    partner: string,
-    beneficiary: string,
     contractMethod?: string,
   ): TxInfo<UniswapParam> {
     if (!contractMethod) throw new Error(`contractMethod need to be passed`);

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

@@ -34,8 +34,3 @@ export const ZERO_ORACLE_OBSERVATION = {
 export const OUT_OF_RANGE_ERROR_POSTFIX = `INVALID_TICK_BIT_MAP_RANGES`;
 
 export const DEFAULT_POOL_INIT_CODE_HASH = `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`;
-
-export enum DirectMethods {
-  directSell = 'directUniV3Swap',
-  directBuy = 'directUniV3Buy',
-}

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

@@ -57,7 +57,6 @@ export type UniswapV3Data = {
     tokenOut: Address;
     fee: NumberAsString;
   }[];
-  isApproved?: boolean;
 };
 
 export type DexParams = {
@@ -73,7 +72,7 @@ export type DexParams = {
   initHash: string;
 };
 
-export type UniswapV3SimpleSwapSellParam = {
+export type UniswapV3SellParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -81,7 +80,7 @@ export type UniswapV3SimpleSwapSellParam = {
   amountOutMinimum: NumberAsString;
 };
 
-export type UniswapV3SimpleSwapBuyParam = {
+export type UniswapV3BuyParam = {
   path: string;
   recipient: Address;
   deadline: string;
@@ -89,26 +88,7 @@ export type UniswapV3SimpleSwapBuyParam = {
   amountInMaximum: NumberAsString;
 };
 
-export type UniswapV3SimpleSwapParams =
-  | UniswapV3SimpleSwapSellParam
-  | UniswapV3SimpleSwapBuyParam;
-
-export type UniswapV3Param = [
-  fromToken: Address,
-  toToken: Address,
-  exchange: Address,
-  fromAmount: NumberAsString,
-  toAmount: NumberAsString,
-  expectedAmount: NumberAsString,
-  feePercent: NumberAsString,
-  deadline: NumberAsString,
-  partner: Address,
-  isApproved: boolean,
-  beneficiary: Address,
-  path: string,
-  permit: string,
-  uuid: string,
-];
+export type UniswapV3Param = UniswapV3SellParam | UniswapV3BuyParam;
 
 export enum UniswapV3Functions {
   exactInput = 'exactInput',

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

@@ -49,20 +49,6 @@ describe('UniswapV3 E2E', () => {
         provider,
       );
     });
-
-    it('directSwap SELL WETH -> USDC', async () => {
-      await testE2E(
-        tokens['WETH'],
-        tokens['USDC'],
-        holders['WETH'],
-        '1000000000000000000',
-        SwapSide.SELL,
-        dexKey,
-        ContractMethod.directUniV3Swap,
-        network,
-        provider,
-      );
-    });
   });
 
   describe('UniswapV3 POLYGON', () => {
@@ -78,7 +64,7 @@ describe('UniswapV3 E2E', () => {
     const tokenBSymbol: string = 'WETH';
     const nativeTokenSymbol = NativeTokenSymbols[network];
 
-    const tokenAAmount: string = '11000000';
+    const tokenAAmount: string = '11111000000';
     const tokenBAmount: string = '11000000000000000000';
     const nativeTokenAmount = '11000000000000000000';
 
@@ -89,17 +75,9 @@ describe('UniswapV3 E2E', () => {
           ContractMethod.simpleSwap,
           ContractMethod.multiSwap,
           ContractMethod.megaSwap,
-          ContractMethod.directUniV3Swap,
-        ],
-      ],
-      [
-        SwapSide.BUY,
-        [
-          ContractMethod.simpleBuy,
-          ContractMethod.buy,
-          ContractMethod.directUniV3Buy,
         ],
       ],
+      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
     ]);
 
     sideToContractMethods.forEach((contractMethods, side) =>
@@ -224,80 +202,4 @@ describe('UniswapV3 E2E', () => {
       }),
     );
   });
-
-  describe('UniswapV3 Optimism', () => {
-    const network = Network.OPTIMISM;
-    const tokens = Tokens[network];
-    const holders = Holders[network];
-    const provider = new StaticJsonRpcProvider(
-      generateConfig(network).privateHttpProvider,
-      network,
-    );
-
-    const tokenASymbol: string = 'OP';
-    const tokenBSymbol: string = 'ETH';
-    const nativeTokenSymbol = NativeTokenSymbols[network];
-
-    const tokenAAmount: string = '1000000000000000000';
-    const tokenBAmount: string = '1000000000000000000';
-    const nativeTokenAmount = '1000000000000000000';
-
-    const sideToContractMethods = new Map([
-      [
-        SwapSide.SELL,
-        [
-          ContractMethod.simpleSwap,
-          ContractMethod.multiSwap,
-          ContractMethod.megaSwap,
-        ],
-      ],
-      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
-    ]);
-
-    sideToContractMethods.forEach((contractMethods, side) =>
-      contractMethods.forEach((contractMethod: ContractMethod) => {
-        describe(`${contractMethod}`, () => {
-          it(`${network} ${side} ${contractMethod} ${nativeTokenSymbol} -> ${tokenASymbol}`, async () => {
-            await testE2E(
-              tokens[nativeTokenSymbol],
-              tokens[tokenASymbol],
-              holders[nativeTokenSymbol],
-              side === SwapSide.SELL ? nativeTokenAmount : tokenAAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${nativeTokenSymbol}`, async () => {
-            await testE2E(
-              tokens[tokenASymbol],
-              tokens[nativeTokenSymbol],
-              holders[tokenASymbol],
-              side === SwapSide.SELL ? tokenAAmount : nativeTokenAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-          it(`${network} ${side} ${contractMethod} ${tokenASymbol} -> ${tokenBSymbol}`, async () => {
-            await testE2E(
-              tokens[tokenASymbol],
-              tokens[tokenBSymbol],
-              holders[tokenASymbol],
-              side === SwapSide.SELL ? tokenAAmount : tokenBAmount,
-              side,
-              dexKey,
-              contractMethod,
-              network,
-              provider,
-            );
-          });
-        });
-      }),
-    );
-  });
 });