@paraswap/dex-lib 2.21.1 → 2.21.3-chronos

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: liquidityUSDToken0 + liquidityUSDToken1,
+    }));
+
+    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: liquidityUSDToken0 + liquidityUSDToken1,
+    }));
+
+    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

@@ -1075,4 +1075,176 @@ 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/tests/constants-e2e.ts

@@ -704,6 +704,10 @@ export const Tokens: {
       address: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
       decimals: 18,
     },
+    ARB: {
+      address: '0x912ce59144191c1204e64559fe8253a0e49e6548',
+      decimals: 18,
+    },
     WETH: {
       address: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
       decimals: 18,
@@ -987,6 +991,7 @@ export const Holders: {
     YUSD: '0x6c1a5ef2acde1fd2fc68def440d2c1eb35bae24a',
   },
   [Network.ARBITRUM]: {
+    ARB: '0xb65edba80a3d81903ecd499c8eb9cf0e19096bd0',
     ETH: '0xF977814e90dA44bFA03b6295A0616a897441aceC',
     DAI: '0x07d7f291e731a41d3f0ea4f1ae5b6d920ffb3fe0',
     WETH: '0xc31e54c7a869b9fcbecc14363cf510d1c41fa443',

package/build/dex/test-dex/config.d.ts

@@ -1,4 +0,0 @@
-import { DexParams } from './types';
-import { DexConfigMap, AdapterMappings } from '../../types';
-export declare const TestDexConfig: DexConfigMap<DexParams>;
-export declare const Adapters: Record<number, AdapterMappings>;

package/build/dex/test-dex/config.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Adapters = exports.TestDexConfig = void 0;
-const constants_1 = require("../../constants");
-exports.TestDexConfig = {
-    TestDex: {
-    // TODO: complete me!
-    },
-};
-exports.Adapters = {
-    // TODO: add adapters for each chain
-    // This is an example to copy
-    [constants_1.Network.MAINNET]: { [constants_1.SwapSide.SELL]: [{ name: '', index: 0 }] },
-};
-//# sourceMappingURL=config.js.map

package/build/dex/test-dex/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/dex/test-dex/config.ts"],"names":[],"mappings":";;;AAEA,+CAAoD;AAEvC,QAAA,aAAa,GAA4B;IACpD,OAAO,EAAE;IACP,qBAAqB;KACtB;CACF,CAAC;AAEW,QAAA,QAAQ,GAAoC;IACvD,oCAAoC;IACpC,6BAA6B;IAC7B,CAAC,mBAAO,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,oBAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE;CACjE,CAAC"}

package/build/dex/test-dex/test-dex-pool.d.ts

@@ -1,39 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { DeepReadonly } from 'ts-essentials';
-import { Log, Logger } from '../../types';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { PoolState } from './types';
-export declare class TestDexEventPool extends StatefulEventSubscriber<PoolState> {
-    protected parentName: string;
-    protected network: number;
-    protected dexHelper: IDexHelper;
-    protected testDexIface: Interface;
-    handlers: {
-        [event: string]: (event: any, state: DeepReadonly<PoolState>, log: Readonly<Log>) => DeepReadonly<PoolState> | null;
-    };
-    logDecoder: (log: Log) => any;
-    addressesSubscribed: string[];
-    constructor(parentName: string, network: number, dexHelper: IDexHelper, logger: Logger, testDexIface?: Interface);
-    /**
-     * The function is called every time any of the subscribed
-     * addresses release log. The function accepts the current
-     * state, updates the state according to the log, and returns
-     * the updated state.
-     * @param state - Current state of event subscriber
-     * @param log - Log released by one of the subscribed addresses
-     * @returns Updates state of the event subscriber after the log
-     */
-    protected processLog(state: DeepReadonly<PoolState>, log: Readonly<Log>): DeepReadonly<PoolState> | null;
-    /**
-     * The function generates state using on-chain calls. This
-     * function is called to regenerate state if the event based
-     * system fails to fetch events and the local state is no
-     * more correct.
-     * @param blockNumber - Blocknumber for which the state should
-     * should be generated
-     * @returns state of the event subscriber at blocknumber
-     */
-    generateState(blockNumber: number): Promise<DeepReadonly<PoolState>>;
-    handleMyEvent(event: any, state: DeepReadonly<PoolState>, log: Readonly<Log>): DeepReadonly<PoolState> | null;
-}