@crypticdot/defituna-core 3.1.0 → 3.2.0

package/dist/nodejs/defituna_core_js_bindings.js

@@ -173,22 +173,1428 @@ function debugString(val) {
     return className;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    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
+ * - `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
+ *
+ * # 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
+ *
+ * # Returns
+ * - `u64`: The amount delta
+ */
+exports.tryGetAmountDeltaA = function(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetAmountDeltaA(retptr, addHeapObject(sqrt_price_1), addHeapObject(sqrt_price_2), addHeapObject(liquidity), round_up);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the amount B delta between two sqrt_prices
+ *
+ * # 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
+ *
+ * # Returns
+ * - `u64`: The amount delta
+ */
+exports.tryGetAmountDeltaB = function(sqrt_price_1, sqrt_price_2, liquidity, round_up) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetAmountDeltaB(retptr, addHeapObject(sqrt_price_1), addHeapObject(sqrt_price_2), addHeapObject(liquidity), round_up);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the next square root price
+ *
+ * # Parameters
+ * - `current_sqrt_price`: The current square root price
+ * - `current_liquidity`: The current liquidity
+ * - `amount`: The amount
+ * - `specified_input`: Whether the input is specified
+ *
+ * # Returns
+ * - `u128`: The next square root price
+ */
+exports.tryGetNextSqrtPriceFromA = function(current_sqrt_price, current_liquidity, amount, specified_input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetNextSqrtPriceFromA(retptr, addHeapObject(current_sqrt_price), addHeapObject(current_liquidity), amount, specified_input);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the next square root price
+ *
+ * # Parameters
+ * - `current_sqrt_price`: The current square root price
+ * - `current_liquidity`: The current liquidity
+ * - `amount`: The amount
+ * - `specified_input`: Whether the input is specified
+ *
+ * # Returns
+ * - `u128`: The next square root price
+ */
+exports.tryGetNextSqrtPriceFromB = function(current_sqrt_price, current_liquidity, amount, specified_input) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetNextSqrtPriceFromB(retptr, addHeapObject(current_sqrt_price), addHeapObject(current_liquidity), amount, specified_input);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * 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
+ * - `amount`: The amount to apply the fee to
+ * - `transfer_fee`: The transfer fee to apply
+ *
+ * # Returns
+ * - `u64`: The amount after the fee has been applied
+ */
+exports.tryApplyTransferFee = function(amount, transfer_fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * 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
+ * - `amount`: The amount to reverse the fee from
+ * - `transfer_fee`: The transfer fee to reverse
+ *
+ * # Returns
+ * - `u64`: The amount before the fee has been applied
+ */
+exports.tryReverseApplyTransferFee = function(amount, transfer_fee) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryReverseApplyTransferFee(retptr, amount, addHeapObject(transfer_fee));
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Get the 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
+ * - `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 maximum amount
+ */
+exports.tryGetMaxAmountWithSlippageTolerance = function(amount, slippage_tolerance_bps) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.tryGetMaxAmountWithSlippageTolerance(retptr, amount, slippage_tolerance_bps);
+        var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        return BigInt.asUintN(64, r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Get the 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);
+    }
+};
+
+/**
+ * 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.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);
+    }
+};
+
+/**
+ * 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.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);
+    }
+};
+
+/**
+ * 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.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);
+    }
+};
+
+/**
+ * Calculate the quote for decreasing liquidity
+ *
+ * # 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
+ *
+ * # Returns
+ * - A DecreaseLiquidityQuote struct containing the estimated token amounts
+ */
+exports.decreaseLiquidityQuote = function(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, 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);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the quote for decreasing liquidity given a token a amount
+ *
+ * # 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
+ *
+ * # Returns
+ * - A DecreaseLiquidityQuote struct containing the estimated token amounts
+ */
+exports.decreaseLiquidityQuoteA = function(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, 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);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the quote for decreasing liquidity given a token b amount
+ *
+ * # 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
+ *
+ * # Returns
+ * - A DecreaseLiquidityQuote struct containing the estimated token amounts
+ */
+exports.decreaseLiquidityQuoteB = function(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, 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);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the quote for increasing liquidity
+ *
+ * # 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
+ *
+ * # Returns
+ * - An IncreaseLiquidityQuote struct containing the estimated token amounts
+ */
+exports.increaseLiquidityQuote = function(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, 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);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the quote for increasing liquidity given a token a amount
+ *
+ * # 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
+ *
+ * # Returns
+ * - An IncreaseLiquidityQuote struct containing the estimated token amounts
+ */
+exports.increaseLiquidityQuoteA = function(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, 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);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate the quote for increasing liquidity given a token b amount
+ *
+ * # 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
+ *
+ * # Returns
+ * - An IncreaseLiquidityQuote struct containing the estimated token amounts
+ */
+exports.increaseLiquidityQuoteB = function(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, 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);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports.tryGetLiquidityFromA = function(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);
+    }
+};
+
+exports.tryGetTokenAFromLiquidity = function(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);
+    }
+};
+
+exports.tryGetLiquidityFromB = function(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);
+    }
+};
+
+exports.tryGetTokenBFromLiquidity = function(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);
+    }
+};
+
+exports.tryGetTokenEstimatesFromLiquidity = function(liquidity_delta, current_sqrt_price, tick_lower_index, tick_upper_index, round_up) {
+    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);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+/**
+ * Calculate fees owed for a position
+ *
+ * # 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
+ * - `CollectFeesQuote`: The fees owed for token A and token B
+ */
+exports.collectFeesQuote = function(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);
+    }
+};
+
+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);
+    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;
+};
+
+exports._POSITION_BUNDLE_SIZE = function() {
+    const ret = wasm._POSITION_BUNDLE_SIZE();
+    return ret >>> 0;
+};
+
+exports._TICK_ARRAY_NOT_EVENLY_SPACED = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._TICK_ARRAY_NOT_EVENLY_SPACED(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._TICK_INDEX_OUT_OF_BOUNDS = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._TICK_INDEX_OUT_OF_BOUNDS(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._INVALID_TICK_INDEX = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._INVALID_TICK_INDEX(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._ARITHMETIC_OVERFLOW = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._ARITHMETIC_OVERFLOW(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._AMOUNT_EXCEEDS_MAX_U64 = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._AMOUNT_EXCEEDS_MAX_U64(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._AMOUNT_EXCEEDS_LIMIT_ORDER_INPUT_AMOUNT = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._AMOUNT_EXCEEDS_LIMIT_ORDER_INPUT_AMOUNT(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._SQRT_PRICE_OUT_OF_BOUNDS = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._SQRT_PRICE_OUT_OF_BOUNDS(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._TICK_SEQUENCE_EMPTY = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._TICK_SEQUENCE_EMPTY(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._SQRT_PRICE_LIMIT_OUT_OF_BOUNDS = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._SQRT_PRICE_LIMIT_OUT_OF_BOUNDS(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._INVALID_SQRT_PRICE_LIMIT_DIRECTION = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._INVALID_SQRT_PRICE_LIMIT_DIRECTION(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._ZERO_TRADABLE_AMOUNT = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._ZERO_TRADABLE_AMOUNT(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._INVALID_TIMESTAMP = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._INVALID_TIMESTAMP(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._INVALID_TRANSFER_FEE = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._INVALID_TRANSFER_FEE(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._INVALID_SLIPPAGE_TOLERANCE = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._INVALID_SLIPPAGE_TOLERANCE(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._TICK_INDEX_NOT_IN_ARRAY = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._TICK_INDEX_NOT_IN_ARRAY(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
 
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
+exports._INVALID_TICK_ARRAY_SEQUENCE = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._INVALID_TICK_ARRAY_SEQUENCE(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+};
+
+exports._LIMIT_ORDER_AND_POOL_ARE_OUT_OF_SYNC = function() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._LIMIT_ORDER_AND_POOL_ARE_OUT_OF_SYNC(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } 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;
+};
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
 }
+/**
+ * Get the first unoccupied position in a bundle
+ *
+ * # Arguments
+ * * `bundle` - The bundle to check
+ *
+ * # Returns
+ * * `u32` - The first unoccupied position (None if full)
+ */
+exports.firstUnoccupiedPositionInBundle = function(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
+ */
+exports.isPositionBundleFull = function(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
+ */
+exports.isPositionBundleEmpty = function(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
+ */
+exports.isPositionInRange = function(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.isPositionInRange(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
+    return ret !== 0;
+};
+
+/**
+ * Calculate the status of a position
+ * The status can be one of three values:
+ * - InRange: The position is in range
+ * - BelowRange: The position is below the range
+ * - AboveRange: The position is above the range
+ *
+ * # Parameters
+ * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
+ * - `tick_index_1` - A i32 integer representing the first tick index of the position
+ * - `tick_index_2` - A i32 integer representing the second tick index of the position
+ *
+ * # Returns
+ * - A PositionStatus enum value indicating the status of the position
+ */
+exports.positionStatus = function(current_sqrt_price, tick_index_1, tick_index_2) {
+    const ret = wasm.positionStatus(addHeapObject(current_sqrt_price), tick_index_1, tick_index_2);
+    return takeObject(ret);
+};
+
+/**
+ * Calculate the token_a / token_b ratio of a (ficticious) position
+ *
+ * # Parameters
+ * - `sqrt_price` - A u128 integer representing the sqrt price of the pool
+ * - `tick_index_1` - A i32 integer representing the first tick index of the position
+ * - `tick_index_2` - A i32 integer representing the second tick index of the position
+ *
+ * # Returns
+ * - A PositionRatio struct containing the ratio of token_a and token_b
+ */
+exports.positionRatioX64 = function(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);
+};
+
+/**
+ * Computes the exact input or output amount for a swap transaction.
+ *
+ * # Arguments
+ * - `token_in`: The input token amount.
+ * - `specified_token_a`: If `true`, the input token is token A. Otherwise, it is token B.
+ * - `slippage_tolerance`: The slippage tolerance in basis points.
+ * - `fusion_pool`: The fusion_pool state.
+ * - `tick_arrays`: The tick arrays needed for the swap.
+ * - `transfer_fee_a`: The transfer fee for token A.
+ * - `transfer_fee_b`: The transfer fee for token B.
+ *
+ * # Returns
+ * The exact input or output amount for the swap transaction.
+ */
+exports.swapQuoteByInputToken = function(token_in, specified_token_a, slippage_tolerance_bps, fusion_pool, tick_arrays, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.swapQuoteByInputToken(retptr, token_in, specified_token_a, slippage_tolerance_bps, addHeapObject(fusion_pool), addHeapObject(tick_arrays), 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);
+    }
+};
+
+/**
+ * Computes the exact input or output amount for a swap transaction.
+ *
+ * # Arguments
+ * - `token_out`: The output token amount.
+ * - `specified_token_a`: If `true`, the output token is token A. Otherwise, it is token B.
+ * - `slippage_tolerance`: The slippage tolerance in basis points.
+ * - `fusion_pool`: The fusion_pool state.
+ * - `tick_arrays`: The tick arrays needed for the swap.
+ * - `transfer_fee_a`: The transfer fee for token A.
+ * - `transfer_fee_b`: The transfer fee for token B.
+ *
+ * # Returns
+ * The exact input or output amount for the swap transaction.
+ */
+exports.swapQuoteByOutputToken = function(token_out, specified_token_a, slippage_tolerance_bps, fusion_pool, tick_arrays, transfer_fee_a, transfer_fee_b) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.swapQuoteByOutputToken(retptr, token_out, specified_token_a, slippage_tolerance_bps, addHeapObject(fusion_pool), addHeapObject(tick_arrays), 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._INVALID_ARGUMENTS = function() {
     try {
@@ -202,6 +1608,73 @@ exports._INVALID_ARGUMENTS = function() {
     }
 };
 
+/**
+ * Spot position increase quote
+ *
+ * # Parameters
+ * - `increase_amount`: Position total size in the collateral_token.
+ * - `collateral_token`: Collateral token.
+ * - `position_token`: Token of the position.
+ * - `leverage`: Leverage (1.0 or higher).
+ * - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
+ * - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
+ * - `fusion_pool`: Fusion pool.
+ * - `tick_arrays`: Five tick arrays around the current pool price.
+ *
+ * # Returns
+ * - `IncreaseSpotPositionQuoteResult`: quote result
+ */
+exports.getIncreaseSpotPositionQuote = function(increase_amount, collateral_token, position_token, leverage, protocol_fee_rate, protocol_fee_rate_on_collateral, fusion_pool, tick_arrays) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.getIncreaseSpotPositionQuote(retptr, increase_amount, addHeapObject(collateral_token), addHeapObject(position_token), leverage, protocol_fee_rate, protocol_fee_rate_on_collateral, addHeapObject(fusion_pool), addHeapObject(tick_arrays));
+        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);
+    }
+};
+
+/**
+ * Spot position decrease quote
+ *
+ * # Parameters
+ * - `increase_amount`: Position total size in the collateral_token.
+ * - `collateral_token`: Collateral token.
+ * - `position_token`: Token of the position.
+ * - `leverage`: Leverage (1.0 or higher).
+ * - `position_amount`: Existing position amount in the position_token.
+ * - `position_debt`: Existing position debt in the token opposite to the position_token.
+ * - `reduce_only`: Only allow reducing the existing position.
+ * - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
+ * - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
+ * - `fusion_pool`: Fusion pool.
+ * - `tick_arrays`: Five tick arrays around the current pool price.
+ *
+ * # Returns
+ * - `DecreaseSpotPositionQuoteResult`: quote result
+ */
+exports.getDecreaseSpotPositionQuote = function(decrease_amount, collateral_token, position_token, leverage, position_amount, position_debt, reduce_only, protocol_fee_rate, protocol_fee_rate_on_collateral, fusion_pool, tick_arrays) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.getDecreaseSpotPositionQuote(retptr, decrease_amount, addHeapObject(collateral_token), addHeapObject(position_token), leverage, position_amount, position_debt, reduce_only, protocol_fee_rate, protocol_fee_rate_on_collateral, addHeapObject(fusion_pool), addHeapObject(tick_arrays));
+        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);
+    }
+};
+
 /**
  * Returns the liquidation price
  *
@@ -230,11 +1703,52 @@ exports.getLiquidationPrice = function(position_token, amount, debt, liquidation
     }
 };
 
+/**
+ * Calculates the maximum tradable amount in the collateral token.
+ *
+ * # Parameters
+ * - `collateral_token`: Collateral token.
+ * - `available_balance`: Available wallet balance in the collateral_token.
+ * - `leverage`: Leverage (1.0 or higher).
+ * - `new_position_token`: Token of the new position.
+ * - `position_token`: Token of the existing position. Should be set to new_position_token if position_amount is zero.
+ * - `position_amount`: Existing position amount in the position_token.
+ * - `position_debt`: Existing position debt in the token opposite to the position_token.
+ * - `reduce_only`: Only allow reducing the existing position.///
+ * - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
+ * - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
+ * - `fusion_pool`: Fusion pool.
+ * - `tick_arrays`: Five tick arrays around the current pool price.
+ *
+ * # Returns
+ * - `u64`: the maximum tradable amount
+ */
+exports.getTradableAmount = function(collateral_token, available_balance, leverage, new_position_token, position_token, position_amount, position_debt, reduce_only, protocol_fee_rate, protocol_fee_rate_on_collateral, fusion_pool, tick_arrays) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.getTradableAmount(retptr, addHeapObject(collateral_token), available_balance, leverage, addHeapObject(new_position_token), addHeapObject(position_token), position_amount, position_debt, reduce_only, protocol_fee_rate, protocol_fee_rate_on_collateral, addHeapObject(fusion_pool), addHeapObject(tick_arrays));
+        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.__wbg_Error_e83987f665cf5504 = function(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
 };
 
+exports.__wbg_Number_bb48ca12f395cd08 = function(arg0) {
+    const ret = Number(getObject(arg0));
+    return ret;
+};
+
 exports.__wbg_String_eecc4a11987127d6 = function(arg0, arg1) {
     const ret = String(getObject(arg1));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -243,6 +1757,13 @@ exports.__wbg_String_eecc4a11987127d6 = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
+exports.__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd = function(arg0, arg1) {
+    const v = getObject(arg1);
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
 exports.__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68 = function(arg0) {
     const v = getObject(arg0);
     const ret = typeof(v) === 'boolean' ? v : undefined;
@@ -257,6 +1778,21 @@ exports.__wbg___wbindgen_debug_string_df47ffb5e35e6763 = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 };
 
+exports.__wbg___wbindgen_in_bb933bd9e1b3bc0f = function(arg0, arg1) {
+    const ret = getObject(arg0) in getObject(arg1);
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_bigint_cb320707dcd35f0b = function(arg0) {
+    const ret = typeof(getObject(arg0)) === 'bigint';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_function_ee8a6c5833c90377 = function(arg0) {
+    const ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+};
+
 exports.__wbg___wbindgen_is_object_c818261d21f283a4 = function(arg0) {
     const val = getObject(arg0);
     const ret = typeof(val) === 'object' && val !== null;
@@ -268,6 +1804,16 @@ exports.__wbg___wbindgen_is_string_fbb76cb2940daafd = function(arg0) {
     return ret;
 };
 
+exports.__wbg___wbindgen_is_undefined_2d472862bd29a478 = function(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+};
+
+exports.__wbg___wbindgen_jsval_eq_6b13ab83478b1c50 = function(arg0, arg1) {
+    const ret = getObject(arg0) === getObject(arg1);
+    return ret;
+};
+
 exports.__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147 = function(arg0, arg1) {
     const ret = getObject(arg0) == getObject(arg1);
     return ret;
@@ -280,6 +1826,11 @@ exports.__wbg___wbindgen_number_get_a20bf9b85341449d = function(arg0, arg1) {
     getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
 };
 
+exports.__wbg___wbindgen_shr_5fb5dd3acf2615de = function(arg0, arg1) {
+    const ret = getObject(arg0) >> getObject(arg1);
+    return addHeapObject(ret);
+};
+
 exports.__wbg___wbindgen_string_get_e4f06c90489ad01b = function(arg0, arg1) {
     const obj = getObject(arg1);
     const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -293,6 +1844,16 @@ exports.__wbg___wbindgen_throw_b855445ff6a94295 = function(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 };
 
+exports.__wbg_call_e762c39fa8ea36bf = function() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+exports.__wbg_done_2042aa2670fb1db1 = function(arg0) {
+    const ret = getObject(arg0).done;
+    return ret;
+};
+
 exports.__wbg_entries_e171b586f8f6bdbf = function(arg0) {
     const ret = Object.entries(getObject(arg0));
     return addHeapObject(ret);
@@ -303,6 +1864,21 @@ exports.__wbg_get_7bed016f185add81 = function(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+exports.__wbg_get_efcb449f58ec27c2 = function() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+exports.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+};
+
+exports.__wbg_get_with_ref_key_6550b2c093d2eb18 = function(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+};
+
 exports.__wbg_instanceof_ArrayBuffer_70beb1189ca63b38 = function(arg0) {
     let result;
     try {
@@ -325,6 +1901,26 @@ exports.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
     return ret;
 };
 
+exports.__wbg_isArray_643fafc484312e19 = function(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+};
+
+exports.__wbg_isArray_96e0af9891d0945d = function(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+};
+
+exports.__wbg_isSafeInteger_d216eda7911dde36 = function(arg0) {
+    const ret = Number.isSafeInteger(getObject(arg0));
+    return ret;
+};
+
+exports.__wbg_iterator_e5822695327a3c39 = function() {
+    const ret = Symbol.iterator;
+    return addHeapObject(ret);
+};
+
 exports.__wbg_length_69bca3cb64fc8748 = function(arg0) {
     const ret = getObject(arg0).length;
     return ret;
@@ -335,21 +1931,69 @@ exports.__wbg_length_cdd215e10d9dd507 = function(arg0) {
     return ret;
 };
 
+exports.__wbg_new_1acc0b6eea89d040 = function() {
+    const ret = new Object();
+    return addHeapObject(ret);
+};
+
 exports.__wbg_new_5a79be3ab53b8aa5 = function(arg0) {
     const ret = new Uint8Array(getObject(arg0));
     return addHeapObject(ret);
 };
 
+exports.__wbg_next_020810e0ae8ebcb0 = function() { return handleError(function (arg0) {
+    const ret = getObject(arg0).next();
+    return addHeapObject(ret);
+}, arguments) };
+
+exports.__wbg_next_2c826fe5dfec6b6a = function(arg0) {
+    const ret = getObject(arg0).next;
+    return addHeapObject(ret);
+};
+
 exports.__wbg_prototypesetcall_2a6620b6922694b2 = function(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 };
 
+exports.__wbg_set_3807d5f0bfc24aa7 = function(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+};
+
+exports.__wbg_value_692627309814bb8c = function(arg0) {
+    const ret = getObject(arg0).value;
+    return addHeapObject(ret);
+};
+
 exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
     return addHeapObject(ret);
 };
 
+exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+};
+
+exports.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+exports.__wbindgen_cast_e7b45dd881f38ce3 = function(arg0, arg1) {
+    // Cast intrinsic for `U128 -> Externref`.
+    const ret = (BigInt.asUintN(64, arg0) | (BigInt.asUintN(64, arg1) << BigInt(64)));
+    return addHeapObject(ret);
+};
+
 exports.__wbindgen_object_clone_ref = function(arg0) {
     const ret = getObject(arg0);
     return addHeapObject(ret);