@crypticdot/defituna-core 3.4.2 → 3.4.4

package/dist/browser/defituna_core_js_bindings_bg.js

@@ -262,752 +262,899 @@ function passArray8ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+
+export function _POSITION_BUNDLE_SIZE() {
+    const ret = wasm._POSITION_BUNDLE_SIZE();
+    return ret >>> 0;
+}
+
+export function _FEE_RATE_MUL_VALUE() {
+    const ret = wasm._FEE_RATE_MUL_VALUE();
+    return ret >>> 0;
+}
+
+export function _MAX_PROTOCOL_FEE_RATE() {
+    const ret = wasm._MAX_PROTOCOL_FEE_RATE();
+    return ret;
+}
+
+export function _PROTOCOL_FEE_RATE_MUL_VALUE() {
+    const ret = wasm._PROTOCOL_FEE_RATE_MUL_VALUE();
+    return ret;
+}
+
+export function _TICK_ARRAY_SIZE() {
+    const ret = wasm._TICK_ARRAY_SIZE();
+    return ret >>> 0;
+}
+
+export function _FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD() {
+    const ret = wasm._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD();
+    return ret;
+}
+
+export function _MIN_TICK_INDEX() {
+    const ret = wasm._MIN_TICK_INDEX();
+    return ret;
+}
+
+export function _MAX_TICK_INDEX() {
+    const ret = wasm._MAX_TICK_INDEX();
+    return ret;
+}
+
 /**
- * Calculate the amount A delta between two sqrt_prices
+ * Get the first tick index in the tick array that contains the specified tick index.
  *
  * # 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
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
  *
  * # Returns
- * - `u64`: The amount delta
+ * - A i32 integer representing the first tick index in the tick array
  */
-export function tryGetAmountDeltaA(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);
-    }
+export function getTickArrayStartTickIndex(tick_index, tick_spacing) {
+    const ret = wasm.getTickArrayStartTickIndex(tick_index, tick_spacing);
+    return ret;
 }
 
 /**
- * Calculate the amount B delta between two sqrt_prices
+ * 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
- * - `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
+ * - `tick_index` - A i32 integer representing the tick integer
  *
  * # Returns
- * - `u64`: The amount delta
+ * - `Ok`: A u128 Q32.64 representing the sqrt_price
  */
-export function tryGetAmountDeltaB(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
+export function tickIndexToSqrtPrice(tick_index) {
     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);
+        wasm.tickIndexToSqrtPrice(retptr, tick_index);
         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);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * Calculate the next square root price
+ * 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.
  *
  * # Parameters
- * - `current_sqrt_price`: The current square root price
- * - `current_liquidity`: The current liquidity
- * - `amount`: The amount
- * - `specified_input`: Whether the input is specified
+ * - `sqrt_price` - A u128 integer representing the sqrt price
  *
  * # Returns
- * - `u128`: The next square root price
+ * - `Ok`: A i32 integer representing the tick integer
  */
-export function tryGetNextSqrtPriceFromA(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);
-    }
+export function sqrtPriceToTickIndex(sqrt_price) {
+    const ret = wasm.sqrtPriceToTickIndex(sqrt_price, sqrt_price >> BigInt(64));
+    return ret;
 }
 
 /**
- * Calculate the next square root price
+ * Get the initializable tick index.
+ * If the tick index is already initializable, it is returned as is.
  *
  * # 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
+ * - `round_up` - A boolean value indicating if the supplied tick index should be rounded up. None will round to the nearest.
  *
  * # Returns
- * - `u128`: The next square root price
+ * - A i32 integer representing the previous initializable tick index
  */
-export function tryGetNextSqrtPriceFromB(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);
-    }
+export function getInitializableTickIndex(tick_index, tick_spacing, round_up) {
+    const ret = wasm.getInitializableTickIndex(tick_index, tick_spacing, isLikeNone(round_up) ? 0xFFFFFF : round_up ? 1 : 0);
+    return 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.
+ * Get the previous initializable tick index.
  *
  * # Parameters
- * - `amount`: The amount to apply the fee to
- * - `transfer_fee`: The transfer fee to apply
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
  *
  * # Returns
- * - `u64`: The amount after the fee has been applied
+ * - A i32 integer representing the previous initializable tick index
  */
-export function tryApplyTransferFee(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);
-    }
+export function getPrevInitializableTickIndex(tick_index, tick_spacing) {
+    const ret = wasm.getPrevInitializableTickIndex(tick_index, tick_spacing);
+    return 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.
+ * Get the next initializable tick index.
  *
  * # Parameters
- * - `amount`: The amount to reverse the fee from
- * - `transfer_fee`: The transfer fee to reverse
+ * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
  *
  * # Returns
- * - `u64`: The amount before the fee has been applied
+ * - A i32 integer representing the next initializable tick index
  */
-export function tryReverseApplyTransferFee(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);
-    }
+export function getNextInitializableTickIndex(tick_index, tick_spacing) {
+    const ret = wasm.getNextInitializableTickIndex(tick_index, tick_spacing);
+    return ret;
 }
 
 /**
- * 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.
+ * Check if a tick is in-bounds.
  *
  * # 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 integer
  *
  * # Returns
- * - `u64`: The maximum amount
+ * - A boolean value indicating if the tick is in-bounds
  */
-export function tryGetMaxAmountWithSlippageTolerance(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);
-    }
+export function isTickIndexInBounds(tick_index) {
+    const ret = wasm.isTickIndexInBounds(tick_index);
+    return ret !== 0;
 }
 
 /**
- * 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.
+ * Check if a tick is initializable.
+ * A tick is initializable if it is divisible by the tick spacing.
  *
  * # 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 integer
+ * - `tick_spacing` - A i32 integer representing the tick spacing
  *
  * # Returns
- * - `u64`: The minimum amount
+ * - A boolean value indicating if the tick is initializable
  */
