@centurion_project/v3-sdk 3.30.0-ctn.0

package/dist/esm/src/utils/computePoolAddress.js

@@ -0,0 +1,29 @@
+import { defaultAbiCoder } from '@ethersproject/abi';
+import { getCreate2Address } from '@ethersproject/address';
+import { keccak256 } from '@ethersproject/solidity';
+import { ChainId, computeZksyncCreate2Address } from '@centurion_project/sdk-core';
+import { poolInitCodeHash } from '../constants';
+/**
+ * Computes a pool address
+ * @param factoryAddress The Uniswap V3 factory address
+ * @param tokenA The first token of the pair, irrespective of sort order
+ * @param tokenB The second token of the pair, irrespective of sort order
+ * @param fee The fee tier of the pool
+ * @param initCodeHashManualOverride Override the init code hash used to compute the pool address if necessary
+ * @param chainId
+ * @returns The pool address
+ */
+export function computePoolAddress({ factoryAddress, tokenA, tokenB, fee, initCodeHashManualOverride, chainId, }) {
+    const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA]; // does safety checks
+    const salt = keccak256(['bytes'], [defaultAbiCoder.encode(['address', 'address', 'uint24'], [token0.address, token1.address, fee])]);
+    const initCodeHash = initCodeHashManualOverride !== null && initCodeHashManualOverride !== void 0 ? initCodeHashManualOverride : poolInitCodeHash(chainId);
+    // ZKSync uses a different create2 address computation
+    // Most likely all ZKEVM chains will use the different computation from standard create2
+    switch (chainId) {
+        case ChainId.ZKSYNC:
+            return computeZksyncCreate2Address(factoryAddress, initCodeHash, salt);
+        default:
+            return getCreate2Address(factoryAddress, salt, initCodeHash);
+    }
+}
+//# sourceMappingURL=computePoolAddress.js.map

package/dist/esm/src/utils/computePoolAddress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computePoolAddress.js","sourceRoot":"","sources":["../../../../src/utils/computePoolAddress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAA;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,OAAO,EAAE,2BAA2B,EAAS,MAAM,6BAA6B,CAAA;AACzF,OAAO,EAAa,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE1D;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB,CAAC,EACjC,cAAc,EACd,MAAM,EACN,MAAM,EACN,GAAG,EACH,0BAA0B,EAC1B,OAAO,GAQR;IACC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA,CAAC,qBAAqB;IAC/G,MAAM,IAAI,GAAG,SAAS,CACpB,CAAC,OAAO,CAAC,EACT,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAClG,CAAA;IACD,MAAM,YAAY,GAAG,0BAA0B,aAA1B,0BAA0B,cAA1B,0BAA0B,GAAI,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAE5E,sDAAsD;IACtD,wFAAwF;IACxF,QAAQ,OAAO,EAAE;QACf,KAAK,OAAO,CAAC,MAAM;YACjB,OAAO,2BAA2B,CAAC,cAAc,EAAE,YAAY,EAAE,IAAI,CAAC,CAAA;QACxE;YACE,OAAO,iBAAiB,CAAC,cAAc,EAAE,IAAI,EAAE,YAAY,CAAC,CAAA;KAC/D;AACH,CAAC"}

package/dist/esm/src/utils/encodeRouteToPath.d.ts

@@ -0,0 +1,8 @@
+import { Currency } from '@centurion_project/sdk-core';
+import { Route } from '../entities/route';
+/**
+ * Converts a route to a hex encoded path
+ * @param route the v3 path to convert to an encoded path
+ * @param exactOutput whether the route should be encoded in reverse, for making exact output swaps
+ */
+export declare function encodeRouteToPath(route: Route<Currency, Currency>, exactOutput: boolean): string;

package/dist/esm/src/utils/encodeRouteToPath.js

