@alcorexchange/alcor-swap-sdk 1.0.0

package/build/utils/isSorted.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSorted = void 0;
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
+ */
+function isSorted(list, comparator) {
+    for (let i = 0; i < list.length - 1; i++) {
+        if (comparator(list[i], list[i + 1]) > 0) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isSorted = isSorted;

package/build/utils/liquidityMath.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiquidityMath = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const internalConstants_1 = require("../internalConstants");
+class LiquidityMath {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static addDelta(x, y) {
+        if (jsbi_1.default.lessThan(y, internalConstants_1.ZERO)) {
+            return jsbi_1.default.subtract(x, jsbi_1.default.multiply(y, internalConstants_1.NEGATIVE_ONE));
+        }
+        else {
+            return jsbi_1.default.add(x, y);
+        }
+    }
+}
+exports.LiquidityMath = LiquidityMath;

package/build/utils/maxLiquidityForAmounts.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxLiquidityForAmounts = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const internalConstants_1 = require("../internalConstants");
+/**
+ * Returns an imprecise maximum amount of liquidity received for a given amount of token 0.
+ * This function is available to accommodate LiquidityAmounts#getLiquidityForAmountA in the v3 periphery,
+ * which could be more precise by at least 32 bits by dividing by Q64 instead of Q64 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits. This imprecise calculation will likely be replaced in a future
+ * v3 router contract.
+ * @param sqrtRatioLX64 The price at the lower boundary
+ * @param sqrtRatioUX64 The price at the upper boundary
+ * @param amountA The token0 amount
+ * @returns liquidity for amountA, imprecise
+ */
+function maxLiquidityForAmountAImprecise(sqrtRatioLX64, sqrtRatioUX64, amountA) {
+    if (jsbi_1.default.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+        [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+    }
+    const intermediate = jsbi_1.default.divide(jsbi_1.default.multiply(sqrtRatioLX64, sqrtRatioUX64), internalConstants_1.Q64);
+    return jsbi_1.default.divide(jsbi_1.default.multiply(jsbi_1.default.BigInt(amountA), intermediate), jsbi_1.default.subtract(sqrtRatioUX64, sqrtRatioLX64));
+}
+/**
+ * Returns a precise maximum amount of liquidity received for a given amount of token 0 by dividing by Q64 instead of Q64 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits.
+ * @param sqrtRatioLX64 The price at the lower boundary
+ * @param sqrtRatioUX64 The price at the upper boundary
+ * @param amountA The token0 amount
+ * @returns liquidity for amountA, precise
+ */
+function maxLiquidityForAmountAPrecise(sqrtRatioLX64, sqrtRatioUX64, amountA) {
+    if (jsbi_1.default.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+        [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+    }
+    const numerator = jsbi_1.default.multiply(jsbi_1.default.multiply(jsbi_1.default.BigInt(amountA), sqrtRatioLX64), sqrtRatioUX64);
+    const denominator = jsbi_1.default.multiply(internalConstants_1.Q64, jsbi_1.default.subtract(sqrtRatioUX64, sqrtRatioLX64));
+    return jsbi_1.default.divide(numerator, denominator);
+}
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token1
+ * @param sqrtRatioLX64 The price at the lower tick boundary
+ * @param sqrtRatioUX64 The price at the upper tick boundary
+ * @param amountB The token1 amount
+ * @returns liquidity for amountB
+ */
+function maxLiquidityForAmountB(sqrtRatioLX64, sqrtRatioUX64, amountB) {
+    if (jsbi_1.default.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+        [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+    }
+    return jsbi_1.default.divide(jsbi_1.default.multiply(jsbi_1.default.BigInt(amountB), internalConstants_1.Q64), jsbi_1.default.subtract(sqrtRatioUX64, sqrtRatioLX64));
+}
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX64 the current price
+ * @param sqrtRatioLX64 price at lower boundary
+ * @param sqrtRatioUX64 price at upper boundary
+ * @param amountA token0 amount
+ * @param amountB token1 amount
+ * @param useFullPrecision if false, liquidity will be maximized according to what the router can calculate,
+ * not what core can theoretically support
+ */
+function maxLiquidityForAmounts(sqrtRatioCurrentX64, sqrtRatioLX64, sqrtRatioUX64, amountA, amountB, useFullPrecision) {
+    if (jsbi_1.default.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+        [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+    }
+    const maxLiquidityForAmountA = useFullPrecision
+        ? maxLiquidityForAmountAPrecise
+        : maxLiquidityForAmountAImprecise;
+    if (jsbi_1.default.lessThanOrEqual(sqrtRatioCurrentX64, sqrtRatioLX64)) {
+        return maxLiquidityForAmountA(sqrtRatioLX64, sqrtRatioUX64, amountA);
+    }
+    else if (jsbi_1.default.lessThan(sqrtRatioCurrentX64, sqrtRatioUX64)) {
+        const liquidityA = maxLiquidityForAmountA(sqrtRatioCurrentX64, sqrtRatioUX64, amountA);
+        const liquidityB = maxLiquidityForAmountB(sqrtRatioLX64, sqrtRatioCurrentX64, amountB);
+        return jsbi_1.default.lessThan(liquidityA, liquidityB) ? liquidityA : liquidityB;
+    }
+    else {
+        return maxLiquidityForAmountB(sqrtRatioLX64, sqrtRatioUX64, amountB);
+    }
+}
+exports.maxLiquidityForAmounts = maxLiquidityForAmounts;

package/build/utils/mostSignificantBit.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mostSignificantBit = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const internalConstants_1 = require("../internalConstants");
+const TWO = jsbi_1.default.BigInt(2);
+const POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow) => [
+    pow,
+    jsbi_1.default.exponentiate(TWO, jsbi_1.default.BigInt(pow)),
+]);
+function mostSignificantBit(x) {
+    (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(x, internalConstants_1.ZERO), "ZERO");
+    (0, tiny_invariant_1.default)(jsbi_1.default.lessThanOrEqual(x, internalConstants_1.MaxUint256), "MAX");
+    let msb = 0;
+    for (const [power, min] of POWERS_OF_2) {
+        if (jsbi_1.default.greaterThanOrEqual(x, min)) {
+            x = jsbi_1.default.signedRightShift(x, jsbi_1.default.BigInt(power));
+            msb += power;
+        }
+    }
+    return msb;
+}
+exports.mostSignificantBit = mostSignificantBit;

package/build/utils/nearestUsableTick.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nearestUsableTick = void 0;
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const tickMath_1 = require("./tickMath");
+/**
+ * Returns the closest tick that is nearest a given tick and usable for the given tick spacing
+ * @param tick the target tick
+ * @param tickSpacing the spacing of the pool
+ */
+function nearestUsableTick(tick, tickSpacing) {
+    (0, tiny_invariant_1.default)(Number.isInteger(tick) && Number.isInteger(tickSpacing), "INTEGERS");
+    (0, tiny_invariant_1.default)(tickSpacing > 0, "TICK_SPACING");
+    (0, tiny_invariant_1.default)(tick >= tickMath_1.TickMath.MIN_TICK && tick <= tickMath_1.TickMath.MAX_TICK, "TICK_BOUND");
+    const rounded = Math.round(tick / tickSpacing) * tickSpacing;
+    if (rounded < tickMath_1.TickMath.MIN_TICK)
+        return rounded + tickSpacing;
+    else if (rounded > tickMath_1.TickMath.MAX_TICK)
+        return rounded - tickSpacing;
+    else
+        return rounded;
+}
+exports.nearestUsableTick = nearestUsableTick;

package/build/utils/positionLibrary.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PositionLibrary = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const _1 = require(".");
+const internalConstants_1 = require("../internalConstants");
+class PositionLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    // replicates the portions of Position#update required to compute unaccounted fees
+    static getTokensOwed(feeGrowthInsideALastX64, feeGrowthInsideBLastX64, liquidity, feeGrowthInsideAX64, feeGrowthInsideBX64) {
+        const tokensOwed0 = jsbi_1.default.divide(jsbi_1.default.multiply((0, _1.subIn128)(feeGrowthInsideAX64, feeGrowthInsideALastX64), liquidity), internalConstants_1.Q64);
+        const tokensOwed1 = jsbi_1.default.divide(jsbi_1.default.multiply((0, _1.subIn128)(feeGrowthInsideBX64, feeGrowthInsideBLastX64), liquidity), internalConstants_1.Q64);
+        return [tokensOwed0, tokensOwed1];
+    }
+}
+exports.PositionLibrary = PositionLibrary;

package/build/utils/priceTickConversions.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.priceToClosestTick = exports.tickToPrice = void 0;
+const price_1 = require("../entities/fractions/price");
+const jsbi_1 = __importDefault(require("jsbi"));
+const internalConstants_1 = require("../internalConstants");
+const encodeSqrtRatioX64_1 = require("./encodeSqrtRatioX64");
+const tickMath_1 = require("./tickMath");
+/**
+ * Returns a price object corresponding to the input tick and the base/quote token
+ * Inputs must be tokens because the address order is used to interpret the price represented by the tick
+ * @param baseToken the base token of the price
+ * @param quoteToken the quote token of the price
+ * @param tick the tick for which to return the price
+ */
+function tickToPrice(baseToken, quoteToken, tick) {
+    const sqrtRatioX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tick);
+    const ratioX128 = jsbi_1.default.multiply(sqrtRatioX64, sqrtRatioX64);
+    return baseToken.sortsBefore(quoteToken)
+        ? new price_1.Price(baseToken, quoteToken, internalConstants_1.Q128, ratioX128)
+        : new price_1.Price(baseToken, quoteToken, ratioX128, internalConstants_1.Q128);
+}
+exports.tickToPrice = tickToPrice;
+/**
+ * Returns the first tick for which the given price is greater than or equal to the tick price
+ * @param price for which to return the closest tick that represents a price less than or equal to the input price,
+ * i.e. the price of the returned tick is less than or equal to the input price
+ */
+function priceToClosestTick(price) {
+    const sorted = price.baseCurrency.sortsBefore(price.quoteCurrency);
+    const sqrtRatioX64 = sorted
+        ? (0, encodeSqrtRatioX64_1.encodeSqrtRatioX64)(price.numerator, price.denominator)
+        : (0, encodeSqrtRatioX64_1.encodeSqrtRatioX64)(price.denominator, price.numerator);
+    let tick = tickMath_1.TickMath.getTickAtSqrtRatio(sqrtRatioX64);
+    const nextTickPrice = tickToPrice(price.baseCurrency, price.quoteCurrency, tick + 1);
+    if (sorted) {
+        if (!price.lessThan(nextTickPrice)) {
+            tick++;
+        }
+    }
+    else {
+        if (!price.greaterThan(nextTickPrice)) {
+            tick++;
+        }
+    }
+    return tick;
+}
+exports.priceToClosestTick = priceToClosestTick;

package/build/utils/sortedInsert.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortedInsert = void 0;
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+// given an array of items sorted by `comparator`, insert an item into its sort index and constrain the size to
+// `maxSize` by removing the last item
+function sortedInsert(items, add, maxSize, comparator) {
+    (0, tiny_invariant_1.default)(maxSize > 0, 'MAX_SIZE_ZERO');
+    // this is an invariant because the interface cannot return multiple removed items if items.length exceeds maxSize
+    (0, tiny_invariant_1.default)(items.length <= maxSize, 'ITEMS_SIZE');
+    // short circuit first item add
+    if (items.length === 0) {
+        items.push(add);
+        return null;
+    }
+    else {
+        const isFull = items.length === maxSize;
+        // short circuit if full and the additional item does not come before the last item
+        if (isFull && comparator(items[items.length - 1], add) <= 0) {
+            return add;
+        }
+        let lo = 0, hi = items.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (comparator(items[mid], add) <= 0) {
+                lo = mid + 1;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        items.splice(lo, 0, add);
+        return isFull ? items.pop() : null;
+    }
+}
+exports.sortedInsert = sortedInsert;

package/build/utils/sqrt.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqrt = exports.MAX_SAFE_INTEGER = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+exports.MAX_SAFE_INTEGER = jsbi_1.default.BigInt(Number.MAX_SAFE_INTEGER);
+const ZERO = jsbi_1.default.BigInt(0);
+const ONE = jsbi_1.default.BigInt(1);
+const TWO = jsbi_1.default.BigInt(2);
+/**
+ * Computes floor(sqrt(value))
+ * @param value the value for which to compute the square root, rounded down
+ */
+function sqrt(value) {
+    (0, tiny_invariant_1.default)(jsbi_1.default.greaterThanOrEqual(value, ZERO), "NEGATIVE");
+    // rely on built in sqrt if possible
+    if (jsbi_1.default.lessThan(value, exports.MAX_SAFE_INTEGER)) {
+        return jsbi_1.default.BigInt(Math.floor(Math.sqrt(jsbi_1.default.toNumber(value))));
+    }
+    let z;
+    let x;
+    z = value;
+    x = jsbi_1.default.add(jsbi_1.default.divide(value, TWO), ONE);
+    while (jsbi_1.default.lessThan(x, z)) {
+        z = x;
+        x = jsbi_1.default.divide(jsbi_1.default.add(jsbi_1.default.divide(value, x), x), TWO);
+    }
+    return z;
+}
+exports.sqrt = sqrt;

package/build/utils/sqrtPriceMath.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqrtPriceMath = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const internalConstants_1 = require("../internalConstants");
+const fullMath_1 = require("./fullMath");
+function multiplyIn128(x, y) {
+    const product = jsbi_1.default.multiply(x, y);
+    return jsbi_1.default.bitwiseAnd(product, internalConstants_1.MaxUint128);
+}
+function addIn128(x, y) {
+    const sum = jsbi_1.default.add(x, y);
+    return jsbi_1.default.bitwiseAnd(sum, internalConstants_1.MaxUint128);
+}
+class SqrtPriceMath {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static getAmountADelta(sqrtRatioLX64, sqrtRatioUX64, liquidity, roundUp) {
+        if (jsbi_1.default.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+            [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+        }
+        const numerator1 = jsbi_1.default.leftShift(liquidity, jsbi_1.default.BigInt(64));
+        const numerator2 = jsbi_1.default.subtract(sqrtRatioUX64, sqrtRatioLX64);
+        return roundUp
+            ? fullMath_1.FullMath.mulDivRoundingUp(fullMath_1.FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioUX64), internalConstants_1.ONE, sqrtRatioLX64)
+            : jsbi_1.default.divide(jsbi_1.default.divide(jsbi_1.default.multiply(numerator1, numerator2), sqrtRatioUX64), sqrtRatioLX64);
+    }
+    static getAmountBDelta(sqrtRatioLX64, sqrtRatioUX64, liquidity, roundUp) {
+        if (jsbi_1.default.greaterThan(sqrtRatioLX64, sqrtRatioUX64)) {
+            [sqrtRatioLX64, sqrtRatioUX64] = [sqrtRatioUX64, sqrtRatioLX64];
+        }
+        return roundUp
+            ? fullMath_1.FullMath.mulDivRoundingUp(liquidity, jsbi_1.default.subtract(sqrtRatioUX64, sqrtRatioLX64), internalConstants_1.Q64)
+            : jsbi_1.default.divide(jsbi_1.default.multiply(liquidity, jsbi_1.default.subtract(sqrtRatioUX64, sqrtRatioLX64)), internalConstants_1.Q64);
+    }
+    static getNextSqrtPriceFromInput(sqrtPX64, liquidity, amountIn, zeroForOne) {
+        (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPX64, internalConstants_1.ZERO));
+        (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(liquidity, internalConstants_1.ZERO));
+        return zeroForOne
+            ? this.getNextSqrtPriceFromAmountARoundingUp(sqrtPX64, liquidity, amountIn, true)
+            : this.getNextSqrtPriceFromAmountBRoundingDown(sqrtPX64, liquidity, amountIn, true);
+    }
+    static getNextSqrtPriceFromOutput(sqrtPX64, liquidity, amountOut, zeroForOne) {
+        (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPX64, internalConstants_1.ZERO));
+        (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(liquidity, internalConstants_1.ZERO));
+        return zeroForOne
+            ? this.getNextSqrtPriceFromAmountBRoundingDown(sqrtPX64, liquidity, amountOut, false)
+            : this.getNextSqrtPriceFromAmountARoundingUp(sqrtPX64, liquidity, amountOut, false);
+    }
+    static getNextSqrtPriceFromAmountARoundingUp(sqrtPX64, liquidity, amount, add) {
+        if (jsbi_1.default.equal(amount, internalConstants_1.ZERO))
+            return sqrtPX64;
+        const numerator1 = jsbi_1.default.leftShift(liquidity, jsbi_1.default.BigInt(64));
+        if (add) {
+            let product = multiplyIn128(amount, sqrtPX64);
+            if (jsbi_1.default.equal(jsbi_1.default.divide(product, amount), sqrtPX64)) {
+                const denominator = addIn128(numerator1, product);
+                if (jsbi_1.default.greaterThanOrEqual(denominator, numerator1)) {
+                    return fullMath_1.FullMath.mulDivRoundingUp(numerator1, sqrtPX64, denominator);
+                }
+            }
+            return fullMath_1.FullMath.mulDivRoundingUp(numerator1, internalConstants_1.ONE, jsbi_1.default.add(jsbi_1.default.divide(numerator1, sqrtPX64), amount));
+        }
+        else {
+            let product = multiplyIn128(amount, sqrtPX64);
+            (0, tiny_invariant_1.default)(jsbi_1.default.equal(jsbi_1.default.divide(product, amount), sqrtPX64));
+            (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(numerator1, product));
+            const denominator = jsbi_1.default.subtract(numerator1, product);
+            return fullMath_1.FullMath.mulDivRoundingUp(numerator1, sqrtPX64, denominator);
+        }
+    }
+    static getNextSqrtPriceFromAmountBRoundingDown(sqrtPX64, liquidity, amount, add) {
+        if (add) {
+            const quotient = jsbi_1.default.lessThanOrEqual(amount, internalConstants_1.MaxUint128)
+                ? jsbi_1.default.divide(jsbi_1.default.leftShift(amount, jsbi_1.default.BigInt(64)), liquidity)
+                : jsbi_1.default.divide(jsbi_1.default.multiply(amount, internalConstants_1.Q64), liquidity);
+            return jsbi_1.default.add(sqrtPX64, quotient);
+        }
+        else {
+            const quotient = fullMath_1.FullMath.mulDivRoundingUp(amount, internalConstants_1.Q64, liquidity);
+            (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPX64, quotient));
+            return jsbi_1.default.subtract(sqrtPX64, quotient);
+        }
+    }
+}
+exports.SqrtPriceMath = SqrtPriceMath;

