@paraswap/dex-lib 2.21.0 → 2.21.1-chronos

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

@@ -353,115 +353,6 @@ describe('QuickSwap', () => {
         });
       });
     });
-
-    describe('CamelotV3', () => {
-      const dexKey = 'CamelotV3';
-
-      const sideToContractMethods = new Map([
-        [
-          SwapSide.SELL,
-          [
-            ContractMethod.simpleSwap,
-            ContractMethod.multiSwap,
-            ContractMethod.megaSwap,
-          ],
-        ],
-        [ SwapSide.BUY, [ ContractMethod.simpleBuy, ContractMethod.buy ] ],
-      ]);
-
-      const pairs: { name: string; sellAmount: string; buyAmount: string }[][] =
-        [
-          [
-            {
-              name: 'WBTC',
-              sellAmount: '1000',
-              buyAmount: '151080000000000',
-            },
-            {
-              name: 'WETH',
-              sellAmount: '1050000000000',
-              buyAmount: '1000',
-            },
-          ],
-          [
-            {
-              name: 'WBTC',
-              sellAmount: '1000',
-              buyAmount: '1300000',
-            },
-            {
-              name: 'USDC',
-              sellAmount: '1000000',
-              buyAmount: '1000',
-            },
-          ],
-          [
-            {
-              name: 'WETH',
-              sellAmount: '10000000000',
-              buyAmount: '10000000',
-            },
-            {
-              name: 'USDC',
-              sellAmount: '10000000',
-              buyAmount: '10000000000',
-            },
-          ],
-          [
-            {
-              name: 'ETH',
-              sellAmount: '10000000000',
-              buyAmount: '10000000',
-            },
-            {
-              name: 'USDC',
-              sellAmount: '10000000',
-              buyAmount: '10000000000',
-            },
-          ],
-        ];
-
-      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],
-                    side === SwapSide.SELL
-                      ? pair[0].sellAmount
-                      : pair[0].buyAmount,
-                    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],
-                    side === SwapSide.SELL
-                      ? pair[1].sellAmount
-                      : pair[1].buyAmount,
-                    side,
-                    dexKey,
-                    contractMethod,
-                    network,
-                    provider,
-                  );
-                });
-              });
-            });
-          });
-        }),
-      );
-    });
   });
 
   describe('Fantom', () => {

package/src/dex/simple-exchange.ts

@@ -1,6 +1,5 @@
 import { Interface } from '@ethersproject/abi';
 import Web3Abi, { AbiCoder } from 'web3-eth-abi';
-import { Contract } from 'web3-eth-contract';
 import { Address, SimpleExchangeParam, NumberAsString } from '../types';
 import { CACHE_PREFIX, ETHER_ADDRESS } from '../constants';
 import SimpleSwapHelperABI from '../abi/SimpleSwapHelperRouter.json';
@@ -10,7 +9,6 @@ import { isETHAddress } from '../utils';
 import { MAX_UINT } from '../constants';
 import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
-import { AbiItem } from 'web3-utils';
 
 /*
  * Context: Augustus routers have all a deadline protection logic implemented globally.
@@ -28,7 +26,6 @@ export class SimpleExchange {
   simpleSwapHelper: Interface;
   protected abiCoder: AbiCoder;
   erc20Interface: Interface;
-  erc20Contract: Contract;
 
   needWrapNative = false;
   isFeeOnTransferSupported = false;
@@ -45,9 +42,6 @@ export class SimpleExchange {
   constructor(dexHelper: IDexHelper, public dexKey: string) {
     this.simpleSwapHelper = new Interface(SimpleSwapHelperABI);
     this.erc20Interface = new Interface(ERC20ABI);
-    this.erc20Contract = new dexHelper.web3Provider.eth.Contract(
-      ERC20ABI as AbiItem[],
-    );
     this.abiCoder = Web3Abi as unknown as AbiCoder;
 
     this.network = dexHelper.config.data.network;

package/src/dex/solidly/config.ts

@@ -114,6 +114,17 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 2,
     },
   },
+  Chronos: {
+    [Network.ARBITRUM]: {
+      subgraphURL: 'https://api.thegraph.com/subgraphs/name/xliee/chronos',
+      factoryAddress: '0xce9240869391928253ed9cc9bcb8cb98cb5b0722',
+      router: '0xb2634B3CBc1E401AB3C2743DB44d459C5c9aA662',
+      initCode:
+        '0x1840ae455256f509042de907fe0623f2e5e0ad44751ef974c4c37c1e516b7644',
+      poolGasCost: 180 * 1000,
+      feeCode: 0,
+    },
+  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {
@@ -135,4 +146,7 @@ export const Adapters: Record<number, AdapterMappings> = {
   [Network.AVALANCHE]: {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 3 }], // solisnek
   },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 1 }], // chronos
+  },
 };

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

@@ -0,0 +1,206 @@
+import { Solidly } from '../solidly';
+import { SolidlyPair } from '../types';
+import { Network, SUBGRAPH_TIMEOUT } from '../../../constants';
+import { IDexHelper } from '../../../dex-helper';
+import { Interface } from '@ethersproject/abi';
+import { getDexKeysWithNetwork } from '../../../utils';
+import { SolidlyConfig } from '../config';
+import _ from 'lodash';
+import { Address, PoolLiquidity } from '../../../types';
+import BigNumber from 'bignumber.js';
+
+const ChronosFactoryABI = [
+  {
+    inputs: [{ internalType: 'bool', name: '_stable', type: 'bool' }],
+    name: 'getFee',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+];
+
+const chronosFactoryIface = new Interface(ChronosFactoryABI);
+
+type ChronosSubgraphPool = {
+  id: string;
+  isStable: boolean;
+  token0: { id: string; decimals: string };
+  reserve0: string;
+  reserve1: string;
+  token1: { id: string; decimals: string; };
+};
+
+export class Chronos extends Solidly {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['Chronos']));
+
+  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: chronosFactoryIface.encodeFunctionData('getFee', [pair.stable]),
+    };
+    const callDecoder = (values: any[]) =>
+      parseInt(
+        chronosFactoryIface
+          .decodeFunctionResult('getFee', values)[0]
+          .toString(),
+      );
+
+    return {
+      callEntry,
+      callDecoder,
+    };
+  }
+
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    count: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.subgraphURL) return [];
+
+    const query = `query ($token: Bytes!, $count: Int) {
+      pools0: pairs(first: $count, orderBy: reserve0, orderDirection: desc, where: {token0: $token, reserve0_gt: 1, reserve1_gt: 1}) {
+        id
+        isStable
+        token0 {
+          id
+          decimals
+        }
+        token1 {
+          id
+          decimals
+        }
+        reserve0,
+        reserve1,
+      }
+      pools1: pairs(first: $count, orderBy: reserve1, orderDirection: desc, where: {token1: $token, reserve0_gt: 1, reserve1_gt: 1}) {
+        id
+        isStable
+        token0 {
+          id
+          decimals
+        }
+        token1 {
+          id
+          decimals
+        },
+        reserve0,
+        reserve1,
+      }
+    }`;
+
+    const { data } = await this.dexHelper.httpRequest.post(
+      this.subgraphURL,
+      {
+        query,
+        variables: { token: tokenAddress.toLowerCase(), count },
+      },
+      SUBGRAPH_TIMEOUT,
+    );
+
+    if (!(data && data.pools0 && data.pools1))
+      throw new Error("Couldn't fetch the pools from the subgraph");
+
+    const pools0 = await this.prepareSubgraphPools(data.pools0, (pool,{
+      address1, decimals1, liquidityUSDToken0, liquidityUSDToken1,
+    }) => ({
+      exchange: this.dexKey,
+      stable: pool.isStable,
+      address: pool.id.toLowerCase(),
+      connectorTokens: [
+        {
+          address: address1,
+          decimals: decimals1,
+        },
+      ],
+      liquidityUSD: parseFloat((liquidityUSDToken0 + liquidityUSDToken1).toFixed()),
+    }));
+
+    const pools1 = await this.prepareSubgraphPools(data.pools1, (pool,{
+      address0, decimals0, liquidityUSDToken0, liquidityUSDToken1,
+    }) => ({
+      exchange: this.dexKey,
+      stable: pool.isStable,
+      address: pool.id.toLowerCase(),
+      connectorTokens: [
+        {
+          address: address0,
+          decimals: decimals0,
+        },
+      ],
+      liquidityUSD: parseFloat((liquidityUSDToken0 + liquidityUSDToken1).toFixed()),
+    }));
+
+    return _.slice(
+      _.sortBy(_.concat(pools0, pools1), [pool => -1 * pool.liquidityUSD]),
+      0,
+      count,
+    );
+  }
+
+  private async prepareSubgraphPools(
+    pools: ChronosSubgraphPool[],
+    iterator: (
+      pool: ChronosSubgraphPool, {
+        address0,
+        address1,
+        decimals0,
+        decimals1,
+        reserve0,
+        reserve1,
+        liquidityUSDToken0,
+        liquidityUSDToken1,
+      }: {
+        address0: string,
+        address1: string,
+        decimals0: number,
+        decimals1: number,
+        reserve0: bigint,
+        reserve1: bigint,
+        liquidityUSDToken0: number,
+        liquidityUSDToken1: number,
+      }) => PoolLiquidity
+  ): Promise<PoolLiquidity[]> {
+    return Promise.all(pools.map(async (
+      pool: ChronosSubgraphPool,
+    ) => {
+      const address0 = pool.token0.id.toLowerCase();
+      const address1 = pool.token1.id.toLowerCase();
+
+      const decimals0 = parseInt(pool.token0.decimals);
+      const decimals1 = parseInt(pool.token1.decimals);
+
+      const reserve0 = BigInt(new BigNumber(pool.reserve0).multipliedBy(10 ** decimals0).toFixed());
+      const reserve1 = BigInt(new BigNumber(pool.reserve1).multipliedBy(10 ** decimals1).toFixed());
+
+      const liquidityUSDToken0 = await this.dexHelper.getTokenUSDPrice({
+        address: address0,
+        decimals: decimals0,
+      }, reserve0);
+
+      const liquidityUSDToken1 = await this.dexHelper.getTokenUSDPrice({
+        address: address1,
+        decimals: decimals1,
+      }, reserve1);
+
+      return iterator(
+        pool, {
+          address0, address1, decimals0, decimals1, reserve0, reserve1, liquidityUSDToken0, liquidityUSDToken1,
+        },
+      );
+    }));
+  }
+}

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,
+  //           );
+  //         });
+  //       });
+  //     });
+  //   });
+  });
 });