@crypticdot/defituna-core 3.3.6 → 3.4.1

package/dist/nodejs/defituna_core_js_bindings.js

@@ -252,232 +252,6 @@ function passArray8ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
-/**
- * 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
- */
-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.
- *
- * # Parameters
- * - `tick_index` - A i32 integer representing the tick integer
- *
- * # Returns
- * - `Ok`: A u128 Q32.64 representing the sqrt_price
- */
-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.
- *
- * # Parameters
- * - `sqrt_price` - A u128 integer representing the sqrt price
- *
- * # Returns
- * - `Ok`: A i32 integer representing the tick integer
- */
-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 integer representing the previous initializable tick index
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-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
- */
-exports.getFullRangeTickIndexes = function(tick_spacing) {
-    const ret = wasm.getFullRangeTickIndexes(tick_spacing);
-    return takeObject(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.
- *
- * # Parameters
- * - `tick_index_1` - A i32 integer representing the first tick index
- * - `tick_index_2` - A i32 integer representing the second tick index
- *
- * # Returns
- * - A TickRange struct containing the lower and upper tick index
- */
-exports.orderTickIndexes = function(tick_index_1, tick_index_2) {
-    const ret = wasm.orderTickIndexes(tick_index_1, tick_index_2);
-    return takeObject(ret);
-};
-
-/**
- * Check if a fusion_pool is a full-range only pool.
- *
- * # Parameters
- * - `tick_spacing` - A u16 integer representing the tick spacing
- *
- * # Returns
- * - A boolean value indicating if the fusion_pool is a full-range only pool
- */
-exports.isFullRangeOnly = function(tick_spacing) {
-    const ret = wasm.isFullRangeOnly(tick_spacing);
-    return ret !== 0;
-};
-
-/**
- * Get the index of a tick in a tick array.
- *
- * # 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
- *
- * # Returns
- * - A u32 integer representing the tick index in the tick array
- */
-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);
-    }
-};
-
 /**
  * Calculate the amount A delta between two sqrt_prices
  *
@@ -674,171 +448,344 @@ exports.tryGetMaxAmountWithSlippageTolerance = function(amount, slippage_toleran
 };
 
 /**
- * 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.
+ * 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
+ * - `amount`: The amount to apply the fee to
+ * - `slippage_tolerance_bps`: The slippage tolerance in bps (should be in range 0..BPS_DENOMINATOR)
+ *
+ * # Returns
+ * - `u64`: The minimum amount
+ */
+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);
+    }
+};
+
+/**
+ * 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
+ * - `amount`: The amount to apply the fee to
+ * - `fee_rate`: The fee rate to apply denominated in 1e6
+ *
+ * # Returns
+ * - `u64`: The amount after the fee has been applied
+ */
+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);
+    }
+};
+
+/**
+ * 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
+ */
+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);
+    }
+};
+
+exports._FEE_RATE_MUL_VALUE = function() {
+    const ret = wasm._FEE_RATE_MUL_VALUE();
+    return ret >>> 0;
+};
+
+exports._MAX_PROTOCOL_FEE_RATE = function() {
+    const ret = wasm._MAX_PROTOCOL_FEE_RATE();
+    return ret;
+};
+
+exports._PROTOCOL_FEE_RATE_MUL_VALUE = function() {
+    const ret = wasm._PROTOCOL_FEE_RATE_MUL_VALUE();
+    return ret;
+};
+
+exports._TICK_ARRAY_SIZE = function() {
+    const ret = wasm._TICK_ARRAY_SIZE();
+    return ret >>> 0;
+};
+
+exports._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD = function() {
+    const ret = wasm._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD();
+    return ret;
+};
+
+exports._MIN_TICK_INDEX = function() {
+    const ret = wasm._MIN_TICK_INDEX();
+    return ret;
+};
+
+exports._MAX_TICK_INDEX = function() {
+    const ret = wasm._MAX_TICK_INDEX();
+    return ret;
+};
+
+/**
+ * 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
+ */
+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.
+ *
+ * # Parameters
+ * - `tick_index` - A i32 integer representing the tick integer
+ *
+ * # Returns
+ * - `Ok`: A u128 Q32.64 representing the sqrt_price
+ */
+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.
+ *
+ * # Parameters
+ * - `sqrt_price` - A u128 integer representing the sqrt price
+ *
+ * # Returns
+ * - `Ok`: A i32 integer representing the tick integer
+ */
+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 integer representing the previous initializable tick index
+ */
+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
+ */
+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
+ */
+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
+ */
+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
- * - `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
  */
-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);
-    }
+exports.isTickInitializable = function(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
  */
-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);
-    }
+exports.invertTickIndex = function(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
  */
-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);
-    }
+exports.invertSqrtPrice = function(sqrt_price) {
+    const ret = wasm.invertSqrtPrice(addHeapObject(sqrt_price));
+    return takeObject(ret);
 };
 
 /**
- * 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.
+ * 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
  */
-exports.limitOrderQuoteByInputToken = function(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);
-    }
+exports.getFullRangeTickIndexes = function(tick_spacing) {
+    const ret = wasm.getFullRangeTickIndexes(tick_spacing);
+    return takeObject(ret);
 };
 
 /**
- * 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.
+ * 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_1` - A i32 integer representing the first tick index
+ * - `tick_index_2` - A i32 integer representing the second tick index
+ *
+ * # Returns
+ * - A TickRange struct containing the lower and upper tick index
  */