package/build/utils/swapMath.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapMath = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const internalConstants_1 = require("../internalConstants");
+const fullMath_1 = require("./fullMath");
+const sqrtPriceMath_1 = require("./sqrtPriceMath");
+const MAX_FEE = jsbi_1.default.exponentiate(jsbi_1.default.BigInt(10), jsbi_1.default.BigInt(6));
+class SwapMath {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static computeSwapStep(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, amountRemaining, feePips) {
+        const returnValues = {};
+        const zeroForOne = jsbi_1.default.greaterThanOrEqual(sqrtRatioCurrentX64, sqrtRatioTargetX64);
+        const exactIn = jsbi_1.default.greaterThanOrEqual(amountRemaining, internalConstants_1.ZERO);
+        if (exactIn) {
+            const amountRemainingLessFee = jsbi_1.default.divide(jsbi_1.default.multiply(amountRemaining, jsbi_1.default.subtract(MAX_FEE, jsbi_1.default.BigInt(feePips))), MAX_FEE);
+            returnValues.amountIn = zeroForOne
+                ? sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(sqrtRatioTargetX64, sqrtRatioCurrentX64, liquidity, true)
+                : sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, true);
+            if (jsbi_1.default.greaterThanOrEqual(amountRemainingLessFee, returnValues.amountIn)) {
+                returnValues.sqrtRatioNextX64 = sqrtRatioTargetX64;
+            }
+            else {
+                returnValues.sqrtRatioNextX64 = sqrtPriceMath_1.SqrtPriceMath.getNextSqrtPriceFromInput(sqrtRatioCurrentX64, liquidity, amountRemainingLessFee, zeroForOne);
+            }
+        }
+        else {
+            returnValues.amountOut = zeroForOne
+                ? sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(sqrtRatioTargetX64, sqrtRatioCurrentX64, liquidity, false)
+                : sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, sqrtRatioTargetX64, liquidity, false);
+            if (jsbi_1.default.greaterThanOrEqual(jsbi_1.default.multiply(amountRemaining, internalConstants_1.NEGATIVE_ONE), returnValues.amountOut)) {
+                returnValues.sqrtRatioNextX64 = sqrtRatioTargetX64;
+            }
+            else {
+                returnValues.sqrtRatioNextX64 =
+                    sqrtPriceMath_1.SqrtPriceMath.getNextSqrtPriceFromOutput(sqrtRatioCurrentX64, liquidity, jsbi_1.default.multiply(amountRemaining, internalConstants_1.NEGATIVE_ONE), zeroForOne);
+            }
+        }
+        const max = jsbi_1.default.equal(sqrtRatioTargetX64, returnValues.sqrtRatioNextX64);
+        if (zeroForOne) {
+            returnValues.amountIn =
+                max && exactIn
+                    ? returnValues.amountIn
+                    : sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(returnValues.sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, true);
+            returnValues.amountOut =
+                max && !exactIn
+                    ? returnValues.amountOut
+                    : sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(returnValues.sqrtRatioNextX64, sqrtRatioCurrentX64, liquidity, false);
+        }
+        else {
+            returnValues.amountIn =
+                max && exactIn
+                    ? returnValues.amountIn
+                    : sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(sqrtRatioCurrentX64, returnValues.sqrtRatioNextX64, liquidity, true);
+            returnValues.amountOut =
+                max && !exactIn
+                    ? returnValues.amountOut
+                    : sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(sqrtRatioCurrentX64, returnValues.sqrtRatioNextX64, liquidity, false);
+        }
+        if (!exactIn &&
+            jsbi_1.default.greaterThan(returnValues.amountOut, jsbi_1.default.multiply(amountRemaining, internalConstants_1.NEGATIVE_ONE))) {
+            returnValues.amountOut = jsbi_1.default.multiply(amountRemaining, internalConstants_1.NEGATIVE_ONE);
+        }
+        if (exactIn &&
+            jsbi_1.default.notEqual(returnValues.sqrtRatioNextX64, sqrtRatioTargetX64)) {
+            // we didn't reach the target, so take the remainder of the maximum input as fee
+            returnValues.feeAmount = jsbi_1.default.subtract(amountRemaining, returnValues.amountIn);
+        }
+        else {
+            returnValues.feeAmount = fullMath_1.FullMath.mulDivRoundingUp(returnValues.amountIn, jsbi_1.default.BigInt(feePips), jsbi_1.default.subtract(MAX_FEE, jsbi_1.default.BigInt(feePips)));
+        }
+        return [
+            returnValues.sqrtRatioNextX64,
+            returnValues.amountIn,
+            returnValues.amountOut,
+            returnValues.feeAmount,
+        ];
+    }
+}
+exports.SwapMath = SwapMath;

