sushi 6.0.12 → 6.0.13

package/evm/pool/sushiswap-v3/utils/sqrtPriceMath.ts

@@ -0,0 +1,162 @@
+import invariant from 'tiny-invariant'
+import { MAX_UINT256 } from '../../../../generic/math/constants.js'
+import { Q96 } from '../internalConstants.js'
+import { FullMath } from './fullMath.js'
+
+const MaxUint160 = 2n ** 160n - 1n
+
+function multiplyIn256(x: bigint, y: bigint): bigint {
+  const product = x * y
+  return product & MAX_UINT256
+}
+
+function addIn256(x: bigint, y: bigint): bigint {
+  const sum = x + y
+  return sum & MAX_UINT256
+}
+
+export abstract class SqrtPriceMath {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static getAmount0Delta(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+    roundUp: boolean,
+  ): bigint {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+      ;[sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96]
+    }
+
+    const numerator1 = liquidity << 96n
+    const numerator2 = sqrtRatioBX96 - sqrtRatioAX96
+
+    return roundUp
+      ? FullMath.mulDivRoundingUp(
+          FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96),
+          1n,
+          sqrtRatioAX96,
+        )
+      : (numerator1 * numerator2) / sqrtRatioBX96 / sqrtRatioAX96
+  }
+
+  public static getAmount1Delta(
+    sqrtRatioAX96: bigint,
+    sqrtRatioBX96: bigint,
+    liquidity: bigint,
+    roundUp: boolean,
+  ): bigint {
+    if (sqrtRatioAX96 > sqrtRatioBX96) {
+      ;[sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96]
+    }
+
+    return roundUp
+      ? FullMath.mulDivRoundingUp(liquidity, sqrtRatioBX96 - sqrtRatioAX96, Q96)
+      : (liquidity * (sqrtRatioBX96 - sqrtRatioAX96)) / Q96
+  }
+
+  public static getNextSqrtPriceFromInput(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amountIn: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    invariant(sqrtPX96 > 0n)
+    invariant(liquidity > 0n)
+
+    return zeroForOne
+      ? this.getNextSqrtPriceFromAmount0RoundingUp(
+          sqrtPX96,
+          liquidity,
+          amountIn,
+          true,
+        )
+      : this.getNextSqrtPriceFromAmount1RoundingDown(
+          sqrtPX96,
+          liquidity,
+          amountIn,
+          true,
+        )
+  }
+
+  public static getNextSqrtPriceFromOutput(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amountOut: bigint,
+    zeroForOne: boolean,
+  ): bigint {
+    invariant(sqrtPX96 > 0n)
+    invariant(liquidity > 0n)
+
+    return zeroForOne
+      ? this.getNextSqrtPriceFromAmount1RoundingDown(
+          sqrtPX96,
+          liquidity,
+          amountOut,
+          false,
+        )
+      : this.getNextSqrtPriceFromAmount0RoundingUp(
+          sqrtPX96,
+          liquidity,
+          amountOut,
+          false,
+        )
+  }
+
+  private static getNextSqrtPriceFromAmount0RoundingUp(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    add: boolean,
+  ): bigint {
+    if (amount === 0n) return sqrtPX96
+    const numerator1 = liquidity << 96n
+
+    if (add) {
+      const product = multiplyIn256(amount, sqrtPX96)
+      if (product / amount === sqrtPX96) {
+        const denominator = addIn256(numerator1, product)
+        if (denominator >= numerator1) {
+          return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator)
+        }
+      }
+
+      return FullMath.mulDivRoundingUp(
+        numerator1,
+        1n,
+        numerator1 / sqrtPX96 + amount,
+      )
+    } else {
+      const product = multiplyIn256(amount, sqrtPX96)
+
+      invariant(product / amount === sqrtPX96)
+      invariant(numerator1 > product)
+      const denominator = numerator1 - product
+      return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator)
+    }
+  }
+
+  private static getNextSqrtPriceFromAmount1RoundingDown(
+    sqrtPX96: bigint,
+    liquidity: bigint,
+    amount: bigint,
+    add: boolean,
+  ): bigint {
+    if (add) {
+      const quotient =
+        amount <= MaxUint160
+          ? (amount << 96n) / liquidity
+          : (amount * Q96) / liquidity
+
+      return sqrtPX96 + quotient
+    } else {
+      const quotient = FullMath.mulDivRoundingUp(amount, Q96, liquidity)
+
+      invariant(sqrtPX96 > quotient)
+      return sqrtPX96 - quotient
+    }
+  }
+}

