@paraswap/dex-lib 2.30.1 → 2.30.2-chronos-v3

package/src/dex/balancer-v2/optimizer.ts

@@ -1,70 +1,83 @@
-import { UnoptimizedRate, OptimalSwapExchange } from '../../types';
-import { BalancerSwapV2 } from './types';
+import _ from 'lodash';
+import { UnoptimizedRate } from '../../types';
 import { SwapSide } from '../../constants';
 import { BalancerConfig } from './config';
-
-const MAX_UINT256 =
-  '115792089237316195423570985008687907853269984665640564039457584007913129639935';
-
-const AllBalancerV2Forks = Object.keys(BalancerConfig);
+import { OptimalSwap } from '@paraswap/core';
 
 export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
-  const fixSwap = (
-    rawSwap: OptimalSwapExchange<any>[],
-    side: SwapSide,
-  ): OptimalSwapExchange<any>[] => {
-    const newBalancers: { [key: string]: OptimalSwapExchange<any> } = {};
-    let optimizedSwap = new Array<OptimalSwapExchange<any>>();
-    rawSwap.forEach((s: OptimalSwapExchange<any>) => {
-      const exchangeKey = s.exchange.toLowerCase();
-      if (AllBalancerV2Forks.some(d => d.toLowerCase() === exchangeKey)) {
-        if (!(exchangeKey in newBalancers)) {
-          newBalancers[exchangeKey] = {
-            exchange: s.exchange,
-            srcAmount: '0',
-            destAmount: '0',
-            percent: 0,
-            poolAddresses: [],
-            data: {
-              swaps: new Array<BalancerSwapV2>(),
-              gasUSD: '0',
-            },
-          };
-        }
-        newBalancers[exchangeKey].srcAmount = (
-          BigInt(newBalancers[exchangeKey].srcAmount) + BigInt(s.srcAmount)
+  const balancerForksList = Object.keys(BalancerConfig).map(b =>
+    b.toLowerCase(),
+  );
+  const fixSwap = (rawRate: OptimalSwap[], side: SwapSide): OptimalSwap[] => {
+    let lastExchange: false | OptimalSwap = false;
+    let optimizedRate = new Array<OptimalSwap>();
+    rawRate.forEach((s: OptimalSwap) => {
+      if (
+        s.swapExchanges.length !== 1 ||
+        !balancerForksList.includes(s.swapExchanges[0].exchange.toLowerCase())
+      ) {
+        lastExchange = false;
+        optimizedRate.push(s);
+      } else if (
+        lastExchange &&
+        lastExchange.swapExchanges[0].exchange.toLowerCase() ===
+          s.swapExchanges[0].exchange.toLowerCase() &&
+        _.last(
+          <any[]>lastExchange.swapExchanges[0].data.swaps,
+        )!.tokenOut.toLowerCase() ===
+          s.swapExchanges[0].data.tokenIn.toLowerCase()
+      ) {
+        const [lastExchangeSwap] = lastExchange.swapExchanges;
+        const [currentSwap] = s.swapExchanges;
+        lastExchangeSwap.srcAmount = (
+          BigInt(lastExchangeSwap.srcAmount) + BigInt(currentSwap.srcAmount)
         ).toString();
 
-        newBalancers[exchangeKey].destAmount = (
-          BigInt(newBalancers[exchangeKey].destAmount) + BigInt(s.destAmount)
+        lastExchangeSwap.destAmount = (
+          BigInt(lastExchangeSwap.destAmount) + BigInt(currentSwap.destAmount)
         ).toString();
 
-        newBalancers[exchangeKey].percent += s.percent;
-        newBalancers[exchangeKey].data.exchangeProxy = s.data.exchangeProxy;
-        newBalancers[exchangeKey].data.gasUSD = (
-          parseFloat(newBalancers[exchangeKey].data.gasUSD) +
-          parseFloat(s.data.gasUSD)
+        lastExchangeSwap.percent += currentSwap.percent;
+        lastExchangeSwap.data.gasUSD = (
+          parseFloat(lastExchangeSwap.data.gasUSD) +
+          parseFloat(currentSwap.data.gasUSD)
         ).toFixed(6);
 
-        newBalancers[exchangeKey].data.swaps.push({
-          poolId: s.data.poolId,
-          amount: side === SwapSide.SELL ? s.srcAmount : s.destAmount,
+        lastExchangeSwap.data.swaps.push({
+          poolId: currentSwap.data.poolId,
+          amount:
+            side === SwapSide.SELL
+              ? currentSwap.srcAmount
+              : currentSwap.destAmount,
+          tokenIn: currentSwap.data.tokenIn,
+          tokenOut: currentSwap.data.tokenOut,
         });
-        newBalancers[exchangeKey].poolAddresses!.push(s.poolAddresses![0]);
+        lastExchangeSwap.poolAddresses!.push(currentSwap.poolAddresses![0]);
       } else {
-        optimizedSwap.push(s);
+        lastExchange = _.cloneDeep(s);
+        lastExchange.swapExchanges[0].data = {};
+        lastExchange.swapExchanges[0].data.gasUSD =
+          s.swapExchanges[0].data.gasUSD;
+        lastExchange.swapExchanges[0].data.swaps = [
+          {
+            poolId: s.swapExchanges[0].data.poolId,
+            amount:
+              side === SwapSide.SELL
+                ? s.swapExchanges[0].srcAmount
+                : s.swapExchanges[0].destAmount,
+            tokenIn: s.swapExchanges[0].data.tokenIn,
+            tokenOut: s.swapExchanges[0].data.tokenOut,
+          },
+        ];
+        optimizedRate.push(lastExchange);
       }
     });
-    optimizedSwap = optimizedSwap.concat(Object.values(newBalancers));
-    return optimizedSwap;
+    return optimizedRate;
   };
 
   or.bestRoute = or.bestRoute.map(r => ({
     ...r,
-    swaps: r.swaps.map(s => ({
-      ...s,
-      swapExchanges: fixSwap(s.swapExchanges, or.side),
-    })),
+    swaps: fixSwap(r.swaps, or.side),
   }));
   return or;
 }

package/src/dex/balancer-v2/types.ts

@@ -82,6 +82,8 @@ export interface SubgraphPoolBase {
 export type BalancerSwapV2 = {
   poolId: string;
   amount: string;
+  tokenIn: string;
+  tokenOut: string;
 };
 
 export type OptimizedBalancerV2Data = {
@@ -139,6 +141,8 @@ export type BalancerV2DirectParam = [
 
 export type BalancerV2Data = {
   poolId: string;
+  tokenIn: string;
+  tokenOut: string;
 };
 
 export type DexParams = {

package/src/dex/curve-v1-factory/price-handlers/functions/calc_token_amount.ts

@@ -35,6 +35,38 @@ const customPlain3CoinThree: calc_token_amount = (
   return (diff * token_amount) / D0;
 };
 
+const factoryPlain2Basic: calc_token_amount = (
+  self: IPoolContext,
+  state: PoolState,
+  amounts: bigint[],
+  is_deposit: boolean,
+) => {
+  const { N_COINS } = self.constants;
+  const amp = state.A;
+  const balances = [...state.balances];
+  const D0 = self.get_D(self, balances, amp);
+  for (const i of _.range(N_COINS)) {
+    if (is_deposit) balances[i] += amounts[i];
+    else balances[i] -= amounts[i];
+  }
+  const D1 = self.get_D(self, balances, amp);
+
+  if (state.totalSupply === undefined) {
+    throw new Error(
+      `${self.IMPLEMENTATION_NAME} customPlain3CoinThree: totalSupply is not provided`,
+    );
+  }
+
+  const token_amount = state.totalSupply;
+  let diff = 0n;
+  if (is_deposit) {
+    diff = D1 - D0;
+  } else {
+    diff = D0 - D1;
+  }
+  return (diff * token_amount) / D0;
+};
+
 const customAvalanche3CoinLending: calc_token_amount = (
   self: IPoolContext,
   state: PoolState,
@@ -114,7 +146,7 @@ const implementations: Record<ImplementationNames, calc_token_amount> = {
   [ImplementationNames.FACTORY_META_USD_BALANCES_FRAX_USDC]: notImplemented,
 
   [ImplementationNames.FACTORY_PLAIN_2_BALANCES]: notImplemented,
-  [ImplementationNames.FACTORY_PLAIN_2_BASIC]: notImplemented,
+  [ImplementationNames.FACTORY_PLAIN_2_BASIC]: factoryPlain2Basic,
   [ImplementationNames.FACTORY_PLAIN_2_ETH]: notImplemented,
   [ImplementationNames.FACTORY_PLAIN_2_OPTIMIZED]: notImplemented,
 

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

@@ -107,6 +107,22 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
         'https://api.thegraph.com/subgraphs/name/lynnshaoyu/uniswap-v3-avax',
     },
   },
+  ChronosV3: {
+    [Network.ARBITRUM]: {
+      factory: '0x4Db9D624F67E00dbF8ef7AE0e0e8eE54aF1dee49',
+      quoter: '0x6E7f0Ca45171a4440c0CDdF3A46A8dC5D4c2d4A0',
+      router: '0xE0aBdFD837D451640CF43cB1Ec4eE87976eFbb41',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x46b44eb4Cc3bEbB9f04C419f691aB85Ff885A4D6',
+      uniswapMulticall: '0xaBB58098A7B5172A9b0B38a1925A522dbf0b4FC3',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      initHash:
+        '0x09c178be473df44d1de6970978a4fdedce1ce52a23b2b979754547f6b43a19a5',
+      subgraphURL:
+        'https://subgraph.chronos.exchange/subgraphs/name/chronos-v3',
+    },
+  },
   RamsesV2: {
     [Network.ARBITRUM]: {
       factory: '0xAA2cd7477c451E703f3B9Ba5663334914763edF8',

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

@@ -501,4 +501,91 @@ describe('UniswapV3 E2E', () => {
       );
     });
   });
+
+  describe('ChronosV3', () => {
+    const dexKey = 'ChronosV3';
+    describe('Arbitrum', () => {
+      const network = Network.ARBITRUM;
+      const tokens = Tokens[network];
+      const holders = Holders[network];
+      const provider = new StaticJsonRpcProvider(
+        generateConfig(network).privateHttpProvider,
+        network,
+      );
+
+      const tokenASymbol: string = 'USDCe';
+      const tokenBSymbol: string = 'USDT';
+      const nativeTokenSymbol = NativeTokenSymbols[network];
+
+      const tokenAAmount: string = '2000000';
+      const tokenBAmount: string = '2000000';
+      const nativeTokenAmount = '100000000000000000';
+
+      const sideToContractMethods = new Map([
+        [
+          SwapSide.SELL,
+          [
+            ContractMethod.simpleSwap,
+            ContractMethod.multiSwap,
+            ContractMethod.megaSwap,
+            ContractMethod.directUniV3Swap,
+          ],
+        ],
+        [
+          SwapSide.BUY,
+          [
+            ContractMethod.simpleBuy,
+            ContractMethod.buy,
+            ContractMethod.directUniV3Buy,
+          ],
+        ],
+      ]);
+
+      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,
+              );
+            });
+          });
+        }),
+      );
+    });
+  });
 });

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

@@ -624,3 +624,138 @@ describe('RamsesV2', () => {
     expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
   });
 });