package/build/utils/tickLibrary.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TickLibrary = exports.subIn128 = exports.subIn256 = void 0;
+const jsbi_1 = __importDefault(require("jsbi"));
+const internalConstants_1 = require("../internalConstants");
+function subIn256(x, y) {
+    const difference = jsbi_1.default.subtract(x, y);
+    if (jsbi_1.default.lessThan(difference, internalConstants_1.ZERO)) {
+        return jsbi_1.default.add(internalConstants_1.Q256, difference);
+    }
+    else {
+        return difference;
+    }
+}
+exports.subIn256 = subIn256;
+function subIn128(x, y) {
+    const difference = jsbi_1.default.subtract(x, y);
+    if (jsbi_1.default.lessThan(difference, internalConstants_1.ZERO)) {
+        return jsbi_1.default.add(internalConstants_1.Q128, difference);
+    }
+    else {
+        return difference;
+    }
+}
+exports.subIn128 = subIn128;
+class TickLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static getFeeGrowthInside(feeGrowthOutsideLower, feeGrowthOutsideUpper, tickLower, tickUpper, tickCurrent, feeGrowthGlobalAX64, feeGrowthGlobalBX64) {
+        let feeGrowthBelowAX64;
+        let feeGrowthBelowBX64;
+        if (tickCurrent >= tickLower) {
+            feeGrowthBelowAX64 = feeGrowthOutsideLower.feeGrowthOutsideAX64;
+            feeGrowthBelowBX64 = feeGrowthOutsideLower.feeGrowthOutsideBX64;
+        }
+        else {
+            feeGrowthBelowAX64 = subIn128(feeGrowthGlobalAX64, feeGrowthOutsideLower.feeGrowthOutsideAX64);
+            feeGrowthBelowBX64 = subIn128(feeGrowthGlobalBX64, feeGrowthOutsideLower.feeGrowthOutsideBX64);
+        }
+        let feeGrowthAboveAX64;
+        let feeGrowthAboveBX64;
+        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),
+        ];
+    }
+}
+exports.TickLibrary = TickLibrary;