-export function tryGetMinAmountWithSlippageTolerance(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);
-    }
+export function isTickInitializable(tick_index, tick_spacing) {
+    const ret = wasm.isTickInitializable(tick_index, tick_spacing);
+    return ret !== 0;
 }
 
 /**
- * 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.
+ * 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
- * - `amount`: The amount to apply the fee to
- * - `fee_rate`: The fee rate to apply denominated in 1e6
+ * - `tick_index` - A i32 integer representing the tick integer
  *
  * # Returns
- * - `u64`: The amount after the fee has been applied
+ * - A i32 integer representing the tick index for the inverse of the price
  */
-export function tryApplySwapFee(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);
-    }
+export function invertTickIndex(tick_index) {
+    const ret = wasm.invertTickIndex(tick_index);
+    return ret;
 }
 
 /**
- * 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.
+ * 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
- * - `amount`: The amount to reverse the fee from
- * - `fee_rate`: The fee rate to reverse denominated in 1e6
+ * - `sqrt_price` - A u128 integer representing the sqrt price
  *
  * # Returns
- * - `u64`: The amount before the fee has been applied
+ * - A u128 integer representing the sqrt price for the inverse of the price
  */
-export function tryReverseApplySwapFee(amount, fee_rate) {
+export function invertSqrtPrice(sqrt_price) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryReverseApplySwapFee(retptr, amount, fee_rate);
+        wasm.invertSqrtPrice(retptr, sqrt_price, sqrt_price >> BigInt(64));
         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);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
-export function _FEE_RATE_MUL_VALUE() {
-    const ret = wasm._FEE_RATE_MUL_VALUE();
-    return ret >>> 0;
-}
-
-export function _MAX_PROTOCOL_FEE_RATE() {
-    const ret = wasm._MAX_PROTOCOL_FEE_RATE();
-    return ret;
-}
-
-export function _PROTOCOL_FEE_RATE_MUL_VALUE() {
-    const ret = wasm._PROTOCOL_FEE_RATE_MUL_VALUE();
-    return ret;
-}
-
-export function _TICK_ARRAY_SIZE() {
-    const ret = wasm._TICK_ARRAY_SIZE();
-    return ret >>> 0;
-}
-
-export function _FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD() {
-    const ret = wasm._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD();
-    return ret;
-}
-
-export function _MIN_TICK_INDEX() {
-    const ret = wasm._MIN_TICK_INDEX();
-    return ret;
-}
-
-export function _MAX_TICK_INDEX() {
-    const ret = wasm._MAX_TICK_INDEX();
-    return ret;
-}
-
 /**
- * Get the first tick index in the tick array that contains the specified tick index.
+ * Get the minimum and maximum tick index that can be initialized.
  *
  * # 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
+ * - A TickRange struct containing the lower and upper tick index
  */
