@paraswap/dex-lib 2.28.12-ramses.2 → 2.29.0

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

@@ -3,13 +3,13 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { Interface, Result } from '@ethersproject/abi';
-import { DummyDexHelper } from '../../dex-helper/index';
+import { DummyDexHelper, IDexHelper } from '../../dex-helper/index';
 import { Network, SwapSide } from '../../constants';
 import { BI_POWS } from '../../bigint-constants';
 import { UniswapV3 } from './uniswap-v3';
 import { checkPoolPrices, checkPoolsLiquidity } from '../../../tests/utils';
 import { Tokens } from '../../../tests/constants-e2e';
-import UniswapV3QuoterABI from '../../abi/uniswap-v3/UniswapV3Quoter.abi.json';
+import UniswapV3QuoterV2ABI from '../../abi/uniswap-v3/UniswapV3QuoterV2.abi.json';
 import { Address } from '@paraswap/core';
 
 const network = Network.POLYGON;
@@ -28,10 +28,8 @@ const amounts = [
 
 const amountsBuy = [0n, 1n * BI_POWS[18], 2n * BI_POWS[18], 3n * BI_POWS[18]];
 
-const dexHelper = new DummyDexHelper(network);
-const dexKey = 'UniswapV3';
 
-const quoterIface = new Interface(UniswapV3QuoterABI);
+const quoterIface = new Interface(UniswapV3QuoterV2ABI);
 
 function getReaderCalldata(
   exchangeAddress: string,
@@ -45,11 +43,13 @@ function getReaderCalldata(
   return amounts.map(amount => ({
     target: exchangeAddress,
     callData: readerIface.encodeFunctionData(funcName, [
-      tokenIn,
-      tokenOut,
-      fee,
-      amount,
-      0n,
+      [
+        tokenIn,
+        tokenOut,
+        amount.toString(),
+        fee.toString(),
+        0,
+      ]
     ]),
   }));
 }
@@ -66,9 +66,11 @@ function decodeReaderResult(
 }
 
 async function checkOnChainPricing(
+  dexHelper: IDexHelper,
   uniswapV3: UniswapV3,
   funcName: string,
   blockNumber: number,
+  exchangeAddress: string,
   prices: bigint[],
   tokenIn: Address,
   tokenOut: Address,
@@ -76,7 +78,7 @@ async function checkOnChainPricing(
   _amounts: bigint[],
 ) {
   // Quoter address
-  const exchangeAddress = '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6';
+  // const exchangeAddress = '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6';
   const readerIface = quoterIface;
 
   const sum = prices.reduce((acc, curr) => (acc += curr), 0n);
@@ -117,6 +119,8 @@ async function checkOnChainPricing(
     decodeReaderResult(readerResult, readerIface, funcName),
   );
 
+  console.log('EXPECTED PRICES: ', expectedPrices);
+
   let firstZeroIndex = prices.slice(1).indexOf(0n);
 
   // we skipped first, so add +1 on result
@@ -130,6 +134,9 @@ async function checkOnChainPricing(
 }
 
 describe('UniswapV3', function () {
+  const dexHelper = new DummyDexHelper(network);
+  const dexKey = 'UniswapV3';
+
   let blockNumber: number;
   let uniswapV3: UniswapV3;
   let uniswapV3Mainnet: UniswapV3;
@@ -138,9 +145,9 @@ describe('UniswapV3', function () {
     blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
     uniswapV3 = new UniswapV3(network, dexKey, dexHelper);
     uniswapV3Mainnet = new UniswapV3(
-      Network.MAINNET,
+      Network.ARBITRUM,
       dexKey,
-      new DummyDexHelper(Network.MAINNET),
+      new DummyDexHelper(Network.ARBITRUM),
     );
   });
 
@@ -173,9 +180,11 @@ describe('UniswapV3', function () {
       poolPrices!.map(async price => {
         const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
         const res = await checkOnChainPricing(
+          dexHelper,
           uniswapV3,
           'quoteExactInputSingle',
           blockNumber,
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
           price.prices,
           TokenA.address,
           TokenB.address,
@@ -219,9 +228,11 @@ describe('UniswapV3', function () {
       poolPrices!.map(async price => {
         const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
         const res = await checkOnChainPricing(
+          dexHelper,
           uniswapV3,
           'quoteExactOutputSingle',
           blockNumber,
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
           price.prices,
           TokenA.address,
           TokenB.address,
@@ -329,9 +340,11 @@ describe('UniswapV3', function () {
       poolPrices!.map(async price => {
         const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
         const res = await checkOnChainPricing(
+          dexHelper,
           uniswapV3,
           'quoteExactInputSingle',
           blockNumber,
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
           price.prices,
           TokenA.address,
           TokenB.address,
@@ -439,9 +452,11 @@ describe('UniswapV3', function () {
       poolPrices!.map(async price => {
         const fee = uniswapV3.eventPools[price.poolIdentifier!]!.feeCode;
         const res = await checkOnChainPricing(
+          dexHelper,
           uniswapV3,
           'quoteExactOutputSingle',
           blockNumber,
+          '0x61fFE014bA17989E743c5F6cB21bF9697530B21e',
           price.prices,
           TokenA.address,
           TokenB.address,
@@ -466,3 +481,146 @@ describe('UniswapV3', function () {
     }
   });
 });
+
+describe('RamsesV2', () => {
+  const dexKey = 'RamsesV2';
+  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 = 'USDC';
+  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,
+      6000000n,
+      12000000n,
+      18000000n,
+      24000000n,
+      30000000n,
+      36000000n,
+      42000000n,
+    ];
+
+    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,
+          '0xAA20EFF7ad2F523590dE6c04918DaAE0904E3b20',
+          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,
+      6000000n,
+      12000000n,
+      18000000n,
+      24000000n,
+      30000000n,
+      36000000n,
+      42000000n,
+    ];
+
+    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,
+          '0xAA20EFF7ad2F523590dE6c04918DaAE0904E3b20',
+          price.prices,
+          TokenA.address,
+          TokenB.address,
+          fee,
+          amounts,
+        );
+        if (res === false) falseChecksCounter++;
+      }),
+    );
+
+    expect(falseChecksCounter).toBeLessThan(poolPrices!.length);
+  });
+});

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

@@ -11,7 +11,7 @@ import {
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import {
   PoolState,
-  DecodedStateMultiCallResultWithRelativeBitmaps,
+  DecodedStateMultiCallResultWithRelativeBitmaps, DecodeStateMultiCallFunc,
 } from './types';
 import UniswapV3PoolABI from '../../abi/uniswap-v3/UniswapV3Pool.abi.json';
 import { bigIntify, catchParseLogError, isSampled } from '../../utils';
@@ -60,6 +60,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     readonly dexHelper: IDexHelper,
     parentName: string,
     readonly stateMultiContract: Contract,
+    readonly decodeStateMultiCallResultWithRelativeBitmaps: DecodeStateMultiCallFunc | undefined,
     readonly erc20Interface: Interface,
     protected readonly factoryAddress: Address,
     public readonly feeCode: bigint,
@@ -226,9 +227,13 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
               this.getBitmapRangeToRequest(),
             )
             .encodeABI(),
-          decodeFunction: decodeStateMultiCallResultWithRelativeBitmaps,
+          decodeFunction:
+            this.decodeStateMultiCallResultWithRelativeBitmaps !== undefined
+              ? this.decodeStateMultiCallResultWithRelativeBitmaps
+              : decodeStateMultiCallResultWithRelativeBitmaps,
         },
       ];
+
       this._stateRequestCallData = callData;
     }
     return this._stateRequestCallData;

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']),
+      _.pick(UniswapV3Config, ['UniswapV3', 'QuickSwapV3.1', 'RamsesV2']),
     );
 
   logger: Logger;
@@ -118,7 +118,9 @@ export class UniswapV3
       this.config.uniswapMulticall,
     );
     this.stateMultiContract = new this.dexHelper.web3Provider.eth.Contract(
-      UniswapV3StateMulticallABI as AbiItem[],
+      this.config.stateMultiCallAbi !== undefined
+        ? this.config.stateMultiCallAbi
+        : UniswapV3StateMulticallABI as AbiItem[],
       this.config.stateMulticall,
     );
 
@@ -239,6 +241,7 @@ export class UniswapV3
         this.dexHelper,
         this.dexKey,
         this.stateMultiContract,
+        this.config.decodeStateMultiCallResultWithRelativeBitmaps,
         this.erc20Interface,
         this.config.factory,
         fee,
@@ -1055,6 +1058,8 @@ export class UniswapV3
       deployer: this.config.deployer?.toLowerCase(),
       initHash: this.config.initHash,
       subgraphURL: this.config.subgraphURL,
+      stateMultiCallAbi: this.config.stateMultiCallAbi,
+      decodeStateMultiCallResultWithRelativeBitmaps: this.config.decodeStateMultiCallResultWithRelativeBitmaps,
     };
     return newConfig;
   }

package/tests/constants-e2e.ts

@@ -1020,7 +1020,7 @@ export const Holders: {
     USDCe: '0x62383739d68dd0f844103db8dfb05a7eded5bbe6',
     USDC: '0xa843392198862f98d17e3aa1421b08f2c2020cff',
     OHM: '0xebce5f29ff5ca9aa330ebdf7ec6b5f474bff271e',
-    USDT: '0x62383739d68dd0f844103db8dfb05a7eded5bbe6',
+    USDT: '0x5ff47d4ab75bcaff6807c81f1367abb53439883c',
     POPS: '0x4b78b52e7de4d8b7d367297cb8a87c1875a9d591',
     FRAX: '0x59bf0545fca0e5ad48e13da269facd2e8c886ba4',
     nUSD: '0x9dd329f5411466d9e0c488ff72519ca9fef0cb40',

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

@@ -1,224 +0,0 @@
-import { Network, SUBGRAPH_TIMEOUT } from '../../../constants';
-import { getDexKeysWithNetwork } from '../../../utils';
-import { SolidlyConfig } from '../config';
-import _ from 'lodash';
-import { Address, PoolLiquidity } from '../../../types';
-import BigNumber from 'bignumber.js';
-import { Solidly } from '../solidly';
-import { IDexHelper } from '../../../dex-helper';
-import { SolidlyPair } from '../types';
-import { Interface } from '@ethersproject/abi';
-
-
-const RamsesFactoryABI = [
-  {
-    inputs: [{internalType: 'address', name: '', type: 'address'}],
-    name: 'pairFee',
-    outputs: [{internalType: 'uint256', 'name': '', type: 'uint256'}],
-    stateMutability: 'view',
-    type: 'function',
-  },
-];
-
-const ramsesFactoryIface = new Interface(RamsesFactoryABI);
-
-export type RamsesSubgraphPool = {
-  id: string;
-  isStable: boolean;
-  token0: string;
-  reserve0: string;
-  reserve1: string;
-  token1: string;
-};
-
-export type RamsesSubgraphToken = {
-  id: string;
-  decimals: string;
-}
-
-export class Ramses extends Solidly {
-
-  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
-    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['Ramses']));
-
-  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: ramsesFactoryIface.encodeFunctionData('pairFee', [pair.exchange]),
-    };
-    const callDecoder = (values: any[]) =>
-      parseInt(
-        ramsesFactoryIface
-          .decodeFunctionResult('pairFee', 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
-        token1
-        reserve0,
-        reserve1,
-      }
-      pools1: pairs(first: $count, orderBy: reserve1, orderDirection: desc, where: {token1: $token, reserve0_gt: 1, reserve1_gt: 1}) {
-        id
-        isStable
-        token0
-        token1
-        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 tokenIds = _.uniq([].concat(data.pools0, data.pools1).map(
-      (pool: RamsesSubgraphPool) => [ pool.token0, pool.token1]).flat(),
-    );
-
-    const tokensQuery = `
-      query ($tokenIds: [String!]) {
-        tokens(where: {id_in: $tokenIds}) {
-          id
-          decimals
-        }
-      }`;
-
-
-    const { data: tokensData } = await this.dexHelper.httpRequest.post(
-      this.subgraphURL,
-      {
-        query: tokensQuery,
-        variables: { tokenIds },
-      },
-      SUBGRAPH_TIMEOUT,
-    );
-
-    const pools0 = await this.prepareSubgraphPools(tokensData.tokens, 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(tokensData.tokens, 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,
-    );
-  }
-
-  protected async prepareSubgraphPools(
-    tokens: RamsesSubgraphToken[],
-    pools: RamsesSubgraphPool[],
-    iterator: (
-      pool: RamsesSubgraphPool, {
-        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: RamsesSubgraphPool,
-    ) => {
-      const address0 = pool.token0.toLowerCase();
-      const address1 = pool.token1.toLowerCase();
-
-      const decimals0 = parseInt(tokens.find((t) => t.id === address0)!.decimals);
-      const decimals1 = parseInt(tokens.find((t) => t.id === address1)!.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,
-        },
-      );
-    }));
-  }
-}