+
+describe('ChronosV3', () => {
+  const dexKey = 'ChronosV3';
+  let blockNumber: number;
+  let uniswapV3: UniswapV3;
+  let uniswapV3Mainnet: UniswapV3;
+
+  const network = Network.ARBITRUM;
+  const dexHelper = new DummyDexHelper(network);
+  const TokenASymbol = 'USDCe';
+  const TokenA = Tokens[network][TokenASymbol];
+
+  const TokenBSymbol = 'USDT';
+  const TokenB = Tokens[network][TokenBSymbol];
+
+  beforeEach(async () => {
+    blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+    uniswapV3 = new UniswapV3(network, dexKey, dexHelper);
+    uniswapV3Mainnet = new UniswapV3(
+      Network.ARBITRUM,
+      dexKey,
+      dexHelper,
+    );
+  });
+
+  it('getPoolIdentifiers and getPricesVolume SELL', async function () {
+
+    const amounts = [0n, BI_POWS[6], 2000000n];
+
+    const pools = await uniswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.SELL,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await uniswapV3.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);
+
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          dexHelper,
+          uniswapV3,
+          'quoteExactInputSingle',
+          blockNumber,
+          '0x6E7f0Ca45171a4440c0CDdF3A46A8dC5D4c2d4A0',
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amounts,
+        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
+
+  it('getPoolIdentifiers and getPricesVolume BUY', async function () {
+
+    const amounts = [0n, BI_POWS[6], 2000000n];
+
+    const pools = await uniswapV3.getPoolIdentifiers(
+      TokenA,
+      TokenB,
+      SwapSide.BUY,
+      blockNumber,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `, pools);
+
+    expect(pools.length).toBeGreaterThan(0);
+
+    const poolPrices = await uniswapV3.getPricesVolume(
+      TokenA,
+      TokenB,
+      amounts,
+      SwapSide.BUY,
+      blockNumber,
+      pools,
+    );
+    console.log(`${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `, poolPrices);
+
+    expect(poolPrices).not.toBeNull();
+    checkPoolPrices(poolPrices!, amounts, SwapSide.SELL, dexKey);
+
+    let falseChecksCounter = 0;
+    await Promise.all(
+      poolPrices!.map(async price => {
+        const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
+        const res = await checkOnChainPricing(
+          dexHelper,
+          uniswapV3,
+          'quoteExactOutputSingle',
+          blockNumber,
+          '0x6E7f0Ca45171a4440c0CDdF3A46A8dC5D4c2d4A0',
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amounts,
+        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
+
+  it.skip('getTopPoolsForToken', async function () {
+    const poolLiquidity = await uniswapV3.getTopPoolsForToken(
+      TokenB.address,
+      10,
+    );
+    console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
+
+    checkPoolsLiquidity(poolLiquidity, TokenB.address, dexKey);
+  });
+});

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

@@ -91,7 +91,7 @@ export class UniswapV3
 
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(
-      _.pick(UniswapV3Config, ['UniswapV3', 'QuickSwapV3.1', 'RamsesV2']),
+      _.pick(UniswapV3Config, ['UniswapV3', 'QuickSwapV3.1', 'RamsesV2', 'ChronosV3']),
     );
 
   logger: Logger;
@@ -120,7 +120,7 @@ export class UniswapV3
     this.stateMultiContract = new this.dexHelper.web3Provider.eth.Contract(
       this.config.stateMultiCallAbi !== undefined
         ? this.config.stateMultiCallAbi
-        : (UniswapV3StateMulticallABI as AbiItem[]),
+        : UniswapV3StateMulticallABI as AbiItem[],
       this.config.stateMulticall,
     );
 
@@ -279,7 +279,7 @@ export class UniswapV3
           e,
         );
       } else {
-        // on unkown error mark as failed and increase retryCount for retry init strategy
+        // on unknown error mark as failed and increase retryCount for retry init strategy
         // note: state would be null by default which allows to fallback
         this.logger.warn(
           `${this.dexKey}: Can not generate pool state for srcAddress=${srcAddress}, destAddress=${destAddress}, fee=${fee} pool fallback to rpc and retry every ${this.config.initRetryFrequency} times, initRetryAttemptCount=${pool.initRetryAttemptCount}`,
@@ -1059,8 +1059,7 @@ export class UniswapV3
       initHash: this.config.initHash,
       subgraphURL: this.config.subgraphURL,
       stateMultiCallAbi: this.config.stateMultiCallAbi,
-      decodeStateMultiCallResultWithRelativeBitmaps:
-        this.config.decodeStateMultiCallResultWithRelativeBitmaps,
+      decodeStateMultiCallResultWithRelativeBitmaps: this.config.decodeStateMultiCallResultWithRelativeBitmaps,
     };
     return newConfig;
   }