@@ -0,0 +1,28 @@
+import { pack } from '@ethersproject/solidity';
+/**
+ * Converts a route to a hex encoded path
+ * @param route the v3 path to convert to an encoded path
+ * @param exactOutput whether the route should be encoded in reverse, for making exact output swaps
+ */
+export function encodeRouteToPath(route, exactOutput) {
+    const firstInputToken = route.input.wrapped;
+    const { path, types } = route.pools.reduce(({ inputToken, path, types }, pool, index) => {
+        const outputToken = pool.token0.equals(inputToken) ? pool.token1 : pool.token0;
+        if (index === 0) {
+            return {
+                inputToken: outputToken,
+                types: ['address', 'uint24', 'address'],
+                path: [inputToken.address, pool.fee, outputToken.address],
+            };
+        }
+        else {
+            return {
+                inputToken: outputToken,
+                types: [...types, 'uint24', 'address'],
+                path: [...path, pool.fee, outputToken.address],
+            };
+        }
+    }, { inputToken: firstInputToken, path: [], types: [] });
+    return exactOutput ? pack(types.reverse(), path.reverse()) : pack(types, path);
+}
+//# sourceMappingURL=encodeRouteToPath.js.map

package/dist/esm/src/utils/encodeRouteToPath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeRouteToPath.js","sourceRoot":"","sources":["../../../../src/utils/encodeRouteToPath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAK9C;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAgC,EAAE,WAAoB;IACtF,MAAM,eAAe,GAAU,KAAK,CAAC,KAAK,CAAC,OAAO,CAAA;IAElD,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CACxC,CACE,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAqE,EAC9F,IAAU,EACV,KAAK,EAC8D,EAAE;QACrE,MAAM,WAAW,GAAU,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAA;QACrF,IAAI,KAAK,KAAK,CAAC,EAAE;YACf,OAAO;gBACL,UAAU,EAAE,WAAW;gBACvB,KAAK,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC;gBACvC,IAAI,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,OAAO,CAAC;aAC1D,CAAA;SACF;aAAM;YACL,OAAO;gBACL,UAAU,EAAE,WAAW;gBACvB,KAAK,EAAE,CAAC,GAAG,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC;gBACtC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,WAAW,CAAC,OAAO,CAAC;aAC/C,CAAA;SACF;IACH,CAAC,EACD,EAAE,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CACrD,CAAA;IAED,OAAO,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;AAChF,CAAC"}

package/dist/esm/src/utils/encodeSqrtRatioX96.d.ts

@@ -0,0 +1,9 @@
+import JSBI from 'jsbi';
+import { BigintIsh } from '@centurion_project/sdk-core';
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
+ * @param amount1 The numerator amount i.e., the amount of token1
+ * @param amount0 The denominator amount i.e., the amount of token0
+ * @returns The sqrt ratio
+ */
+export declare function encodeSqrtRatioX96(amount1: BigintIsh, amount0: BigintIsh): JSBI;

package/dist/esm/src/utils/encodeSqrtRatioX96.js

@@ -0,0 +1,15 @@
+import JSBI from 'jsbi';
+import { sqrt } from '@centurion_project/sdk-core';
+/**
+ * Returns the sqrt ratio as a Q64.96 corresponding to a given ratio of amount1 and amount0
+ * @param amount1 The numerator amount i.e., the amount of token1
+ * @param amount0 The denominator amount i.e., the amount of token0
+ * @returns The sqrt ratio
+ */
+export function encodeSqrtRatioX96(amount1, amount0) {
+    const numerator = JSBI.leftShift(JSBI.BigInt(amount1), JSBI.BigInt(192));
+    const denominator = JSBI.BigInt(amount0);
+    const ratioX192 = JSBI.divide(numerator, denominator);
+    return sqrt(ratioX192);
+}
+//# sourceMappingURL=encodeSqrtRatioX96.js.map

package/dist/esm/src/utils/encodeSqrtRatioX96.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodeSqrtRatioX96.js","sourceRoot":"","sources":["../../../../src/utils/encodeSqrtRatioX96.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAa,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAE7D;;;;;GAKG;AAEH,MAAM,UAAU,kBAAkB,CAAC,OAAkB,EAAE,OAAkB;IACvE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;IACxE,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACxC,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,CAAA;IACrD,OAAO,IAAI,CAAC,SAAS,CAAC,CAAA;AACxB,CAAC"}

package/dist/esm/src/utils/fullMath.d.ts

@@ -0,0 +1,8 @@
+import JSBI from 'jsbi';
+export declare abstract class FullMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static mulDivRoundingUp(a: JSBI, b: JSBI, denominator: JSBI): JSBI;
+}

package/dist/esm/src/utils/fullMath.js

