@paraswap/dex-lib 2.28.11-ramses-v2 → 2.28.11

package/src/dex/algebra/lib/TickTable.ts

@@ -43,7 +43,7 @@ export class TickTable {
       // wordPos
       BigInt.asIntN(16, tick >> 8n),
       // bitPos
-      BigInt.asUintN(8, tick & BigInt(0xff)),
+      BigInt.asUintN(8, tick & 0xffn),
     ];
   }
 
@@ -56,7 +56,7 @@ export class TickTable {
       tick /= tickSpacing;
     }
     const [rowNumber, bitNumber] = TickTable.position(tick);
-    const mask = 1n << bitNumber;
+    const mask = BigInt.asUintN(256, 1n << bitNumber);
 
     // toggleTick is used only in _updatePosition which is always state changing event
     // Therefore it is never used in price query
@@ -83,20 +83,24 @@ export class TickTable {
     tickSpacing?: bigint,
   ): [bigint, boolean] {
     if (tickSpacing !== undefined) {
-      tick = Yul.sub(
-        Yul.sdiv(tick, tickSpacing),
-        Yul.and(
-          Yul.slt(tick, 0n),
-          Yul.not(Yul.iszero(Yul.smod(tick, tickSpacing))),
+      tick = BigInt.asIntN(
+        24,
+        Yul.sub(
+          Yul.sdiv(tick, tickSpacing),
+          Yul.and(
+            Yul.slt(tick, 0n),
+            Yul.not(Yul.iszero(Yul.smod(tick, tickSpacing))),
+          ),
         ),
       );
     }
-    const [rowNumber, bitNumber] = TickTable.position(tick);
-    isWordPosOut(rowNumber, state.startTickBitmap, isPriceQuery);
-    let tickBitmapValue = state.tickBitmap[rowNumber.toString()];
-    tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
     if (lte) {
-      const _row = tickBitmapValue << (255n - bitNumber);
+      const [rowNumber, bitNumber] = TickTable.position(tick);
+      isWordPosOut(rowNumber, state.startTickBitmap, isPriceQuery);
+      let tickBitmapValue = state.tickBitmap[rowNumber.toString()];
+      tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
+
+      const _row = BigInt.asUintN(256, tickBitmapValue << (255n - bitNumber));
       if (_row != 0n) {
         tick -= BigInt.asIntN(24, 255n - TickTable.getMostSignificantBit(_row));
         return [TickTable.boundTick(tick, tickSpacing), true];
@@ -106,7 +110,13 @@ export class TickTable {
       }
     } else {
       tick += 1n;
-      const _row = tickBitmapValue >> bitNumber;
+
+      const [rowNumber, bitNumber] = TickTable.position(tick);
+      isWordPosOut(rowNumber, state.startTickBitmap, isPriceQuery);
+      let tickBitmapValue = state.tickBitmap[rowNumber.toString()];
+      tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
+
+      const _row = BigInt.asUintN(256, tickBitmapValue >> bitNumber);
       if (_row !== 0n) {
         tick += BigInt.asIntN(
           24,
@@ -123,80 +133,71 @@ export class TickTable {
   static getSingleSignificantBit(word: bigint): bigint {
     let singleBitPos = 0n;
     singleBitPos = Yul.iszero(
-      word &&
-        BigInt(
-          '0x5555555555555555555555555555555555555555555555555555555555555555',
-        ),
+      word &
+        0x5555555555555555555555555555555555555555555555555555555555555555n,
     );
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff',
-          ),
-      ) << 7n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x00000000000000000000000000000000ffffffffffffffffffffffffffffffffn,
+      ) <<
+        7n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff',
-          ),
-      ) << 6n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffffn,
+      ) <<
+        6n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff',
-          ),
-      ) << 5n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffffn,
+      ) <<
+        5n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff',
-          ),
-      ) << 4n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffffn,
+      ) <<
+        4n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff',
-          ),
-      ) << 3n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ffn,
+      ) <<
+        3n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f',
-          ),
-      ) << 2n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0fn,
+      ) <<
+        2n);
     singleBitPos =
-      singleBitPos ||
-      Yul.iszero(
-        word &&
-          BigInt(
-            '0x3333333333333333333333333333333333333333333333333333333333333333',
-          ),
-      ) << 1n;
+      singleBitPos |
+      (Yul.iszero(
+        word &
+          0x3333333333333333333333333333333333333333333333333333333333333333n,
+      ) <<
+        1n);
 
     return BigInt.asUintN(8, singleBitPos);
   }
 
   static getMostSignificantBit(word: bigint): bigint {
-    word = word || word >> 1n;
-    word = word || word >> 2n;
-    word = word || word >> 4n;
-    word = word || word >> 8n;
-    word = word || word >> 16n;
-    word = word || word >> 32n;
-    word = word || word >> 64n;
-    word = word || word >> 128n;
+    word = word | (word >> 1n);
+    word = word | (word >> 2n);
+    word = word | (word >> 4n);
+    word = word | (word >> 8n);
+    word = word | (word >> 16n);
+    word = word | (word >> 32n);
+    word = word | (word >> 64n);
+    word = word | (word >> 128n);
     word = word - (word >> 1n);
     return TickTable.getSingleSignificantBit(BigInt.asUintN(256, word));
   }

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

@@ -2,9 +2,6 @@ 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];
 
@@ -107,25 +104,6 @@ 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/types.ts

@@ -1,8 +1,6 @@
-import { BigNumber, BytesLike } from 'ethers';
+import { BigNumber } 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;
@@ -62,8 +60,6 @@ export type UniswapV3Data = {
   isApproved?: boolean;
 };
 
-export type DecodeStateMultiCallFunc = (result: MultiResult<BytesLike> | BytesLike) => DecodedStateMultiCallResultWithRelativeBitmaps;
-
 export type DexParams = {
   router: Address;
   quoter: Address;
@@ -76,8 +72,6 @@ export type DexParams = {
   deployer?: Address;
   subgraphURL: string;
   initHash: string;
-  stateMultiCallAbi?: AbiItem[];
-  decodeStateMultiCallResultWithRelativeBitmaps? : DecodeStateMultiCallFunc,
 };
 
 export type UniswapV3SimpleSwapSellParam = {