-export function getTickArrayStartTickIndex(tick_index, tick_spacing) {
-    const ret = wasm.getTickArrayStartTickIndex(tick_index, tick_spacing);
-    return ret;
+export function getFullRangeTickIndexes(tick_spacing) {
+    const ret = wasm.getFullRangeTickIndexes(tick_spacing);
+    return takeObject(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.
+ * 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
- * - `tick_index` - A i32 integer representing the tick integer
+ * - `tick_index_1` - A i32 integer representing the first tick index
+ * - `tick_index_2` - A i32 integer representing the second tick index
  *
  * # Returns
- * - `Ok`: A u128 Q32.64 representing the sqrt_price
+ * - A TickRange struct containing the lower and upper tick index
  */
-export function tickIndexToSqrtPrice(tick_index) {
-    const ret = wasm.tickIndexToSqrtPrice(tick_index);
+export function orderTickIndexes(tick_index_1, tick_index_2) {
+    const ret = wasm.orderTickIndexes(tick_index_1, tick_index_2);
     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.
+ * Check if a fusion_pool is a full-range only pool.
  *
  * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price
+ * - `tick_spacing` - A u16 integer representing the tick spacing
  *
  * # Returns
- * - `Ok`: A i32 integer representing the tick integer
+ * - A boolean value indicating if the fusion_pool is a full-range only pool
  */
-export function sqrtPriceToTickIndex(sqrt_price) {
-    const ret = wasm.sqrtPriceToTickIndex(addHeapObject(sqrt_price));
-    return ret;
+export function isFullRangeOnly(tick_spacing) {
+    const ret = wasm.isFullRangeOnly(tick_spacing);
+    return ret !== 0;
 }
 
 /**
- * Get the initializable tick index.
- * If the tick index is already initializable, it is returned as is.
+ * Get the index of a tick in a tick array.
  *
  * # 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.
+ * - `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
- * - A i32 integer representing the previous initializable tick index
+ * - A u32 integer representing the tick index in the tick array
  */
-export function getInitializableTickIndex(tick_index, tick_spacing, round_up) {
-    const ret = wasm.getInitializableTickIndex(tick_index, tick_spacing, isLikeNone(round_up) ? 0xFFFFFF : round_up ? 1 : 0);
-    return ret;
+export function getTickIndexInArray(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);
+    }
 }
 
 /**
- * Get the previous initializable tick index.
+ * Calculate the quote for decreasing liquidity
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * - `liquidity_delta` - The amount of liquidity to decrease
+ * - `slippage_tolerance` - The slippage tolerance in bps
+ * - `current_sqrt_price` - The current sqrt price of the pool
+ * - `tick_index_1` - The first tick index of the position
+ * - `tick_index_2` - The second tick index of the position
+ * - `transfer_fee_a` - The transfer fee for token A in bps
+ * - `transfer_fee_b` - The transfer fee for token B in bps
  *
  * # Returns
- * - A i32 integer representing the previous initializable tick index
+ * - A DecreaseLiquidityQuote struct containing the estimated token amounts
  */
-export function getPrevInitializableTickIndex(tick_index, tick_spacing) {
-    const ret = wasm.getPrevInitializableTickIndex(tick_index, tick_spacing);
-    return ret;
+export function decreaseLiquidityQuote(liquidity_delta, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.decreaseLiquidityQuote(retptr, liquidity_delta, liquidity_delta >> BigInt(64), slippage_tolerance_bps, current_sqrt_price, current_sqrt_price >> BigInt(64), tick_index_1, tick_index_2, 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 next initializable tick index.
+ * Calculate the quote for decreasing liquidity given a token a amount
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * - `token_amount_a` - The amount of token a to decrease
+ * - `slippage_tolerance` - The slippage tolerance in bps
+ * - `current_sqrt_price` - The current sqrt price of the pool
+ * - `tick_index_1` - The first tick index of the position
+ * - `tick_index_2` - The second tick index of the position
+ * - `transfer_fee_a` - The transfer fee for token A in bps
+ * - `transfer_fee_b` - The transfer fee for token B in bps
  *
  * # Returns
- * - A i32 integer representing the next initializable tick index
+ * - A DecreaseLiquidityQuote struct containing the estimated token amounts
  */
-export function getNextInitializableTickIndex(tick_index, tick_spacing) {
-    const ret = wasm.getNextInitializableTickIndex(tick_index, tick_spacing);
-    return ret;
+export function decreaseLiquidityQuoteA(token_amount_a, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.decreaseLiquidityQuoteA(retptr, token_amount_a, slippage_tolerance_bps, current_sqrt_price, current_sqrt_price >> BigInt(64), tick_index_1, tick_index_2, 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);
+    }
 }
 
 /**
- * Check if a tick is in-bounds.
+ * Calculate the quote for decreasing liquidity given a token b amount
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
+ * - `token_amount_b` - The amount of token b to decrease
+ * - `slippage_tolerance` - The slippage tolerance in bps
+ * - `current_sqrt_price` - The current sqrt price of the pool
+ * - `tick_index_1` - The first tick index of the position
+ * - `tick_index_2` - The second tick index of the position
+ * - `transfer_fee_a` - The transfer fee for token A in bps
+ * - `transfer_fee_b` - The transfer fee for token B in bps
  *
  * # Returns
- * - A boolean value indicating if the tick is in-bounds
+ * - A DecreaseLiquidityQuote struct containing the estimated token amounts
  */
-export function isTickIndexInBounds(tick_index) {
-    const ret = wasm.isTickIndexInBounds(tick_index);
-    return ret !== 0;
+export function decreaseLiquidityQuoteB(token_amount_b, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.decreaseLiquidityQuoteB(retptr, token_amount_b, slippage_tolerance_bps, current_sqrt_price, current_sqrt_price >> BigInt(64), tick_index_1, tick_index_2, 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);
+    }
 }
 
 /**
- * Check if a tick is initializable.
- * A tick is initializable if it is divisible by the tick spacing.
+ * Calculate the quote for increasing liquidity
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * - `liquidity_delta` - The amount of liquidity to increase
+ * - `slippage_tolerance` - The slippage tolerance in bps
+ * - `current_sqrt_price` - The current sqrt price of the pool
+ * - `tick_index_1` - The first tick index of the position
+ * - `tick_index_2` - The second tick index of the position
+ * - `transfer_fee_a` - The transfer fee for token A in bps
+ * - `transfer_fee_b` - The transfer fee for token B in bps
  *
  * # Returns
- * - A boolean value indicating if the tick is initializable
+ * - An IncreaseLiquidityQuote struct containing the estimated token amounts
  */
-export function isTickInitializable(tick_index, tick_spacing) {
-    const ret = wasm.isTickInitializable(tick_index, tick_spacing);
-    return ret !== 0;
+export function increaseLiquidityQuote(liquidity_delta, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.increaseLiquidityQuote(retptr, liquidity_delta, liquidity_delta >> BigInt(64), slippage_tolerance_bps, current_sqrt_price, current_sqrt_price >> BigInt(64), tick_index_1, tick_index_2, 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
+ * Calculate the quote for increasing liquidity given a token a amount
  *
  * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
+ * - `token_amount_a` - The amount of token a to increase
+ * - `slippage_tolerance` - The slippage tolerance in bps
+ * - `current_sqrt_price` - The current sqrt price of the pool
+ * - `tick_index_1` - The first tick index of the position
+ * - `tick_index_2` - The second tick index of the position
+ * - `transfer_fee_a` - The transfer fee for token A in bps
+ * - `transfer_fee_b` - The transfer fee for token B in bps
  *
  * # Returns
- * - A i32 integer representing the tick index for the inverse of the price
+ * - An IncreaseLiquidityQuote struct containing the estimated token amounts
  */
-export function invertTickIndex(tick_index) {
-    const ret = wasm.invertTickIndex(tick_index);
-    return ret;
+export function increaseLiquidityQuoteA(token_amount_a, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.increaseLiquidityQuoteA(retptr, token_amount_a, slippage_tolerance_bps, current_sqrt_price, current_sqrt_price >> BigInt(64), tick_index_1, tick_index_2, 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 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.
+ * Calculate the quote for increasing liquidity given a token b amount
  *
  * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price
+ * - `token_amount_b` - The amount of token b to increase
+ * - `slippage_tolerance` - The slippage tolerance in bps
+ * - `current_sqrt_price` - The current sqrt price of the pool
+ * - `tick_index_1` - The first tick index of the position
+ * - `tick_index_2` - The second tick index of the position
+ * - `transfer_fee_a` - The transfer fee for token A in bps
+ * - `transfer_fee_b` - The transfer fee for token B in bps
  *
  * # Returns
- * - A u128 integer representing the sqrt price for the inverse of the price
+ * - An IncreaseLiquidityQuote struct containing the estimated token amounts
  */
-export function invertSqrtPrice(sqrt_price) {
-    const ret = wasm.invertSqrtPrice(addHeapObject(sqrt_price));
-    return takeObject(ret);
+export function increaseLiquidityQuoteB(token_amount_b, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.increaseLiquidityQuoteB(retptr, token_amount_b, slippage_tolerance_bps, current_sqrt_price, current_sqrt_price >> BigInt(64), tick_index_1, tick_index_2, 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);
+    }
+}
+
+export function tryGetLiquidityFromA(token_delta_a, sqrt_price_lower, sqrt_price_upper) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+        wasm.tryGetLiquidityFromA(retptr, token_delta_a, sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+        var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+        if (r5) {
+            throw takeObject(r4);
+        }
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(32);
+    }
+}
+
+export function tryGetTokenAFromLiquidity(liquidity_delta, sqrt_price_lower, sqrt_price_upper, round_up) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetTokenAFromLiquidity(retptr, liquidity_delta, liquidity_delta >> BigInt(64), sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64), 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);
+    }
+}
+
+export function tryGetLiquidityFromB(token_delta_b, sqrt_price_lower, sqrt_price_upper) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+        wasm.tryGetLiquidityFromB(retptr, token_delta_b, sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+        var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+        if (r5) {
+            throw takeObject(r4);
+        }
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(32);
+    }
+}
+
+export function tryGetTokenBFromLiquidity(liquidity_delta, sqrt_price_lower, sqrt_price_upper, round_up) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetTokenBFromLiquidity(retptr, liquidity_delta, liquidity_delta >> BigInt(64), sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64), 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);
+    }
+}
+
+export function tryGetAmountsFromLiquidity(liquidity_delta, current_sqrt_price, tick_lower_index, tick_upper_index, round_up) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetAmountsFromLiquidity(retptr, liquidity_delta, liquidity_delta >> BigInt(64), current_sqrt_price, current_sqrt_price >> BigInt(64), tick_lower_index, tick_upper_index, round_up);
+        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);
+    }
+}
+
+export function tryGetLiquidityFromAmounts(sqrt_price, sqrt_price_a_x64, sqrt_price_b_x64, amount_a, amount_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+        wasm.tryGetLiquidityFromAmounts(retptr, sqrt_price, sqrt_price >> BigInt(64), sqrt_price_a_x64, sqrt_price_a_x64 >> BigInt(64), sqrt_price_b_x64, sqrt_price_b_x64 >> BigInt(64), amount_a, amount_b);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+        var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+        if (r5) {
+            throw takeObject(r4);
+        }
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(32);
+    }
 }
 
 /**
- * Get the minimum and maximum tick index that can be initialized.
+ * Calculate fees owed for a position
  *
- * # Parameters
- * - `tick_spacing` - A i32 integer representing the tick spacing
+ * # Paramters
+ * - `fusion_pool`: The fusion_pool 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 TickRange struct containing the lower and upper tick index
+ * - `CollectFeesQuote`: The fees owed for token A and token B
  */
-export function getFullRangeTickIndexes(tick_spacing) {
-    const ret = wasm.getFullRangeTickIndexes(tick_spacing);
-    return takeObject(ret);
+export function collectFeesQuote(fusion_pool, 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(fusion_pool), 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);
+    }
+}
+
+export function limitOrderFee(fusion_pool) {
+    const ret = wasm.limitOrderFee(addHeapObject(fusion_pool));
+    return ret;
 }
 
 /**
- * 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.
+ * Calculate the amount A delta between two sqrt_prices
  *
  * # Parameters
- * - `tick_index_1` - A i32 integer representing the first tick index
- * - `tick_index_2` - A i32 integer representing the second tick index
+ * - `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
- * - A TickRange struct containing the lower and upper tick index
+ * - `u64`: The amount delta
  */
-export function orderTickIndexes(tick_index_1, tick_index_2) {
-    const ret = wasm.orderTickIndexes(tick_index_1, tick_index_2);
-    return takeObject(ret);
+export function tryGetAmountDeltaA(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetAmountDeltaA(retptr, sqrt_price_1, sqrt_price_1 >> BigInt(64), sqrt_price_2, sqrt_price_2 >> BigInt(64), liquidity, liquidity >> BigInt(64), 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);
+    }
 }
 
 /**
- * Check if a fusion_pool is a full-range only pool.
+ * Calculate the amount B delta between two sqrt_prices
  *
  * # Parameters
- * - `tick_spacing` - A u16 integer representing the tick spacing
+ * - `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
- * - A boolean value indicating if the fusion_pool is a full-range only pool
+ * - `u64`: The amount delta
  */
-export function isFullRangeOnly(tick_spacing) {
-    const ret = wasm.isFullRangeOnly(tick_spacing);
-    return ret !== 0;
+export function tryGetAmountDeltaB(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetAmountDeltaB(retptr, sqrt_price_1, sqrt_price_1 >> BigInt(64), sqrt_price_2, sqrt_price_2 >> BigInt(64), liquidity, liquidity >> BigInt(64), 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);
+    }
 }
 
 /**
- * Get the index of a tick in a tick array.
+ * Calculate the next square root price
  *
  * # 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
+ * - `current_sqrt_price`: The current square root price
+ * - `current_liquidity`: The current liquidity
+ * - `amount`: The amount
+ * - `specified_input`: Whether the input is specified
  *
  * # Returns
- * - A u32 integer representing the tick index in the tick array
+ * - `u128`: The next square root price
  */
-export function getTickIndexInArray(tick_index, tick_array_start_index, tick_spacing) {
+export function tryGetNextSqrtPriceFromA(current_sqrt_price, current_liquidity, amount, specified_input) {
     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);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+        wasm.tryGetNextSqrtPriceFromA(retptr, current_sqrt_price, current_sqrt_price >> BigInt(64), current_liquidity, current_liquidity >> BigInt(64), amount, specified_input);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+        var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+        if (r5) {
+            throw takeObject(r4);
         }
-        return r0 >>> 0;
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
     } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_add_to_stack_pointer(32);
     }
 }
 
 /**
- * Calculate the quote for decreasing liquidity
+ * Calculate the next square root price
  *
  * # Parameters
- * - `liquidity_delta` - The amount of liquidity to decrease
- * - `slippage_tolerance` - The slippage tolerance in bps
- * - `current_sqrt_price` - The current sqrt price of the pool
- * - `tick_index_1` - The first tick index of the position
- * - `tick_index_2` - The second tick index of the position
- * - `transfer_fee_a` - The transfer fee for token A in bps
- * - `transfer_fee_b` - The transfer fee for token B in bps
+ * - `current_sqrt_price`: The current square root price
+ * - `current_liquidity`: The current liquidity
+ * - `amount`: The amount
+ * - `specified_input`: Whether the input is specified
  *
  * # Returns
- * - A DecreaseLiquidityQuote struct containing the estimated token amounts
+ * - `u128`: The next square root price
  */
