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

package/src/dex/index.ts

@@ -42,7 +42,6 @@ import { WooFiV2 } from './woo-fi-v2/woo-fi-v2';
 import { ParaSwapLimitOrders } from './paraswap-limit-orders/paraswap-limit-orders';
 import { AugustusRFQOrder } from './augustus-rfq';
 import { Solidly } from './solidly/solidly';
-import { Ramses } from './solidly/forks-override/ramses';
 import { Thena } from './solidly/forks-override/thena';
 import { Chronos } from './solidly/forks-override/chronos';
 import { Velodrome } from './solidly/forks-override/velodrome';
@@ -125,7 +124,6 @@ const Dexes = [
   Solidly,
   SolidlyEthereum,
   SpiritSwapV2,
-  Ramses,
   Thena,
   Chronos,
   Velodrome,

package/src/dex/solidly/config.ts

@@ -125,18 +125,6 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 0,
     },
   },
-  Ramses: {
-    [Network.ARBITRUM]: {
-      subgraphURL:
-        'https://api.thegraph.com/subgraphs/name/ramsesexchange/api-subgraph',
-      factoryAddress: '0xAAA20D08e59F6561f242b08513D36266C5A29415',
-      router: '0xb2634B3CBc1E401AB3C2743DB44d459C5c9aA662',
-      initCode:
-        '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
-      poolGasCost: 180 * 1000,
-      feeCode: 0,
-    },
-  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {
@@ -159,6 +147,6 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 3 }], // solisnek
   },
   [Network.ARBITRUM]: {
-    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 1 }], // chronos, ramses
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 1 }], // chronos
   },
 };

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

@@ -1179,100 +1179,5 @@ describe('Solidly E2E', () => {
         }),
       );
     });
-
-    describe('Ramses', () => {
-      const dexKey = 'Ramses';
-
-      const sideToContractMethods = new Map([
-        [
-          SwapSide.SELL,
-          [
-            ContractMethod.simpleSwap,
-            ContractMethod.multiSwap,
-            ContractMethod.megaSwap,
-          ],
-        ],
-      ]);
-
-      const pairs: { name: string; sellAmount: string }[][] = [
-        [
-          {
-            name: 'ETH',
-            sellAmount: '1000000000000000000',
-          },
-          {
-            name: 'USDCe',
-            sellAmount: '100000000',
-          },
-        ],
-        [
-          {
-            name: 'WETH',
-            sellAmount: '1000000000000000000',
-          },
-          {
-            name: 'USDCe',
-            sellAmount: '100000000',
-          },
-        ],
-        [
-          {
-            name: 'USDT',
-            sellAmount: '100000000',
-          },
-          {
-            name: 'USDCe',
-            sellAmount: '100000000',
-          },
-        ],
-        [
-          {
-            name: 'USDCe',
-            sellAmount: '100000000',
-          },
-          {
-            name: 'DAI',
-            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,
-                  );
-                });
-              });
-            });
-          });
-        }),
-      );
-    });
   });
 });

package/src/dex/solidly/solidly-integration.test.ts

@@ -12,8 +12,6 @@ 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';
-import { Ramses } from './forks-override/ramses';
-import * as util from 'util';
 
 const amounts18 = [0n, BI_POWS[18], 2000000000000000000n];
 const amounts6 = [0n, BI_POWS[6], 2000000n];
@@ -62,7 +60,7 @@ const constructCheckOnChainPricing =
       funcName,
       tokenIn,
     );
-
+    console.log('readerCallData', readerCallData);
     const readerResult = (
       await dexHelper.multiContract.methods
         .aggregate(readerCallData)
@@ -72,8 +70,6 @@ const constructCheckOnChainPricing =
       decodeReaderResult(readerResult, readerIface, funcName),
     );
 
-    console.log('ON-CHAIN PRICES: ', expectedPrices);
-
     expect(prices.map(p => p.toString())).toEqual(
       expectedPrices.map(p => p.toString()),
     );
@@ -772,141 +768,5 @@ describe('Solidly integration tests', () => {
         });
       });
     });
