@paraswap/dex-lib 2.20.3 → 2.21.1-chronos

package/src/dex/curve-v2.ts

@@ -3,26 +3,15 @@ import { SwapSide } from '../constants';
 import {
   AdapterExchangeParam,
   Address,
-  ExchangeTxInfo,
   NumberAsString,
-  PreprocessTransactionOptions,
   SimpleExchangeParam,
-  Token,
-  TxInfo,
 } from '../types';
 import { IDexTxBuilder } from './idex';
-import {
-  getLocalDeadlineAsFriendlyPlaceholder,
-  SimpleExchange,
-} from './simple-exchange';
+import { SimpleExchange } from './simple-exchange';
 import GenericFactoryZapABI from '../abi/curve-v2/GenericFactoryZap.json';
-import DirectSwapABI from '../abi/DirectSwap.json';
 import CurveV2ABI from '../abi/CurveV2.json';
+import Web3 from 'web3';
 import { IDexHelper } from '../dex-helper';
-import { assert } from 'ts-essentials';
-import { Logger } from 'log4js';
-import { OptimalSwapExchange } from '@paraswap/core';
-import { uuidToBytes16 } from '../utils';
 
 export enum CurveV2SwapType {
   EXCHANGE,
@@ -30,15 +19,12 @@ export enum CurveV2SwapType {
   EXCHANGE_GENERIC_FACTORY_ZAP,
 }
 
-const DIRECT_METHOD_NAME = 'directCurveV2Swap';
-
 type CurveV2Data = {
   i: number;
   j: number;
   exchange: string;
   originalPoolAddress: Address;
   swapType: CurveV2SwapType;
-  isApproved?: boolean;
 };
 
 type CurveV2Param = [
@@ -57,26 +43,6 @@ type CurveV2ParamsForGenericFactoryZap = [
   min_dy: NumberAsString,
 ];
 
-export type DirectCurveV2Param = [
-  fromToken: Address,
-  toToken: Address,
-  exchange: Address,
-  poolAddress: Address,
-  fromAmount: NumberAsString,
-  toAmount: NumberAsString,
-  expectedAmount: NumberAsString,
-  feePercent: NumberAsString,
-  i: NumberAsString,
-  j: NumberAsString,
-  partner: Address,
-  isApproved: boolean,
-  swapType: CurveV2SwapType,
-  beneficiary: Address,
-  needWrapNative: boolean,
-  permit: string,
-  uuid: string,
-];
-
 enum CurveV2SwapFunctions {
   exchange = 'exchange(uint256 i, uint256 j, uint256 dx, uint256 minDy)',
   exchange_underlying = 'exchange_underlying(uint256 i, uint256 j, uint256 dx, uint256 minDy)',
@@ -85,31 +51,25 @@ enum CurveV2SwapFunctions {
 
 export class CurveV2
   extends SimpleExchange
-  implements IDexTxBuilder<CurveV2Data, DirectCurveV2Param>
+  implements IDexTxBuilder<CurveV2Data, CurveV2Param>
 {
   static dexKeys = ['curvev2'];
   exchangeRouterInterface: Interface;
   genericFactoryZapIface: Interface;
   minConversionRate = '1';
   needWrapNative = true;
-  logger: Logger;
-
-  readonly directSwapIface = new Interface(DirectSwapABI);
 
-  constructor(readonly dexHelper: IDexHelper) {
+  constructor(dexHelper: IDexHelper) {
     super(dexHelper, 'curvev2');
     this.exchangeRouterInterface = new Interface(CurveV2ABI as JsonFragment[]);
     this.genericFactoryZapIface = new Interface(GenericFactoryZapABI);
-    this.logger = dexHelper.getLogger(
-      `CurveV2_${dexHelper.config.data.network}`,
-    );
   }
 
   getAdapterParam(
-    _0: string,
-    _1: string,
-    _2: string,
-    _3: string,
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
     data: CurveV2Data,
     side: SwapSide,
   ): AdapterExchangeParam {
@@ -140,127 +100,6 @@ export class CurveV2
     };
   }
 
-  getTokenFromAddress(address: Address): Token {
-    // In this Dex decimals are not used
-    return { address, decimals: 0 };
-  }
-
-  async preProcessTransaction(
-    optimalSwapExchange: OptimalSwapExchange<CurveV2Data>,
-    srcToken: Token,
-    _0: Token,
-    _1: SwapSide,
-    options: PreprocessTransactionOptions,
-  ): Promise<[OptimalSwapExchange<CurveV2Data>, ExchangeTxInfo]> {
-    if (!options.isDirectMethod) {
-      return [
-        optimalSwapExchange,
-        {
-          deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-        },
-      ];
-    }
-
-    assert(
-      optimalSwapExchange.data !== undefined,
-      `preProcessTransaction: data field is missing`,
-    );
-
-    let isApproved: boolean | undefined;
-
-    try {
-      this.erc20Contract.options.address =
-        this.dexHelper.config.wrapETH(srcToken).address;
-      const allowance = await this.erc20Contract.methods
-        .allowance(this.augustusAddress, optimalSwapExchange.data.exchange)
-        .call(undefined, 'latest');
-      isApproved =
-        BigInt(allowance.toString()) >= BigInt(optimalSwapExchange.srcAmount);
-    } catch (e) {
-      this.logger.error(
-        `preProcessTransaction failed to retrieve allowance info: `,
-        e,
-      );
-    }
-
-    return [
-      {
-        ...optimalSwapExchange,
-        data: {
-          ...optimalSwapExchange.data,
-          isApproved,
-        },
-      },
-      {
-        deadline: BigInt(getLocalDeadlineAsFriendlyPlaceholder()),
-      },
-    ];
-  }
-
-  getDirectParam(
-    srcToken: Address,
-    destToken: Address,
-    srcAmount: NumberAsString,
-    destAmount: NumberAsString,
-    expectedAmount: NumberAsString,
-    data: CurveV2Data,
-    side: SwapSide,
-    permit: string,
-    uuid: string,
-    feePercent: NumberAsString,
-    _0: NumberAsString,
-    partner: string,
-    beneficiary: string,
-    contractMethod?: string,
-  ): TxInfo<DirectCurveV2Param> {
-    if (contractMethod !== DIRECT_METHOD_NAME) {
-      throw new Error(`Invalid contract method ${contractMethod}`);
-    }
-    assert(side === SwapSide.SELL, 'Buy not supported');
-
-    let isApproved: boolean = !!data.isApproved;
-    if (data.isApproved === undefined) {
-      this.logger.warn(`isApproved is undefined, defaulting to false`);
-    }
-
-    const swapParams: DirectCurveV2Param = [
-      srcToken,
-      destToken,
-      data.exchange,
-      data.originalPoolAddress,
-      srcAmount,
-      destAmount,
-      expectedAmount,
-      feePercent,
-      data.i.toString(),
-      data.j.toString(),
-      partner,
-      isApproved,
-      data.swapType,
-      beneficiary,
-      // For now we always wrap native. We don't support non native trade
-      true,
-      permit,
-      uuidToBytes16(uuid),
-    ];
-
-    const encoder = (...params: DirectCurveV2Param) => {
-      return this.directSwapIface.encodeFunctionData(DIRECT_METHOD_NAME, [
-        params,
-      ]);
-    };
-
-    return {
-      params: swapParams,
-      encoder,
-      networkFee: '0',
-    };
-  }
-
-  static getDirectFunctionName(): string[] {
-    return [DIRECT_METHOD_NAME];
-  }
-
   async getSimpleParam(
     srcToken: string,
     destToken: string,

package/src/dex/idex.ts

@@ -76,15 +76,9 @@ export interface IDexTxBuilder<ExchangeData, DirectParam = null> {
     destToken: Address,
     srcAmount: NumberAsString,
     destAmount: NumberAsString,
-    expectedAmount: NumberAsString,
     data: ExchangeData,
     side: SwapSide,
     permit: string,
-    uuid: string,
-    feePercent: NumberAsString,
-    deadline: NumberAsString,
-    partner: string,
-    beneficiary: string,
     contractMethod?: string,
   ): TxInfo<DirectParam>;
 }

package/src/dex/index.ts

@@ -43,6 +43,7 @@ import { ParaSwapLimitOrders } from './paraswap-limit-orders/paraswap-limit-orde
 import { AugustusRFQOrder } from './augustus-rfq';
 import { Solidly } from './solidly/solidly';
 import { Thena } from './solidly/forks-override/thena';
+import { Chronos } from './solidly/forks-override/chronos';
 import { Velodrome } from './solidly/forks-override/velodrome';
 import { SpiritSwapV2 } from './solidly/forks-override/spiritSwapV2';
 import { Synthetix } from './synthetix/synthetix';
@@ -64,7 +65,6 @@ import { MaverickV1 } from './maverick-v1/maverick-v1';
 import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ZyberSwapV3 } from './quickswap/zyberswap-v3';
 import { TraderJoeV2 } from './trader-joe-v2';
-import { SwaapV2 } from './swaap-v2/swaap-v2';
 import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
@@ -122,6 +122,7 @@ const Dexes = [
   SolidlyEthereum,
   SpiritSwapV2,
   Thena,
+  Chronos,
   Velodrome,
   Cone,
   SoliSnek,
@@ -132,7 +133,6 @@ const Dexes = [
   Hashflow,
   MaverickV1,
   Camelot,
-  SwaapV2,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

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

@@ -32,7 +32,10 @@ describe('PancakeswapV3 E2E', () => {
           ContractMethod.megaSwap,
         ],
       ],
-      [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
+      [SwapSide.BUY, [
+        ContractMethod.simpleBuy,
+        ContractMethod.buy,
+      ]],
     ]);
 
     const pairs: { name: string; sellAmount: string; buyAmount: string }[][] = [
@@ -95,8 +98,8 @@ describe('PancakeswapV3 E2E', () => {
           sellAmount: '10000000000',
           buyAmount: '500000000000000000000',
         },
-      ],
-    ];
+      ]
+    ]
 
     sideToContractMethods.forEach((contractMethods, side) =>
       describe(`${side}`, () => {

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

@@ -76,6 +76,7 @@ const testingData: Partial<{ [key in Network]: any }> = {
 };
 
 describe('PancakeswapV3', function () {
+
   describe('BSC', () => {
     describe('WBNB -> USDT', () => {
       it('getPoolIdentifiers and getPricesVolume SELL', async function () {
@@ -87,7 +88,11 @@ describe('PancakeswapV3', function () {
         const WBNB = Tokens[network]['WBNB'];
         const USDT = Tokens[network]['USDT'];
 
-        const amounts = [0n, 1n * BI_POWS[18], 2n * BI_POWS[18]];
+        const amounts = [
+          0n,
+          1n * BI_POWS[18],
+          2n * BI_POWS[18],
+        ];
 
         const pools = await pancakeswapV3.getPoolIdentifiers(
           WBNB,
@@ -95,7 +100,10 @@ describe('PancakeswapV3', function () {
           SwapSide.SELL,
           blockNumber,
         );
-        console.log(`WBNB <> USDT Pool Identifiers: `, pools);
+        console.log(
+          `WBNB <> USDT Pool Identifiers: `,
+          pools,
+        );
 
         expect(pools.length).toBeGreaterThan(0);
 
@@ -107,7 +115,10 @@ describe('PancakeswapV3', function () {
           blockNumber,
           pools,
         );
-        console.log(`WBNB <> USDT Pool Prices: `, poolPrices);
+        console.log(
+          `WBNB <> USDT Pool Prices: `,
+          poolPrices,
+        );
 
         expect(poolPrices).not.toBeNull();
         checkPoolPrices(

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

@@ -28,7 +28,7 @@ import {
   PoolState,
   UniswapV3Data,
   UniswapV3Functions,
-  UniswapV3SimpleSwapParams,
+  UniswapV3Param,
 } from '../uniswap-v3/types';
 import {
   getLocalDeadlineAsFriendlyPlaceholder,
@@ -69,7 +69,7 @@ const PANCAKESWAPV3_QUOTE_GASLIMIT = 200_000;
 
 export class PancakeswapV3
   extends SimpleExchange
-  implements IDex<UniswapV3Data>
+  implements IDex<UniswapV3Data, UniswapV3Param>
 {
   readonly isFeeOnTransferSupported: boolean = false;
   readonly eventPools: Record<string, PancakeSwapV3EventPool | null> = {};
@@ -733,7 +733,7 @@ export class PancakeswapV3
         : UniswapV3Functions.exactOutput;
 
     const path = this._encodePath(data.path, side);
-    const swapFunctionParams: UniswapV3SimpleSwapParams =
+    const swapFunctionParams: UniswapV3Param =
       side === SwapSide.SELL
         ? {
             recipient: this.augustusAddress,

package/src/dex/pancakeswap-v3/utils.ts

@@ -2,7 +2,10 @@ import { BytesLike, ethers } from 'ethers';
 import { assert } from 'ts-essentials';
 import { extractSuccessAndValue } from '../../lib/decoders';
 import { MultiResult } from '../../lib/multi-wrapper';
-import { DecodedStateMultiCallResultWithRelativeBitmaps } from '../uniswap-v3/types';
+import {
+  DecodedStateMultiCallResultWithRelativeBitmaps,
+} from '../uniswap-v3/types';
+
 
 export function decodeStateMultiCallResultWithRelativeBitmaps(
   result: MultiResult<BytesLike> | BytesLike,

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