@@ -0,0 +1,16 @@
+import JSBI from 'jsbi';
+import { ONE, ZERO } from '../internalConstants';
+export class FullMath {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static mulDivRoundingUp(a, b, denominator) {
+        const product = JSBI.multiply(a, b);
+        let result = JSBI.divide(product, denominator);
+        if (JSBI.notEqual(JSBI.remainder(product, denominator), ZERO))
+            result = JSBI.add(result, ONE);
+        return result;
+    }
+}
+//# sourceMappingURL=fullMath.js.map

package/dist/esm/src/utils/fullMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fullMath.js","sourceRoot":"","sources":["../../../../src/utils/fullMath.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAEhD,MAAM,OAAgB,QAAQ;IAC5B;;OAEG;IACH,gBAAuB,CAAC;IAEjB,MAAM,CAAC,gBAAgB,CAAC,CAAO,EAAE,CAAO,EAAE,WAAiB;QAChE,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QACnC,IAAI,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,CAAA;QAC9C,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC,EAAE,IAAI,CAAC;YAAE,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAC7F,OAAO,MAAM,CAAA;IACf,CAAC;CACF"}

package/dist/esm/src/utils/index.d.ts

@@ -0,0 +1,18 @@
+export * from './calldata';
+export * from './computePoolAddress';
+export * from './encodeRouteToPath';
+export * from './encodeSqrtRatioX96';
+export * from './fullMath';
+export * from './isSorted';
+export * from './liquidityMath';
+export * from './maxLiquidityForAmounts';
+export * from './mostSignificantBit';
+export * from './nearestUsableTick';
+export * from './position';
+export * from './priceTickConversions';
+export * from './sqrtPriceMath';
+export * from './v3swap';
+export * from './swapMath';
+export * from './tickLibrary';
+export * from './tickList';
+export * from './tickMath';

package/dist/esm/src/utils/index.js

@@ -0,0 +1,19 @@
+export * from './calldata';
+export * from './computePoolAddress';
+export * from './encodeRouteToPath';
+export * from './encodeSqrtRatioX96';
+export * from './fullMath';
+export * from './isSorted';
+export * from './liquidityMath';
+export * from './maxLiquidityForAmounts';
+export * from './mostSignificantBit';
+export * from './nearestUsableTick';
+export * from './position';
+export * from './priceTickConversions';
+export * from './sqrtPriceMath';
+export * from './v3swap';
+export * from './swapMath';
+export * from './tickLibrary';
+export * from './tickList';
+export * from './tickMath';
+//# sourceMappingURL=index.js.map

package/dist/esm/src/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,sBAAsB,CAAA;AACpC,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,qBAAqB,CAAA;AACnC,cAAc,YAAY,CAAA;AAC1B,cAAc,wBAAwB,CAAA;AACtC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA"}

package/dist/esm/src/utils/isSorted.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
+ */
+export declare function isSorted<T>(list: Array<T>, comparator: (a: T, b: T) => number): boolean;

package/dist/esm/src/utils/isSorted.js

@@ -0,0 +1,15 @@
+/**
+ * Determines if a tick list is sorted
+ * @param list The tick list
+ * @param comparator The comparator
+ * @returns true if sorted
+ */
+export 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;
+}
+//# sourceMappingURL=isSorted.js.map

package/dist/esm/src/utils/isSorted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSorted.js","sourceRoot":"","sources":["../../../../src/utils/isSorted.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAI,IAAc,EAAE,UAAkC;IAC5E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QACxC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;YACxC,OAAO,KAAK,CAAA;SACb;KACF;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/esm/src/utils/liquidityMath.d.ts

@@ -0,0 +1,8 @@
+import JSBI from 'jsbi';
+export declare abstract class LiquidityMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static addDelta(x: JSBI, y: JSBI): JSBI;
+}

package/dist/esm/src/utils/liquidityMath.js

@@ -0,0 +1,17 @@
+import JSBI from 'jsbi';
+import { NEGATIVE_ONE, ZERO } from '../internalConstants';
+export class LiquidityMath {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static addDelta(x, y) {
+        if (JSBI.lessThan(y, ZERO)) {
+            return JSBI.subtract(x, JSBI.multiply(y, NEGATIVE_ONE));
+        }
+        else {
+            return JSBI.add(x, y);
+        }
+    }
+}
+//# sourceMappingURL=liquidityMath.js.map