-export function decreaseLiquidityQuote(liquidity_delta, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+export function tryGetNextSqrtPriceFromB(current_sqrt_price, current_liquidity, amount, specified_input) {
     try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.decreaseLiquidityQuote(retptr, addHeapObject(liquidity_delta), slippage_tolerance_bps, addHeapObject(current_sqrt_price), tick_index_1, tick_index_2, 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);
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
+        wasm.tryGetNextSqrtPriceFromB(retptr, current_sqrt_price, current_sqrt_price >> BigInt(64), current_liquidity, current_liquidity >> BigInt(64), amount, specified_input);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
+        var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
+        if (r5) {
+            throw takeObject(r4);
         }
-        return takeObject(r0);
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
     } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_add_to_stack_pointer(32);
     }
 }
 
 /**
- * Calculate the quote for decreasing liquidity given a token a amount
+ * 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
- * - `token_amount_a` - The amount of token a to decrease
- * - `slippage_tolerance` - The slippage tolerance in bps
- * - `current_sqrt_price` - The current sqrt price of the pool
- * - `tick_index_1` - The first tick index of the position
- * - `tick_index_2` - The second tick index of the position
- * - `transfer_fee_a` - The transfer fee for token A in bps
- * - `transfer_fee_b` - The transfer fee for token B in bps
+ * - `amount`: The amount to apply the fee to
+ * - `transfer_fee`: The transfer fee to apply
  *
  * # Returns
- * - A DecreaseLiquidityQuote struct containing the estimated token amounts
+ * - `u64`: The amount after the fee has been applied
  */
