@paraswap/dex-lib 2.28.3 → 2.28.4-algebra-events-fix.1

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

@@ -0,0 +1,215 @@
+import { IAlgebraPoolState } from '../types';
+import { _require } from '../../../utils';
+import { DeepReadonly } from 'ts-essentials';
+import {
+  OUT_OF_RANGE_ERROR_POSTFIX,
+  TICK_BITMAP_BUFFER,
+  TICK_BITMAP_TO_USE,
+} from '../../uniswap-v3/constants';
+import { TickMath } from '../../uniswap-v3/contract-math/TickMath';
+import { Yul } from './yul-helper';
+
+function isWordPosOut(
+  wordPos: bigint,
+  startTickBitmap: bigint,
+  // For pricing we use wider range to check price impact. If function called from event
+  // it must always be within buffer
+  isPriceQuery: boolean,
+) {
+  let lowerTickBitmapLimit;
+  let upperTickBitmapLimit;
+
+  if (isPriceQuery) {
+    lowerTickBitmapLimit =
+      startTickBitmap - (TICK_BITMAP_BUFFER + TICK_BITMAP_TO_USE);
+    upperTickBitmapLimit =
+      startTickBitmap + (TICK_BITMAP_BUFFER + TICK_BITMAP_TO_USE);
+  } else {
+    lowerTickBitmapLimit = startTickBitmap - TICK_BITMAP_BUFFER;
+    upperTickBitmapLimit = startTickBitmap + TICK_BITMAP_BUFFER;
+  }
+
+  _require(
+    wordPos >= lowerTickBitmapLimit && wordPos <= upperTickBitmapLimit,
+    `wordPos is out of safe state tickBitmap request range: ${OUT_OF_RANGE_ERROR_POSTFIX}`,
+    { wordPos },
+    `wordPos >= LOWER_TICK_REQUEST_LIMIT && wordPos <= UPPER_TICK_REQUEST_LIMIT`,
+  );
+}
+
+export class TickTable {
+  static position(tick: bigint) {
+    return [
+      // wordPos
+      BigInt.asIntN(16, tick >> 8n),
+      // bitPos
+      BigInt.asUintN(8, tick & BigInt(0xff)),
+    ];
+  }
+
+  static toggleTick(
+    state: Pick<IAlgebraPoolState, 'startTickBitmap' | 'tickBitmap'>,
+    tick: bigint,
+    tickSpacing?: bigint,
+  ) {
+    if (tickSpacing !== undefined) {
+      tick /= tickSpacing;
+    }
+    const [rowNumber, bitNumber] = TickTable.position(tick);
+    const mask = 1n << bitNumber;
+
+    // toggleTick is used only in _updatePosition which is always state changing event
+    // Therefore it is never used in price query
+    isWordPosOut(rowNumber, state.startTickBitmap, false);
+
+    const stringWordPos = rowNumber.toString();
+    if (state.tickBitmap[stringWordPos] === undefined) {
+      state.tickBitmap[stringWordPos] = 0n;
+    }
+
+    state.tickBitmap[stringWordPos] ^= mask;
+    if (state.tickBitmap[stringWordPos] === 0n) {
+      delete state.tickBitmap[stringWordPos];
+    }
+  }
+
+  static nextInitializedTickWithinOneWord(
+    state: DeepReadonly<
+      Pick<IAlgebraPoolState, 'startTickBitmap' | 'tickBitmap'>
+    >,
+    tick: bigint,
+    lte: boolean,
+    isPriceQuery: boolean,
+    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))),
+        ),
+      );
+    }
+    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);
+      if (_row != 0n) {
+        tick -= BigInt.asIntN(24, 255n - TickTable.getMostSignificantBit(_row));
+        return [TickTable.boundTick(tick), true];
+      } else {
+        tick -= BigInt.asIntN(24, bitNumber);
+        return [TickTable.boundTick(tick), false];
+      }
+    } else {
+      tick += 1n;
+      const _row = tickBitmapValue >> bitNumber;
+      if (_row !== 0n) {
+        tick += BigInt.asIntN(
+          24,
+          TickTable.getSingleSignificantBit(-_row & _row),
+        );
+        return [TickTable.boundTick(tick), true];
+      } else {
+        tick += BigInt.asIntN(24, 255n - bitNumber);
+        return [TickTable.boundTick(tick), false];
+      }
+    }
+  }
+
+  static getSingleSignificantBit(word: bigint): bigint {
+    let singleBitPos = 0n;
+    singleBitPos = Yul.iszero(
+      word &&
+        BigInt(
+          '0x5555555555555555555555555555555555555555555555555555555555555555',
+        ),
+    );
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff',
+          ),
+      ) << 7n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff',
+          ),
+      ) << 6n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff',
+          ),
+      ) << 5n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff',
+          ),
+      ) << 4n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff',
+          ),
+      ) << 3n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f',
+          ),
+      ) << 2n;
+    singleBitPos =
+      singleBitPos ||
+      Yul.iszero(
+        word &&
+          BigInt(
+            '0x3333333333333333333333333333333333333333333333333333333333333333',
+          ),
+      ) << 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 >> 1n);
+    return TickTable.getSingleSignificantBit(word);
+  }
+
+  static boundTick(tick: bigint, tickSpacing?: bigint): bigint {
+    if (tickSpacing !== undefined) {
+      tick *= tickSpacing;
+    }
+    let boundedTick = tick;
+    if (boundedTick < TickMath.MIN_TICK) {
+      boundedTick = TickMath.MIN_TICK;
+    } else if (boundedTick > TickMath.MAX_TICK) {
+      boundedTick = TickMath.MAX_TICK;
+    }
+    return boundedTick;
+  }
+}