package/dist/esm/src/utils/liquidityMath.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"liquidityMath.js","sourceRoot":"","sources":["../../../../src/utils/liquidityMath.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAEzD,MAAM,OAAgB,aAAa;IACjC;;OAEG;IACH,gBAAuB,CAAC;IAEjB,MAAM,CAAC,QAAQ,CAAC,CAAO,EAAE,CAAO;QACrC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE;YAC1B,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAA;SACxD;aAAM;YACL,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;SACtB;IACH,CAAC;CACF"}

package/dist/esm/src/utils/maxLiquidityForAmounts.d.ts

@@ -0,0 +1,14 @@
+import { BigintIsh } from '@centurion_project/sdk-core';
+import JSBI from 'jsbi';
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX96 the current price
+ * @param sqrtRatioAX96 price at lower boundary
+ * @param sqrtRatioBX96 price at upper boundary
+ * @param amount0 token0 amount
+ * @param amount1 token1 amount
+ * @param useFullPrecision if false, liquidity will be maximized according to what the router can calculate,
+ * not what core can theoretically support
+ */
+export declare function maxLiquidityForAmounts(sqrtRatioCurrentX96: JSBI, sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, amount0: BigintIsh, amount1: BigintIsh, useFullPrecision: boolean): JSBI;

package/dist/esm/src/utils/maxLiquidityForAmounts.js

@@ -0,0 +1,82 @@
+import JSBI from 'jsbi';
+import { Q96 } from '../internalConstants';
+/**
+ * Returns an imprecise maximum amount of liquidity received for a given amount of token 0.
+ * This function is available to accommodate LiquidityAmounts#getLiquidityForAmount0 in the v3 periphery,
+ * which could be more precise by at least 32 bits by dividing by Q64 instead of Q96 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 sqrtRatioAX96 The price at the lower boundary
+ * @param sqrtRatioBX96 The price at the upper boundary
+ * @param amount0 The token0 amount
+ * @returns liquidity for amount0, imprecise
+ */
+function maxLiquidityForAmount0Imprecise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
+    if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+        ;
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    const intermediate = JSBI.divide(JSBI.multiply(sqrtRatioAX96, sqrtRatioBX96), Q96);
+    return JSBI.divide(JSBI.multiply(JSBI.BigInt(amount0), intermediate), JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96));
+}
+/**
+ * Returns a precise maximum amount of liquidity received for a given amount of token 0 by dividing by Q64 instead of Q96 in the intermediate step,
+ * and shifting the subtracted ratio left by 32 bits.
+ * @param sqrtRatioAX96 The price at the lower boundary
+ * @param sqrtRatioBX96 The price at the upper boundary
+ * @param amount0 The token0 amount
+ * @returns liquidity for amount0, precise
+ */
+function maxLiquidityForAmount0Precise(sqrtRatioAX96, sqrtRatioBX96, amount0) {
+    if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+        ;
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    const numerator = JSBI.multiply(JSBI.multiply(JSBI.BigInt(amount0), sqrtRatioAX96), sqrtRatioBX96);
+    const denominator = JSBI.multiply(Q96, JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96));
+    return JSBI.divide(numerator, denominator);
+}
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token1
+ * @param sqrtRatioAX96 The price at the lower tick boundary
+ * @param sqrtRatioBX96 The price at the upper tick boundary
+ * @param amount1 The token1 amount
+ * @returns liquidity for amount1
+ */
+function maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1) {
+    if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+        ;
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    return JSBI.divide(JSBI.multiply(JSBI.BigInt(amount1), Q96), JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96));
+}
+/**
+ * Computes the maximum amount of liquidity received for a given amount of token0, token1,
+ * and the prices at the tick boundaries.
+ * @param sqrtRatioCurrentX96 the current price
+ * @param sqrtRatioAX96 price at lower boundary
+ * @param sqrtRatioBX96 price at upper boundary
+ * @param amount0 token0 amount
+ * @param amount1 token1 amount
+ * @param useFullPrecision if false, liquidity will be maximized according to what the router can calculate,
+ * not what core can theoretically support
+ */
+export function maxLiquidityForAmounts(sqrtRatioCurrentX96, sqrtRatioAX96, sqrtRatioBX96, amount0, amount1, useFullPrecision) {
+    if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+        ;
+        [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+    }
+    const maxLiquidityForAmount0 = useFullPrecision ? maxLiquidityForAmount0Precise : maxLiquidityForAmount0Imprecise;
+    if (JSBI.lessThanOrEqual(sqrtRatioCurrentX96, sqrtRatioAX96)) {
+        return maxLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
+    }
+    else if (JSBI.lessThan(sqrtRatioCurrentX96, sqrtRatioBX96)) {
+        const liquidity0 = maxLiquidityForAmount0(sqrtRatioCurrentX96, sqrtRatioBX96, amount0);
+        const liquidity1 = maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioCurrentX96, amount1);
+        return JSBI.lessThan(liquidity0, liquidity1) ? liquidity0 : liquidity1;
+    }
+    else {
+        return maxLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
+    }
+}
+//# sourceMappingURL=maxLiquidityForAmounts.js.map