-export function decreaseLiquidityQuoteA(token_amount_a, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+export function tryApplyTransferFee(amount, transfer_fee) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.decreaseLiquidityQuoteA(retptr, token_amount_a, slippage_tolerance_bps, addHeapObject(current_sqrt_price), tick_index_1, tick_index_2, 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);
+        wasm.tryApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
         }
-        return takeObject(r0);
+        return BigInt.asUintN(64, r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * Calculate the quote for decreasing liquidity given a token b amount
+ * 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
- * - `token_amount_b` - The amount of token b to decrease
- * - `slippage_tolerance` - The slippage tolerance in bps
- * - `current_sqrt_price` - The current sqrt price of the pool
- * - `tick_index_1` - The first tick index of the position
- * - `tick_index_2` - The second tick index of the position
- * - `transfer_fee_a` - The transfer fee for token A in bps
- * - `transfer_fee_b` - The transfer fee for token B in bps
+ * - `amount`: The amount to reverse the fee from
+ * - `transfer_fee`: The transfer fee to reverse
  *
  * # Returns
- * - A DecreaseLiquidityQuote struct containing the estimated token amounts
+ * - `u64`: The amount before the fee has been applied
  */
-export function decreaseLiquidityQuoteB(token_amount_b, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+export function tryReverseApplyTransferFee(amount, transfer_fee) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.decreaseLiquidityQuoteB(retptr, token_amount_b, slippage_tolerance_bps, addHeapObject(current_sqrt_price), tick_index_1, tick_index_2, 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);
+        wasm.tryReverseApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
         }
-        return takeObject(r0);
+        return BigInt.asUintN(64, r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * Calculate the quote for increasing liquidity
+ * 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
- * - `liquidity_delta` - The amount of liquidity to increase
- * - `slippage_tolerance` - The slippage tolerance in bps
- * - `current_sqrt_price` - The current sqrt price of the pool
- * - `tick_index_1` - The first tick index of the position
- * - `tick_index_2` - The second tick index of the position
- * - `transfer_fee_a` - The transfer fee for token A in bps
- * - `transfer_fee_b` - The transfer fee for token B in bps
+ * - `amount`: The amount to apply the fee to
+ * - `slippage_tolerance_bps`: The slippage tolerance in bps (should be in range 0..BPS_DENOMINATOR)
  *
  * # Returns
- * - An IncreaseLiquidityQuote struct containing the estimated token amounts
+ * - `u64`: The maximum amount
  */
-export function increaseLiquidityQuote(liquidity_delta, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+export function tryGetMaxAmountWithSlippageTolerance(amount, slippage_tolerance_bps) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.increaseLiquidityQuote(retptr, addHeapObject(liquidity_delta), slippage_tolerance_bps, addHeapObject(current_sqrt_price), tick_index_1, tick_index_2, 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);
+        wasm.tryGetMaxAmountWithSlippageTolerance(retptr, amount, slippage_tolerance_bps);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
         }
-        return takeObject(r0);
+        return BigInt.asUintN(64, r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * Calculate the quote for increasing liquidity given a token a amount
+ * 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
- * - `token_amount_a` - The amount of token a to increase
- * - `slippage_tolerance` - The slippage tolerance in bps
- * - `current_sqrt_price` - The current sqrt price of the pool
- * - `tick_index_1` - The first tick index of the position
- * - `tick_index_2` - The second tick index of the position
- * - `transfer_fee_a` - The transfer fee for token A in bps
- * - `transfer_fee_b` - The transfer fee for token B in bps
+ * - `amount`: The amount to apply the fee to
+ * - `slippage_tolerance_bps`: The slippage tolerance in bps (should be in range 0..BPS_DENOMINATOR)
  *
  * # Returns
- * - An IncreaseLiquidityQuote struct containing the estimated token amounts
+ * - `u64`: The minimum amount
  */
-export function increaseLiquidityQuoteA(token_amount_a, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+export function tryGetMinAmountWithSlippageTolerance(amount, slippage_tolerance_bps) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.increaseLiquidityQuoteA(retptr, token_amount_a, slippage_tolerance_bps, addHeapObject(current_sqrt_price), tick_index_1, tick_index_2, 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);
+        wasm.tryGetMinAmountWithSlippageTolerance(retptr, amount, slippage_tolerance_bps);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
         }
-        return takeObject(r0);
+        return BigInt.asUintN(64, r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * Calculate the quote for increasing liquidity given a token b amount
+ * 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
- * - `token_amount_b` - The amount of token b to increase
- * - `slippage_tolerance` - The slippage tolerance in bps
- * - `current_sqrt_price` - The current sqrt price of the pool
- * - `tick_index_1` - The first tick index of the position
- * - `tick_index_2` - The second tick index of the position
- * - `transfer_fee_a` - The transfer fee for token A in bps
- * - `transfer_fee_b` - The transfer fee for token B in bps
+ * - `amount`: The amount to apply the fee to
+ * - `fee_rate`: The fee rate to apply denominated in 1e6
  *
  * # Returns
- * - An IncreaseLiquidityQuote struct containing the estimated token amounts
+ * - `u64`: The amount after the fee has been applied
  */
-export function increaseLiquidityQuoteB(token_amount_b, slippage_tolerance_bps, current_sqrt_price, tick_index_1, tick_index_2, transfer_fee_a, transfer_fee_b) {
+export function tryApplySwapFee(amount, fee_rate) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.increaseLiquidityQuoteB(retptr, token_amount_b, slippage_tolerance_bps, addHeapObject(current_sqrt_price), tick_index_1, tick_index_2, 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);
+        wasm.tryApplySwapFee(retptr, amount, fee_rate);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
         }
-        return takeObject(r0);
+        return BigInt.asUintN(64, r0);
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
-export function tryGetLiquidityFromA(token_delta_a, sqrt_price_lower, sqrt_price_upper) {
+/**
+ * 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
+ * - `amount`: The amount to reverse the fee from
+ * - `fee_rate`: The fee rate to reverse denominated in 1e6
+ *
+ * # Returns
+ * - `u64`: The amount before the fee has been applied
+ */
+export function tryReverseApplySwapFee(amount, fee_rate) {
     try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-        wasm.tryGetLiquidityFromA(retptr, token_delta_a, sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64));
+        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().getBigInt64(retptr + 8 * 1, true);
-        var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
-        var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
-        if (r5) {
-            throw takeObject(r4);
+        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) | (BigInt.asUintN(64, r2) << BigInt(64)));
+        return BigInt.asUintN(64, r0);
     } finally {
-        wasm.__wbindgen_add_to_stack_pointer(32);
+        wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
-export function tryGetTokenAFromLiquidity(liquidity_delta, sqrt_price_lower, sqrt_price_upper, round_up) {
+/**
+ * Computes the limit order output amount by input amount.
+ * ### Parameters
+ * - `amount_in` - The input token amount of a limit order.
+ * - `a_to_b_order` - The limit order direction.
+ * - `tick_index` - The tick index of an order.
+ * - `fusion_pool` - The fusion_pool state.
+ */
+export function limitOrderQuoteByInputToken(amount_in, a_to_b_order, tick_index, fusion_pool) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetTokenAFromLiquidity(retptr, liquidity_delta, liquidity_delta >> BigInt(64), sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64), round_up);
+        wasm.limitOrderQuoteByInputToken(retptr, amount_in, a_to_b_order, tick_index, addHeapObject(fusion_pool));
         var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
         var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
@@ -1020,27 +1167,42 @@ export function tryGetTokenAFromLiquidity(liquidity_delta, sqrt_price_lower, sqr
     }
 }
 
-export function tryGetLiquidityFromB(token_delta_b, sqrt_price_lower, sqrt_price_upper) {
+/**
+ * Computes the limit order input amount by output amount.
+ * ### Parameters
+ * - `amount_out` - The output token amount of a limit order.
+ * - `a_to_b_order` - The limit order direction.
+ * - `tick_index` - The tick index of an order.
+ * - `fusion_pool` - The fusion_pool state.
+ */
+export function limitOrderQuoteByOutputToken(amount_out, a_to_b_order, tick_index, fusion_pool) {
     try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-32);
-        wasm.tryGetLiquidityFromB(retptr, token_delta_b, sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64));
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.limitOrderQuoteByOutputToken(retptr, amount_out, a_to_b_order, tick_index, addHeapObject(fusion_pool));
         var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
-        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
-        var r4 = getDataViewMemory0().getInt32(retptr + 4 * 4, true);
-        var r5 = getDataViewMemory0().getInt32(retptr + 4 * 5, true);
-        if (r5) {
-            throw takeObject(r4);
+        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) | (BigInt.asUintN(64, r2) << BigInt(64)));
+        return BigInt.asUintN(64, r0);
     } finally {
-        wasm.__wbindgen_add_to_stack_pointer(32);
+        wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
-export function tryGetTokenBFromLiquidity(liquidity_delta, sqrt_price_lower, sqrt_price_upper, round_up) {
+/**
+ * Computes the limit order reward by input amount.
+ * ### Parameters
+ * - `amount_out` - The output token amount of a limit order (swap input).
+ * - `a_to_b_order` - The limit order direction.
+ * - `tick_index` - The tick index of an order.
+ * - `fusion_pool` - The fusion_pool state.
+ */
+export function limitOrderRewardByOutputToken(amount_out, fee_rate, protocol_fee_rate) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetTokenBFromLiquidity(retptr, liquidity_delta, liquidity_delta >> BigInt(64), sqrt_price_lower, sqrt_price_lower >> BigInt(64), sqrt_price_upper, sqrt_price_upper >> BigInt(64), round_up);
+        wasm.limitOrderRewardByOutputToken(retptr, amount_out, fee_rate, protocol_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);
@@ -1053,10 +1215,10 @@ export function tryGetTokenBFromLiquidity(liquidity_delta, sqrt_price_lower, sqr
     }
 }
 
-export function tryGetTokenEstimatesFromLiquidity(liquidity_delta, current_sqrt_price, tick_lower_index, tick_upper_index, round_up) {
+export function decreaseLimitOrderQuote(fusion_pool, limit_order, tick, amount, transfer_fee_a, transfer_fee_b) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.tryGetTokenEstimatesFromLiquidity(retptr, liquidity_delta, liquidity_delta >> BigInt(64), current_sqrt_price, current_sqrt_price >> BigInt(64), tick_lower_index, tick_upper_index, round_up);
+        wasm.decreaseLimitOrderQuote(retptr, addHeapObject(fusion_pool), addHeapObject(limit_order), addHeapObject(tick), amount, 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);
@@ -1070,131 +1232,202 @@ export function tryGetTokenEstimatesFromLiquidity(liquidity_delta, current_sqrt_
 }
 
 /**
- * Calculate fees owed for a position
+ * Get the first unoccupied position in a bundle
  *
- * # Paramters
- * - `fusion_pool`: The fusion_pool 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
+ * # Arguments
+ * * `bundle` - The bundle to check
  *
  * # Returns
- * - `CollectFeesQuote`: The fees owed for token A and token B
+ * * `u32` - The first unoccupied position (None if full)
  */
-export function collectFeesQuote(fusion_pool, 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(fusion_pool), 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);
-    }
+export function firstUnoccupiedPositionInBundle(bitmap) {
+    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.firstUnoccupiedPositionInBundle(ptr0, len0);
+    return ret === 0x100000001 ? undefined : ret;
 }
 
-export function limitOrderFee(fusion_pool) {
-    const ret = wasm.limitOrderFee(addHeapObject(fusion_pool));
-    return 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
+ */
+export function isPositionBundleFull(bitmap) {
+    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.isPositionBundleFull(ptr0, len0);
+    return ret !== 0;
 }
 
 /**
- * Computes the limit order output amount by input amount.
- * ### Parameters
- * - `amount_in` - The input token amount of a limit order.
- * - `a_to_b_order` - The limit order direction.
- * - `tick_index` - The tick index of an order.
- * - `fusion_pool` - The fusion_pool state.
+ * Check whether a position bundle is empty
+ *
+ * # Arguments
+ * * `bundle` - The bundle to check
+ *
+ * # Returns
+ * * `bool` - Whether the bundle is empty
  */
-export function limitOrderQuoteByInputToken(amount_in, a_to_b_order, tick_index, fusion_pool) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.limitOrderQuoteByInputToken(retptr, amount_in, a_to_b_order, tick_index, addHeapObject(fusion_pool));
-        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);
-    }
+export function isPositionBundleEmpty(bitmap) {
+    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.isPositionBundleEmpty(ptr0, len0);
+    return ret !== 0;
 }
 
 /**
- * Computes the limit order input amount by output amount.
- * ### Parameters
- * - `amount_out` - The output token amount of a limit order.
- * - `a_to_b_order` - The limit order direction.
- * - `tick_index` - The tick index of an order.
- * - `fusion_pool` - The fusion_pool state.
+ * 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
  */
-export function limitOrderQuoteByOutputToken(amount_out, a_to_b_order, tick_index, fusion_pool) {
+export function isPositionInRange(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.isPositionInRange(current_sqrt_price, current_sqrt_price >> BigInt(64), 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
+ */
+export function positionStatus(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.positionStatus(current_sqrt_price, current_sqrt_price >> BigInt(64), 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
+ */
+export function positionRatioX64(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.positionRatioX64(current_sqrt_price, current_sqrt_price >> BigInt(64), 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
+ */
+export function priceToSqrtPrice(price, decimals_a, decimals_b) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.limitOrderQuoteByOutputToken(retptr, amount_out, a_to_b_order, tick_index, addHeapObject(fusion_pool));
+        wasm.priceToSqrtPrice(retptr, price, decimals_a, decimals_b);
         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);
+        var r2 = getDataViewMemory0().getBigInt64(retptr + 8 * 1, true);
+        return (BigInt.asUintN(64, r0) | (BigInt.asUintN(64, r2) << BigInt(64)));
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
 /**
- * Computes the limit order reward by input amount.
- * ### Parameters
- * - `amount_out` - The output token amount of a limit order (swap input).
- * - `a_to_b_order` - The limit order direction.
- * - `tick_index` - The tick index of an order.
- * - `fusion_pool` - The fusion_pool state.
+ * 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
+ */
+export function sqrtPriceToPrice(sqrt_price, decimals_a, decimals_b) {
+    const ret = wasm.sqrtPriceToPrice(sqrt_price, sqrt_price >> BigInt(64), 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
+ */
+export function invertPrice(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
  */
-export function limitOrderRewardByOutputToken(amount_out, fee_rate, protocol_fee_rate) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.limitOrderRewardByOutputToken(retptr, amount_out, fee_rate, protocol_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);
-    }
-}
-
-export function decreaseLimitOrderQuote(fusion_pool, limit_order, tick, amount, transfer_fee_a, transfer_fee_b) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.decreaseLimitOrderQuote(retptr, addHeapObject(fusion_pool), addHeapObject(limit_order), addHeapObject(tick), amount, 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);
-    }
+export function tickIndexToPrice(tick_index, decimals_a, decimals_b) {
+    const ret = wasm.tickIndexToPrice(tick_index, decimals_a, decimals_b);
+    return ret;
 }
 
-export function _POSITION_BUNDLE_SIZE() {
-    const ret = wasm._POSITION_BUNDLE_SIZE();
-    return ret >>> 0;
+/**
+ * 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
+ */
+export function priceToTickIndex(price, decimals_a, decimals_b) {
+    const ret = wasm.priceToTickIndex(price, decimals_a, decimals_b);
+    return ret;
 }
 
 export function _TICK_ARRAY_NOT_EVENLY_SPACED() {
@@ -1401,198 +1634,6 @@ export function _LIMIT_ORDER_AND_POOL_ARE_OUT_OF_SYNC() {
     }
 }
 
-/**
- * Get the first unoccupied position in a bundle
- *
- * # Arguments
- * * `bundle` - The bundle to check
- *
- * # Returns
- * * `u32` - The first unoccupied position (None if full)
- */
-export function firstUnoccupiedPositionInBundle(bitmap) {
-    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export);
-    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
- */
-export function isPositionBundleFull(bitmap) {
-    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export);
-    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
- */
-export function isPositionBundleEmpty(bitmap) {
-    const ptr0 = passArray8ToWasm0(bitmap, wasm.__wbindgen_export);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.isPositionBundleEmpty(ptr0, len0);
-    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
- */
-export function isPositionInRange(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
- */
-export function positionStatus(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
- */
-export function positionRatioX64(current_sqrt_price, tick_index_1, tick_index_2) {
-    const ret = wasm.positionRatioX64(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
- */
-export function priceToSqrtPrice(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
- */
-export function sqrtPriceToPrice(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
- */
-export function invertPrice(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
- */
-export function tickIndexToPrice(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
- */
-export function priceToTickIndex(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.
  *
@@ -1674,7 +1715,7 @@ export function swapQuoteByOutputToken(token_out, specified_token_a, slippage_to
 export function getLpPositionLiquidationPrices(tick_lower_index, tick_upper_index, liquidity, leftovers_a, leftovers_b, debt_a, debt_b, liquidation_threshold) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.getLpPositionLiquidationPrices(retptr, tick_lower_index, tick_upper_index, addHeapObject(liquidity), leftovers_a, leftovers_b, debt_a, debt_b, liquidation_threshold);
+        wasm.getLpPositionLiquidationPrices(retptr, tick_lower_index, tick_upper_index, liquidity, liquidity >> BigInt(64), leftovers_a, leftovers_b, debt_a, debt_b, liquidation_threshold);
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1772,9 +1813,9 @@ export function getDecreaseSpotPositionQuote(decrease_amount, collateral_token,
  *
  * # Parameters
  * - `position_token`: Token of the position
- * - `amount`: Position total size (decimal)
- * - `debt`: Position total debt (decimal)
- * - `liquidation_threshold`: Liquidation threshold of the market (decimal)
+ * - `amount`: Position total size
+ * - `debt`: Position total debt
+ * - `liquidation_threshold`: Liquidation threshold of a market
  *
  * # Returns
  * - `f64`: Decimal liquidation price
@@ -1881,12 +1922,12 @@ export function solana_program_init() {
     wasm.solana_program_init();
 }
 
-function __wasm_bindgen_func_elem_2635(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_2635(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_2634(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_2634(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_3208(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_3208(arg0, arg1);
+function __wasm_bindgen_func_elem_3207(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_3207(arg0, arg1);
 }
 
 function __wasm_bindgen_func_elem_495(arg0, arg1, arg2, arg3) {
@@ -3299,7 +3340,7 @@ export function __wbg_warn_1d74dddbe2fd1dbb(arg0) {
 
 export function __wbindgen_cast_0660a350899916ec(arg0, arg1) {
     // Cast intrinsic for `Closure(Closure { dtor_idx: 360, function: Function { arguments: [], shim_idx: 361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3204, __wasm_bindgen_func_elem_3208);
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3203, __wasm_bindgen_func_elem_3207);
     return addHeapObject(ret);
 };
 
@@ -3311,7 +3352,7 @@ export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
 
 export function __wbindgen_cast_2e5f7f1574aa20c6(arg0, arg1) {
     // Cast intrinsic for `Closure(Closure { dtor_idx: 232, function: Function { arguments: [Externref], shim_idx: 227, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_2654, __wasm_bindgen_func_elem_2635);
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_2653, __wasm_bindgen_func_elem_2634);
     return addHeapObject(ret);
 };