-
-    describe('Ramses', function () {
-      const dexKey = 'Ramses';
-      const ramses = new Ramses(network, dexKey, dexHelper);
-
-      describe('UniswapV2 like pool', function () {
-        const TokenASymbol = 'USDCe';
-        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 ramses.getPoolIdentifiers(
-            tokenA,
-            tokenB,
-            SwapSide.SELL,
-            blocknumber,
-          );
-          console.log(
-            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-            pools,
-          );
-
-          expect(pools.length).toBeGreaterThan(0);
-
-          console.log('AMOUNTS: ', amounts);
-
-          const poolPrices = await ramses.getPricesVolume(
-            tokenA,
-            tokenB,
-            amounts,
-            SwapSide.SELL,
-            blocknumber,
-            pools,
-          );
-          console.log(
-            `${TokenASymbol} <> ${TokenBSymbol} Pool Prices: `,
-            util.inspect(poolPrices, false, null, true),
-          );
-
-          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(
-              ramses,
-              'getAmountOut',
-              blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
-              tokenA.address,
-              amounts,
-            );
-          }
-        });
-
-        it('getTopPoolsForToken', async function () {
-          const poolLiquidity = await ramses.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 = 'USDCe';
-        const tokenB = Tokens[network][TokenBSymbol];
-
-        const amounts = amounts6;
-
-        it('getPoolIdentifiers and getPricesVolume', async function () {
-          const blocknumber = await dexHelper.web3Provider.eth.getBlockNumber();
-          const pools = await ramses.getPoolIdentifiers(
-            tokenA,
-            tokenB,
-            SwapSide.SELL,
-            blocknumber,
-          );
-          console.log(
-            `${TokenASymbol} <> ${TokenBSymbol} Pool Identifiers: `,
-            pools,
-          );
-
-          expect(pools.length).toBeGreaterThan(0);
-
-          const poolPrices = await ramses.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(
-              ramses,
-              'getAmountOut',
-              blocknumber,
-              poolPrices![i].prices,
-              poolPrices![i].poolAddresses![0],
-              tokenA.address,
-              amounts,
-            );
-          }
-        });
-
-        it('getTopPoolsForToken', async function () {
-          const poolLiquidity = await ramses.getTopPoolsForToken(
-            tokenA.address,
-            10,
-          );
-          console.log(`${TokenASymbol} Top Pools:`, poolLiquidity);
-
-          checkPoolsLiquidity(poolLiquidity, tokenA.address, dexKey);
-        });
-      });
-    });
   });
 });

package/src/dex/solidly/solidly.ts

@@ -72,7 +72,6 @@ export class Solidly extends UniswapV2 {
         'Thena',
         'SoliSnek',
         'Chronos',
-        'Ramses'
       ]),
     );
 