package/evm/pool/sushiswap-v3/utils/swapMath.ts

@@ -0,0 +1,140 @@
+import type { SushiSwapV3FeeAmount } from '../../../config/index.js'
+import { FullMath } from './fullMath.js'
+import { SqrtPriceMath } from './sqrtPriceMath.js'
+
+const MAX_FEE = 10n ** 6n
+
+export abstract class SwapMath {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static computeSwapStep(
+    sqrtRatioCurrentX96: bigint,
+    sqrtRatioTargetX96: bigint,
+    liquidity: bigint,
+    amountRemaining: bigint,
+    feePips: SushiSwapV3FeeAmount,
+  ): [bigint, bigint, bigint, bigint] {
+    // We know that all will be assigned, typescript just doesn't see it for amountIn/Out
+    let sqrtRatioNextX96
+    let amountIn = 0n
+    let amountOut = 0n
+    let feeAmount
+
+    const zeroForOne = sqrtRatioCurrentX96 >= sqrtRatioTargetX96
+    const exactIn = amountRemaining >= 0n
+
+    if (exactIn) {
+      const amountRemainingLessFee =
+        (amountRemaining * (MAX_FEE - BigInt(feePips))) / MAX_FEE
+      amountIn = zeroForOne
+        ? SqrtPriceMath.getAmount0Delta(
+            sqrtRatioTargetX96,
+            sqrtRatioCurrentX96,
+            liquidity,
+            true,
+          )
+        : SqrtPriceMath.getAmount1Delta(
+            sqrtRatioCurrentX96,
+            sqrtRatioTargetX96,
+            liquidity,
+            true,
+          )
+      if (amountRemainingLessFee >= amountIn) {
+        sqrtRatioNextX96 = sqrtRatioTargetX96
+      } else {
+        sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          amountRemainingLessFee,
+          zeroForOne,
+        )
+      }
+    } else {
+      amountOut = zeroForOne
+        ? SqrtPriceMath.getAmount1Delta(
+            sqrtRatioTargetX96,
+            sqrtRatioCurrentX96,
+            liquidity,
+            false,
+          )
+        : SqrtPriceMath.getAmount0Delta(
+            sqrtRatioCurrentX96,
+            sqrtRatioTargetX96,
+            liquidity,
+            false,
+          )
+      if (amountRemaining * -1n >= amountOut) {
+        sqrtRatioNextX96 = sqrtRatioTargetX96
+      } else {
+        sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
+          sqrtRatioCurrentX96,
+          liquidity,
+          amountRemaining * -1n,
+          zeroForOne,
+        )
+      }
+    }
+
+    const max = sqrtRatioTargetX96 === sqrtRatioNextX96
+
+    if (zeroForOne) {
+      amountIn =
+        max && exactIn
+          ? amountIn
+          : SqrtPriceMath.getAmount0Delta(
+              sqrtRatioNextX96,
+              sqrtRatioCurrentX96,
+              liquidity,
+              true,
+            )
+      amountOut =
+        max && !exactIn
+          ? amountOut
+          : SqrtPriceMath.getAmount1Delta(
+              sqrtRatioNextX96,
+              sqrtRatioCurrentX96,
+              liquidity,
+              false,
+            )
+    } else {
+      amountIn =
+        max && exactIn
+          ? amountIn
+          : SqrtPriceMath.getAmount1Delta(
+              sqrtRatioCurrentX96,
+              sqrtRatioNextX96,
+              liquidity,
+              true,
+            )
+      amountOut =
+        max && !exactIn
+          ? amountOut
+          : SqrtPriceMath.getAmount0Delta(
+              sqrtRatioCurrentX96,
+              sqrtRatioNextX96,
+              liquidity,
+              false,
+            )
+    }
+
+    if (!exactIn && amountOut > amountRemaining * -1n) {
+      amountOut = amountRemaining * -1n
+    }
+
+    if (exactIn && sqrtRatioNextX96 !== sqrtRatioTargetX96) {
+      // we didn't reach the target, so take the remainder of the maximum input as fee
+      feeAmount = amountRemaining - amountIn
+    } else {
+      feeAmount = FullMath.mulDivRoundingUp(
+        amountIn,
+        BigInt(feePips),
+        MAX_FEE - BigInt(feePips),
+      )
+    }
+
+    return [sqrtRatioNextX96, amountIn, amountOut, feeAmount]
+  }
+}