package/dist/esm/src/utils/maxLiquidityForAmounts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maxLiquidityForAmounts.js","sourceRoot":"","sources":["../../../../src/utils/maxLiquidityForAmounts.ts"],"names":[],"mappings":"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"}

package/dist/esm/src/utils/mostSignificantBit.d.ts

@@ -0,0 +1,2 @@
+import JSBI from 'jsbi';
+export declare function mostSignificantBit(x: JSBI): number;

package/dist/esm/src/utils/mostSignificantBit.js

@@ -0,0 +1,22 @@
+import { MaxUint256 } from '@centurion_project/sdk-core';
+import JSBI from 'jsbi';
+import invariant from 'tiny-invariant';
+import { ZERO } from '../internalConstants';
+const TWO = JSBI.BigInt(2);
+const POWERS_OF_2 = [128, 64, 32, 16, 8, 4, 2, 1].map((pow) => [
+    pow,
+    JSBI.exponentiate(TWO, JSBI.BigInt(pow)),
+]);
+export function mostSignificantBit(x) {
+    invariant(JSBI.greaterThan(x, ZERO), 'ZERO');
+    invariant(JSBI.lessThanOrEqual(x, MaxUint256), 'MAX');
+    let msb = 0;
+    for (const [power, min] of POWERS_OF_2) {
+        if (JSBI.greaterThanOrEqual(x, min)) {
+            x = JSBI.signedRightShift(x, JSBI.BigInt(power));
+            msb += power;
+        }
+    }
+    return msb;
+}
+//# sourceMappingURL=mostSignificantBit.js.map

package/dist/esm/src/utils/mostSignificantBit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mostSignificantBit.js","sourceRoot":"","sources":["../../../../src/utils/mostSignificantBit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AACxD,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAE3C,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;AAC1B,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAW,EAAkB,EAAE,CAAC;IACrF,GAAG;IACH,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;CACzC,CAAC,CAAA;AAEF,MAAM,UAAU,kBAAkB,CAAC,CAAO;IACxC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAA;IAC5C,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,KAAK,CAAC,CAAA;IAErD,IAAI,GAAG,GAAW,CAAC,CAAA;IACnB,KAAK,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,WAAW,EAAE;QACtC,IAAI,IAAI,CAAC,kBAAkB,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE;YACnC,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YAChD,GAAG,IAAI,KAAK,CAAA;SACb;KACF;IACD,OAAO,GAAG,CAAA;AACZ,CAAC"}

package/dist/esm/src/utils/nearestUsableTick.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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
+ */
+export declare function nearestUsableTick(tick: number, tickSpacing: number): number;

package/dist/esm/src/utils/nearestUsableTick.js

@@ -0,0 +1,20 @@
+import invariant from 'tiny-invariant';
+import { TickMath } from './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
+ */
+export function nearestUsableTick(tick, tickSpacing) {
+    invariant(Number.isInteger(tick) && Number.isInteger(tickSpacing), 'INTEGERS');
+    invariant(tickSpacing > 0, 'TICK_SPACING');
+    invariant(tick >= TickMath.MIN_TICK && tick <= TickMath.MAX_TICK, 'TICK_BOUND');
+    const rounded = Math.round(tick / tickSpacing) * tickSpacing;
+    if (rounded < TickMath.MIN_TICK)
+        return rounded + tickSpacing;
+    else if (rounded > TickMath.MAX_TICK)
+        return rounded - tickSpacing;
+    else
+        return rounded;
+}
+//# sourceMappingURL=nearestUsableTick.js.map

