@orca-so/whirlpools-core 2.0.0 → 3.1.0

package/dist/nodejs/orca_whirlpools_core_js_bindings.js

@@ -192,230 +192,441 @@ function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
+
+module.exports._TICK_ARRAY_SIZE = function() {
+    const ret = wasm._TICK_ARRAY_SIZE();
+    return ret >>> 0;
+};
+
+module.exports._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD = function() {
+    const ret = wasm._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD();
+    return ret;
+};
+
+module.exports._MIN_TICK_INDEX = function() {
+    const ret = wasm._MIN_TICK_INDEX();
+    return ret;
+};
+
+module.exports._MAX_TICK_INDEX = function() {
+    const ret = wasm._MAX_TICK_INDEX();
+    return ret;
+};
+
 /**
- * Check if the whirlpool is initialized with adaptive fee
+ * Convert a price into a sqrt priceX64
+ * IMPORTANT: floating point operations can reduce the precision of the result.
+ * Make sure to do these operations last and not to use the result for further calculations.
  *
- * # Paramters
- * - `whirlpool`: The whirlpool state
+ * # Parameters
+ * * `price` - The price to convert
+ * * `decimals_a` - The number of decimals of the base token
+ * * `decimals_b` - The number of decimals of the quote token
  *
  * # Returns
- * - A boolean value indicating if the whirlpool is initialized with adaptive fee
+ * * `u128` - The sqrt priceX64
  */