package/evm/pool/sushiswap-v3/utils/tickLibrary.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest'
+import { TickLibrary } from './tickLibrary.js'
+
+describe('TickLibrary', () => {
+  describe('#getFeeGrowthInside', () => {
+    it('0', () => {
+      const [feeGrowthInside0X128, feeGrowthInside1X128] =
+        TickLibrary.getFeeGrowthInside(
+          {
+            feeGrowthOutside0X128: 0n,
+            feeGrowthOutside1X128: 0n,
+          },
+          {
+            feeGrowthOutside0X128: 0n,
+            feeGrowthOutside1X128: 0n,
+          },
+          -1,
+          1,
+          0,
+          0n,
+          0n,
+        )
+      expect(feeGrowthInside0X128).toEqual(0n)
+      expect(feeGrowthInside1X128).toEqual(0n)
+    })
+
+    it('non-0, all inside', () => {
+      const [feeGrowthInside0X128, feeGrowthInside1X128] =
+        TickLibrary.getFeeGrowthInside(
+          {
+            feeGrowthOutside0X128: 0n,
+            feeGrowthOutside1X128: 0n,
+          },
+          {
+            feeGrowthOutside0X128: 0n,
+            feeGrowthOutside1X128: 0n,
+          },
+          -1,
+          1,
+          0,
+          2n ** 128n,
+          2n ** 128n,
+        )
+      expect(feeGrowthInside0X128).toEqual(2n ** 128n)
+      expect(feeGrowthInside1X128).toEqual(2n ** 128n)
+    })
+
+    it('non-0, all outside', () => {
+      const [feeGrowthInside0X128, feeGrowthInside1X128] =
+        TickLibrary.getFeeGrowthInside(
+          {
+            feeGrowthOutside0X128: 2n ** 128n,
+            feeGrowthOutside1X128: 2n ** 128n,
+          },
+          {
+            feeGrowthOutside0X128: 0n,
+            feeGrowthOutside1X128: 0n,
+          },
+          -1,
+          1,
+          0,
+          2n ** 128n,
+          2n ** 128n,
+        )
+      expect(feeGrowthInside0X128).toEqual(0n)
+      expect(feeGrowthInside1X128).toEqual(0n)
+    })
+
+    it('non-0, some outside', () => {
+      const [feeGrowthInside0X128, feeGrowthInside1X128] =
+        TickLibrary.getFeeGrowthInside(
+          {
+            feeGrowthOutside0X128: 2n ** 127n,
+            feeGrowthOutside1X128: 2n ** 127n,
+          },
+          {
+            feeGrowthOutside0X128: 0n,
+            feeGrowthOutside1X128: 0n,
+          },
+          -1,
+          1,
+          0,
+          2n ** 128n,
+          2n ** 128n,
+        )
+      expect(feeGrowthInside0X128).toEqual(2n ** 127n)
+      expect(feeGrowthInside1X128).toEqual(2n ** 127n)
+    })
+  })
+})

package/evm/pool/sushiswap-v3/utils/tickLibrary.ts