package/dist/esm/src/utils/nearestUsableTick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearestUsableTick.js","sourceRoot":"","sources":["../../../../src/utils/nearestUsableTick.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY,EAAE,WAAmB;IACjE,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,UAAU,CAAC,CAAA;IAC9E,SAAS,CAAC,WAAW,GAAG,CAAC,EAAE,cAAc,CAAC,CAAA;IAC1C,SAAS,CAAC,IAAI,IAAI,QAAQ,CAAC,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAA;IAC/E,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,WAAW,CAAC,GAAG,WAAW,CAAA;IAC5D,IAAI,OAAO,GAAG,QAAQ,CAAC,QAAQ;QAAE,OAAO,OAAO,GAAG,WAAW,CAAA;SACxD,IAAI,OAAO,GAAG,QAAQ,CAAC,QAAQ;QAAE,OAAO,OAAO,GAAG,WAAW,CAAA;;QAC7D,OAAO,OAAO,CAAA;AACrB,CAAC"}

package/dist/esm/src/utils/position.d.ts

@@ -0,0 +1,8 @@
+import JSBI from 'jsbi';
+export declare abstract class PositionLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getTokensOwed(feeGrowthInside0LastX128: JSBI, feeGrowthInside1LastX128: JSBI, liquidity: JSBI, feeGrowthInside0X128: JSBI, feeGrowthInside1X128: JSBI): JSBI[];
+}

package/dist/esm/src/utils/position.js

@@ -0,0 +1,16 @@
+import JSBI from 'jsbi';
+import { subIn256 } from '.';
+const Q128 = JSBI.exponentiate(JSBI.BigInt(2), JSBI.BigInt(128));
+export class PositionLibrary {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    // replicates the portions of Position#update required to compute unaccounted fees
+    static getTokensOwed(feeGrowthInside0LastX128, feeGrowthInside1LastX128, liquidity, feeGrowthInside0X128, feeGrowthInside1X128) {
+        const tokensOwed0 = JSBI.divide(JSBI.multiply(subIn256(feeGrowthInside0X128, feeGrowthInside0LastX128), liquidity), Q128);
+        const tokensOwed1 = JSBI.divide(JSBI.multiply(subIn256(feeGrowthInside1X128, feeGrowthInside1LastX128), liquidity), Q128);
+        return [tokensOwed0, tokensOwed1];
+    }
+}
+//# sourceMappingURL=position.js.map

package/dist/esm/src/utils/position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.js","sourceRoot":"","sources":["../../../../src/utils/position.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAA;AAE5B,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;AAEhE,MAAM,OAAgB,eAAe;IACnC;;OAEG;IACH,gBAAuB,CAAC;IAExB,kFAAkF;IAC3E,MAAM,CAAC,aAAa,CACzB,wBAA8B,EAC9B,wBAA8B,EAC9B,SAAe,EACf,oBAA0B,EAC1B,oBAA0B;QAE1B,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAC7B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,oBAAoB,EAAE,wBAAwB,CAAC,EAAE,SAAS,CAAC,EAClF,IAAI,CACL,CAAA;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAC7B,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,oBAAoB,EAAE,wBAAwB,CAAC,EAAE,SAAS,CAAC,EAClF,IAAI,CACL,CAAA;QAED,OAAO,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;IACnC,CAAC;CACF"}

package/dist/esm/src/utils/priceTickConversions.d.ts

@@ -0,0 +1,15 @@
+import { Price, Token } from '@centurion_project/sdk-core';
+/**
+ * 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
+ */
+export declare function tickToPrice(baseToken: Token, quoteToken: Token, tick: number): Price<Token, Token>;
+/**
+ * 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
+ */
+export declare function priceToClosestTick(price: Price<Token, Token>): number;

package/dist/esm/src/utils/priceTickConversions.js