-module.exports.isInitializedWithAdaptiveFee = function(whirlpool) {
-    const ret = wasm.isInitializedWithAdaptiveFee(addHeapObject(whirlpool));
+module.exports.priceToSqrtPrice = function(price, decimals_a, decimals_b) {
+    const ret = wasm.priceToSqrtPrice(price, decimals_a, decimals_b);
+    return takeObject(ret);
+};
+
+/**
+ * Convert a sqrt priceX64 into a tick index
+ * IMPORTANT: floating point operations can reduce the precision of the result.
+ * Make sure to do these operations last and not to use the result for further calculations.
+ *
+ * # Parameters
+ * * `sqrt_price` - The sqrt priceX64 to convert
+ * * `decimals_a` - The number of decimals of the base token
+ * * `decimals_b` - The number of decimals of the quote token
+ *
+ * # Returns
+ * * `f64` - The decimal price
+ */
+module.exports.sqrtPriceToPrice = function(sqrt_price, decimals_a, decimals_b) {
+    const ret = wasm.sqrtPriceToPrice(addHeapObject(sqrt_price), decimals_a, decimals_b);
+    return ret;
+};
+
+/**
+ * Invert a price
+ * IMPORTANT: floating point operations can reduce the precision of the result.
+ * Make sure to do these operations last and not to use the result for further calculations.
+ *
+ * # Parameters
+ * * `price` - The price to invert
+ * * `decimals_a` - The number of decimals of the base token
+ * * `decimals_b` - The number of decimals of the quote token
+ *
+ * # Returns
+ * * `f64` - The inverted price
+ */
+module.exports.invertPrice = function(price, decimals_a, decimals_b) {
+    const ret = wasm.invertPrice(price, decimals_a, decimals_b);
+    return ret;
+};
+
+/**
+ * Convert a tick index into a price
+ * IMPORTANT: floating point operations can reduce the precision of the result.
+ * Make sure to do these operations last and not to use the result for further calculations.
+ *
+ * # Parameters
+ * * `tick_index` - The tick index to convert
+ * * `decimals_a` - The number of decimals of the base token
+ * * `decimals_b` - The number of decimals of the quote token
+ *
+ * # Returns
+ * * `f64` - The decimal price
+ */
+module.exports.tickIndexToPrice = function(tick_index, decimals_a, decimals_b) {
+    const ret = wasm.tickIndexToPrice(tick_index, decimals_a, decimals_b);
+    return ret;
+};
+
+/**
+ * Convert a price into a tick index
+ * IMPORTANT: floating point operations can reduce the precision of the result.
+ * Make sure to do these operations last and not to use the result for further calculations.
+ *
+ * # Parameters
+ * * `price` - The price to convert
+ * * `decimals_a` - The number of decimals of the base token
+ * * `decimals_b` - The number of decimals of the quote token
+ *
+ * # Returns
+ * * `i32` - The tick index
+ */
+module.exports.priceToTickIndex = function(price, decimals_a, decimals_b) {
+    const ret = wasm.priceToTickIndex(price, decimals_a, decimals_b);
+    return ret;
+};
+
+/**
+ * Computes min/max sqrt-price bounds for slippage protection.
+ *
+ * Cap: `slippage_tolerance_bps` is clamped to BPS_DENOMINATOR (10_000) so the radicands
+ * `(10000 ± bps)` stay non-negative and we never take sqrt of a negative.
+ *
+ * # Parameters
+ * * `sqrt_price` - The current sqrt priceX64
+ * * `slippage_tolerance_bps` - The slippage tolerance in basis points
+ *
+ * # Returns
+ * * `SqrtPriceSlippageBounds` - The min and max sqrt price bounds
+ */
+module.exports.getSqrtPriceSlippageBounds = function(sqrt_price, slippage_tolerance_bps) {
+    const ret = wasm.getSqrtPriceSlippageBounds(addHeapObject(sqrt_price), slippage_tolerance_bps);
+    return takeObject(ret);
+};
+
+module.exports._POSITION_BUNDLE_SIZE = function() {
+    const ret = wasm._POSITION_BUNDLE_SIZE();
+    return ret >>> 0;
+};
+
+module.exports._FEE_RATE_DENOMINATOR = function() {
+    const ret = wasm._FEE_RATE_DENOMINATOR();
+    return ret >>> 0;
+};
+
+/**
+ * Check if a position is in range.
+ * When a position is in range it is earning fees and rewards
+ *
+ * # Parameters
+ * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
+ * - `tick_index_1` - A i32 integer representing the first tick index of the position
+ * - `tick_index_2` - A i32 integer representing the second tick index of the position
+ *
+ * # Returns
+ * - A boolean value indicating if the position is in range
+ */
+module.exports.isPositionInRange = function(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.isPositionInRange(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
     return ret !== 0;
 };
 
 /**
- * Calculate the amount A delta between two sqrt_prices
+ * Calculate the status of a position
+ * The status can be one of three values:
+ * - InRange: The position is in range
+ * - BelowRange: The position is below the range
+ * - AboveRange: The position is above the range
  *
  * # Parameters
- * - `sqrt_price_1`: The first square root price
- * - `sqrt_price_2`: The second square root price
- * - `liquidity`: The liquidity
- * - `round_up`: Whether to round up or not
+ * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
+ * - `tick_index_1` - A i32 integer representing the first tick index of the position
+ * - `tick_index_2` - A i32 integer representing the second tick index of the position
  *
  * # Returns
- * - `u64`: The amount delta
+ * - A PositionStatus enum value indicating the status of the position
  */
-module.exports.tryGetAmountDeltaA = function(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetAmountDeltaA(retptr, addHeapObject(sqrt_price_1), addHeapObject(sqrt_price_2), addHeapObject(liquidity), round_up);
-        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        if (r3) {
-            throw takeObject(r2);
-        }
-        return BigInt.asUintN(64, r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+module.exports.positionStatus = function(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.positionStatus(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
+    return takeObject(ret);
 };
 
 /**
- * Calculate the amount B delta between two sqrt_prices
+ * Calculate the token_a / token_b ratio of a (ficticious) position
  *
  * # Parameters
- * - `sqrt_price_1`: The first square root price
- * - `sqrt_price_2`: The second square root price
- * - `liquidity`: The liquidity
- * - `round_up`: Whether to round up or not
+ * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
+ * - `tick_index_1` - A i32 integer representing the first tick index of the position
+ * - `tick_index_2` - A i32 integer representing the second tick index of the position
  *
  * # Returns
- * - `u64`: The amount delta
+ * - A PositionRatio struct containing the ratio of token_a and token_b
  */
-module.exports.tryGetAmountDeltaB = function(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetAmountDeltaB(retptr, addHeapObject(sqrt_price_1), addHeapObject(sqrt_price_2), addHeapObject(liquidity), round_up);
-        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        if (r3) {
-            throw takeObject(r2);
-        }
-        return BigInt.asUintN(64, r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+module.exports.positionRatio = function(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.positionRatio(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
+    return takeObject(ret);
 };
 
 /**
- * Calculate the next square root price
+ * Get the first tick index in the tick array that contains the specified tick index.
  *
  * # Parameters
- * - `current_sqrt_price`: The current square root price
- * - `current_liquidity`: The current liquidity
- * - `amount`: The amount
- * - `specified_input`: Whether the input is specified
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
  *
  * # Returns
- * - `u128`: The next square root price
+ * - A i32 integer representing the first tick index in the tick array
  */
-module.exports.tryGetNextSqrtPriceFromA = function(current_sqrt_price, current_liquidity, amount, specified_input) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetNextSqrtPriceFromA(retptr, addHeapObject(current_sqrt_price), addHeapObject(current_liquidity), amount, specified_input);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+module.exports.getTickArrayStartTickIndex = function(tick_index, tick_spacing) {
+    const ret = wasm.getTickArrayStartTickIndex(tick_index, tick_spacing);
+    return ret;
 };
 
 /**
- * Calculate the next square root price
+ * Derive the sqrt-price from a tick index. The precision of this method is only guarranted
+ * if tick is within the bounds of {max, min} tick-index.
  *
  * # Parameters
- * - `current_sqrt_price`: The current square root price
- * - `current_liquidity`: The current liquidity
- * - `amount`: The amount
- * - `specified_input`: Whether the input is specified
+ * - `tick_index` - A i32 integer representing the tick integer
  *
  * # Returns
- * - `u128`: The next square root price
+ * - `Ok`: A u128 Q32.64 representing the sqrt_price
  */
-module.exports.tryGetNextSqrtPriceFromB = function(current_sqrt_price, current_liquidity, amount, specified_input) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetNextSqrtPriceFromB(retptr, addHeapObject(current_sqrt_price), addHeapObject(current_liquidity), amount, specified_input);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+module.exports.tickIndexToSqrtPrice = function(tick_index) {
+    const ret = wasm.tickIndexToSqrtPrice(tick_index);
+    return takeObject(ret);
+};
+
+/**
+ * Derive the tick index from a sqrt price. The precision of this method is only guarranted
+ * if tick is within the bounds of {max, min} tick-index.
+ * This function will make panic for zero sqrt price.
+ *
+ * # Parameters
+ * - `sqrt_price` - A u128 integer representing the sqrt price
+ *
+ * # Returns
+ * - `Ok`: A i32 integer representing the tick integer
+ */
+module.exports.sqrtPriceToTickIndex = function(sqrt_price) {
+    const ret = wasm.sqrtPriceToTickIndex(addHeapObject(sqrt_price));
+    return ret;
+};
+
+/**
+ * Get the initializable tick index.
+ * If the tick index is already initializable, it is returned as is.
+ *
+ * # Parameters
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
+ * - `round_up` - A boolean value indicating if the supplied tick index should be rounded up. None will round to the nearest.
+ *
+ * # Returns
+ * - A i32 representing the initializable tick index (rounded per round_up or nearest).
+ */
+module.exports.getInitializableTickIndex = function(tick_index, tick_spacing, round_up) {
+    const ret = wasm.getInitializableTickIndex(tick_index, tick_spacing, isLikeNone(round_up) ? 0xFFFFFF : round_up ? 1 : 0);
+    return ret;
+};
+
+/**
+ * Get the previous initializable tick index.
+ *
+ * # Parameters
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
+ *
+ * # Returns
+ * - A i32 integer representing the previous initializable tick index
+ */
+module.exports.getPrevInitializableTickIndex = function(tick_index, tick_spacing) {
+    const ret = wasm.getPrevInitializableTickIndex(tick_index, tick_spacing);
+    return ret;
+};
+
+/**
+ * Get the next initializable tick index.
+ *
+ * # Parameters
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
+ *
+ * # Returns
+ * - A i32 integer representing the next initializable tick index
+ */
+module.exports.getNextInitializableTickIndex = function(tick_index, tick_spacing) {
+    const ret = wasm.getNextInitializableTickIndex(tick_index, tick_spacing);
+    return ret;
+};
+
+/**
+ * Check if a tick is in-bounds.
+ *
+ * # Parameters
+ * - `tick_index` - A i32 integer representing the tick integer
+ *
+ * # Returns
+ * - A boolean value indicating if the tick is in-bounds
+ */
+module.exports.isTickIndexInBounds = function(tick_index) {
+    const ret = wasm.isTickIndexInBounds(tick_index);
+    return ret !== 0;
+};
+
+/**
+ * Check if a tick is initializable.
+ * A tick is initializable if it is divisible by the tick spacing.
+ *
+ * # Parameters
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
+ *
+ * # Returns
+ * - A boolean value indicating if the tick is initializable
+ */
+module.exports.isTickInitializable = function(tick_index, tick_spacing) {
+    const ret = wasm.isTickInitializable(tick_index, tick_spacing);
+    return ret !== 0;
+};
+
+/**
+ * Get the tick index for the inverse of the price that this tick represents.
+ * Eg: Consider tick i where Pb/Pa = 1.0001 ^ i
+ * inverse of this, i.e. Pa/Pb = 1 / (1.0001 ^ i) = 1.0001^-i
+ *
+ * # Parameters
+ * - `tick_index` - A i32 integer representing the tick integer
+ *
+ * # Returns
+ * - A i32 integer representing the tick index for the inverse of the price
+ */
+module.exports.invertTickIndex = function(tick_index) {
+    const ret = wasm.invertTickIndex(tick_index);
+    return ret;
+};
+
+/**
+ * Get the sqrt price for the inverse of the price that this tick represents.
+ * Because converting to a tick index and then back to a sqrt price is lossy,
+ * this function is clamped to the nearest tick index.
+ *
+ * # Parameters
+ * - `sqrt_price` - A u128 integer representing the sqrt price
+ *
+ * # Returns
+ * - A u128 integer representing the sqrt price for the inverse of the price
+ */
+module.exports.invertSqrtPrice = function(sqrt_price) {
+    const ret = wasm.invertSqrtPrice(addHeapObject(sqrt_price));
+    return takeObject(ret);
+};
+
+/**
+ * Get the minimum and maximum tick index that can be initialized.
+ *
+ * # Parameters
+ * - `tick_spacing` - A i32 integer representing the tick spacing
+ *
+ * # Returns
+ * - A TickRange struct containing the lower and upper tick index
+ */
+module.exports.getFullRangeTickIndexes = function(tick_spacing) {
+    const ret = wasm.getFullRangeTickIndexes(tick_spacing);
+    return takeObject(ret);
 };
 
 /**
- * Apply a transfer fee to an amount
- * e.g. You send 10000 amount with 100 fee rate. The fee amount will be 100.
- * So the amount after fee will be 9900.
+ * Order tick indexes in ascending order.
+ * If the lower tick index is greater than the upper tick index, the indexes are swapped.
+ * This is useful for ensuring that the lower tick index is always less than the upper tick index.
  *
  * # Parameters
- * - `amount`: The amount to apply the fee to
- * - `transfer_fee`: The transfer fee to apply
+ * - `tick_index_1` - A i32 integer representing the first tick index
+ * - `tick_index_2` - A i32 integer representing the second tick index
  *
  * # Returns
- * - `u64`: The amount after the fee has been applied
+ * - A TickRange struct containing the lower and upper tick index
  */
-module.exports.tryApplyTransferFee = function(amount, transfer_fee) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
-        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        if (r3) {
-            throw takeObject(r2);
-        }
-        return BigInt.asUintN(64, r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+module.exports.orderTickIndexes = function(tick_index_1, tick_index_2) {
+    const ret = wasm.orderTickIndexes(tick_index_1, tick_index_2);
+    return takeObject(ret);
 };
 
 /**
- * Reverse the application of a transfer fee to an amount
- * e.g. You received 9900 amount with 100 fee rate. The fee amount will be 100.
- * So the amount before fee will be 10000.
+ * Check if a whirlpool is a full-range only pool.
  *
  * # Parameters
- * - `amount`: The amount to reverse the fee from
- * - `transfer_fee`: The transfer fee to reverse
+ * - `tick_spacing` - A u16 integer representing the tick spacing
  *
  * # Returns
- * - `u64`: The amount before the fee has been applied
+ * - A boolean value indicating if the whirlpool is a full-range only pool
  */
-module.exports.tryReverseApplyTransferFee = function(amount, transfer_fee) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryReverseApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
-        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        if (r3) {
-            throw takeObject(r2);
-        }
-        return BigInt.asUintN(64, r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+module.exports.isFullRangeOnly = function(tick_spacing) {
+    const ret = wasm.isFullRangeOnly(tick_spacing);
+    return ret !== 0;
 };
 
 /**
- * Get the maximum amount with a slippage tolerance
- * e.g. Your estimated amount you send is 10000 with 100 slippage tolerance. The max you send will be 10100.
+ * Get the index of a tick in a tick array.
  *
  * # Parameters
- * - `amount`: The amount to apply the fee to
- * - `slippage_tolerance_bps`: The slippage tolerance in bps (should be in range 0..BPS_DENOMINATOR)
+ * - `tick_index` - A i32 integer representing the tick index
+ * - `tick_array_start_index` - A i32 integer representing the start tick index of the tick array
+ * - `tick_spacing` - A u16 integer representing the tick spacing
  *
  * # Returns
- * - `u64`: The maximum amount
+ * - A u32 integer representing the tick index in the tick array
  */
-module.exports.tryGetMaxAmountWithSlippageTolerance = function(amount, slippage_tolerance_bps) {
+module.exports.getTickIndexInArray = function(tick_index, tick_array_start_index, tick_spacing) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetMaxAmountWithSlippageTolerance(retptr, amount, slippage_tolerance_bps);
-        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        wasm.getTickIndexInArray(retptr, tick_index, tick_array_start_index, tick_spacing);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        if (r3) {
-            throw takeObject(r2);
+        if (r2) {
+            throw takeObject(r1);
         }
-        return BigInt.asUintN(64, r0);
+        return r0 >>> 0;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 };
 
 /**
- * Get the minimum amount with a slippage tolerance
- * e.g. Your estimated amount you receive is 10000 with 100 slippage tolerance. The min amount you receive will be 9900.
+ * Calculate the amount A delta between two sqrt_prices
  *
  * # Parameters
- * - `amount`: The amount to apply the fee to
- * - `slippage_tolerance_bps`: The slippage tolerance in bps (should be in range 0..BPS_DENOMINATOR)
+ * - `sqrt_price_1`: The first square root price
+ * - `sqrt_price_2`: The second square root price
+ * - `liquidity`: The liquidity
+ * - `round_up`: Whether to round up or not
  *
  * # Returns
- * - `u64`: The minimum amount
+ * - `u64`: The amount delta
  */
-module.exports.tryGetMinAmountWithSlippageTolerance = function(amount, slippage_tolerance_bps) {
+module.exports.tryGetAmountDeltaA = function(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetMinAmountWithSlippageTolerance(retptr, amount, slippage_tolerance_bps);
+        wasm.tryGetAmountDeltaA(retptr, addHeapObject(sqrt_price_1), addHeapObject(sqrt_price_2), addHeapObject(liquidity), round_up);
         var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
         var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
@@ -429,21 +640,21 @@ module.exports.tryGetMinAmountWithSlippageTolerance = function(amount, slippage_
 };
 
 /**
- * Apply a swap fee to an amount
- * e.g. You send 10000 amount with 10000 fee rate. The fee amount will be 100.
- * So the amount after fee will be 9900.
+ * Calculate the amount B delta between two sqrt_prices
  *
  * # Parameters
- * - `amount`: The amount to apply the fee to
- * - `fee_rate`: The fee rate to apply denominated in 1e6
+ * - `sqrt_price_1`: The first square root price
+ * - `sqrt_price_2`: The second square root price
+ * - `liquidity`: The liquidity
+ * - `round_up`: Whether to round up or not
  *
  * # Returns
- * - `u64`: The amount after the fee has been applied
+ * - `u64`: The amount delta
  */
-module.exports.tryApplySwapFee = function(amount, fee_rate) {
+module.exports.tryGetAmountDeltaB = function(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryApplySwapFee(retptr, amount, fee_rate);
+        wasm.tryGetAmountDeltaB(retptr, addHeapObject(sqrt_price_1), addHeapObject(sqrt_price_2), addHeapObject(liquidity), round_up);
         var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
         var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
@@ -457,53 +668,49 @@ module.exports.tryApplySwapFee = function(amount, fee_rate) {
 };
 
 /**
- * Reverse the application of a swap fee to an amount
- * e.g. You received 9900 amount with 10000 fee rate. The fee amount will be 100.
- * So the amount before fee will be 10000.
+ * Calculate the next square root price
  *
  * # Parameters
- * - `amount`: The amount to reverse the fee from
- * - `fee_rate`: The fee rate to reverse denominated in 1e6
+ * - `current_sqrt_price`: The current square root price
+ * - `current_liquidity`: The current liquidity
+ * - `amount`: The amount
+ * - `specified_input`: Whether the input is specified
  *
  * # Returns
- * - `u64`: The amount before the fee has been applied
+ * - `u128`: The next square root price
  */
-module.exports.tryReverseApplySwapFee = function(amount, fee_rate) {
+module.exports.tryGetNextSqrtPriceFromA = function(current_sqrt_price, current_liquidity, amount, specified_input) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryReverseApplySwapFee(retptr, amount, fee_rate);
-        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        wasm.tryGetNextSqrtPriceFromA(retptr, addHeapObject(current_sqrt_price), addHeapObject(current_liquidity), amount, specified_input);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-        if (r3) {
-            throw takeObject(r2);
+        if (r2) {
+            throw takeObject(r1);
         }
-        return BigInt.asUintN(64, r0);
+        return takeObject(r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 };
 
 /**
- * Calculate rewards owed for a position
+ * Calculate the next square root price
  *
- * # Paramters
- * - `whirlpool`: The whirlpool state
- * - `position`: The position state
- * - `tick_lower`: The lower tick state
- * - `tick_upper`: The upper tick state
- * - `current_timestamp`: The current timestamp
- * - `transfer_fee_1`: The transfer fee for token 1
- * - `transfer_fee_2`: The transfer fee for token 2
- * - `transfer_fee_3`: The transfer fee for token 3
+ * # Parameters
+ * - `current_sqrt_price`: The current square root price
+ * - `current_liquidity`: The current liquidity
+ * - `amount`: The amount
+ * - `specified_input`: Whether the input is specified
  *
  * # Returns
- * - `CollectRewardsQuote`: The rewards owed for the 3 reward tokens.
+ * - `u128`: The next square root price
  */
-module.exports.collectRewardsQuote = function(whirlpool, position, tick_lower, tick_upper, current_timestamp, transfer_fee_1, transfer_fee_2, transfer_fee_3) {
+module.exports.tryGetNextSqrtPriceFromB = function(current_sqrt_price, current_liquidity, amount, specified_input) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.collectRewardsQuote(retptr, addHeapObject(whirlpool), addHeapObject(position), addHeapObject(tick_lower), addHeapObject(tick_upper), current_timestamp, isLikeNone(transfer_fee_1) ? 0 : addHeapObject(transfer_fee_1), isLikeNone(transfer_fee_2) ? 0 : addHeapObject(transfer_fee_2), isLikeNone(transfer_fee_3) ? 0 : addHeapObject(transfer_fee_3));
+        wasm.tryGetNextSqrtPriceFromB(retptr, addHeapObject(current_sqrt_price), addHeapObject(current_liquidity), amount, specified_input);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -516,285 +723,306 @@ module.exports.collectRewardsQuote = function(whirlpool, position, tick_lower, t
     }
 };
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-/**
- * Get the first unoccupied position in a bundle
- *
- * # Arguments
- * * `bundle` - The bundle to check
- *
- * # Returns
- * * `u32` - The first unoccupied position (None if full)
- */
-module.exports.firstUnoccupiedPositionInBundle = function(bitmap) {
-    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export_0);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.firstUnoccupiedPositionInBundle(ptr0, len0);
-    return ret === 0x100000001 ? undefined : ret;
-};
-
-/**
- * Check whether a position bundle is full
- * A position bundle can contain 256 positions
- *
- * # Arguments
- * * `bundle` - The bundle to check
- *
- * # Returns
- * * `bool` - Whether the bundle is full
- */
-module.exports.isPositionBundleFull = function(bitmap) {
-    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export_0);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.isPositionBundleFull(ptr0, len0);
-    return ret !== 0;
-};
-
-/**
- * Check whether a position bundle is empty
- *
- * # Arguments
- * * `bundle` - The bundle to check
- *
- * # Returns
- * * `bool` - Whether the bundle is empty
- */
-module.exports.isPositionBundleEmpty = function(bitmap) {
-    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export_0);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.isPositionBundleEmpty(ptr0, len0);
-    return ret !== 0;
-};
-
-/**
- * Get the first tick index in the tick array that contains the specified tick index.
- *
- * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
- *
- * # Returns
- * - A i32 integer representing the first tick index in the tick array
- */
-module.exports.getTickArrayStartTickIndex = function(tick_index, tick_spacing) {
-    const ret = wasm.getTickArrayStartTickIndex(tick_index, tick_spacing);
-    return ret;
-};
-
 /**
- * Derive the sqrt-price from a tick index. The precision of this method is only guarranted
- * if tick is within the bounds of {max, min} tick-index.
+ * Apply a transfer fee to an amount
+ * e.g. You send 10000 amount with 100 fee rate. The fee amount will be 100.
+ * So the amount after fee will be 9900.
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
+ * - `amount`: The amount to apply the fee to
+ * - `transfer_fee`: The transfer fee to apply
  *
  * # Returns
- * - `Ok`: A u128 Q32.64 representing the sqrt_price
+ * - `u64`: The amount after the fee has been applied
  */
-module.exports.tickIndexToSqrtPrice = function(tick_index) {
-    const ret = wasm.tickIndexToSqrtPrice(tick_index);
-    return takeObject(ret);
+module.exports.tryApplyTransferFee = function(amount, transfer_fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
 /**
- * Derive the tick index from a sqrt price. The precision of this method is only guarranted
- * if tick is within the bounds of {max, min} tick-index.
+ * Reverse the application of a transfer fee to an amount
+ * e.g. You received 9900 amount with 100 fee rate. The fee amount will be 100.
+ * So the amount before fee will be 10000.
  *
  * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price
+ * - `amount`: The amount to reverse the fee from
+ * - `transfer_fee`: The transfer fee to reverse
  *
  * # Returns
- * - `Ok`: A i32 integer representing the tick integer
+ * - `u64`: The amount before the fee has been applied
  */
-module.exports.sqrtPriceToTickIndex = function(sqrt_price) {
-    const ret = wasm.sqrtPriceToTickIndex(addHeapObject(sqrt_price));
-    return ret;
+module.exports.tryReverseApplyTransferFee = function(amount, transfer_fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryReverseApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
 /**
- * Get the initializable tick index.
- * If the tick index is already initializable, it is returned as is.
+ * Get the maximum amount with a slippage tolerance
+ * e.g. Your estimated amount you send is 10000 with 100 slippage tolerance. The max you send will be 10100.
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
- * - `round_up` - A boolean value indicating if the supplied tick index should be rounded up. None will round to the nearest.
+ * - `amount`: The amount to apply the fee to
+ * - `slippage_tolerance_bps`: The slippage tolerance in bps (should be in range 0..BPS_DENOMINATOR)
  *
  * # Returns
- * - A i32 integer representing the previous initializable tick index
+ * - `u64`: The maximum amount
  */
-module.exports.getInitializableTickIndex = function(tick_index, tick_spacing, round_up) {
-    const ret = wasm.getInitializableTickIndex(tick_index, tick_spacing, isLikeNone(round_up) ? 0xFFFFFF : round_up ? 1 : 0);
-    return ret;
+module.exports.tryGetMaxAmountWithSlippageTolerance = function(amount, slippage_tolerance_bps) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetMaxAmountWithSlippageTolerance(retptr, amount, slippage_tolerance_bps);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
 /**
- * Get the previous initializable tick index.
+ * Get the minimum amount with a slippage tolerance
+ * e.g. Your estimated amount you receive is 10000 with 100 slippage tolerance. The min amount you receive will be 9900.
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * - `amount`: The amount to apply the fee to
+ * - `slippage_tolerance_bps`: The slippage tolerance in bps (should be in range 0..BPS_DENOMINATOR)
  *
  * # Returns
- * - A i32 integer representing the previous initializable tick index
+ * - `u64`: The minimum amount
  */
-module.exports.getPrevInitializableTickIndex = function(tick_index, tick_spacing) {
-    const ret = wasm.getPrevInitializableTickIndex(tick_index, tick_spacing);
-    return ret;
+module.exports.tryGetMinAmountWithSlippageTolerance = function(amount, slippage_tolerance_bps) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetMinAmountWithSlippageTolerance(retptr, amount, slippage_tolerance_bps);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
 /**
- * Get the next initializable tick index.
+ * Apply a swap fee to an amount
+ * e.g. You send 10000 amount with 10000 fee rate. The fee amount will be 100.
+ * So the amount after fee will be 9900.
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * - `amount`: The amount to apply the fee to
+ * - `fee_rate`: The fee rate to apply denominated in 1e6
  *
  * # Returns
- * - A i32 integer representing the next initializable tick index
+ * - `u64`: The amount after the fee has been applied
  */
-module.exports.getNextInitializableTickIndex = function(tick_index, tick_spacing) {
-    const ret = wasm.getNextInitializableTickIndex(tick_index, tick_spacing);
-    return ret;
+module.exports.tryApplySwapFee = function(amount, fee_rate) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryApplySwapFee(retptr, amount, fee_rate);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
 /**
- * Check if a tick is in-bounds.
+ * Reverse the application of a swap fee to an amount
+ * e.g. You received 9900 amount with 10000 fee rate. The fee amount will be 100.
+ * So the amount before fee will be 10000.
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
+ * - `amount`: The amount to reverse the fee from
+ * - `fee_rate`: The fee rate to reverse denominated in 1e6
  *
  * # Returns
- * - A boolean value indicating if the tick is in-bounds
+ * - `u64`: The amount before the fee has been applied
  */
-module.exports.isTickIndexInBounds = function(tick_index) {
-    const ret = wasm.isTickIndexInBounds(tick_index);
-    return ret !== 0;
+module.exports.tryReverseApplySwapFee = function(amount, fee_rate) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryReverseApplySwapFee(retptr, amount, fee_rate);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
 /**
- * Check if a tick is initializable.
- * A tick is initializable if it is divisible by the tick spacing.
+ * Calculate fees owed for a position
  *
- * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * # Paramters
+ * - `whirlpool`: The whirlpool state
+ * - `position`: The position state
+ * - `tick_lower`: The lower tick state
+ * - `tick_upper`: The upper tick state
+ * - `transfer_fee_a`: The transfer fee for token A
+ * - `transfer_fee_b`: The transfer fee for token B
  *
  * # Returns
- * - A boolean value indicating if the tick is initializable
+ * - `CollectFeesQuote`: The fees owed for token A and token B
  */
-module.exports.isTickInitializable = function(tick_index, tick_spacing) {
-    const ret = wasm.isTickInitializable(tick_index, tick_spacing);
-    return ret !== 0;
+module.exports.collectFeesQuote = function(whirlpool, position, tick_lower, tick_upper, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.collectFeesQuote(retptr, addHeapObject(whirlpool), addHeapObject(position), addHeapObject(tick_lower), addHeapObject(tick_upper), isLikeNone(transfer_fee_a) ? 0 : addHeapObject(transfer_fee_a), isLikeNone(transfer_fee_b) ? 0 : addHeapObject(transfer_fee_b));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
-/**
- * Get the tick index for the inverse of the price that this tick represents.
- * Eg: Consider tick i where Pb/Pa = 1.0001 ^ i
- * inverse of this, i.e. Pa/Pb = 1 / (1.0001 ^ i) = 1.0001^-i
- *
- * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- *
- * # Returns
- * - A i32 integer representing the tick index for the inverse of the price
- */
-module.exports.invertTickIndex = function(tick_index) {
-    const ret = wasm.invertTickIndex(tick_index);
-    return ret;
+module.exports._NUM_REWARDS = function() {
+    const ret = wasm._NUM_REWARDS();
+    return ret >>> 0;
 };
 
 /**
- * Get the sqrt price for the inverse of the price that this tick represents.
- * Because converting to a tick index and then back to a sqrt price is lossy,
- * this function is clamped to the nearest tick index.
+ * Check if the whirlpool is initialized with adaptive fee
  *
- * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price
+ * # Paramters
+ * - `whirlpool`: The whirlpool state
  *
  * # Returns
- * - A u128 integer representing the sqrt price for the inverse of the price
+ * - A boolean value indicating if the whirlpool is initialized with adaptive fee
  */
-module.exports.invertSqrtPrice = function(sqrt_price) {
-    const ret = wasm.invertSqrtPrice(addHeapObject(sqrt_price));
-    return takeObject(ret);
+module.exports.isInitializedWithAdaptiveFee = function(whirlpool) {
+    const ret = wasm.isInitializedWithAdaptiveFee(addHeapObject(whirlpool));
+    return ret !== 0;
 };
 
 /**
- * Get the minimum and maximum tick index that can be initialized.
+ * Calculate rewards owed for a position
  *
- * # Parameters
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * # Paramters
+ * - `whirlpool`: The whirlpool state
+ * - `position`: The position state
+ * - `tick_lower`: The lower tick state
+ * - `tick_upper`: The upper tick state
+ * - `current_timestamp`: The current timestamp
+ * - `transfer_fee_1`: The transfer fee for token 1
+ * - `transfer_fee_2`: The transfer fee for token 2
+ * - `transfer_fee_3`: The transfer fee for token 3
  *
  * # Returns
- * - A TickRange struct containing the lower and upper tick index
+ * - `CollectRewardsQuote`: The rewards owed for the 3 reward tokens.
  */
-module.exports.getFullRangeTickIndexes = function(tick_spacing) {
-    const ret = wasm.getFullRangeTickIndexes(tick_spacing);
-    return takeObject(ret);
+module.exports.collectRewardsQuote = function(whirlpool, position, tick_lower, tick_upper, current_timestamp, transfer_fee_1, transfer_fee_2, transfer_fee_3) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.collectRewardsQuote(retptr, addHeapObject(whirlpool), addHeapObject(position), addHeapObject(tick_lower), addHeapObject(tick_upper), current_timestamp, isLikeNone(transfer_fee_1) ? 0 : addHeapObject(transfer_fee_1), isLikeNone(transfer_fee_2) ? 0 : addHeapObject(transfer_fee_2), isLikeNone(transfer_fee_3) ? 0 : addHeapObject(transfer_fee_3));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 };
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
- * Order tick indexes in ascending order.
- * If the lower tick index is greater than the upper tick index, the indexes are swapped.
- * This is useful for ensuring that the lower tick index is always less than the upper tick index.
+ * Get the first unoccupied position in a bundle
  *
- * # Parameters
- * - `tick_index_1` - A i32 integer representing the first tick index
- * - `tick_index_2` - A i32 integer representing the second tick index
+ * # Arguments
+ * * `bundle` - The bundle to check
  *
  * # Returns
- * - A TickRange struct containing the lower and upper tick index
+ * * `u32` - The first unoccupied position (None if full)
  */
-module.exports.orderTickIndexes = function(tick_index_1, tick_index_2) {
-    const ret = wasm.orderTickIndexes(tick_index_1, tick_index_2);
-    return takeObject(ret);
+module.exports.firstUnoccupiedPositionInBundle = function(bitmap) {
+    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export_0);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.firstUnoccupiedPositionInBundle(ptr0, len0);
+    return ret === 0x100000001 ? undefined : ret;
 };
 
 /**
- * Check if a whirlpool is a full-range only pool.
+ * Check whether a position bundle is full
+ * A position bundle can contain 256 positions
  *
- * # Parameters
- * - `tick_spacing` - A u16 integer representing the tick spacing
+ * # Arguments
+ * * `bundle` - The bundle to check
  *
  * # Returns
- * - A boolean value indicating if the whirlpool is a full-range only pool
+ * * `bool` - Whether the bundle is full
  */
-module.exports.isFullRangeOnly = function(tick_spacing) {
-    const ret = wasm.isFullRangeOnly(tick_spacing);
+module.exports.isPositionBundleFull = function(bitmap) {
+    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export_0);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.isPositionBundleFull(ptr0, len0);
     return ret !== 0;
 };
 
 /**
- * Get the index of a tick in a tick array.
+ * Check whether a position bundle is empty
  *
- * # Parameters
- * - `tick_index` - A i32 integer representing the tick index
- * - `tick_array_start_index` - A i32 integer representing the start tick index of the tick array
- * - `tick_spacing` - A u16 integer representing the tick spacing
+ * # Arguments
+ * * `bundle` - The bundle to check
  *
  * # Returns
- * - A u32 integer representing the tick index in the tick array
+ * * `bool` - Whether the bundle is empty
  */
-module.exports.getTickIndexInArray = function(tick_index, tick_array_start_index, tick_spacing) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.getTickIndexInArray(retptr, tick_index, tick_array_start_index, tick_spacing);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return r0 >>> 0;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+module.exports.isPositionBundleEmpty = function(bitmap) {
+    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export_0);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.isPositionBundleEmpty(ptr0, len0);
+    return ret !== 0;
 };
 
 module.exports._VOLATILITY_ACCUMULATOR_SCALE_FACTOR = function() {
@@ -822,11 +1050,6 @@ module.exports._FEE_RATE_HARD_LIMIT = function() {
     return ret >>> 0;
 };
 
-module.exports._POSITION_BUNDLE_SIZE = function() {
-    const ret = wasm._POSITION_BUNDLE_SIZE();
-    return ret >>> 0;
-};
-
 module.exports._TICK_ARRAY_NOT_EVENLY_SPACED = function() {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
@@ -1019,179 +1242,6 @@ module.exports._INVALID_ADAPTIVE_FEE_INFO = function() {
     }
 };
 
-module.exports._NUM_REWARDS = function() {
-    const ret = wasm._NUM_REWARDS();
-    return ret >>> 0;
-};
-
-module.exports._FEE_RATE_DENOMINATOR = function() {
-    const ret = wasm._FEE_RATE_DENOMINATOR();
-    return ret >>> 0;
-};
-
-module.exports._TICK_ARRAY_SIZE = function() {
-    const ret = wasm._TICK_ARRAY_SIZE();
-    return ret >>> 0;
-};
-
-module.exports._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD = function() {
-    const ret = wasm._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD();
-    return ret;
-};
-
-module.exports._MIN_TICK_INDEX = function() {
-    const ret = wasm._MIN_TICK_INDEX();
-    return ret;
-};
-
-module.exports._MAX_TICK_INDEX = function() {
-    const ret = wasm._MAX_TICK_INDEX();
-    return ret;
-};
-
-/**
- * Check if a position is in range.
- * When a position is in range it is earning fees and rewards
- *
- * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
- * - `tick_index_1` - A i32 integer representing the first tick index of the position
- * - `tick_index_2` - A i32 integer representing the second tick index of the position
- *
- * # Returns
- * - A boolean value indicating if the position is in range
- */
-module.exports.isPositionInRange = function(current_sqrt_price, tick_index_1, tick_index_2) {
-    const ret = wasm.isPositionInRange(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
-    return ret !== 0;
-};
-
-/**
- * Calculate the status of a position
- * The status can be one of three values:
- * - InRange: The position is in range
- * - BelowRange: The position is below the range
- * - AboveRange: The position is above the range
- *
- * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
- * - `tick_index_1` - A i32 integer representing the first tick index of the position
- * - `tick_index_2` - A i32 integer representing the second tick index of the position
- *
- * # Returns
- * - A PositionStatus enum value indicating the status of the position
- */
-module.exports.positionStatus = function(current_sqrt_price, tick_index_1, tick_index_2) {
-    const ret = wasm.positionStatus(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
-    return takeObject(ret);
-};
-
-/**
- * Calculate the token_a / token_b ratio of a (ficticious) position
- *
- * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
- * - `tick_index_1` - A i32 integer representing the first tick index of the position
- * - `tick_index_2` - A i32 integer representing the second tick index of the position
- *
- * # Returns
- * - A PositionRatio struct containing the ratio of token_a and token_b
- */
-module.exports.positionRatio = function(current_sqrt_price, tick_index_1, tick_index_2) {
-    const ret = wasm.positionRatio(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
-    return takeObject(ret);
-};
-
-/**
- * Convert a price into a sqrt priceX64
- * IMPORTANT: floating point operations can reduce the precision of the result.
- * Make sure to do these operations last and not to use the result for further calculations.
- *
- * # Parameters
- * * `price` - The price to convert
- * * `decimals_a` - The number of decimals of the base token
- * * `decimals_b` - The number of decimals of the quote token
- *
- * # Returns
- * * `u128` - The sqrt priceX64
- */
-module.exports.priceToSqrtPrice = function(price, decimals_a, decimals_b) {
-    const ret = wasm.priceToSqrtPrice(price, decimals_a, decimals_b);
-    return takeObject(ret);
-};
-
-/**
- * Convert a sqrt priceX64 into a tick index
- * IMPORTANT: floating point operations can reduce the precision of the result.
- * Make sure to do these operations last and not to use the result for further calculations.
- *
- * # Parameters
- * * `sqrt_price` - The sqrt priceX64 to convert
- * * `decimals_a` - The number of decimals of the base token
- * * `decimals_b` - The number of decimals of the quote token
- *
- * # Returns
- * * `f64` - The decimal price
- */
-module.exports.sqrtPriceToPrice = function(sqrt_price, decimals_a, decimals_b) {
-    const ret = wasm.sqrtPriceToPrice(addHeapObject(sqrt_price), decimals_a, decimals_b);
-    return ret;
-};
-
-/**
- * Invert a price
- * IMPORTANT: floating point operations can reduce the precision of the result.
- * Make sure to do these operations last and not to use the result for further calculations.
- *
- * # Parameters
- * * `price` - The price to invert
- * * `decimals_a` - The number of decimals of the base token
- * * `decimals_b` - The number of decimals of the quote token
- *
- * # Returns
- * * `f64` - The inverted price
- */
-module.exports.invertPrice = function(price, decimals_a, decimals_b) {
-    const ret = wasm.invertPrice(price, decimals_a, decimals_b);
-    return ret;
-};
-
-/**
- * Convert a tick index into a price
- * IMPORTANT: floating point operations can reduce the precision of the result.
- * Make sure to do these operations last and not to use the result for further calculations.
- *
- * # Parameters
- * * `tick_index` - The tick index to convert
- * * `decimals_a` - The number of decimals of the base token
- * * `decimals_b` - The number of decimals of the quote token
- *
- * # Returns
- * * `f64` - The decimal price
- */
-module.exports.tickIndexToPrice = function(tick_index, decimals_a, decimals_b) {
-    const ret = wasm.tickIndexToPrice(tick_index, decimals_a, decimals_b);
-    return ret;
-};
-
-/**
- * Convert a price into a tick index
- * IMPORTANT: floating point operations can reduce the precision of the result.
- * Make sure to do these operations last and not to use the result for further calculations.
- *
- * # Parameters
- * * `price` - The price to convert
- * * `decimals_a` - The number of decimals of the base token
- * * `decimals_b` - The number of decimals of the quote token
- *
- * # Returns
- * * `i32` - The tick index
- */
-module.exports.priceToTickIndex = function(price, decimals_a, decimals_b) {
-    const ret = wasm.priceToTickIndex(price, decimals_a, decimals_b);
-    return ret;
-};
-
 /**
  * Computes the exact input or output amount for a swap transaction.
  *
@@ -1258,36 +1308,6 @@ module.exports.swapQuoteByOutputToken = function(token_out, specified_token_a, s
     }
 };
 
-/**
- * Calculate fees owed for a position
- *
- * # Paramters
- * - `whirlpool`: The whirlpool state
- * - `position`: The position state
- * - `tick_lower`: The lower tick state
- * - `tick_upper`: The upper tick state
- * - `transfer_fee_a`: The transfer fee for token A
- * - `transfer_fee_b`: The transfer fee for token B
- *
- * # Returns
- * - `CollectFeesQuote`: The fees owed for token A and token B
- */
-module.exports.collectFeesQuote = function(whirlpool, position, tick_lower, tick_upper, transfer_fee_a, transfer_fee_b) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.collectFeesQuote(retptr, addHeapObject(whirlpool), addHeapObject(position), addHeapObject(tick_lower), addHeapObject(tick_upper), isLikeNone(transfer_fee_a) ? 0 : addHeapObject(transfer_fee_a), isLikeNone(transfer_fee_b) ? 0 : addHeapObject(transfer_fee_b));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-};
-
 /**
  * Calculate the quote for decreasing liquidity
  *