@@ -0,0 +1,76 @@
+interface FeeGrowthOutside {
+  feeGrowthOutside0X128: bigint
+  feeGrowthOutside1X128: bigint
+}
+
+const Q256 = 2n ** 256n
+
+export function subIn256(x: bigint, y: bigint): bigint {
+  const difference = x - y
+
+  if (difference < 0n) {
+    return Q256 + difference
+  } else {
+    return difference
+  }
+}
+
+export abstract class TickLibrary {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static getFeeGrowthInside(
+    feeGrowthOutsideLower: FeeGrowthOutside,
+    feeGrowthOutsideUpper: FeeGrowthOutside,
+    tickLower: number,
+    tickUpper: number,
+    tickCurrent: number,
+    feeGrowthGlobal0X128: bigint,
+    feeGrowthGlobal1X128: bigint,
+  ) {
+    let feeGrowthBelow0X128: bigint
+    let feeGrowthBelow1X128: bigint
+    if (tickCurrent >= tickLower) {
+      feeGrowthBelow0X128 = feeGrowthOutsideLower.feeGrowthOutside0X128
+      feeGrowthBelow1X128 = feeGrowthOutsideLower.feeGrowthOutside1X128
+    } else {
+      feeGrowthBelow0X128 = subIn256(
+        feeGrowthGlobal0X128,
+        feeGrowthOutsideLower.feeGrowthOutside0X128,
+      )
+      feeGrowthBelow1X128 = subIn256(
+        feeGrowthGlobal1X128,
+        feeGrowthOutsideLower.feeGrowthOutside1X128,
+      )
+    }
+
+    let feeGrowthAbove0X128: bigint
+    let feeGrowthAbove1X128: bigint
+    if (tickCurrent < tickUpper) {
+      feeGrowthAbove0X128 = feeGrowthOutsideUpper.feeGrowthOutside0X128
+      feeGrowthAbove1X128 = feeGrowthOutsideUpper.feeGrowthOutside1X128
+    } else {
+      feeGrowthAbove0X128 = subIn256(
+        feeGrowthGlobal0X128,
+        feeGrowthOutsideUpper.feeGrowthOutside0X128,
+      )
+      feeGrowthAbove1X128 = subIn256(
+        feeGrowthGlobal1X128,
+        feeGrowthOutsideUpper.feeGrowthOutside1X128,
+      )
+    }
+
+    return [
+      subIn256(
+        subIn256(feeGrowthGlobal0X128, feeGrowthBelow0X128),
+        feeGrowthAbove0X128,
+      ),
+      subIn256(
+        subIn256(feeGrowthGlobal1X128, feeGrowthBelow1X128),
+        feeGrowthAbove1X128,
+      ),
+    ]
+  }
+}

package/evm/pool/sushiswap-v3/utils/tickList.test.ts