@@ -0,0 +1,44 @@
+import { Price } from '@centurion_project/sdk-core';
+import JSBI from 'jsbi';
+import { Q192 } from '../internalConstants';
+import { encodeSqrtRatioX96 } from './encodeSqrtRatioX96';
+import { TickMath } from './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
+ */
+export function tickToPrice(baseToken, quoteToken, tick) {
+    const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(tick);
+    const ratioX192 = JSBI.multiply(sqrtRatioX96, sqrtRatioX96);
+    return baseToken.sortsBefore(quoteToken)
+        ? new Price(baseToken, quoteToken, Q192, ratioX192)
+        : new Price(baseToken, quoteToken, ratioX192, Q192);
+}
+/**
+ * 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
+ */
+export function priceToClosestTick(price) {
+    const sorted = price.baseCurrency.sortsBefore(price.quoteCurrency);
+    const sqrtRatioX96 = sorted
+        ? encodeSqrtRatioX96(price.numerator, price.denominator)
+        : encodeSqrtRatioX96(price.denominator, price.numerator);
+    let tick = TickMath.getTickAtSqrtRatio(sqrtRatioX96);
+    const nextTickPrice = tickToPrice(price.baseCurrency, price.quoteCurrency, tick + 1);
+    if (sorted) {
+        if (!price.lessThan(nextTickPrice)) {
+            tick++;
+        }
+    }
+    else {
+        if (!price.greaterThan(nextTickPrice)) {
+            tick++;
+        }
+    }
+    return tick;
+}
+//# sourceMappingURL=priceTickConversions.js.map