-exports.limitOrderQuoteByOutputToken = function(amount_out, a_to_b_order, tick_index, fusion_pool) {
-    try {
-        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().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);
-    }
+exports.orderTickIndexes = function(tick_index_1, tick_index_2) {
+    const ret = wasm.orderTickIndexes(tick_index_1, tick_index_2);
+    return takeObject(ret);
 };
 
 /**
- * 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.
+ * Check if a fusion_pool is a full-range only pool.
+ *
+ * # Parameters
+ * - `tick_spacing` - A u16 integer representing the tick spacing
+ *
+ * # Returns
+ * - A boolean value indicating if the fusion_pool is a full-range only pool
  */
-exports.limitOrderRewardByOutputToken = function(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);
-    }
+exports.isFullRangeOnly = function(tick_spacing) {
+    const ret = wasm.isFullRangeOnly(tick_spacing);
+    return ret !== 0;
 };
 
-exports.decreaseLimitOrderQuote = function(fusion_pool, limit_order, tick, amount, transfer_fee_a, transfer_fee_b) {
+/**
+ * Get the index of a tick in a tick array.
+ *
+ * # 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
+ *
+ * # Returns
+ * - A u32 integer representing the tick index in the tick array
+ */
+exports.getTickIndexInArray = function(tick_index, tick_array_start_index, tick_spacing) {
     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));
+        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 takeObject(r0);
+        return r0 >>> 0;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
@@ -1137,124 +1084,102 @@ exports.collectFeesQuote = function(fusion_pool, position, tick_lower, tick_uppe
             throw takeObject(r1);
         }
         return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-};
-
-exports.limitOrderFee = function(fusion_pool) {
-    const ret = wasm.limitOrderFee(addHeapObject(fusion_pool));
-    return ret;
-};
-
-exports._TICK_ARRAY_SIZE = function() {
-    const ret = wasm._TICK_ARRAY_SIZE();
-    return ret >>> 0;
-};
-
-exports._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD = function() {
-    const ret = wasm._FULL_RANGE_ONLY_TICK_SPACING_THRESHOLD();
-    return ret;
-};
-
-exports._MIN_TICK_INDEX = function() {
-    const ret = wasm._MIN_TICK_INDEX();
-    return ret;
-};
-
-exports._MAX_TICK_INDEX = function() {
-    const ret = wasm._MAX_TICK_INDEX();
-    return 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
- */
-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
- */
-exports.sqrtPriceToPrice = function(sqrt_price, decimals_a, decimals_b) {
-    const ret = wasm.sqrtPriceToPrice(addHeapObject(sqrt_price), decimals_a, decimals_b);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports.limitOrderFee = function(fusion_pool) {
+    const ret = wasm.limitOrderFee(addHeapObject(fusion_pool));
     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
+ * 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.
  */
-exports.invertPrice = function(price, decimals_a, decimals_b) {
-    const ret = wasm.invertPrice(price, decimals_a, decimals_b);
-    return ret;
+exports.limitOrderQuoteByInputToken = function(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);
+    }
 };
 
 /**
- * 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
+ * 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.
  */
-exports.tickIndexToPrice = function(tick_index, decimals_a, decimals_b) {
-    const ret = wasm.tickIndexToPrice(tick_index, decimals_a, decimals_b);
-    return ret;
+exports.limitOrderQuoteByOutputToken = function(amount_out, a_to_b_order, tick_index, fusion_pool) {
+    try {
+        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().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);
+    }
 };
 
 /**
- * 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
+ * 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.
  */
-exports.priceToTickIndex = function(price, decimals_a, decimals_b) {
-    const ret = wasm.priceToTickIndex(price, decimals_a, decimals_b);
-    return ret;
+exports.limitOrderRewardByOutputToken = function(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);
+    }
+};
+
+exports.decreaseLimitOrderQuote = function(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);
+    }
 };
 
 exports._POSITION_BUNDLE_SIZE = function() {
@@ -1466,21 +1391,6 @@ exports._LIMIT_ORDER_AND_POOL_ARE_OUT_OF_SYNC = function() {
     }
 };
 
