@alcorexchange/alcor-swap-sdk 1.0.0

package/build/entities/pool.js

@@ -0,0 +1,248 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pool = void 0;
+const fractions_1 = require("./fractions");
+const internalConstants_1 = require("../internalConstants");
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const internalConstants_2 = require("../internalConstants");
+const liquidityMath_1 = require("../utils/liquidityMath");
+const swapMath_1 = require("../utils/swapMath");
+const tickMath_1 = require("../utils/tickMath");
+const tickDataProvider_1 = require("./tickDataProvider");
+const tickListDataProvider_1 = require("./tickListDataProvider");
+/**
+ * By default, pools will not allow operations that require ticks.
+ */
+const NO_TICK_DATA_PROVIDER_DEFAULT = new tickDataProvider_1.NoTickDataProvider();
+/**
+ * Represents a V3 pool
+ */
+class Pool {
+    /**
+     * Construct a pool
+     * @param tokenA One of the tokens in the pool
+     * @param tokenB The other token in the pool
+     * @param fee The fee in hundredths of a bips of the input amount of every swap that is collected by the pool
+     * @param sqrtPriceX64 The sqrt of the current ratio of amounts of tokenB to tokenA
+     * @param liquidity The current value of in range liquidity
+     * @param tickCurrent The current tick of the pool
+     * @param ticks The current state of the pool ticks or a data provider that can return tick data
+     */
+    constructor({ id, tokenA, tokenB, fee, sqrtPriceX64, liquidity, tickCurrent, ticks = NO_TICK_DATA_PROVIDER_DEFAULT, feeGrowthGlobalAX64 = 0, feeGrowthGlobalBX64 = 0, }) {
+        (0, tiny_invariant_1.default)(Number.isInteger(fee) && fee < 1000000, "FEE");
+        const tickCurrentSqrtRatioX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickCurrent);
+        const nextTickSqrtRatioX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickCurrent + 1);
+        (0, tiny_invariant_1.default)(jsbi_1.default.greaterThanOrEqual(jsbi_1.default.BigInt(sqrtPriceX64), tickCurrentSqrtRatioX64) &&
+            jsbi_1.default.lessThanOrEqual(jsbi_1.default.BigInt(sqrtPriceX64), nextTickSqrtRatioX64), "PRICE_BOUNDS");
+        // always create a copy of the list since we want the pool's tick list to be immutable
+        this.id = id;
+        this.fee = fee;
+        this.sqrtPriceX64 = jsbi_1.default.BigInt(sqrtPriceX64);
+        this.liquidity = jsbi_1.default.BigInt(liquidity);
+        this.tickCurrent = tickCurrent;
+        this.feeGrowthGlobalAX64 = jsbi_1.default.BigInt(feeGrowthGlobalAX64);
+        this.feeGrowthGlobalBX64 = jsbi_1.default.BigInt(feeGrowthGlobalBX64);
+        this.tickDataProvider = Array.isArray(ticks)
+            ? new tickListDataProvider_1.TickListDataProvider(ticks, internalConstants_1.TICK_SPACINGS[fee])
+            : ticks;
+        [this.tokenA, this.tokenB] = tokenA.sortsBefore(tokenB)
+            ? [tokenA, tokenB]
+            : [tokenB, tokenA];
+    }
+    /**
+     * Returns true if the token is either tokenA or tokenB
+     * @param token The token to check
+     * @returns True if token is either tokenA or token
+     */
+    involvesToken(token) {
+        return token.equals(this.tokenA) || token.equals(this.tokenB);
+    }
+    /**
+     * Returns the current mid price of the pool in terms of tokenA, i.e. the ratio of tokenB over tokenA
+     */
+    get tokenAPrice() {
+        var _a;
+        return ((_a = this._tokenAPrice) !== null && _a !== void 0 ? _a : (this._tokenAPrice = new fractions_1.Price(this.tokenA, this.tokenB, internalConstants_2.Q128, jsbi_1.default.multiply(this.sqrtPriceX64, this.sqrtPriceX64))));
+    }
+    /**
+     * Returns the current mid price of the pool in terms of tokenB, i.e. the ratio of tokenA over tokenB
+     */
+    get tokenBPrice() {
+        var _a;
+        return ((_a = this._tokenBPrice) !== null && _a !== void 0 ? _a : (this._tokenBPrice = new fractions_1.Price(this.tokenB, this.tokenA, jsbi_1.default.multiply(this.sqrtPriceX64, this.sqrtPriceX64), internalConstants_2.Q128)));
+    }
+    /**
+     * Return the price of the given token in terms of the other token in the pool.
+     * @param token The token to return price of
+     * @returns The price of the given token, in terms of the other.
+     */
+    priceOf(token) {
+        (0, tiny_invariant_1.default)(this.involvesToken(token), "TOKEN");
+        return token.equals(this.tokenA) ? this.tokenAPrice : this.tokenBPrice;
+    }
+    /**
+     * Given an input amount of a token, return the computed output amount, and a pool with state updated after the trade
+     * @param inputAmount The input amount for which to quote the output amount
+     * @param sqrtPriceLimitX64 The Q64.96 sqrt price limit
+     * @returns The output amount and the pool with updated state
+     */
+    getOutputAmount(inputAmount, sqrtPriceLimitX64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            (0, tiny_invariant_1.default)(this.involvesToken(inputAmount.currency), "TOKEN");
+            const zeroForOne = inputAmount.currency.equals(this.tokenA);
+            const { amountCalculated: outputAmount, sqrtPriceX64, liquidity, tickCurrent, } = yield this.swap(zeroForOne, inputAmount.quotient, sqrtPriceLimitX64);
+            const outputToken = zeroForOne ? this.tokenB : this.tokenA;
+            return [
+                fractions_1.CurrencyAmount.fromRawAmount(outputToken, jsbi_1.default.multiply(outputAmount, internalConstants_2.NEGATIVE_ONE)),
+                new Pool({
+                    id: this.id,
+                    tokenA: this.tokenA,
+                    tokenB: this.tokenB,
+                    fee: this.fee,
+                    sqrtPriceX64,
+                    liquidity,
+                    tickCurrent,
+                    ticks: this.tickDataProvider,
+                    feeGrowthGlobalAX64: this.feeGrowthGlobalAX64,
+                    feeGrowthGlobalBX64: this.feeGrowthGlobalBX64,
+                })
+            ];
+        });
+    }
+    /**
+     * Given a desired output amount of a token, return the computed input amount and a pool with state updated after the trade
+     * @param outputAmount the output amount for which to quote the input amount
+     * @param sqrtPriceLimitX64 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns The input amount and the pool with updated state
+     */
+    getInputAmount(outputAmount, sqrtPriceLimitX64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const zeroForOne = outputAmount.currency.equals(this.tokenB);
+            const { amountCalculated: inputAmount, sqrtPriceX64, liquidity, tickCurrent, } = yield this.swap(zeroForOne, jsbi_1.default.multiply(outputAmount.quotient, internalConstants_2.NEGATIVE_ONE), sqrtPriceLimitX64);
+            const inputToken = zeroForOne ? this.tokenA : this.tokenB;
+            return [
+                fractions_1.CurrencyAmount.fromRawAmount(inputToken, inputAmount),
+                new Pool({
+                    id: this.id,
+                    tokenA: this.tokenA,
+                    tokenB: this.tokenB,
+                    fee: this.fee,
+                    sqrtPriceX64,
+                    liquidity,
+                    tickCurrent,
+                    ticks: this.tickDataProvider,
+                    feeGrowthGlobalAX64: this.feeGrowthGlobalAX64,
+                    feeGrowthGlobalBX64: this.feeGrowthGlobalBX64,
+                }),
+            ];
+        });
+    }
+    /**
+     * Executes a swap
+     * @param zeroForOne Whether the amount in is tokenA or tokenB
+     * @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
+     * @param sqrtPriceLimitX64 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this value after the swap. If one for zero, the price cannot be greater than this value after the swap
+     * @returns amountCalculated
+     * @returns sqrtPriceX64
+     * @returns liquidity
+     * @returns tickCurrent
+     */
+    swap(zeroForOne, amountSpecified, sqrtPriceLimitX64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!sqrtPriceLimitX64)
+                sqrtPriceLimitX64 = zeroForOne
+                    ? jsbi_1.default.add(tickMath_1.TickMath.MIN_SQRT_RATIO, internalConstants_2.ONE)
+                    : jsbi_1.default.subtract(tickMath_1.TickMath.MAX_SQRT_RATIO, internalConstants_2.ONE);
+            if (zeroForOne) {
+                (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPriceLimitX64, tickMath_1.TickMath.MIN_SQRT_RATIO), "RATIO_MIN");
+                (0, tiny_invariant_1.default)(jsbi_1.default.lessThan(sqrtPriceLimitX64, this.sqrtPriceX64), "RATIO_CURRENT");
+            }
+            else {
+                (0, tiny_invariant_1.default)(jsbi_1.default.lessThan(sqrtPriceLimitX64, tickMath_1.TickMath.MAX_SQRT_RATIO), "RATIO_MAX");
+                (0, tiny_invariant_1.default)(jsbi_1.default.greaterThan(sqrtPriceLimitX64, this.sqrtPriceX64), "RATIO_CURRENT");
+            }
+            const exactInput = jsbi_1.default.greaterThanOrEqual(amountSpecified, internalConstants_2.ZERO);
+            // keep track of swap state
+            const state = {
+                amountSpecifiedRemaining: amountSpecified,
+                amountCalculated: internalConstants_2.ZERO,
+                sqrtPriceX64: this.sqrtPriceX64,
+                tick: this.tickCurrent,
+                liquidity: this.liquidity,
+            };
+            // start swap while loop
+            while (jsbi_1.default.notEqual(state.amountSpecifiedRemaining, internalConstants_2.ZERO) &&
+                state.sqrtPriceX64 != sqrtPriceLimitX64) {
+                const step = {};
+                step.sqrtPriceStartX64 = state.sqrtPriceX64;
+                // because each iteration of the while loop rounds, we can't optimize this code (relative to the smart contract)
+                // by simply traversing to the next available tick, we instead need to exactly replicate
+                // tickBitmap.nextInitializedTickWithinOneWord
+                [step.tickNext, step.initialized] =
+                    yield this.tickDataProvider.nextInitializedTickWithinOneWord(state.tick, zeroForOne, this.tickSpacing);
+                if (step.tickNext < tickMath_1.TickMath.MIN_TICK) {
+                    step.tickNext = tickMath_1.TickMath.MIN_TICK;
+                }
+                else if (step.tickNext > tickMath_1.TickMath.MAX_TICK) {
+                    step.tickNext = tickMath_1.TickMath.MAX_TICK;
+                }
+                step.sqrtPriceNextX64 = tickMath_1.TickMath.getSqrtRatioAtTick(step.tickNext);
+                [state.sqrtPriceX64, step.amountIn, step.amountOut, step.feeAmount] =
+                    swapMath_1.SwapMath.computeSwapStep(state.sqrtPriceX64, (zeroForOne
+                        ? jsbi_1.default.lessThan(step.sqrtPriceNextX64, sqrtPriceLimitX64)
+                        : jsbi_1.default.greaterThan(step.sqrtPriceNextX64, sqrtPriceLimitX64))
+                        ? sqrtPriceLimitX64
+                        : step.sqrtPriceNextX64, state.liquidity, state.amountSpecifiedRemaining, this.fee);
+                if (exactInput) {
+                    state.amountSpecifiedRemaining = jsbi_1.default.subtract(state.amountSpecifiedRemaining, jsbi_1.default.add(step.amountIn, step.feeAmount));
+                    state.amountCalculated = jsbi_1.default.subtract(state.amountCalculated, step.amountOut);
+                }
+                else {
+                    state.amountSpecifiedRemaining = jsbi_1.default.add(state.amountSpecifiedRemaining, step.amountOut);
+                    state.amountCalculated = jsbi_1.default.add(state.amountCalculated, jsbi_1.default.add(step.amountIn, step.feeAmount));
+                }
+                // TODO
+                if (jsbi_1.default.equal(state.sqrtPriceX64, step.sqrtPriceNextX64)) {
+                    // if the tick is initialized, run the tick transition
+                    if (step.initialized) {
+                        let liquidityNet = jsbi_1.default.BigInt((yield this.tickDataProvider.getTick(step.tickNext)).liquidityNet);
+                        // if we're moving leftward, we interpret liquidityNet as the opposite sign
+                        // safe because liquidityNet cannot be type(int128).min
+                        if (zeroForOne)
+                            liquidityNet = jsbi_1.default.multiply(liquidityNet, internalConstants_2.NEGATIVE_ONE);
+                        state.liquidity = liquidityMath_1.LiquidityMath.addDelta(state.liquidity, liquidityNet);
+                    }
+                    state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
+                }
+                else if (jsbi_1.default.notEqual(state.sqrtPriceX64, step.sqrtPriceStartX64)) {
+                    // updated comparison function
+                    // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
+                    state.tick = tickMath_1.TickMath.getTickAtSqrtRatio(state.sqrtPriceX64);
+                }
+            }
+            return {
+                amountCalculated: state.amountCalculated,
+                sqrtPriceX64: state.sqrtPriceX64,
+                liquidity: state.liquidity,
+                tickCurrent: state.tick,
+            };
+        });
+    }
+    get tickSpacing() {
+        return internalConstants_1.TICK_SPACINGS[this.fee];
+    }
+}
+exports.Pool = Pool;

