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

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

@@ -3,7 +3,6 @@ import { PoolStateV1_1, PoolState_v1_9 } from '../types';
 import { NumberAsString, SwapSide } from '@paraswap/core';
 import { OutputResult, TickInfo } from '../../uniswap-v3/types';
 import { Tick } from '../../uniswap-v3/contract-math/Tick';
-import { TickBitMap } from '../../uniswap-v3/contract-math/TickBitMap';
 import { SqrtPriceMath } from '../../uniswap-v3/contract-math/SqrtPriceMath';
 import { TickMath } from '../../uniswap-v3/contract-math/TickMath';
 import { LiquidityMath } from '../../uniswap-v3/contract-math/LiquidityMath';
@@ -21,6 +20,8 @@ import {
   MAX_PRICING_COMPUTATION_STEPS_ALLOWED,
   OUT_OF_RANGE_ERROR_POSTFIX,
 } from '../../uniswap-v3/constants';
+import { TickManager } from './TickManager';
+import { TickTable } from './TickTable';
 
 type UpdatePositionCache = {
   price: bigint;
@@ -112,10 +113,9 @@ function _priceComputationCycles(
 
     try {
       [step.tickNext, step.initialized] =
-        TickBitMap.nextInitializedTickWithinOneWord(
+        TickTable.nextInitializedTickWithinOneWord(
           poolState,
           state.tick,
-          poolState.tickSpacing,
           zeroForOne,
           true,
         );
@@ -378,9 +378,9 @@ class AlgebraMathClass {
     currentTick: bigint,
     currentPrice: bigint,
   ) {
-    let amount0;
-    let amount1;
-    let globalLiquidityDelta;
+    let amount0 = 0n;
+    let amount1 = 0n;
+    let globalLiquidityDelta = 0n;
     // If current tick is less than the provided bottom one then only the token0 has to be provided
     if (currentTick < bottomTick) {
       amount0 = SqrtPriceMath._getAmount0DeltaO(
@@ -434,7 +434,7 @@ class AlgebraMathClass {
       const time = this._blockTimestamp(state);
 
       if (
-        Tick.update(
+        TickManager.update(
           state,
           bottomTick,
           cache.tick,
@@ -447,10 +447,10 @@ class AlgebraMathClass {
         )
       ) {
         toggledBottom = true;
-        TickBitMap.flipTick(state, bottomTick, state.tickSpacing);
+        TickTable.toggleTick(state, bottomTick);
       }
       if (
-        Tick.update(
+        TickManager.update(
           state,
           topTick,
           cache.tick,
@@ -463,13 +463,13 @@ class AlgebraMathClass {
         )
       ) {
         toggledTop = true;
-        TickBitMap.flipTick(state, topTick, state.tickSpacing);
+        TickTable.toggleTick(state, topTick);
       }
     }
 
     // skip fee && position related stuffs
 
-    // same as UniwapV3Pool.sol line 327 ->   if (params.liquidityDelta != 0) {
+    // same as UniswapV3Pool.sol line 327 ->   if (params.liquidityDelta != 0) {
     if (liquidityDelta !== 0n) {
       // if liquidityDelta is negative and the tick was toggled, it means that it should not be initialized anymore, so we delete it
       if (liquidityDelta < 0) {
@@ -510,7 +510,7 @@ class AlgebraMathClass {
 
     let cache: SwapCalculationCache = {
       amountCalculated: 0n,
-      amountRequiredInitial: BI_MAX_INT, // similarly to waht we did for uniswap
+      amountRequiredInitial: BI_MAX_INT, // similarly to what we did for uniswap
       communityFee: 0n,
       exactInput: false,
       fee: 0n,
@@ -563,17 +563,15 @@ class AlgebraMathClass {
       stepSqrtPrice: 0n,
       tickCount: 0,
     };
-    let i = 0;
     // swap until there is remaining input or output tokens or we reach the price limit
     while (true) {
       step.stepSqrtPrice = currentPrice;
 
       //equivalent of tickTable.nextTickInTheSameRow(currentTick, zeroToOne);
       [step.nextTick, step.initialized] =
-        TickBitMap.nextInitializedTickWithinOneWord(
+        TickTable.nextInitializedTickWithinOneWord(
           poolState,
           currentTick,
-          poolState.tickSpacing,
           zeroToOne,
           false,
         );

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

@@ -0,0 +1,91 @@
+import { IAlgebraPoolState } from '../types';
+import { LiquidityMath } from '../../uniswap-v3/contract-math/LiquidityMath';
+import { _require } from '../../../utils';
+import { NumberAsString } from '@paraswap/core';
+import { ZERO_TICK_INFO } from '../../uniswap-v3/constants';
+import { TickInfo } from '../../uniswap-v3/types';
+
+export class TickManager {
+  static update(
+    state: Pick<IAlgebraPoolState, 'ticks'>,
+    tick: bigint,
+    tickCurrent: bigint,
+    liquidityDelta: bigint,
+    secondsPerLiquidityCumulativeX128: bigint,
+    tickCumulative: bigint,
+    time: bigint,
+    upper: boolean,
+    maxLiquidity: bigint,
+  ): boolean {
+    let info = state.ticks[Number(tick)];
+
+    if (info === undefined) {
+      info = { ...ZERO_TICK_INFO };
+      state.ticks[Number(tick)] = info;
+    }
+
+    // uint128 liquidityTotalBefore = data.liquidityTotal;
+    // uint128 liquidityTotalAfter = LiquidityMath.addDelta(liquidityTotalBefore, liquidityDelta);
+    // require(liquidityTotalAfter < Constants.MAX_LIQUIDITY_PER_TICK + 1, 'LO');
+    const liquidityGrossBefore = info.liquidityGross;
+    const liquidityGrossAfter = LiquidityMath.addDelta(
+      liquidityGrossBefore,
+      liquidityDelta,
+    );
+    _require(
+      liquidityGrossAfter <= maxLiquidity,
+      'LO',
+      { liquidityGrossAfter, maxLiquidity },
+      'liquidityGrossAfter <= maxLiquidity',
+    );
+
+    // int128 liquidityDeltaBefore = data.liquidityDelta;
+    const liquidityNetBefore = info.liquidityNet;
+
+    // // when the lower (upper) tick is crossed left to right (right to left), liquidity must be added (removed)
+    // data.liquidityDelta = upper
+    //   ? int256(liquidityDeltaBefore).sub(liquidityDelta).toInt128()
+    //   : int256(liquidityDeltaBefore).add(liquidityDelta).toInt128();
+    //
+    // data.liquidityTotal = liquidityTotalAfter;
+    info.liquidityNet = upper
+      ? BigInt.asIntN(
+          128,
+          BigInt.asIntN(256, liquidityNetBefore) - liquidityDelta,
+        )
+      : BigInt.asIntN(
+          128,
+          BigInt.asIntN(256, liquidityNetBefore) + liquidityDelta,
+        );
+
+    // flipped = (liquidityTotalAfter == 0);
+    // if (liquidityTotalBefore == 0) {
+    //   flipped = !flipped;
+    //   // by convention, we assume that all growth before a tick was initialized happened _below_ the tick
+    //   if (tick <= currentTick) {
+    //     data.outerFeeGrowth0Token = totalFeeGrowth0Token;
+    //     data.outerFeeGrowth1Token = totalFeeGrowth1Token;
+    //     data.outerSecondsPerLiquidity = secondsPerLiquidityCumulative;
+    //     data.outerTickCumulative = tickCumulative;
+    //     data.outerSecondsSpent = time;
+    //   }
+    //   data.initialized = true;
+    // }
+
+    let flipped = liquidityGrossAfter === 0n;
+    if (liquidityGrossBefore === 0n) {
+      flipped = !flipped;
+      if (tick <= tickCurrent) {
+        info.secondsPerLiquidityOutsideX128 = secondsPerLiquidityCumulativeX128;
+        info.tickCumulativeOutside = tickCumulative;
+        info.secondsOutside = time;
+      }
+      info.initialized = true;
+    }
+
+    // data.liquidityTotal = liquidityTotalAfter;
+    info.liquidityGross = liquidityGrossAfter;
+
+    return flipped;
+  }
+}

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

@@ -0,0 +1,199 @@
+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';
+
+const iszero = (x: bigint) => (x === 0n ? 1n : 0n);
+
+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,
+  ) {
+    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,
+  ): [bigint, boolean] {
+    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 = iszero(
+      word &&
+        BigInt(
+          '0x5555555555555555555555555555555555555555555555555555555555555555',
+        ),
+    );
+    singleBitPos =
+      singleBitPos ||
+      iszero(
+        word &&
+          BigInt(
+            '0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff',
+          ),
+      ) << 7n;
+    singleBitPos =
+      singleBitPos ||
+      iszero(
+        word &&
+          BigInt(
+            '0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff',
+          ),
+      ) << 6n;
+    singleBitPos =
+      singleBitPos ||
+      iszero(
+        word &&
+          BigInt(
+            '0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff',
+          ),
+      ) << 5n;
+    singleBitPos =
+      singleBitPos ||
+      iszero(
+        word &&
+          BigInt(
+            '0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff',
+          ),
+      ) << 4n;
+    singleBitPos =
+      singleBitPos ||
+      iszero(
+        word &&
+          BigInt(
+            '0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff',
+          ),
+      ) << 3n;
+    singleBitPos =
+      singleBitPos ||
+      iszero(
+        word &&
+          BigInt(
+            '0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f',
+          ),
+      ) << 2n;
+    singleBitPos =
+      singleBitPos ||
+      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): bigint {
+    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/types.ts

@@ -71,6 +71,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>