@@ -0,0 +1,216 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+import { Tick } from '../entities/Tick.js'
+import { TickList } from './tickList.js'
+import { TickMath } from './tickMath.js'
+
+describe('TickList', () => {
+  let highTick: Tick
+  let lowTick: Tick
+  let midTick: Tick
+
+  beforeEach(() => {
+    lowTick = new Tick({
+      index: TickMath.MIN_TICK + 1,
+      liquidityNet: 10,
+      liquidityGross: 10,
+    })
+    midTick = new Tick({
+      index: 0,
+      liquidityNet: -5,
+      liquidityGross: 5,
+    })
+    highTick = new Tick({
+      index: TickMath.MAX_TICK - 1,
+      liquidityNet: -5,
+      liquidityGross: 5,
+    })
+  })
+
+  describe('#validate', () => {
+    it('errors for incomplete lists', () => {
+      expect(() => {
+        TickList.validateList([lowTick], 1)
+      }).toThrow('ZERO_NET')
+    })
+    it('errors for unsorted lists', () => {
+      expect(() => {
+        TickList.validateList([highTick, lowTick, midTick], 1)
+      }).toThrow('SORTED')
+    })
+    it('errors if ticks are not on multiples of tick spacing', () => {
+      expect(() => {
+        TickList.validateList([highTick, lowTick, midTick], 1337)
+      }).toThrow('TICK_SPACING')
+    })
+  })
+
+  it('#isBelowSmallest', () => {
+    const ticks = [lowTick, midTick, highTick]
+    expect(TickList.isBelowSmallest(ticks, TickMath.MIN_TICK)).toBe(true)
+    expect(TickList.isBelowSmallest(ticks, TickMath.MIN_TICK + 1)).toBe(false)
+  })
+
+  it('#isAtOrAboveLargest', () => {
+    const result = [lowTick, midTick, highTick]
+    expect(TickList.isAtOrAboveLargest(result, TickMath.MAX_TICK - 2)).toBe(
+      false,
+    )
+    expect(TickList.isAtOrAboveLargest(result, TickMath.MAX_TICK - 1)).toBe(
+      true,
+    )
+  })
+
+  describe('#nextInitializedTick', () => {
+    let ticks: Tick[]
+
+    beforeEach(() => {
+      ticks = [lowTick, midTick, highTick]
+    })
+
+    it('low - lte = true', () => {
+      expect(() => {
+        TickList.nextInitializedTick(ticks, TickMath.MIN_TICK, true)
+      }).toThrow('BELOW_SMALLEST')
+
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MIN_TICK + 1, true),
+      ).toEqual(lowTick)
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MIN_TICK + 2, true),
+      ).toEqual(lowTick)
+    })
+
+    it('low - lte = false', () => {
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MIN_TICK, false),
+      ).toEqual(lowTick)
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MIN_TICK + 1, false),
+      ).toEqual(midTick)
+    })
+
+    it('mid - lte = true', () => {
+      expect(TickList.nextInitializedTick(ticks, 0, true)).toEqual(midTick)
+      expect(TickList.nextInitializedTick(ticks, 1, true)).toEqual(midTick)
+    })
+
+    it('mid - lte = false', () => {
+      expect(TickList.nextInitializedTick(ticks, -1, false)).toEqual(midTick)
+      expect(TickList.nextInitializedTick(ticks, 0 + 1, false)).toEqual(
+        highTick,
+      )
+    })
+
+    it('high - lte = true', () => {
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MAX_TICK - 1, true),
+      ).toEqual(highTick)
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MAX_TICK, true),
+      ).toEqual(highTick)
+    })
+
+    it('high - lte = false', () => {
+      expect(() => {
+        TickList.nextInitializedTick(ticks, TickMath.MAX_TICK - 1, false)
+      }).toThrow('AT_OR_ABOVE_LARGEST')
+
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MAX_TICK - 2, false),
+      ).toEqual(highTick)
+      expect(
+        TickList.nextInitializedTick(ticks, TickMath.MAX_TICK - 3, false),
+      ).toEqual(highTick)
+    })
+  })
+
+  describe('#nextInitializedTickWithinOneWord', () => {
+    let ticks: Tick[]
+
+    beforeEach(() => {
+      ticks = [lowTick, midTick, highTick]
+    })
+
+    it('words around 0, lte = true', () => {
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -257, true, 1),
+      ).toEqual([-512, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -256, true, 1),
+      ).toEqual([-256, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -1, true, 1),
+      ).toEqual([-256, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 0, true, 1),
+      ).toEqual([0, true])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 1, true, 1),
+      ).toEqual([0, true])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 255, true, 1),
+      ).toEqual([0, true])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 256, true, 1),
+      ).toEqual([256, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 257, true, 1),
+      ).toEqual([256, false])
+    })
+
+    it('words around 0, lte = false', () => {
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -258, false, 1),
+      ).toEqual([-257, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -257, false, 1),
+      ).toEqual([-1, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -256, false, 1),
+      ).toEqual([-1, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -2, false, 1),
+      ).toEqual([-1, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, -1, false, 1),
+      ).toEqual([0, true])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 0, false, 1),
+      ).toEqual([255, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 1, false, 1),
+      ).toEqual([255, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 254, false, 1),
+      ).toEqual([255, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 255, false, 1),
+      ).toEqual([511, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 256, false, 1),
+      ).toEqual([511, false])
+    })
+
+    it('performs correctly with tickSpacing > 1', () => {
+      ticks = [
+        new Tick({
+          index: 0,
+          liquidityNet: 0,
+          liquidityGross: 0,
+        }),
+        new Tick({
+          index: 511,
+          liquidityNet: 0,
+          liquidityGross: 0,
+        }),
+      ]
+
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 0, false, 1),
+      ).toEqual([255, false])
+      expect(
+        TickList.nextInitializedTickWithinOneWord(ticks, 0, false, 2),
+      ).toEqual([510, false])
+    })
+  })
+})