package/src/dex/algebra/lib/yul-helper.ts

@@ -0,0 +1,29 @@
+export class Yul {
+  static sub(x: bigint, y: bigint): bigint {
+    return x - y;
+  }
+
+  static sdiv(x: bigint, y: bigint): bigint {
+    return y === 0n ? 0n : x / y;
+  }
+
+  static and(x: bigint, y: bigint): bigint {
+    return x & y;
+  }
+
+  static slt(x: bigint, y: bigint): bigint {
+    return x < y ? 1n : 0n;
+  }
+
+  static not(x: bigint): bigint {
+    return ~x;
+  }
+
+  static iszero(x: bigint): bigint {
+    return x === 0n ? 1n : 0n;
+  }
+
+  static smod(x: bigint, y: bigint): bigint {
+    return y === 0n ? 0n : x % y;
+  }
+}

package/src/dex/algebra/types.ts

@@ -23,6 +23,7 @@ export type PoolStateV1_1 = {
   startTickBitmap: bigint;
   balance0: bigint;
   balance1: bigint;
+  areTicksCompressed: boolean;
 };
 
 type GlobalState_v1_9 = {
@@ -47,6 +48,7 @@ export type PoolState_v1_9 = {
   startTickBitmap: bigint;
   balance0: bigint;
   balance1: bigint;
+  areTicksCompressed: boolean;
 };
 
 export type AlgebraData = {
@@ -71,6 +73,8 @@ export type DexParams = {
   version: 'v1.1' | 'v1.9';
 };
 
+export type IAlgebraPoolState = PoolStateV1_1 | PoolState_v1_9;
+
 export type TickBitMapMappingsWithBigNumber = {
   index: number;
   value: BigNumber;

package/src/dex/uniswap-v3/contract-math/TickBitMap.ts

@@ -120,13 +120,4 @@ export class TickBitMap {
 
     return [next, initialized];
   }
-
-  static _putZeroIfUndefined(
-    state: PoolState,
-    tickBitmapValue: bigint | undefined,
-    wordPos: bigint,
-    isPriceQuery: boolean = false,
-  ): bigint {
-    return tickBitmapValue === undefined ? 0n : tickBitmapValue;
-  }
 }

package/src/dex/uniswap-v3/contract-math/utils.ts

@@ -38,16 +38,18 @@ export function _reduceTicks(
 ) {
   return ticksToReduce.reduce<Record<string, TickInfo>>((acc, curr) => {
     const { index, value } = curr;
-    acc[index] = {
-      liquidityGross: bigIntify(value.liquidityGross),
-      liquidityNet: bigIntify(value.liquidityNet),
-      tickCumulativeOutside: bigIntify(value.tickCumulativeOutside),
-      secondsPerLiquidityOutsideX128: bigIntify(
-        value.secondsPerLiquidityOutsideX128,
-      ),
-      secondsOutside: bigIntify(value.secondsOutside),
-      initialized: value.initialized,
-    };
+    if (value.initialized) {
+      acc[index] = {
+        liquidityGross: bigIntify(value.liquidityGross),
+        liquidityNet: bigIntify(value.liquidityNet),
+        tickCumulativeOutside: bigIntify(value.tickCumulativeOutside),
+        secondsPerLiquidityOutsideX128: bigIntify(
+          value.secondsPerLiquidityOutsideX128,
+        ),
+        secondsOutside: bigIntify(value.secondsOutside),
+        initialized: value.initialized,
+      };
+    }
     return acc;
   }, ticks);
 }

package/tests/constants-e2e.ts

@@ -705,7 +705,7 @@ export const Tokens: {
     HATCHY: {
       address: '0x502580fc390606b47fc3b741d6d49909383c28a9',
       decimals: 18,
-    }
+    },
   },
   [Network.ARBITRUM]: {
     DAI: {
@@ -781,6 +781,14 @@ export const Tokens: {
       address: '0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f',
       decimals: 8,
     },
+    USDCe: {
+      address: '0xff970a61a04b1ca14834a43f5de4533ebddb5cc8',
+      decimals: 6,
+    },
+    LEX: {
+      address: '0x6bB7A17AcC227fd1F6781D1EEDEAE01B42047eE0',
+      decimals: 18,
+    },
   },
   [Network.OPTIMISM]: {
     DAI: {

package/.idea/aws.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="accountSettings">
-    <option name="activeProfile" value="profile:default" />
-    <option name="activeRegion" value="us-east-1" />
-    <option name="recentlyUsedProfiles">
-      <list>
-        <option value="profile:default" />
-      </list>
-    </option>
-    <option name="recentlyUsedRegions">
-      <list>
-        <option value="us-east-1" />
-      </list>
-    </option>
-  </component>
-</project>

package/.idea/codeStyles/Project.xml

@@ -1,19 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <ScalaCodeStyleSettings>
-      <option name="MULTILINE_STRING_CLOSING_QUOTES_ON_NEW_LINE" value="true" />
-    </ScalaCodeStyleSettings>
-    <TypeScriptCodeStyleSettings version="0">
-      <option name="SPACE_WITHIN_ARRAY_INITIALIZER_BRACKETS" value="true" />
-      <option name="USE_DOUBLE_QUOTES" value="false" />
-      <option name="SPACES_WITHIN_IMPORTS" value="true" />
-    </TypeScriptCodeStyleSettings>
-    <codeStyleSettings language="TypeScript">
-      <indentOptions>
-        <option name="INDENT_SIZE" value="2" />
-        <option name="CONTINUATION_INDENT_SIZE" value="2" />
-        <option name="TAB_SIZE" value="2" />
-      </indentOptions>
-    </codeStyleSettings>
-  </code_scheme>
-</component>

package/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
-  </state>
-</component>

package/.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/paraswap-dex-lib.iml" filepath="$PROJECT_DIR$/.idea/paraswap-dex-lib.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/paraswap-dex-lib.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>