@typus/typus-perp-sdk 1.1.32 → 1.1.34

package/dist/src/generated/typus_perp/lp_pool.js

@@ -0,0 +1,1483 @@
+"use strict";
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BurnLpEvent = exports.UpdateLiquidityValueEvent = exports.CompleteRebalancingEvent = exports.RebalanceEvent = exports.RebalanceProcess = exports.ManagerRemoveLiquidityTokenEvent = exports.ResumeTokenPoolEvent = exports.SuspendTokenPoolEvent = exports.ResumePoolEvent = exports.SuspendPoolEvent = exports.RedeemEvent = exports.SwapEvent = exports.UpdateBorrowInfoEvent = exports.MintLpEvent = exports.UpdateMarginConfigEvent = exports.ManagerEmergencyWithdrawEvent = exports.ManagerEmergencyDepositEvent = exports.UpdateSpotConfigEvent = exports.AddLiquidityTokenEvent = exports.UpdateRebalanceCostThresholdBpEvent = exports.UpdateUnlockCountdownTsMsEvent = exports.NewLiquidityPoolEvent = exports.ManagerDepositReceipt = exports.DeactivatingShares = exports.LiquidityPool = exports.LiquidityPoolInfo = exports.TokenPool = exports.State = exports.Config = exports.MarginConfig = exports.SpotConfig = exports.Registry = void 0;
+exports.init = init;
+exports.newLiquidityPool = newLiquidityPool;
+exports.updateUnlockCountdownTsMs = updateUnlockCountdownTsMs;
+exports.updateRebalanceCostThresholdBp = updateRebalanceCostThresholdBp;
+exports.addLiquidityToken = addLiquidityToken;
+exports.updateSpotConfig = updateSpotConfig;
+exports.managerEmergencyDeposit = managerEmergencyDeposit;
+exports.managerEmergencyWithdraw = managerEmergencyWithdraw;
+exports.updateMarginConfig = updateMarginConfig;
+exports.mintLp = mintLp;
+exports.updateBorrowInfo = updateBorrowInfo;
+exports.swap = swap;
+exports.redeem = redeem;
+exports.claim = claim;
+exports.suspendPool = suspendPool;
+exports.resumePool = resumePool;
+exports.suspendTokenPool = suspendTokenPool;
+exports.resumeTokenPool = resumeTokenPool;
+exports.managerRemoveLiquidityToken = managerRemoveLiquidityToken;
+exports.checkTokenPoolStatus = checkTokenPoolStatus;
+exports.tokenPoolIsActive = tokenPoolIsActive;
+exports.rebalance = rebalance;
+exports.completeRebalancing = completeRebalancing;
+exports.managerRemoveAllLiquidity = managerRemoveAllLiquidity;
+exports.updateLiquidityValue = updateLiquidityValue;
+exports.getPoolLiquidity = getPoolLiquidity;
+exports.updateTvl = updateTvl;
+exports.orderFilled = orderFilled;
+exports.updateReserveAmount = updateReserveAmount;
+exports.putCollateral = putCollateral;
+exports.requestCollateral = requestCollateral;
+exports.putReceiptCollaterals = putReceiptCollaterals;
+exports.getReceiptCollateral = getReceiptCollateral;
+exports.calculateMintLp = calculateMintLp;
+exports.calculateBurnLp = calculateBurnLp;
+exports.calculateLpFee = calculateLpFee;
+exports.calculateSwapFee = calculateSwapFee;
+exports.checkTvlUpdated = checkTvlUpdated;
+exports.burnLp_ = burnLp_;
+exports.viewSwapResult = viewSwapResult;
+exports.getReceiptCollateralBcs = getReceiptCollateralBcs;
+exports.getExpiredReceiptCollateralBcs = getExpiredReceiptCollateralBcs;
+exports.getLiquidityPool = getLiquidityPool;
+exports.getMutLiquidityPool = getMutLiquidityPool;
+exports.safetyCheck = safetyCheck;
+exports.checkActive = checkActive;
+exports.oracleMatched = oracleMatched;
+exports.getTokenPool = getTokenPool;
+exports.getMutTokenPool = getMutTokenPool;
+exports.getLpTokenType = getLpTokenType;
+exports.getLiquidityTokenDecimal = getLiquidityTokenDecimal;
+exports.getTokenPoolState = getTokenPoolState;
+exports.checkTradingOrderSizeValid = checkTradingOrderSizeValid;
+exports.getCumulativeBorrowRate = getCumulativeBorrowRate;
+exports.getTvlUsd = getTvlUsd;
+exports.getBorrowRateDecimal = getBorrowRateDecimal;
+exports.deprecated = deprecated;
+exports.getUserDeactivatingShares = getUserDeactivatingShares;
+/**
+ * The `lp_pool` module is the heart of the TLP (Typus Liquidity Pool) logic. It
+ * defines the structures for liquidity pools, token pools, and their
+ * configurations. It also contains the entry functions for creating pools, adding
+ * liquidity, swapping, and redeeming.
+ */
+const index_1 = require("../utils/index");
+const bcs_1 = require("@mysten/sui/bcs");
+const object = __importStar(require("./deps/sui/object"));
+const type_name = __importStar(require("./deps/std/type_name"));
+const escrow = __importStar(require("./escrow"));
+const balance = __importStar(require("./deps/sui/balance"));
+const $moduleName = "@typus/perp::lp_pool";
+exports.Registry = new index_1.MoveStruct({
+    name: `${$moduleName}::Registry`,
+    fields: {
+        id: object.UID,
+        /** The number of pools in the registry. */
+        num_pool: bcs_1.bcs.u64(),
+        /** The UID of the liquidity pool registry. */
+        liquidity_pool_registry: object.UID,
+    },
+});
+exports.SpotConfig = new index_1.MoveStruct({
+    name: `${$moduleName}::SpotConfig`,
+    fields: {
+        /** The minimum deposit amount. */
+        min_deposit: bcs_1.bcs.u64(),
+        /** The maximum capacity of the pool. */
+        max_capacity: bcs_1.bcs.u64(),
+        /** The target weight of the token in the pool in basis points. */
+        target_weight_bp: bcs_1.bcs.u64(),
+        /** The basic mint fee in basis points. */
+        basic_mint_fee_bp: bcs_1.bcs.u64(),
+        /** The additional mint fee in basis points. */
+        additional_mint_fee_bp: bcs_1.bcs.u64(),
+        /** The basic burn fee in basis points. */
+        basic_burn_fee_bp: bcs_1.bcs.u64(),
+        /** The additional burn fee in basis points. */
+        additional_burn_fee_bp: bcs_1.bcs.u64(),
+        /** The swap fee in basis points. */
+        swap_fee_bp: bcs_1.bcs.u64(),
+        /** The protocol's share of the swap fee in basis points. */
+        swap_fee_protocol_share_bp: bcs_1.bcs.u64(),
+        /** The protocol's share of the lending interest in basis points. */
+        lending_protocol_share_bp: bcs_1.bcs.u64(),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.MarginConfig = new index_1.MoveStruct({
+    name: `${$moduleName}::MarginConfig`,
+    fields: {
+        /** The basic borrow rate at utilization 0. */
+        basic_borrow_rate_0: bcs_1.bcs.u64(),
+        /** The basic borrow rate at utilization 1. */
+        basic_borrow_rate_1: bcs_1.bcs.u64(),
+        /** The basic borrow rate at utilization 2. */
+        basic_borrow_rate_2: bcs_1.bcs.u64(),
+        /** The utilization threshold 0 in basis points. */
+        utilization_threshold_bp_0: bcs_1.bcs.u64(),
+        /** The utilization threshold 1 in basis points. */
+        utilization_threshold_bp_1: bcs_1.bcs.u64(),
+        /** The borrow interval in milliseconds. */
+        borrow_interval_ts_ms: bcs_1.bcs.u64(),
+        /** The maximum order reserve ratio in basis points. */
+        max_order_reserve_ratio_bp: bcs_1.bcs.u64(),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.Config = new index_1.MoveStruct({
+    name: `${$moduleName}::Config`,
+    fields: {
+        /** The address of the oracle. */
+        oracle_id: bcs_1.bcs.Address,
+        /** The number of decimals for the liquidity token. */
+        liquidity_token_decimal: bcs_1.bcs.u64(),
+        /** The spot-related configuration for the token pool. */
+        spot_config: exports.SpotConfig,
+        /** The margin-related configuration for the token pool. */
+        margin_config: exports.MarginConfig,
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.State = new index_1.MoveStruct({
+    name: `${$moduleName}::State`,
+    fields: {
+        /** The amount of liquidity in the pool. */
+        liquidity_amount: bcs_1.bcs.u64(),
+        /** The value of the liquidity in USD. */
+        value_in_usd: bcs_1.bcs.u64(),
+        /** The amount of liquidity reserved for open positions. */
+        reserved_amount: bcs_1.bcs.u64(),
+        /** The timestamp of the last update to the value_in_usd. */
+        update_ts_ms: bcs_1.bcs.u64(),
+        /** Whether the token pool is active. */
+        is_active: bcs_1.bcs.bool(),
+        /** The timestamp of the last borrow rate calculation. */
+        last_borrow_rate_ts_ms: bcs_1.bcs.u64(),
+        /** The cumulative borrow rate. */
+        cumulative_borrow_rate: bcs_1.bcs.u64(),
+        /** The previous timestamp of the last borrow rate calculation. */
+        previous_last_borrow_rate_ts_ms: bcs_1.bcs.u64(),
+        /** The previous cumulative borrow rate. */
+        previous_cumulative_borrow_rate: bcs_1.bcs.u64(),
+        /** The current lending amount. */
+        current_lending_amount: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.TokenPool = new index_1.MoveStruct({
+    name: `${$moduleName}::TokenPool`,
+    fields: {
+        /** The type name of the token. */
+        token_type: type_name.TypeName,
+        /** The configuration for the token pool. */
+        config: exports.Config,
+        /** The state of the token pool. */
+        state: exports.State,
+    },
+});
+exports.LiquidityPoolInfo = new index_1.MoveStruct({
+    name: `${$moduleName}::LiquidityPoolInfo`,
+    fields: {
+        /** The number of decimals for the LP token. */
+        lp_token_decimal: bcs_1.bcs.u64(),
+        /** The total supply of LP tokens. */
+        total_share_supply: bcs_1.bcs.u64(),
+        /** The total value locked in the pool in USD. */
+        tvl_usd: bcs_1.bcs.u64(),
+        /** Whether the pool is active. */
+        is_active: bcs_1.bcs.bool(),
+    },
+});
+exports.LiquidityPool = new index_1.MoveStruct({
+    name: `${$moduleName}::LiquidityPool`,
+    fields: {
+        /**
+         * The UID of the object. Token balances are dynamic fields under this id with
+         * TypeName key.
+         */
+        id: object.UID,
+        /** The index of the pool. */
+        index: bcs_1.bcs.u64(),
+        /** The type name of the LP token. */
+        lp_token_type: type_name.TypeName,
+        /** A vector of the type names of the liquidity tokens. */
+        liquidity_tokens: bcs_1.bcs.vector(type_name.TypeName),
+        /** A vector of the token pools. */
+        token_pools: bcs_1.bcs.vector(exports.TokenPool),
+        /** Information about the liquidity pool. */
+        pool_info: exports.LiquidityPoolInfo,
+        /** A vector of unsettled bid receipts from liquidations. */
+        liquidated_unsettled_receipts: bcs_1.bcs.vector(escrow.UnsettledBidReceipt),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+        /** Padding for future use. */
+        bcs_padding: bcs_1.bcs.vector(bcs_1.bcs.u8()),
+    },
+});
+exports.DeactivatingShares = new index_1.MoveStruct({
+    name: `${$moduleName}::DeactivatingShares`,
+    fields: {
+        /** The balance of the deactivating shares. */
+        balance: balance.Balance,
+        /** The timestamp of the redemption. */
+        redeem_ts_ms: bcs_1.bcs.u64(),
+        /** The timestamp when the shares can be unlocked. */
+        unlock_ts_ms: bcs_1.bcs.u64(),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.ManagerDepositReceipt = new index_1.MoveStruct({
+    name: `${$moduleName}::ManagerDepositReceipt`,
+    fields: {
+        id: object.UID,
+        /** The index of the pool. */
+        index: bcs_1.bcs.u64(),
+        /** The type name of the token. */
+        token_type: type_name.TypeName,
+        /** The amount of the deposit. */
+        amount: bcs_1.bcs.u64(),
+        /** Padding for future use. */
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.NewLiquidityPoolEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::NewLiquidityPoolEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        lp_token_type: type_name.TypeName,
+        lp_token_decimal: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateUnlockCountdownTsMsEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateUnlockCountdownTsMsEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        previous_unlock_countdown_ts_ms: bcs_1.bcs.u64(),
+        new_unlock_countdown_ts_ms: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateRebalanceCostThresholdBpEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateRebalanceCostThresholdBpEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        previous_rebalance_cost_threshold_bp: bcs_1.bcs.u64(),
+        new_rebalance_cost_threshold_bp: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.AddLiquidityTokenEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::AddLiquidityTokenEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        token_type: type_name.TypeName,
+        config: exports.Config,
+        state: exports.State,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateSpotConfigEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateSpotConfigEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token_type: type_name.TypeName,
+        previous_spot_config: exports.SpotConfig,
+        new_spot_config: exports.SpotConfig,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.ManagerEmergencyDepositEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::ManagerEmergencyDepositEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token_type: type_name.TypeName,
+        amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.ManagerEmergencyWithdrawEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::ManagerEmergencyWithdrawEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token_type: type_name.TypeName,
+        amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateMarginConfigEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateMarginConfigEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token_type: type_name.TypeName,
+        previous_margin_config: exports.MarginConfig,
+        new_margin_config: exports.MarginConfig,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.MintLpEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::MintLpEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token_type: type_name.TypeName,
+        deposit_amount: bcs_1.bcs.u64(),
+        deposit_amount_usd: bcs_1.bcs.u64(),
+        mint_fee_usd: bcs_1.bcs.u64(),
+        lp_token_type: type_name.TypeName,
+        minted_lp_amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateBorrowInfoEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateBorrowInfoEvent`,
+    fields: {
+        index: bcs_1.bcs.u64(),
+        liquidity_token_type: type_name.TypeName,
+        previous_borrow_ts_ms: bcs_1.bcs.u64(),
+        previous_cumulative_borrow_rate: bcs_1.bcs.u64(),
+        borrow_interval_ts_ms: bcs_1.bcs.u64(),
+        last_borrow_rate_ts_ms: bcs_1.bcs.u64(),
+        last_cumulative_borrow_rate: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.SwapEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::SwapEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        from_token_type: type_name.TypeName,
+        from_amount: bcs_1.bcs.u64(),
+        to_token_type: type_name.TypeName,
+        min_to_amount: bcs_1.bcs.u64(),
+        actual_to_amount: bcs_1.bcs.u64(),
+        fee_amount: bcs_1.bcs.u64(),
+        fee_amount_usd: bcs_1.bcs.u64(),
+        oracle_price_from_token: bcs_1.bcs.u64(),
+        oracle_price_to_token: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.RedeemEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::RedeemEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        share: bcs_1.bcs.u64(),
+        share_price: bcs_1.bcs.u64(),
+        timestamp_ts_ms: bcs_1.bcs.u64(),
+        unlock_ts_ms: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.SuspendPoolEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::SuspendPoolEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.ResumePoolEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::ResumePoolEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.SuspendTokenPoolEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::SuspendTokenPoolEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token: type_name.TypeName,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.ResumeTokenPoolEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::ResumeTokenPoolEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token: type_name.TypeName,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.ManagerRemoveLiquidityTokenEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::ManagerRemoveLiquidityTokenEvent`,
+    fields: {
+        index: bcs_1.bcs.u64(),
+        liquidity_token: type_name.TypeName,
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.RebalanceProcess = new index_1.MoveStruct({
+    name: `${$moduleName}::RebalanceProcess`,
+    fields: {
+        index: bcs_1.bcs.u64(),
+        token_type_a: type_name.TypeName,
+        token_decimal_a: bcs_1.bcs.u64(),
+        token_amount_a: bcs_1.bcs.u64(),
+        oracle_price_a: bcs_1.bcs.u64(),
+        reduced_usd: bcs_1.bcs.u64(),
+        token_type_b: type_name.TypeName,
+        token_decimal_b: bcs_1.bcs.u64(),
+        oracle_price_b: bcs_1.bcs.u64(),
+    },
+});
+exports.RebalanceEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::RebalanceEvent`,
+    fields: {
+        index: bcs_1.bcs.u64(),
+        from_token: type_name.TypeName,
+        to_token: type_name.TypeName,
+        rebalance_amount: bcs_1.bcs.u64(),
+        from_token_oracle_price: bcs_1.bcs.u64(),
+        to_token_oracle_price: bcs_1.bcs.u64(),
+        reduced_usd: bcs_1.bcs.u64(),
+        tvl_usd: bcs_1.bcs.u64(),
+        from_token_liquidity_amount: bcs_1.bcs.u64(),
+        to_token_liquidity_amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.CompleteRebalancingEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::CompleteRebalancingEvent`,
+    fields: {
+        index: bcs_1.bcs.u64(),
+        from_token: type_name.TypeName,
+        to_token: type_name.TypeName,
+        from_token_oracle_price: bcs_1.bcs.u64(),
+        to_token_oracle_price: bcs_1.bcs.u64(),
+        swapped_back_usd: bcs_1.bcs.u64(),
+        tvl_usd: bcs_1.bcs.u64(),
+        from_token_liquidity_amount: bcs_1.bcs.u64(),
+        to_token_liquidity_amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.UpdateLiquidityValueEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::UpdateLiquidityValueEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        liquidity_token: type_name.TypeName,
+        price: bcs_1.bcs.u64(),
+        value_in_usd: bcs_1.bcs.u64(),
+        lp_pool_tvl_usd: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+exports.BurnLpEvent = new index_1.MoveStruct({
+    name: `${$moduleName}::BurnLpEvent`,
+    fields: {
+        sender: bcs_1.bcs.Address,
+        index: bcs_1.bcs.u64(),
+        lp_token_type: type_name.TypeName,
+        burn_lp_amount: bcs_1.bcs.u64(),
+        burn_amount_usd: bcs_1.bcs.u64(),
+        burn_fee_usd: bcs_1.bcs.u64(),
+        liquidity_token_type: type_name.TypeName,
+        withdraw_token_amount: bcs_1.bcs.u64(),
+        u64_padding: bcs_1.bcs.vector(bcs_1.bcs.u64()),
+    },
+});
+function init(options = {}) {
+    const packageAddress = options.package ?? "@typus/perp";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "init",
+    });
+}
+/** [Authorized Function] Creates a new liquidity pool. */
+function newLiquidityPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64", "u64"];
+    const parameterNames = ["version", "registry", "lpTokenDecimal", "unlockCountdownTsMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "new_liquidity_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Updates the unlock countdown. */
+function updateUnlockCountdownTsMs(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64", "u64"];
+    const parameterNames = ["version", "registry", "index", "unlockCountdownTsMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_unlock_countdown_ts_ms",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Updates the rebalance cost threshold. */
+function updateRebalanceCostThresholdBp(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64", "u64"];
+    const parameterNames = ["version", "registry", "index", "rebalanceCostThresholdBp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_rebalance_cost_threshold_bp",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Adds a new liquidity token to a pool. */
+function addLiquidityToken(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = [
+        "version",
+        "registry",
+        "index",
+        "oracle",
+        "tokenDecimal",
+        "targetWeightBp",
+        "minDeposit",
+        "maxCapacity",
+        "basicMintFeeBp",
+        "additionalMintFeeBp",
+        "basicBurnFeeBp",
+        "additionalBurnFeeBp",
+        "swapFeeBp",
+        "swapFeeProtocolShareBp",
+        "lendingProtocolShareBp",
+        "basicBorrowRate_0",
+        "basicBorrowRate_1",
+        "basicBorrowRate_2",
+        "utilizationThresholdBp_0",
+        "utilizationThresholdBp_1",
+        "borrowIntervalTsMs",
+        "maxOrderReserveRatioBp",
+    ];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "add_liquidity_token",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Updates the spot configuration for a token. */
+function updateSpotConfig(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+    ];
+    const parameterNames = [
+        "version",
+        "registry",
+        "index",
+        "targetWeightBp",
+        "minDeposit",
+        "maxCapacity",
+        "basicMintFeeBp",
+        "additionalMintFeeBp",
+        "basicBurnFeeBp",
+        "additionalBurnFeeBp",
+        "swapFeeBp",
+        "swapFeeProtocolShareBp",
+        "lendingProtocolShareBp",
+    ];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_spot_config",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Allows a manager to deposit tokens in an emergency. */
+function managerEmergencyDeposit(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+    ];
+    const parameterNames = ["version", "registry", "index", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "manager_emergency_deposit",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Allows a manager to withdraw tokens in an emergency. */
+function managerEmergencyWithdraw(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        `${packageAddress}::lp_pool::ManagerDepositReceipt`,
+    ];
+    const parameterNames = ["version", "registry", "index", "receipt"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "manager_emergency_withdraw",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Updates the margin configuration for a token. */
+function updateMarginConfig(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::option::Option<u64>",
+    ];
+    const parameterNames = [
+        "version",
+        "registry",
+        "index",
+        "basicBorrowRate_0",
+        "basicBorrowRate_1",
+        "basicBorrowRate_2",
+        "utilizationThresholdBp_0",
+        "utilizationThresholdBp_1",
+        "borrowIntervalTsMs",
+        "maxOrderReserveRatioBp",
+    ];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_margin_config",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [User Function] Mints LP tokens. */
+function mintLp(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        `${packageAddress}::treasury_caps::TreasuryCaps`,
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "u64",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "treasuryCaps", "oracle", "index", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "mint_lp",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [User Function] Updates the borrow information for all tokens in a pool. */
+function updateBorrowInfo(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_borrow_info",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [User Function] Swaps one token for another. */
+function swap(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "oracleFromToken", "oracleToToken", "fromCoin", "minToAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "swap",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [User Function] Redeems LP tokens for underlying assets. */
+function redeem(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[0]}>`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "balance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "redeem",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [User Function] Claims underlying assets from redeemed LP tokens. */
+function claim(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        `${packageAddress}::treasury_caps::TreasuryCaps`,
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "treasuryCaps", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "claim",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Suspends a liquidity pool. */
+function suspendPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "suspend_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Resumes a liquidity pool. */
+function resumePool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "resume_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Suspends a token pool. */
+function suspendTokenPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "suspend_token_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Resumes a token pool. */
+function resumeTokenPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "resume_token_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Manager removes a liquidity token. */
+function managerRemoveLiquidityToken(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "manager_remove_liquidity_token",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function checkTokenPoolStatus(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::Registry`, "u64", "bool"];
+    const parameterNames = ["registry", "index", "assertActive"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "check_token_pool_status",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function tokenPoolIsActive(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::TokenPool`];
+    const parameterNames = ["tokenPool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "token_pool_is_active",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** [Authorized Function] Manager take the liquidity token A to swap. */
+function rebalance(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "oracleTokenA", "oracleTokenB", "rebalanceAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "rebalance",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [Authorized Function] Manager swap back the liquidity token from A to B. */
+function completeRebalancing(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[1]}>`,
+        `${packageAddress}::lp_pool::RebalanceProcess`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "oracleTokenA", "oracleTokenB", "swappedBackBalance", "rebalanceProcess"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "complete_rebalancing",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * Only for current contract sunset purpose. Will be removed in new contract
+ * [Authorized Function] Manager remove all liquidity of a token.
+ */
+function managerRemoveAllLiquidity(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "manager_remove_all_liquidity",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/** [User Function] Update the liquidity value with oracle. */
+function updateLiquidityValue(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_liquidity_value",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+/**
+ * [View Function] Get the liquidity pool token amounts. Return
+ * [total_share_supply, tvl_usd, token_types, amounts, usds]
+ */
+function getPoolLiquidity(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::admin::Version`, `${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["version", "registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_pool_liquidity",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function updateTvl(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "liquidityPool", "tokenType", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_tvl",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function orderFilled(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "bool",
+        "u64",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[0]}>`,
+    ];
+    const parameterNames = ["liquidityPool", "addReserve", "dReserve", "feeBalance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "order_filled",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function updateReserveAmount(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::LiquidityPool`, "bool", "u64"];
+    const parameterNames = ["liquidityPool", "addReserve", "dReserve"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "update_reserve_amount",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function putCollateral(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[0]}>`,
+        "u64",
+        "u64",
+    ];
+    const parameterNames = ["liquidityPool", "collateral", "collateralOraclePrice", "collateralOraclePriceDecimal"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "put_collateral",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function requestCollateral(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::LiquidityPool`, "u64", "u64", "u64"];
+    const parameterNames = ["liquidityPool", "collateralAmount", "collateralOraclePrice", "collateralOraclePriceDecimal"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "request_collateral",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function putReceiptCollaterals(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        `vector<${packageAddress}::escrow::UnsettledBidReceipt>`,
+    ];
+    const parameterNames = ["liquidityPool", "unsettledBidReceipts"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "put_receipt_collaterals",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getReceiptCollateral(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::LiquidityPool`];
+    const parameterNames = ["liquidityPool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_receipt_collateral",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculateMintLp(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "u64",
+        "u64",
+        "u64",
+    ];
+    const parameterNames = ["registry", "index", "tokenType", "price", "priceDecimal", "depositAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "calculate_mint_lp",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculateBurnLp(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "u64",
+        "u64",
+        "u64",
+    ];
+    const parameterNames = ["registry", "index", "tokenType", "price", "priceDecimal", "burnAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "calculate_burn_lp",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculateLpFee(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "u64",
+        "u64",
+        "bool",
+    ];
+    const parameterNames = ["liquidityPool", "tokenType", "depositAmount", "depositAmountUsd", "isMint"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "calculate_lp_fee",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculateSwapFee(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "u64",
+        "u64",
+        "bool",
+    ];
+    const parameterNames = ["liquidityPool", "tokenType", "amount", "amountUsd", "swapIn"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "calculate_swap_fee",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function checkTvlUpdated(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["liquidityPool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "check_tvl_updated",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function burnLp_(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        `${packageAddress}::treasury_caps::TreasuryCaps`,
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        `0x0000000000000000000000000000000000000000000000000000000000000002::balance::Balance<${options.typeArguments[0]}>`,
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "treasuryCaps", "oracle", "burnLpBalance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "burn_lp_",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function viewSwapResult(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::admin::Version`,
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "0x1d17058789bd1e1e79f1a92424519a88146f191f58a06cc4d9ab23d17d46ab73::oracle::Oracle",
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock",
+    ];
+    const parameterNames = ["version", "registry", "index", "oracleFromToken", "oracleToToken", "fromAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "view_swap_result",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}
+function getReceiptCollateralBcs(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_receipt_collateral_bcs",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getExpiredReceiptCollateralBcs(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::Registry`,
+        "0x6c9a394a43844fc09d9617bc8a8e775a4521f0e28e83de1da780d043a498671f::typus_dov_single::Registry",
+        "u64",
+    ];
+    const parameterNames = ["registry", "dovRegistry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_expired_receipt_collateral_bcs",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getLiquidityPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_liquidity_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getMutLiquidityPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_mut_liquidity_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function safetyCheck(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "address",
+    ];
+    const parameterNames = ["liquidityPool", "tokenType", "oracleId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "safety_check",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function checkActive(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::LiquidityPool`];
+    const parameterNames = ["liquidityPool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "check_active",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function oracleMatched(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "address",
+    ];
+    const parameterNames = ["liquidityPool", "tokenType", "oracleId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "oracle_matched",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getTokenPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["liquidityPool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_token_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getMutTokenPool(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["liquidityPool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_mut_token_pool",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getLpTokenType(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::Registry`, "u64"];
+    const parameterNames = ["registry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_lp_token_type",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getLiquidityTokenDecimal(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::Registry`,
+        "u64",
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["registry", "index", "liquidityToken"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_liquidity_token_decimal",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getTokenPoolState(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["liquidityPool", "liquidityToken"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_token_pool_state",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function checkTradingOrderSizeValid(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+        "u64",
+    ];
+    const parameterNames = ["liquidityPool", "liquidityToken", "reserveAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "check_trading_order_size_valid",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getCumulativeBorrowRate(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [
+        `${packageAddress}::lp_pool::LiquidityPool`,
+        "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName",
+    ];
+    const parameterNames = ["liquidityPool", "liquidityToken"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_cumulative_borrow_rate",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getTvlUsd(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::LiquidityPool`];
+    const parameterNames = ["liquidityPool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_tvl_usd",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function getBorrowRateDecimal(options = {}) {
+    const packageAddress = options.package ?? "@typus/perp";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_borrow_rate_decimal",
+    });
+}
+function deprecated(options = {}) {
+    const packageAddress = options.package ?? "@typus/perp";
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "deprecated",
+    });
+}
+function getUserDeactivatingShares(options) {
+    const packageAddress = options.package ?? "@typus/perp";
+    const argumentsTypes = [`${packageAddress}::lp_pool::Registry`, "u64", "address"];
+    const parameterNames = ["registry", "index", "user"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: "lp_pool",
+        function: "get_user_deactivating_shares",
+        arguments: (0, index_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments,
+    });
+}