-exports._FEE_RATE_MUL_VALUE = function() {
-    const ret = wasm._FEE_RATE_MUL_VALUE();
-    return ret >>> 0;
-};
-
-exports._MAX_PROTOCOL_FEE_RATE = function() {
-    const ret = wasm._MAX_PROTOCOL_FEE_RATE();
-    return ret;
-};
-
-exports._PROTOCOL_FEE_RATE_MUL_VALUE = function() {
-    const ret = wasm._PROTOCOL_FEE_RATE_MUL_VALUE();
-    return ret;
-};
-
 /**
  * Get the first unoccupied position in a bundle
  *
@@ -1583,6 +1493,128 @@ exports.positionRatioX64 = function(current_sqrt_price, tick_index_1, tick_index
     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
+ */
+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
+ */
+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
+ */
+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
+ */
+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
+ */
+exports.priceToTickIndex = function(price, decimals_a, decimals_b) {
+    const ret = wasm.priceToTickIndex(price, decimals_a, decimals_b);
+    return ret;
+};
+
+/**
+ * Computes the liquidation prices for an existing position.
+ *
+ * # Parameters
+ * - `lower_tick_index`: The lower tick index of the position.
+ * - `upper_tick_index`: The upper tick index of the position.
+ * - `leftovers_a`: The amount of leftovers A in the position.
+ * - `leftovers_a`: The amount of leftovers B in the position.
+ * - `liquidity`: Liquidity of the position.
+ * - `debt_a`: The amount of tokens A borrowed.
+ * - `debt_b`: The amount of tokens B borrowed.
+ * - `liquidation_threshold`: The liquidation threshold of the market.
+ *
+ * # Returns
+ * - `LiquidationPrices`: An object containing lower/upper liquidation prices.
+ */
+exports.getLpPositionLiquidationPrices = function(lower_tick_index, upper_tick_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, lower_tick_index, upper_tick_index, addHeapObject(liquidity), 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);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
 /**
  * Computes the exact input or output amount for a swap transaction.
  *
@@ -1711,10 +1743,10 @@ exports.getDecreaseSpotPositionQuote = function(decrease_amount, collateral_toke
  * # Returns
  * - `f64`: Decimal liquidation price
  */
-exports.getLiquidationPrice = function(position_token, amount, debt, liquidation_threshold) {
+exports.getSpotPositionLiquidationPrice = function(position_token, amount, debt, liquidation_threshold) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.getLiquidationPrice(retptr, position_token, amount, debt, liquidation_threshold);
+        wasm.getSpotPositionLiquidationPrice(retptr, position_token, amount, debt, liquidation_threshold);
         var r0 = getDataViewMemory0().getFloat64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
         var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
@@ -1760,8 +1792,8 @@ exports.getTradableAmount = function(collateral_token, available_balance, levera
     }
 };
 
-exports.calculateTunaProtocolFee = function(collateral_token, borrowed_token, collateral, borrow, protocol_fee_rate_on_collateral, protocol_fee_rate) {
-    const ret = wasm.calculateTunaProtocolFee(collateral_token, borrowed_token, collateral, borrow, protocol_fee_rate_on_collateral, protocol_fee_rate);
+exports.calculateTunaSpotPositionProtocolFee = function(collateral_token, borrowed_token, collateral, borrow, protocol_fee_rate_on_collateral, protocol_fee_rate) {
+    const ret = wasm.calculateTunaSpotPositionProtocolFee(collateral_token, borrowed_token, collateral, borrow, protocol_fee_rate_on_collateral, protocol_fee_rate);
     return takeObject(ret);
 };
 
@@ -1808,16 +1840,16 @@ exports.solana_program_init = function() {
     wasm.solana_program_init();
 };
 
-function __wasm_bindgen_func_elem_3103(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_3103(arg0, arg1);
+function __wasm_bindgen_func_elem_3356(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_3356(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_3312(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_3312(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_3164(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_3164(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_480(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_480(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_495(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_495(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
@@ -2996,7 +3028,7 @@ exports.__wbg_new_3c3d849046688a66 = function(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wasm_bindgen_func_elem_480(a, state0.b, arg0, arg1);
+                return __wasm_bindgen_func_elem_495(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -3252,9 +3284,15 @@ exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
     return addHeapObject(ret);
 };
 
-exports.__wbindgen_cast_829978f7e672581b = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 337, function: Function { arguments: [], shim_idx: 338, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3099, __wasm_bindgen_func_elem_3103);
+exports.__wbindgen_cast_4765ab8ace056f92 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 386, function: Function { arguments: [Externref], shim_idx: 381, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3375, __wasm_bindgen_func_elem_3356);
+    return addHeapObject(ret);
+};
+
+exports.__wbindgen_cast_7727c787a531a20f = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 347, function: Function { arguments: [], shim_idx: 348, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3160, __wasm_bindgen_func_elem_3164);
     return addHeapObject(ret);
 };
 
@@ -3276,12 +3314,6 @@ exports.__wbindgen_cast_e7b45dd881f38ce3 = function(arg0, arg1) {
     return addHeapObject(ret);
 };
 
-exports.__wbindgen_cast_e9643297b4d6a498 = function(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { dtor_idx: 372, function: Function { arguments: [Externref], shim_idx: 383, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3285, __wasm_bindgen_func_elem_3312);
-    return addHeapObject(ret);
-};
-
 exports.__wbindgen_object_clone_ref = function(arg0) {
     const ret = getObject(arg0);
     return addHeapObject(ret);