@@ -521,7 +520,6 @@ export class Solidly extends UniswapV2 {
     const pair = await this.findSolidlyPair(from, to, stable);
     if (!(pair && pair.pool && pair.exchange)) return null;
     const pairState = pair.pool.getState(blockNumber);
-
     if (!pairState) {
       this.logger.error(
         `Error_orderPairParams expected reserves, got none (maybe the pool doesn't exist) ${

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

@@ -2,6 +2,9 @@ import { DexParams } from './types';
 import { DexConfigMap, AdapterMappings } from '../../types';
 import { Network, SwapSide } from '../../constants';
 import { Address } from '../../types';
+import RamsesV2StateMulticallABI from '../../abi/RamsesV2StateMulticall.abi.json';
+import { AbiItem } from 'web3-utils';
+import { decodeStateMultiCallResultWithRelativeBitmaps } from './forks/ramses-v2/utils';
 
 const SUPPORTED_FEES = [10000n, 3000n, 500n, 100n];
 
@@ -104,6 +107,25 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
         'https://api.thegraph.com/subgraphs/name/lynnshaoyu/uniswap-v3-avax',
     },
   },
+  RamsesV2: {
+    [Network.ARBITRUM]: {
+      factory: '0xAA2cd7477c451E703f3B9Ba5663334914763edF8',
+      deployer: '0xb3e423ab9cE6C03D98326A3A2a0D7D96b0829f22',
+      quoter: '0xAA20EFF7ad2F523590dE6c04918DaAE0904E3b20',
+      router: '0xAA23611badAFB62D37E7295A682D21960ac85A90',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x50EE4112Cab9c79812F23bE079aB3911395ACc8e',
+      stateMultiCallAbi: RamsesV2StateMulticallABI as AbiItem[],
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initRetryFrequency: 10,
+      decodeStateMultiCallResultWithRelativeBitmaps,
+      initHash:
+        '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ramsesexchange/concentrated-liquidity-graph',
+    },
+  },
   'QuickSwapV3.1': {
     [Network.ZKEVM]: {
       factory: '0xD9a2AD9E927Bd7014116CC5c7328f028D4318178',

package/src/dex/uniswap-v3/forks/ramses-v2/utils.ts

@@ -0,0 +1,72 @@
+import { MultiResult } from '../../../../lib/multi-wrapper';
+import { BytesLike, ethers } from 'ethers';
+import { DecodedStateMultiCallResultWithRelativeBitmaps } from '../../types';
+import { extractSuccessAndValue } from '../../../../lib/decoders';
+import { assert } from 'ts-essentials';
+
+export function decodeStateMultiCallResultWithRelativeBitmaps(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedStateMultiCallResultWithRelativeBitmaps {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeStateMultiCallResultWithRelativeBitmaps failed to get decodable result: ${result}`,
+  );
+
+  const decoded = ethers.utils.defaultAbiCoder.decode(
+    [
+      // I don't want to pass here any interface, so I just use it in ethers format
+      `
+      tuple(
+        address pool,
+        uint256 blockTimestamp,
+        tuple(
+          uint160 sqrtPriceX96,
+          int24 tick,
+          uint16 observationIndex,
+          uint16 observationCardinality,
+          uint16 observationCardinalityNext,
+          uint8 feeProtocol,
+          bool unlocked,
+        ) slot0,
+        uint128 liquidity,
+        int24 tickSpacing,
+        uint128 maxLiquidityPerTick,
+        tuple(
+          uint32 blockTimestamp,
+          int56 tickCumulative,
+          uint160 secondsPerLiquidityCumulativeX128,
+          bool initialized,
+          uint160 secondsPerBoostedLiquidityPeriodX128,
+          uint32 boostedInRange,
+        ) observation,
+        tuple(
+          int16 index,
+          uint256 value
+        )[] tickBitmap,
+        tuple(
+          int24 index,
+          tuple(
+            uint128 liquidityGross,
+            int128 liquidityNet,
+            uint128 cleanUnusedSlot,
+            uint128 cleanUnusedSlot2,
+            uint256 feeGrowthOutside0X128,
+            uint256 feeGrowthOutside1X128,
+            int56 tickCumulativeOutside,
+            uint160 secondsPerLiquidityOutsideX128,
+            uint32 secondsOutside,
+            bool initialized,
+          ) value,
+        )[] ticks
+      )
+    `,
+    ],
+    toDecode,
+  )[0];
+
+  // This conversion is not precise, because when we decode, we have more values
+  // But I typed only the ones that are used later
+  return decoded as DecodedStateMultiCallResultWithRelativeBitmaps;
+}

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

@@ -1,6 +1,8 @@
-import { BigNumber } from 'ethers';
+import { BigNumber, BytesLike } from 'ethers';
 import { NumberAsString } from '../../types';
 import { Address } from '../../types';
+import { AbiItem } from 'web3-utils';
+import { MultiResult } from '../../lib/multi-wrapper';
 
 export type OracleObservation = {
   blockTimestamp: bigint;
@@ -60,6 +62,8 @@ export type UniswapV3Data = {
   isApproved?: boolean;
 };
 
+export type DecodeStateMultiCallFunc = (result: MultiResult<BytesLike> | BytesLike) => DecodedStateMultiCallResultWithRelativeBitmaps;
+
 export type DexParams = {
   router: Address;
   quoter: Address;
@@ -72,6 +76,8 @@ export type DexParams = {
   deployer?: Address;
   subgraphURL: string;
   initHash: string;
+  stateMultiCallAbi?: AbiItem[];
+  decodeStateMultiCallResultWithRelativeBitmaps? : DecodeStateMultiCallFunc,
 };
 
 export type UniswapV3SimpleSwapSellParam = {