@alcorexchange/alcor-swap-sdk 1.0.0

package/src/utils/sqrtPriceMath.ts

@@ -0,0 +1,169 @@
+import JSBI from "jsbi";
+import invariant from "tiny-invariant";
+import { ONE, ZERO, Q64, MaxUint128 } from "../internalConstants";
+import { FullMath } from "./fullMath";
+
+function multiplyIn128(x: JSBI, y: JSBI): JSBI {
+  const product = JSBI.multiply(x, y);
+  return JSBI.bitwiseAnd(product, MaxUint128);
+}
+
+function addIn128(x: JSBI, y: JSBI): JSBI {
+  const sum = JSBI.add(x, y);
+  return JSBI.bitwiseAnd(sum, MaxUint128);
+}
+
+export abstract class SqrtPriceMath {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static getAmountADelta(
+    sqrtRatioLX64: JSBI,
+    sqrtRatioUX64: JSBI,
+    liquidity: JSBI,
+    roundUp: boolean
+  ): JSBI {
+    if (JSBI.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+      [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+    }
+
+    const numerator1 = JSBI.leftShift(liquidity, JSBI.BigInt(64));
+    const numerator2 = JSBI.subtract(sqrtRatioUX64, sqrtRatioLX64);
+
+    return roundUp
+      ? FullMath.mulDivRoundingUp(
+          FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioUX64),
+          ONE,
+          sqrtRatioLX64
+        )
+      : JSBI.divide(
+          JSBI.divide(JSBI.multiply(numerator1, numerator2), sqrtRatioUX64),
+          sqrtRatioLX64
+        );
+  }
+
+  public static getAmountBDelta(
+    sqrtRatioLX64: JSBI,
+    sqrtRatioUX64: JSBI,
+    liquidity: JSBI,
+    roundUp: boolean
+  ): JSBI {
+    if (JSBI.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+      [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+    }
+
+    return roundUp
+      ? FullMath.mulDivRoundingUp(
+          liquidity,
+          JSBI.subtract(sqrtRatioUX64, sqrtRatioLX64),
+          Q64
+        )
+      : JSBI.divide(
+          JSBI.multiply(liquidity, JSBI.subtract(sqrtRatioUX64, sqrtRatioLX64)),
+          Q64
+        );
+  }
+
+  public static getNextSqrtPriceFromInput(
+    sqrtPX64: JSBI,
+    liquidity: JSBI,
+    amountIn: JSBI,
+    zeroForOne: boolean
+  ): JSBI {
+    invariant(JSBI.greaterThan(sqrtPX64, ZERO));
+    invariant(JSBI.greaterThan(liquidity, ZERO));
+
+    return zeroForOne
+      ? this.getNextSqrtPriceFromAmountARoundingUp(
+          sqrtPX64,
+          liquidity,
+          amountIn,
+          true
+        )
+      : this.getNextSqrtPriceFromAmountBRoundingDown(
+          sqrtPX64,
+          liquidity,
+          amountIn,
+          true
+        );
+  }
+
+  public static getNextSqrtPriceFromOutput(
+    sqrtPX64: JSBI,
+    liquidity: JSBI,
+    amountOut: JSBI,
+    zeroForOne: boolean
+  ): JSBI {
+    invariant(JSBI.greaterThan(sqrtPX64, ZERO));
+    invariant(JSBI.greaterThan(liquidity, ZERO));
+
+    return zeroForOne
+      ? this.getNextSqrtPriceFromAmountBRoundingDown(
+          sqrtPX64,
+          liquidity,
+          amountOut,
+          false
+        )
+      : this.getNextSqrtPriceFromAmountARoundingUp(
+          sqrtPX64,
+          liquidity,
+          amountOut,
+          false
+        );
+  }
+
+  private static getNextSqrtPriceFromAmountARoundingUp(
+    sqrtPX64: JSBI,
+    liquidity: JSBI,
+    amount: JSBI,
+    add: boolean
+  ): JSBI {
+    if (JSBI.equal(amount, ZERO)) return sqrtPX64;
+    const numerator1 = JSBI.leftShift(liquidity, JSBI.BigInt(64));
+
+    if (add) {
+      let product = multiplyIn128(amount, sqrtPX64);
+      if (JSBI.equal(JSBI.divide(product, amount), sqrtPX64)) {
+        const denominator = addIn128(numerator1, product);
+        if (JSBI.greaterThanOrEqual(denominator, numerator1)) {
+          return FullMath.mulDivRoundingUp(numerator1, sqrtPX64, denominator);
+        }
+      }
+
+      return FullMath.mulDivRoundingUp(
+        numerator1,
+        ONE,
+        JSBI.add(JSBI.divide(numerator1, sqrtPX64), amount)
+      );
+    } else {
+      let product = multiplyIn128(amount, sqrtPX64);
+
+      invariant(JSBI.equal(JSBI.divide(product, amount), sqrtPX64));
+      invariant(JSBI.greaterThan(numerator1, product));
+      const denominator = JSBI.subtract(numerator1, product);
+      return FullMath.mulDivRoundingUp(numerator1, sqrtPX64, denominator);
+    }
+  }
+
+  private static getNextSqrtPriceFromAmountBRoundingDown(
+    sqrtPX64: JSBI,
+    liquidity: JSBI,
+    amount: JSBI,
+    add: boolean
+  ): JSBI {
+    if (add) {
+      const quotient = JSBI.lessThanOrEqual(amount, MaxUint128)
+        ? JSBI.divide(JSBI.leftShift(amount, JSBI.BigInt(64)), liquidity)
+        : JSBI.divide(JSBI.multiply(amount, Q64), liquidity);
+
+      return JSBI.add(sqrtPX64, quotient);
+    } else {
+      const quotient = FullMath.mulDivRoundingUp(amount, Q64, liquidity);
+
+      invariant(JSBI.greaterThan(sqrtPX64, quotient));
+      return JSBI.subtract(sqrtPX64, quotient);
+    }
+  }
+}

package/src/utils/swapMath.ts

@@ -0,0 +1,175 @@
+import JSBI from "jsbi";
+import { NEGATIVE_ONE, ZERO, FeeAmount } from "../internalConstants";
+import { FullMath } from "./fullMath";
+import { SqrtPriceMath } from "./sqrtPriceMath";
+
+const MAX_FEE = JSBI.exponentiate(JSBI.BigInt(10), JSBI.BigInt(6));
+
+export abstract class SwapMath {
+  /**
+   * Cannot be constructed.
+   */
+  private constructor() {}
+
+  public static computeSwapStep(
+    sqrtRatioCurrentX64: JSBI,
+    sqrtRatioTargetX64: JSBI,
+    liquidity: JSBI,
+    amountRemaining: JSBI,
+    feePips: FeeAmount
+  ): [JSBI, JSBI, JSBI, JSBI] {
+    const returnValues: Partial<{
+      sqrtRatioNextX64: JSBI;
+      amountIn: JSBI;
+      amountOut: JSBI;
+      feeAmount: JSBI;
+    }> = {};
+
+    const zeroForOne = JSBI.greaterThanOrEqual(
+      sqrtRatioCurrentX64,
+      sqrtRatioTargetX64
+    );
+    const exactIn = JSBI.greaterThanOrEqual(amountRemaining, ZERO);
+
+    if (exactIn) {
+      const amountRemainingLessFee = JSBI.divide(
+        JSBI.multiply(
+          amountRemaining,
+          JSBI.subtract(MAX_FEE, JSBI.BigInt(feePips))
+        ),
+        MAX_FEE
+      );
+      returnValues.amountIn = zeroForOne
+        ? SqrtPriceMath.getAmountADelta(
+            sqrtRatioTargetX64,
+            sqrtRatioCurrentX64,
+            liquidity,
+            true
+          )
+        : SqrtPriceMath.getAmountBDelta(
+            sqrtRatioCurrentX64,
+            sqrtRatioTargetX64,
+            liquidity,
+            true
+          );
+      if (
+        JSBI.greaterThanOrEqual(amountRemainingLessFee, returnValues.amountIn!)
+      ) {
+        returnValues.sqrtRatioNextX64 = sqrtRatioTargetX64;
+      } else {
+        returnValues.sqrtRatioNextX64 = SqrtPriceMath.getNextSqrtPriceFromInput(
+          sqrtRatioCurrentX64,
+          liquidity,
+          amountRemainingLessFee,
+          zeroForOne
+        );
+      }
+    } else {
+      returnValues.amountOut = zeroForOne
+        ? SqrtPriceMath.getAmountBDelta(
+            sqrtRatioTargetX64,
+            sqrtRatioCurrentX64,
+            liquidity,
+            false
+          )
+        : SqrtPriceMath.getAmountADelta(
+            sqrtRatioCurrentX64,
+            sqrtRatioTargetX64,
+            liquidity,
+            false
+          );
+      if (
+        JSBI.greaterThanOrEqual(
+          JSBI.multiply(amountRemaining, NEGATIVE_ONE),
+          returnValues.amountOut
+        )
+      ) {
+        returnValues.sqrtRatioNextX64 = sqrtRatioTargetX64;
+      } else {
+        returnValues.sqrtRatioNextX64 =
+          SqrtPriceMath.getNextSqrtPriceFromOutput(
+            sqrtRatioCurrentX64,
+            liquidity,
+            JSBI.multiply(amountRemaining, NEGATIVE_ONE),
+            zeroForOne
+          );
+      }
+    }
+
+    const max = JSBI.equal(sqrtRatioTargetX64, returnValues.sqrtRatioNextX64);
+
+    if (zeroForOne) {
+      returnValues.amountIn =
+        max && exactIn
+          ? returnValues.amountIn
+          : SqrtPriceMath.getAmountADelta(
+              returnValues.sqrtRatioNextX64,
+              sqrtRatioCurrentX64,
+              liquidity,
+              true
+            );
+      returnValues.amountOut =
+        max && !exactIn
+          ? returnValues.amountOut
+          : SqrtPriceMath.getAmountBDelta(
+              returnValues.sqrtRatioNextX64,
+              sqrtRatioCurrentX64,
+              liquidity,
+              false
+            );
+    } else {
+      returnValues.amountIn =
+        max && exactIn
+          ? returnValues.amountIn
+          : SqrtPriceMath.getAmountBDelta(
+              sqrtRatioCurrentX64,
+              returnValues.sqrtRatioNextX64,
+              liquidity,
+              true
+            );
+      returnValues.amountOut =
+        max && !exactIn
+          ? returnValues.amountOut
+          : SqrtPriceMath.getAmountADelta(
+              sqrtRatioCurrentX64,
+              returnValues.sqrtRatioNextX64,
+              liquidity,
+              false
+            );
+    }
+
+    if (
+      !exactIn &&
+      JSBI.greaterThan(
+        returnValues.amountOut!,
+        JSBI.multiply(amountRemaining, NEGATIVE_ONE)
+      )
+    ) {
+      returnValues.amountOut = JSBI.multiply(amountRemaining, NEGATIVE_ONE);
+    }
+
+    if (
+      exactIn &&
+      JSBI.notEqual(returnValues.sqrtRatioNextX64, sqrtRatioTargetX64)
+    ) {
+      // we didn't reach the target, so take the remainder of the maximum input as fee
+      returnValues.feeAmount = JSBI.subtract(
+        amountRemaining,
+        returnValues.amountIn!
+      );
+    } else {
+      returnValues.feeAmount = FullMath.mulDivRoundingUp(
+        returnValues.amountIn!,
+        JSBI.BigInt(feePips),
+        JSBI.subtract(MAX_FEE, JSBI.BigInt(feePips))
+      );
+    }
+
+    return [
+      returnValues.sqrtRatioNextX64!,
+      returnValues.amountIn!,
+      returnValues.amountOut!,
+      returnValues.feeAmount!,
+    ];
+  }
+}

package/src/utils/tickLibrary.ts

@@ -0,0 +1,88 @@
+import JSBI from "jsbi";
+import { BigintIsh, ZERO, Q256, Q128 } from "../internalConstants";
+
+interface FeeGrowthOutside {
+  feeGrowthOutsideAX64: JSBI;
+  feeGrowthOutsideBX64: JSBI;
+}
+
+export function subIn256(x: JSBI, y: JSBI): JSBI {
+  const difference = JSBI.subtract(x, y);
+
+  if (JSBI.lessThan(difference, ZERO)) {
+    return JSBI.add(Q256, difference);
+  } else {
+    return difference;
+  }
+}
+
+export function subIn128(x: JSBI, y: JSBI): JSBI {
+  const difference = JSBI.subtract(x, y);
+
+  if (JSBI.lessThan(difference, ZERO)) {
+    return JSBI.add(Q128, 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,
+    feeGrowthGlobalAX64: JSBI,
+    feeGrowthGlobalBX64: JSBI
+  ) {
+    let feeGrowthBelowAX64: JSBI;
+    let feeGrowthBelowBX64: JSBI;
+    if (tickCurrent >= tickLower) {
+      feeGrowthBelowAX64 = feeGrowthOutsideLower.feeGrowthOutsideAX64;
+      feeGrowthBelowBX64 = feeGrowthOutsideLower.feeGrowthOutsideBX64;
+    } else {
+      feeGrowthBelowAX64 = subIn128(
+        feeGrowthGlobalAX64,
+        feeGrowthOutsideLower.feeGrowthOutsideAX64
+      );
+
+      feeGrowthBelowBX64 = subIn128(
+        feeGrowthGlobalBX64,
+        feeGrowthOutsideLower.feeGrowthOutsideBX64
+      );
+    }
+
+    let feeGrowthAboveAX64: JSBI;
+    let feeGrowthAboveBX64: JSBI;
+    if (tickCurrent < tickUpper) {
+      feeGrowthAboveAX64 = feeGrowthOutsideUpper.feeGrowthOutsideAX64;
+      feeGrowthAboveBX64 = feeGrowthOutsideUpper.feeGrowthOutsideBX64;
+    } else {
+      feeGrowthAboveAX64 = subIn128(
+        feeGrowthGlobalAX64,
+        feeGrowthOutsideUpper.feeGrowthOutsideAX64
+      );
+      feeGrowthAboveBX64 = subIn128(
+        feeGrowthGlobalBX64,
+        feeGrowthOutsideUpper.feeGrowthOutsideBX64
+      );
+    }
+
+    return [
+      subIn128(
+        subIn128(feeGrowthGlobalAX64, feeGrowthBelowAX64),
+        feeGrowthAboveAX64
+      ),
+      subIn128(
+        subIn128(feeGrowthGlobalBX64, feeGrowthBelowBX64),
+        feeGrowthAboveBX64
+      ),
+    ];
+  }
+}

package/src/utils/tickList.ts

@@ -0,0 +1,147 @@
+import JSBI from "jsbi";
+import invariant from "tiny-invariant";
+import { Tick } from "../entities/tick";
+import { ZERO } from "../internalConstants";
+import { isSorted } from "./isSorted";
+
+function tickComparator(a: Tick, b: Tick) {
+  return a.id - b.id;
+}
+
+/**x
+ * Utility methods for interacting with sorted lists of ticks
+ */
+export abstract class TickList {
+  /**
+   * Cannot be constructed
+   */
+  private constructor() {}
+
+  public static validateList(ticks: Tick[], tickSpacing: number) {
+    invariant(tickSpacing > 0, "TICK_SPACING_NONZERO");
+    // ensure ticks are spaced appropriately
+    invariant(
+      ticks.every(({ id }) => id % tickSpacing === 0),
+      "TICK_SPACING"
+    );
+
+    // ensure tick liquidity deltas sum to 0
+    invariant(
+      JSBI.equal(
+        ticks.reduce(
+          (accumulator, { liquidityNet }) =>
+            JSBI.add(accumulator, liquidityNet),
+          ZERO
+        ),
+        ZERO
+      ),
+      "ZERO_NET"
+    );
+
+    invariant(isSorted(ticks, tickComparator), "SORTED");
+  }
+
+  public static isBelowSmallest(ticks: readonly Tick[], tick: number): boolean {
+    invariant(ticks.length > 0, "LENGTH");
+    return tick < ticks[0].id;
+  }
+
+  public static isAtOrAboveLargest(
+    ticks: readonly Tick[],
+    tick: number
+  ): boolean {
+    invariant(ticks.length > 0, "LENGTH");
+    return tick >= ticks[ticks.length - 1].id;
+  }
+
+  public static getTick(ticks: readonly Tick[], id: number): Tick {
+    const tick = ticks[this.binarySearch(ticks, id)];
+    invariant(tick.id === id, "NOT_CONTAINED");
+    return tick;
+  }
+
+  /**
+   * Finds the largest tick in the list of ticks that is less than or equal to tick
+   * @param ticks list of ticks
+   * @param tick tick to find the largest tick that is less than or equal to tick
+   * @private
+   */
+  private static binarySearch(ticks: readonly Tick[], tick: number): number {
+    invariant(!this.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+
+    let l = 0;
+    let r = ticks.length - 1;
+    let i;
+    while (true) {
+      i = Math.floor((l + r) / 2);
+
+      if (
+        ticks[i].id <= tick &&
+        (i === ticks.length - 1 || ticks[i + 1].id > tick)
+      ) {
+        return i;
+      }
+
+      if (ticks[i].id < tick) {
+        l = i + 1;
+      } else {
+        r = i - 1;
+      }
+    }
+  }
+
+  public static nextInitializedTick(
+    ticks: readonly Tick[],
+    tick: number,
+    lte: boolean
+  ): Tick {
+    if (lte) {
+      invariant(!TickList.isBelowSmallest(ticks, tick), "BELOW_SMALLEST");
+      if (TickList.isAtOrAboveLargest(ticks, tick)) {
+        return ticks[ticks.length - 1];
+      }
+      const id = this.binarySearch(ticks, tick);
+      return ticks[id];
+    } else {
+      invariant(!this.isAtOrAboveLargest(ticks, tick), "AT_OR_ABOVE_LARGEST");
+      if (this.isBelowSmallest(ticks, tick)) {
+        return ticks[0];
+      }
+      const id = this.binarySearch(ticks, tick);
+      return ticks[id + 1];
+    }
+  }
+
+  public static nextInitializedTickWithinOneWord(
+    ticks: readonly Tick[],
+    tick: number,
+    lte: boolean,
+    tickSpacing: number
+  ): [number, boolean] {
+    const compressed = Math.floor(tick / tickSpacing); // matches rounding in the code
+
+    if (lte) {
+      const wordPos = compressed >> 7;
+      const minimum = (wordPos << 7) * tickSpacing;
+
+      if (TickList.isBelowSmallest(ticks, tick)) {
+        return [minimum, false];
+      }
+
+      const id = TickList.nextInitializedTick(ticks, tick, lte).id;
+      const nextInitializedTick = Math.max(minimum, id);
+      return [nextInitializedTick, nextInitializedTick === id];
+    } else {
+      const wordPos = (compressed + 1) >> 7;
+      const maximum = (((wordPos + 1) << 7) - 1) * tickSpacing;
+
+      if (this.isAtOrAboveLargest(ticks, tick)) {
+        return [maximum, false];
+      }
+
+      const id = this.nextInitializedTick(ticks, tick, lte).id;
+      const nextInitializedTick = Math.min(maximum, id);
+      return [nextInitializedTick, nextInitializedTick === id];
+    }
+  }
+}