package/dist/esm/src/utils/priceTickConversions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"priceTickConversions.js","sourceRoot":"","sources":["../../../../src/utils/priceTickConversions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAS,MAAM,6BAA6B,CAAA;AAC1D,OAAO,IAAI,MAAM,MAAM,CAAA;AACvB,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAC3C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CAAC,SAAgB,EAAE,UAAiB,EAAE,IAAY;IAC3E,MAAM,YAAY,GAAG,QAAQ,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAA;IAEtD,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC,CAAA;IAE3D,OAAO,SAAS,CAAC,WAAW,CAAC,UAAU,CAAC;QACtC,CAAC,CAAC,IAAI,KAAK,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,CAAC;QACnD,CAAC,CAAC,IAAI,KAAK,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,CAAA;AACvD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAA0B;IAC3D,MAAM,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,KAAK,CAAC,aAAa,CAAC,CAAA;IAElE,MAAM,YAAY,GAAG,MAAM;QACzB,CAAC,CAAC,kBAAkB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC;QACxD,CAAC,CAAC,kBAAkB,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;IAE1D,IAAI,IAAI,GAAG,QAAQ,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;IACpD,MAAM,aAAa,GAAG,WAAW,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,aAAa,EAAE,IAAI,GAAG,CAAC,CAAC,CAAA;IACpF,IAAI,MAAM,EAAE;QACV,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE;YAClC,IAAI,EAAE,CAAA;SACP;KACF;SAAM;QACL,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,aAAa,CAAC,EAAE;YACrC,IAAI,EAAE,CAAA;SACP;KACF;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/esm/src/utils/sqrtPriceMath.d.ts

@@ -0,0 +1,13 @@
+import JSBI from 'jsbi';
+export declare abstract class SqrtPriceMath {
+    /**
+     * Cannot be constructed.
+     */
+    private constructor();
+    static getAmount0Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getAmount1Delta(sqrtRatioAX96: JSBI, sqrtRatioBX96: JSBI, liquidity: JSBI, roundUp: boolean): JSBI;
+    static getNextSqrtPriceFromInput(sqrtPX96: JSBI, liquidity: JSBI, amountIn: JSBI, zeroForOne: boolean): JSBI;
+    static getNextSqrtPriceFromOutput(sqrtPX96: JSBI, liquidity: JSBI, amountOut: JSBI, zeroForOne: boolean): JSBI;
+    private static getNextSqrtPriceFromAmount0RoundingUp;
+    private static getNextSqrtPriceFromAmount1RoundingDown;
+}

package/dist/esm/src/utils/sqrtPriceMath.js

@@ -0,0 +1,90 @@
+import { MaxUint256 } from '@centurion_project/sdk-core';
+import JSBI from 'jsbi';
+import invariant from 'tiny-invariant';
+import { ONE, ZERO, Q96 } from '../internalConstants';
+import { FullMath } from './fullMath';
+const MaxUint160 = JSBI.subtract(JSBI.exponentiate(JSBI.BigInt(2), JSBI.BigInt(160)), ONE);
+function multiplyIn256(x, y) {
+    const product = JSBI.multiply(x, y);
+    return JSBI.bitwiseAnd(product, MaxUint256);
+}
+function addIn256(x, y) {
+    const sum = JSBI.add(x, y);
+    return JSBI.bitwiseAnd(sum, MaxUint256);
+}
+export class SqrtPriceMath {
+    /**
+     * Cannot be constructed.
+     */
+    constructor() { }
+    static getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
+        if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+            ;
+            [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+        }
+        const numerator1 = JSBI.leftShift(liquidity, JSBI.BigInt(96));
+        const numerator2 = JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96);
+        return roundUp
+            ? FullMath.mulDivRoundingUp(FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96), ONE, sqrtRatioAX96)
+            : JSBI.divide(JSBI.divide(JSBI.multiply(numerator1, numerator2), sqrtRatioBX96), sqrtRatioAX96);
+    }
+    static getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, liquidity, roundUp) {
+        if (JSBI.greaterThan(sqrtRatioAX96, sqrtRatioBX96)) {
+            ;
+            [sqrtRatioAX96, sqrtRatioBX96] = [sqrtRatioBX96, sqrtRatioAX96];
+        }
+        return roundUp
+            ? FullMath.mulDivRoundingUp(liquidity, JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96), Q96)
+            : JSBI.divide(JSBI.multiply(liquidity, JSBI.subtract(sqrtRatioBX96, sqrtRatioAX96)), Q96);
+    }
+    static getNextSqrtPriceFromInput(sqrtPX96, liquidity, amountIn, zeroForOne) {
+        invariant(JSBI.greaterThan(sqrtPX96, ZERO));
+        invariant(JSBI.greaterThan(liquidity, ZERO));
+        return zeroForOne
+            ? this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true)
+            : this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountIn, true);
+    }
+    static getNextSqrtPriceFromOutput(sqrtPX96, liquidity, amountOut, zeroForOne) {
+        invariant(JSBI.greaterThan(sqrtPX96, ZERO));
+        invariant(JSBI.greaterThan(liquidity, ZERO));
+        return zeroForOne
+            ? this.getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountOut, false)
+            : this.getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountOut, false);
+    }
+    static getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amount, add) {
+        if (JSBI.equal(amount, ZERO))
+            return sqrtPX96;
+        const numerator1 = JSBI.leftShift(liquidity, JSBI.BigInt(96));
+        if (add) {
+            let product = multiplyIn256(amount, sqrtPX96);
+            if (JSBI.equal(JSBI.divide(product, amount), sqrtPX96)) {
+                const denominator = addIn256(numerator1, product);
+                if (JSBI.greaterThanOrEqual(denominator, numerator1)) {
+                    return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator);
+                }
+            }
+            return FullMath.mulDivRoundingUp(numerator1, ONE, JSBI.add(JSBI.divide(numerator1, sqrtPX96), amount));
+        }
+        else {
+            let product = multiplyIn256(amount, sqrtPX96);
+            invariant(JSBI.equal(JSBI.divide(product, amount), sqrtPX96));
+            invariant(JSBI.greaterThan(numerator1, product));
+            const denominator = JSBI.subtract(numerator1, product);
+            return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator);
+        }
+    }
+    static getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amount, add) {
+        if (add) {
+            const quotient = JSBI.lessThanOrEqual(amount, MaxUint160)
+                ? JSBI.divide(JSBI.leftShift(amount, JSBI.BigInt(96)), liquidity)
+                : JSBI.divide(JSBI.multiply(amount, Q96), liquidity);
+            return JSBI.add(sqrtPX96, quotient);
+        }
+        else {
+            const quotient = FullMath.mulDivRoundingUp(amount, Q96, liquidity);
+            invariant(JSBI.greaterThan(sqrtPX96, quotient));
+            return JSBI.subtract(sqrtPX96, quotient);
+        }
+    }
+}
+//# sourceMappingURL=sqrtPriceMath.js.map