package/build/entities/position.js

@@ -0,0 +1,364 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Position = void 0;
+const fractions_1 = require("./fractions");
+const internalConstants_1 = require("../internalConstants");
+const jsbi_1 = __importDefault(require("jsbi"));
+const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
+const internalConstants_2 = require("../internalConstants");
+const maxLiquidityForAmounts_1 = require("../utils/maxLiquidityForAmounts");
+const priceTickConversions_1 = require("../utils/priceTickConversions");
+const sqrtPriceMath_1 = require("../utils/sqrtPriceMath");
+const tickMath_1 = require("../utils/tickMath");
+const encodeSqrtRatioX64_1 = require("../utils/encodeSqrtRatioX64");
+const pool_1 = require("./pool");
+const utils_1 = require("../utils");
+class Position {
+    /**
+     * Constructs a position for a given pool with the given liquidity
+     * @param pool For which pool the liquidity is assigned
+     * @param liquidity The amount of liquidity that is in the position
+     * @param lower The lower tick of the position
+     * @param upper The upper tick of the position
+     */
+    constructor({ id, owner, pool, liquidity, tickLower, tickUpper, feeGrowthInsideALastX64 = 0, feeGrowthInsideBLastX64 = 0, }) {
+        // cached resuts for the getters
+        this._tokenAAmount = null;
+        this._tokenBAmount = null;
+        this._mintAmounts = null;
+        (0, tiny_invariant_1.default)(tickLower < tickUpper, "TICK_ORDER");
+        (0, tiny_invariant_1.default)(tickLower >= tickMath_1.TickMath.MIN_TICK && tickLower % pool.tickSpacing === 0, "TICK_LOWER");
+        (0, tiny_invariant_1.default)(tickUpper <= tickMath_1.TickMath.MAX_TICK && tickUpper % pool.tickSpacing === 0, "TICK_UPPER");
+        this.id = id;
+        this.owner = owner;
+        this.pool = pool;
+        this.tickLower = tickLower;
+        this.tickUpper = tickUpper;
+        this.liquidity = jsbi_1.default.BigInt(liquidity);
+        this.feeGrowthInsideALastX64 = jsbi_1.default.BigInt(feeGrowthInsideALastX64);
+        this.feeGrowthInsideBLastX64 = jsbi_1.default.BigInt(feeGrowthInsideBLastX64);
+    }
+    get inRange() {
+        return (this.tickLower < this.pool.tickCurrent &&
+            this.pool.tickCurrent < this.tickUpper);
+    }
+    /**
+     * Returns the price of tokenA at the lower tick
+     */
+    get tokenAPriceLower() {
+        return (0, priceTickConversions_1.tickToPrice)(this.pool.tokenA, this.pool.tokenB, this.tickLower);
+    }
+    /**
+     * Returns the price of tokenA at the upper tick
+     */
+    get tokenAPriceUpper() {
+        return (0, priceTickConversions_1.tickToPrice)(this.pool.tokenA, this.pool.tokenB, this.tickUpper);
+    }
+    /**
+     * Returns the amount of tokenA that this position's liquidity could be burned for at the current pool price
+     */
+    get amountA() {
+        if (this._tokenAAmount === null) {
+            if (this.pool.tickCurrent < this.tickLower) {
+                this._tokenAAmount = fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenA, sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(tickMath_1.TickMath.getSqrtRatioAtTick(this.tickLower), tickMath_1.TickMath.getSqrtRatioAtTick(this.tickUpper), this.liquidity, false));
+            }
+            else if (this.pool.tickCurrent < this.tickUpper) {
+                this._tokenAAmount = fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenA, sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(this.pool.sqrtPriceX64, tickMath_1.TickMath.getSqrtRatioAtTick(this.tickUpper), this.liquidity, false));
+            }
+            else {
+                this._tokenAAmount = fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenA, internalConstants_2.ZERO);
+            }
+        }
+        return this._tokenAAmount;
+    }
+    /**
+     * Returns the amount of tokenB that this position's liquidity could be burned for at the current pool price
+     */
+    get amountB() {
+        if (this._tokenBAmount === null) {
+            if (this.pool.tickCurrent < this.tickLower) {
+                this._tokenBAmount = fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenB, internalConstants_2.ZERO);
+            }
+            else if (this.pool.tickCurrent < this.tickUpper) {
+                this._tokenBAmount = fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenB, sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(tickMath_1.TickMath.getSqrtRatioAtTick(this.tickLower), this.pool.sqrtPriceX64, this.liquidity, false));
+            }
+            else {
+                this._tokenBAmount = fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenB, sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(tickMath_1.TickMath.getSqrtRatioAtTick(this.tickLower), tickMath_1.TickMath.getSqrtRatioAtTick(this.tickUpper), this.liquidity, false));
+            }
+        }
+        return this._tokenBAmount;
+    }
+    /**
+     * Returns the lower and upper sqrt ratios if the price 'slips' up to slippage tolerance percentage
+     * @param slippageTolerance The amount by which the price can 'slip' before the transaction will revert
+     * @returns The sqrt ratios after slippage
+     */
+    ratiosAfterSlippage(slippageTolerance) {
+        const priceLower = this.pool.tokenAPrice.asFraction.multiply(new fractions_1.Percent(1).subtract(slippageTolerance));
+        const priceUpper = this.pool.tokenAPrice.asFraction.multiply(slippageTolerance.add(1));
+        let sqrtPriceX64Lower = (0, encodeSqrtRatioX64_1.encodeSqrtRatioX64)(priceLower.numerator, priceLower.denominator);
+        if (jsbi_1.default.lessThanOrEqual(sqrtPriceX64Lower, tickMath_1.TickMath.MIN_SQRT_RATIO)) {
+            sqrtPriceX64Lower = jsbi_1.default.add(tickMath_1.TickMath.MIN_SQRT_RATIO, jsbi_1.default.BigInt(1));
+        }
+        let sqrtPriceX64Upper = (0, encodeSqrtRatioX64_1.encodeSqrtRatioX64)(priceUpper.numerator, priceUpper.denominator);
+        if (jsbi_1.default.greaterThanOrEqual(sqrtPriceX64Upper, tickMath_1.TickMath.MAX_SQRT_RATIO)) {
+            sqrtPriceX64Upper = jsbi_1.default.subtract(tickMath_1.TickMath.MAX_SQRT_RATIO, jsbi_1.default.BigInt(1));
+        }
+        return {
+            sqrtPriceX64Lower,
+            sqrtPriceX64Upper,
+        };
+    }
+    /**
+     * Returns the minimum amounts that must be sent in order to safely mint the amount of liquidity held by the position
+     * with the given slippage tolerance
+     * @param slippageTolerance Tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    mintAmountsWithSlippage(slippageTolerance) {
+        // get lower/upper prices
+        const { sqrtPriceX64Upper, sqrtPriceX64Lower } = this.ratiosAfterSlippage(slippageTolerance);
+        // construct counterfactual pools
+        const poolLower = new pool_1.Pool({
+            id: this.pool.id,
+            tokenA: this.pool.tokenA,
+            tokenB: this.pool.tokenB,
+            fee: this.pool.fee,
+            sqrtPriceX64: sqrtPriceX64Lower,
+            liquidity: 0 /* liquidity doesn't matter */,
+            tickCurrent: tickMath_1.TickMath.getTickAtSqrtRatio(sqrtPriceX64Lower),
+            feeGrowthGlobalAX64: this.feeGrowthInsideALastX64,
+            feeGrowthGlobalBX64: this.feeGrowthInsideBLastX64,
+            ticks: this.pool.tickDataProvider
+        });
+        const poolUpper = new pool_1.Pool({
+            id: this.pool.id,
+            tokenA: this.pool.tokenA,
+            tokenB: this.pool.tokenB,
+            fee: this.pool.fee,
+            sqrtPriceX64: sqrtPriceX64Upper,
+            liquidity: 0 /* liquidity doesn't matter */,
+            tickCurrent: tickMath_1.TickMath.getTickAtSqrtRatio(sqrtPriceX64Upper),
+            feeGrowthGlobalAX64: this.feeGrowthInsideALastX64,
+            feeGrowthGlobalBX64: this.feeGrowthInsideBLastX64,
+            ticks: this.pool.tickDataProvider
+        });
+        // because the router is imprecise, we need to calculate the position that will be created (assuming no slippage)
+        const positionThatWillBeCreated = Position.fromAmounts(Object.assign(Object.assign({ id: this.id, owner: this.owner, pool: this.pool, tickLower: this.tickLower, tickUpper: this.tickUpper }, this.mintAmounts), { useFullPrecision: false, feeGrowthInsideALastX64: this.feeGrowthInsideALastX64, feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64 }));
+        // we want the smaller amounts...
+        // ...which occurs at the upper price for amountA...
+        const { amountA } = new Position({
+            id: this.id,
+            owner: this.owner,
+            pool: poolUpper,
+            liquidity: positionThatWillBeCreated.liquidity,
+            tickLower: this.tickLower,
+            tickUpper: this.tickUpper,
+            feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
+            feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+        }).mintAmounts;
+        // ...and the lower for amountB
+        const { amountB } = new Position({
+            id: this.id,
+            owner: this.owner,
+            pool: poolLower,
+            liquidity: positionThatWillBeCreated.liquidity,
+            tickLower: this.tickLower,
+            tickUpper: this.tickUpper,
+            feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
+            feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+        }).mintAmounts;
+        return { amountA, amountB };
+    }
+    /**
+     * Returns the minimum amounts that should be requested in order to safely burn the amount of liquidity held by the
+     * position with the given slippage tolerance
+     * @param slippageTolerance tolerance of unfavorable slippage from the current price
+     * @returns The amounts, with slippage
+     */
+    burnAmountsWithSlippage(slippageTolerance) {
+        // get lower/upper prices
+        const { sqrtPriceX64Upper, sqrtPriceX64Lower } = this.ratiosAfterSlippage(slippageTolerance);
+        // construct counterfactual pools
+        const poolLower = new pool_1.Pool({
+            id: this.pool.id,
+            tokenA: this.pool.tokenA,
+            tokenB: this.pool.tokenB,
+            fee: this.pool.fee,
+            sqrtPriceX64: sqrtPriceX64Lower,
+            liquidity: 0 /* liquidity doesn't matter */,
+            tickCurrent: tickMath_1.TickMath.getTickAtSqrtRatio(sqrtPriceX64Lower),
+            feeGrowthGlobalAX64: this.feeGrowthInsideALastX64,
+            feeGrowthGlobalBX64: this.feeGrowthInsideBLastX64,
+            ticks: this.pool.tickDataProvider
+        });
+        const poolUpper = new pool_1.Pool({
+            id: this.pool.id,
+            tokenA: this.pool.tokenA,
+            tokenB: this.pool.tokenB,
+            fee: this.pool.fee,
+            sqrtPriceX64: sqrtPriceX64Upper,
+            liquidity: 0 /* liquidity doesn't matter */,
+            tickCurrent: tickMath_1.TickMath.getTickAtSqrtRatio(sqrtPriceX64Upper),
+            feeGrowthGlobalAX64: this.feeGrowthInsideALastX64,
+            feeGrowthGlobalBX64: this.feeGrowthInsideBLastX64,
+            ticks: this.pool.tickDataProvider
+        });
+        // we want the smaller amounts...
+        // ...which occurs at the upper price for amountA...
+        const amountA = new Position({
+            id: this.id,
+            owner: this.owner,
+            pool: poolUpper,
+            liquidity: this.liquidity,
+            tickLower: this.tickLower,
+            tickUpper: this.tickUpper,
+            feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
+            feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+        }).amountA;
+        // ...and the lower for amountB
+        const amountB = new Position({
+            id: this.id,
+            owner: this.owner,
+            pool: poolLower,
+            liquidity: this.liquidity,
+            tickLower: this.tickLower,
+            tickUpper: this.tickUpper,
+            feeGrowthInsideALastX64: this.feeGrowthInsideALastX64,
+            feeGrowthInsideBLastX64: this.feeGrowthInsideBLastX64,
+        }).amountB;
+        return { amountA: amountA, amountB: amountB };
+    }
+    /**
+     * Returns the minimum amounts that must be sent in order to mint the amount of liquidity held by the position at
+     * the current price for the pool
+     */
+    get mintAmounts() {
+        if (this._mintAmounts === null) {
+            if (this.pool.tickCurrent < this.tickLower) {
+                return {
+                    amountA: sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(tickMath_1.TickMath.getSqrtRatioAtTick(this.tickLower), tickMath_1.TickMath.getSqrtRatioAtTick(this.tickUpper), this.liquidity, true),
+                    amountB: internalConstants_2.ZERO,
+                };
+            }
+            else if (this.pool.tickCurrent < this.tickUpper) {
+                return {
+                    amountA: sqrtPriceMath_1.SqrtPriceMath.getAmountADelta(this.pool.sqrtPriceX64, tickMath_1.TickMath.getSqrtRatioAtTick(this.tickUpper), this.liquidity, true),
+                    amountB: sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(tickMath_1.TickMath.getSqrtRatioAtTick(this.tickLower), this.pool.sqrtPriceX64, this.liquidity, true),
+                };
+            }
+            else {
+                return {
+                    amountA: internalConstants_2.ZERO,
+                    amountB: sqrtPriceMath_1.SqrtPriceMath.getAmountBDelta(tickMath_1.TickMath.getSqrtRatioAtTick(this.tickLower), tickMath_1.TickMath.getSqrtRatioAtTick(this.tickUpper), this.liquidity, true),
+                };
+            }
+        }
+        return this._mintAmounts;
+    }
+    /**
+     * Computes the maximum amount of liquidity received for a given amount of tokenA, tokenB,
+     * and the prices at the tick boundaries.
+     * @param pool The pool for which the position should be created
+     * @param lower The lower tick of the position
+     * @param upper The upper tick of the position
+     * @param amountA tokenA amount
+     * @param amountB tokenB amount
+     * @param useFullPrecision If false, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The amount of liquidity for the position
+     */
+    static fromAmounts({ id, owner, pool, tickLower, tickUpper, amountA, amountB, useFullPrecision, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, }) {
+        const sqrtRatioLX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickLower);
+        const sqrtRatioUX64 = tickMath_1.TickMath.getSqrtRatioAtTick(tickUpper);
+        return new Position({
+            id,
+            owner,
+            pool,
+            tickLower,
+            tickUpper,
+            liquidity: (0, maxLiquidityForAmounts_1.maxLiquidityForAmounts)(pool.sqrtPriceX64, sqrtRatioLX64, sqrtRatioUX64, amountA, amountB, useFullPrecision),
+            feeGrowthInsideALastX64,
+            feeGrowthInsideBLastX64
+        });
+    }
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of tokenA, assuming an unlimited amount of tokenB
+     * @param pool The pool for which the position is created
+     * @param lower The lower tick
+     * @param upper The upper tick
+     * @param amountA The desired amount of tokenA
+     * @param useFullPrecision If true, liquidity will be maximized according to what the router can calculate,
+     * not what core can theoretically support
+     * @returns The position
+     */
+    static fromAmountA({ id, owner, pool, tickLower, tickUpper, amountA, useFullPrecision, feeGrowthInsideALastX64, feeGrowthInsideBLastX64 }) {
+        return Position.fromAmounts({
+            id,
+            owner,
+            pool,
+            tickLower,
+            tickUpper,
+            amountA,
+            amountB: internalConstants_1.MaxUint64,
+            useFullPrecision,
+            feeGrowthInsideALastX64,
+            feeGrowthInsideBLastX64
+        });
+    }
+    /**
+     * Computes a position with the maximum amount of liquidity received for a given amount of tokenB, assuming an unlimited amount of tokenA
+     * @param pool The pool for which the position is created
+     * @param lower The lower tick
+     * @param upper The upper tick
+     * @param amountB The desired amount of tokenB
+     * @returns The position
+     */
+    static fromAmountB({ id, owner, pool, tickLower, tickUpper, amountB, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, }) {
+        // this function always uses full precision,
+        return Position.fromAmounts({
+            id,
+            owner,
+            pool,
+            tickLower,
+            tickUpper,
+            amountA: internalConstants_1.MaxUint64,
+            amountB,
+            useFullPrecision: true,
+            feeGrowthInsideALastX64,
+            feeGrowthInsideBLastX64,
+        });
+    }
+    /**
+     * Computes a position fees
+     * @returns The position
+     */
+    getFees() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { liquidity, tickLower, tickUpper, feeGrowthInsideALastX64, feeGrowthInsideBLastX64, pool } = this;
+            const lower = yield this.pool.tickDataProvider.getTick(tickLower);
+            const upper = yield this.pool.tickDataProvider.getTick(tickUpper);
+            const { feeGrowthGlobalAX64, feeGrowthGlobalBX64 } = pool;
+            const [feeGrowthInsideAX64, feeGrowthInsideBX64] = utils_1.TickLibrary.getFeeGrowthInside(lower, upper, tickLower, tickUpper, pool.tickCurrent, feeGrowthGlobalAX64, feeGrowthGlobalBX64);
+            const tokensOwedA = jsbi_1.default.divide(jsbi_1.default.multiply((0, utils_1.subIn128)(feeGrowthInsideAX64, feeGrowthInsideALastX64), liquidity), internalConstants_1.Q64);
+            const tokensOwedB = jsbi_1.default.divide(jsbi_1.default.multiply((0, utils_1.subIn128)(feeGrowthInsideBX64, feeGrowthInsideBLastX64), liquidity), internalConstants_1.Q64);
+            return {
+                feesA: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenA, tokensOwedA),
+                feesB: fractions_1.CurrencyAmount.fromRawAmount(this.pool.tokenB, tokensOwedB),
+            };
+        });
+    }
+}
+exports.Position = Position;