@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/waterx_perp/lp_pool.js

@@ -0,0 +1,1630 @@
+"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.AumMarketContribution = exports.WlpAum = exports.RedeemRequest = exports.WlpPool = exports.TokenPoolInfo = void 0;
+exports.assertWxaProtocolPerm = assertWxaProtocolPerm;
+exports.createPool = createPool;
+exports.createAum = createAum;
+exports.assertVersion = assertVersion;
+exports.allowVersion = allowVersion;
+exports.disallowVersion = disallowVersion;
+exports.addToken = addToken;
+exports.updateTokenPoolConfig = updateTokenPoolConfig;
+exports.mintWlp = mintWlp;
+exports.requestRedeem = requestRedeem;
+exports.mintWlpWithPricingTvl = mintWlpWithPricingTvl;
+exports.doRequestRedeem = doRequestRedeem;
+exports.cancelRedeem = cancelRedeem;
+exports.rejectRedeemByAdmin = rejectRedeemByAdmin;
+exports.rejectRedeemByRedeemOperator = rejectRedeemByRedeemOperator;
+exports.settleRedeem = settleRedeem;
+exports.settleRedeemWithPricingTvl = settleRedeemWithPricingTvl;
+exports.updateBorrowRates = updateBorrowRates;
+exports.updateTokenValue = updateTokenValue;
+exports.aumPoolId = aumPoolId;
+exports.aumMarketCount = aumMarketCount;
+exports.aumTotalTraderProfitUsd = aumTotalTraderProfitUsd;
+exports.aumTotalTraderLossUsd = aumTotalTraderLossUsd;
+exports.aumMarketContribution = aumMarketContribution;
+exports.aumMarketContributionByIndex = aumMarketContributionByIndex;
+exports.aumContributionIsTraderProfit = aumContributionIsTraderProfit;
+exports.aumContributionPnlUsd = aumContributionPnlUsd;
+exports.aumContributionLastRefreshTimestamp = aumContributionLastRefreshTimestamp;
+exports.registerMarketAum = registerMarketAum;
+exports.refreshMarketAum = refreshMarketAum;
+exports.aumEquityUsd = aumEquityUsd;
+exports.cumulativeBorrowRate = cumulativeBorrowRate;
+exports.tvlUsd = tvlUsd;
+exports.checkOiCap = checkOiCap;
+exports.checkReserveValid = checkReserveValid;
+exports.increaseReserve = increaseReserve;
+exports.decreaseReserve = decreaseReserve;
+exports.putCollateral = putCollateral;
+exports.requestCollateral = requestCollateral;
+exports.tokenPoolInfo = tokenPoolInfo;
+exports.tokenDecimal = tokenDecimal;
+exports.tokenTicker = tokenTicker;
+exports.suspendPool = suspendPool;
+exports.resumePool = resumePool;
+exports.isActive = isActive;
+exports.lpDecimal = lpDecimal;
+exports.totalLpSupply = totalLpSupply;
+exports.borrowRedeemRequests = borrowRedeemRequests;
+exports.poolTvlUsd = poolTvlUsd;
+exports.tokenCount = tokenCount;
+exports.borrowTokenPoolByIndex = borrowTokenPoolByIndex;
+exports.tpiTokenType = tpiTokenType;
+exports.tpiTicker = tpiTicker;
+exports.tpiTokenDecimal = tpiTokenDecimal;
+exports.tpiLiquidityAmount = tpiLiquidityAmount;
+exports.tpiReservedAmount = tpiReservedAmount;
+exports.tpiValueUsd = tpiValueUsd;
+exports.tpiTargetWeightBps = tpiTargetWeightBps;
+exports.tpiMintFeeBps = tpiMintFeeBps;
+exports.tpiBurnFeeBps = tpiBurnFeeBps;
+exports.tpiCumulativeBorrowRate = tpiCumulativeBorrowRate;
+exports.tpiLastPriceRefreshTimestamp = tpiLastPriceRefreshTimestamp;
+exports.redeemRecipientAccountId = redeemRecipientAccountId;
+exports.redeemLpAmount = redeemLpAmount;
+exports.redeemTokenType = redeemTokenType;
+exports.redeemRequestTimestamp = redeemRequestTimestamp;
+exports.findTokenPoolIndex = findTokenPoolIndex;
+exports.borrowTokenPool = borrowTokenPool;
+exports.borrowMutTokenPool = borrowMutTokenPool;
+exports.refreshTokenValueWithPrice = refreshTokenValueWithPrice;
+exports.addAumContribution = addAumContribution;
+exports.removeAumContribution = removeAumContribution;
+exports.assertAumFresh = assertAumFresh;
+exports.assertPricesFresh = assertPricesFresh;
+exports.assertRedeemAllowed = assertRedeemAllowed;
+exports.assertTokenRedeemAllowed = assertTokenRedeemAllowed;
+exports.calculateTotalWlpUtilizationBps = calculateTotalWlpUtilizationBps;
+exports.takeRedeemRequest = takeRedeemRequest;
+exports.returnRejectedRedeemRequest = returnRejectedRedeemRequest;
+exports.calculateDynamicFee = calculateDynamicFee;
+exports.assertValidBorrowConfig = assertValidBorrowConfig;
+exports.assertValidMaxReserveRatio = assertValidMaxReserveRatio;
+exports.calculateBorrowRate = calculateBorrowRate;
+exports.calculateBorrowRateAccrual = calculateBorrowRateAccrual;
+/**
+ * WLP (WaterX Liquidity Pool) — counterparty to all traders. Manages liquidity
+ * pools, token pools, minting/burning WLP, and borrowing. Mint is instant; redeem
+ * is T+1.
+ */
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const type_name = __importStar(require("./deps/std/type_name.js"));
+const float = __importStar(require("./deps/bucket_v2_framework/float.js"));
+const vec_set = __importStar(require("./deps/sui/vec_set.js"));
+const coin = __importStar(require("./deps/sui/coin.js"));
+const keyed_big_vector = __importStar(require("./keyed_big_vector.js"));
+const balance = __importStar(require("./deps/sui/balance.js"));
+const $moduleName = '@waterx/perp::lp_pool';
+exports.TokenPoolInfo = new index_ts_1.MoveStruct({ name: `${$moduleName}::TokenPoolInfo`, fields: {
+        /** Token type. */
+        token_type: type_name.TypeName,
+        /**
+         * Oracle ticker bound to this token type. Set at `add_token` time and immutable
+         * thereafter. Every per-token price lookup (`mint_wlp`, `settle_redeem`,
+         * `update_token_value`, perp collateral pricing) goes through this field — callers
+         * do _not_ supply a ticker string, eliminating the "lie about the asset I'm
+         * pricing" attack class.
+         */
+        ticker: bcs_1.bcs.string(),
+        /** Token decimal. */
+        token_decimal: bcs_1.bcs.u8(),
+        /** Target weight in bps (e.g., 5000 = 50%). */
+        target_weight_bps: bcs_1.bcs.u64(),
+        /** Mint fee in bps. */
+        mint_fee_bps: bcs_1.bcs.u64(),
+        /** Burn fee in bps. */
+        burn_fee_bps: bcs_1.bcs.u64(),
+        /** Max capacity. */
+        max_capacity: bcs_1.bcs.u64(),
+        /** Min deposit. */
+        min_deposit: bcs_1.bcs.u64(),
+        /** Per-interval borrow rate at utilization 0 (Float, 1e9 scale). */
+        basic_borrow_rate_0: float.Float,
+        /** Per-interval borrow rate at utilization threshold_0 (Float). */
+        basic_borrow_rate_1: float.Float,
+        /** Per-interval borrow rate at utilization threshold_1 (Float). */
+        basic_borrow_rate_2: float.Float,
+        utilization_threshold_0_bps: bcs_1.bcs.u64(),
+        utilization_threshold_1_bps: bcs_1.bcs.u64(),
+        borrow_interval_ms: bcs_1.bcs.u64(),
+        max_reserve_ratio_bps: bcs_1.bcs.u64(),
+        /** Liquidity amount in token units. */
+        liquidity_amount: bcs_1.bcs.u64(),
+        /** Value in USD. */
+        value_usd: float.Float,
+        /** Reserved amount for open positions. */
+        reserved_amount: bcs_1.bcs.u64(),
+        /** Last borrow rate update timestamp. */
+        last_borrow_timestamp: bcs_1.bcs.u64(),
+        /** Cumulative borrow rate as Float (1e9 scale). */
+        cumulative_borrow_rate: float.Float,
+        /** Last timestamp when this token price was refreshed via oracle. */
+        last_price_refresh_timestamp: bcs_1.bcs.u64()
+    } });
+exports.WlpPool = new index_ts_1.MoveStruct({ name: `${$moduleName}::WlpPool<phantom LP_TOKEN>`, fields: {
+        id: bcs_1.bcs.Address,
+        /** Whether this pool is active. */
+        is_active: bcs_1.bcs.bool(),
+        /** Allowed protocol versions (admin-managed). */
+        allowed_versions: vec_set.VecSet(bcs_1.bcs.u16()),
+        /** LP token treasury cap. */
+        lp_treasury_cap: coin.TreasuryCap,
+        /** LP token decimal. */
+        lp_decimal: bcs_1.bcs.u8(),
+        /** Supported token types. */
+        token_types: bcs_1.bcs.vector(type_name.TypeName),
+        /** Token pool configs and states. */
+        token_pools: bcs_1.bcs.vector(exports.TokenPoolInfo),
+        /** Total value locked in USD (Float). */
+        tvl_usd: float.Float,
+        /** Redeem requests. */
+        redeem_requests: keyed_big_vector.KeyedBigVector,
+        /** Next redeem request ID. */
+        next_redeem_id: bcs_1.bcs.u64()
+    } });
+exports.RedeemRequest = new index_ts_1.MoveStruct({ name: `${$moduleName}::RedeemRequest<phantom LP_TOKEN>`, fields: {
+        /** Wxa account ID to repay into at settlement. */
+        recipient_account_id: bcs_1.bcs.Address,
+        /** LP balance held pending settlement. */
+        lp_balance: balance.Balance,
+        /** Requested token type to receive. */
+        token_type: type_name.TypeName,
+        /** Request timestamp. */
+        request_timestamp: bcs_1.bcs.u64()
+    } });
+exports.WlpAum = new index_ts_1.MoveStruct({ name: `${$moduleName}::WlpAum<phantom LP_TOKEN>`, fields: {
+        id: bcs_1.bcs.Address,
+        /** WLP pool this AUM object prices. */
+        pool_id: bcs_1.bcs.Address,
+        /** Registered market PnL contributions keyed by market ID. */
+        market_contributions: keyed_big_vector.KeyedBigVector,
+        /** Sum of registered markets where traders are in profit. */
+        total_trader_profit_usd: float.Float,
+        /** Sum of registered markets where traders are in loss. */
+        total_trader_loss_usd: float.Float
+    } });
+exports.AumMarketContribution = new index_ts_1.MoveStruct({ name: `${$moduleName}::AumMarketContribution`, fields: {
+        /** Whether the market's aggregate unrealized PnL is trader profit. */
+        is_trader_profit: bcs_1.bcs.bool(),
+        /** Absolute aggregate unrealized PnL in USD. */
+        pnl_usd: float.Float,
+        /** Timestamp of the oracle price used to refresh this contribution. */
+        last_refresh_timestamp: bcs_1.bcs.u64()
+    } });
+/**
+ * Pre-take permission check for WLP actions. Uses `WaterXPerp` as the permission
+ * scope (shared witness across the perp's wxa surface). `PERM_MINT_WLP` and
+ * `PERM_REDEEM_WLP` are the relevant bits. Must run before any `wxa_account::take`
+ * so a failed auth doesn't drain.
+ */
+function assertWxaProtocolPerm(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'address',
+        'u32',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["wxaRegistry", "accountId", "sender", "permission"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_wxa_protocol_perm',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new WLP pool (AdminCap-gated). */
+function createPool(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u8'
+    ];
+    const parameterNames = ["Cap", "lpTreasuryCap", "lpDecimal"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'create_pool',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a pool-level AUM object used for multi-market WLP share pricing. */
+function createAum(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["Cap", "pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'create_aum',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function assertVersion(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["wlpPool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function allowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["wlpPool", "_", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'allow_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function disallowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["wlpPool", "_", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'disallow_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Adds a supported token to the pool. `basic_borrow_rate_0/1/2` are scaled Float
+ * values (1e9 scale).
+ */
+function addToken(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        'u8',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u128',
+        'u128',
+        'u128',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "Cap", "ticker", "tokenDecimal", "targetWeightBps", "mintFeeBps", "burnFeeBps", "maxCapacity", "minDeposit", "basicBorrowRate_0", "basicBorrowRate_1", "basicBorrowRate_2", "utilizationThreshold_0Bps", "utilizationThreshold_1Bps", "borrowIntervalMs", "maxReserveRatioBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'add_token',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Updates configuration for an existing token pool (AdminCap-gated). Does not
+ * modify state fields (liquidity, value, reserved, borrow state).
+ */
+function updateTokenPoolConfig(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        'u128',
+        'u128',
+        'u128',
+        'u64',
+        'u64',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["pool", "Cap", "targetWeightBps", "mintFeeBps", "burnFeeBps", "maxCapacity", "minDeposit", "basicBorrowRate_0", "basicBorrowRate_1", "basicBorrowRate_2", "utilizationThreshold_0Bps", "utilizationThreshold_1Bps", "borrowIntervalMs", "maxReserveRatioBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'update_token_pool_config',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Mints WLP by taking `deposit_amount` of `TOKEN` from the caller's wxa stored
+ * balance, pricing against AUM-adjusted TVL, and putting the minted WLP back into
+ * the same wxa account. Returns the minted `lp_amount` (also emitted on
+ * `WlpMinted`).
+ */
+function mintWlp(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig", "wxaRegistry", "aum", "senderRequest", "accountId", "depositAmount", "minLpAmount", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'mint_wlp',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Enqueues a WLP redeem (T+1 settlement) by taking `lp_amount` of `LP_TOKEN` from
+ * the caller's wxa stored balance into a pending `RedeemRequest`. Returns the
+ * `request_id`. Settlement (via `settle_redeem`) and cancellation (via
+ * `cancel_redeem`) repay the proceeds / WLP back into the same wxa account.
+ */
+function requestRedeem(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig", "wxaRegistry", "senderRequest", "accountId", "lpAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'request_redeem',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function mintWlpWithPricingTvl(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        'u64',
+        'address',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig", "deposit", "oracle", "ticker", "pricingTvlUsd", "minLpAmount", "accountId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'mint_wlp_with_pricing_tvl',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function doRequestRedeem(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig", "recipientAccountId", "lpBalance", "expectedLpAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'do_request_redeem',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Cancels a pending WLP redeem request. Caller must hold `PERM_REDEEM_WLP` on the
+ * recipient wxa account (checked under the shared `WaterXPerp` permission scope).
+ * The escrowed WLP is put back into the recipient account.
+ */
+function cancelRedeem(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig", "wxaRegistry", "senderRequest", "requestId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'cancel_redeem',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Rejects a pending WLP redeem request as admin and repays the LP back to the
+ * original recipient's wxa account.
+ */
+function rejectRedeemByAdmin(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "wxaRegistry", "Cap", "requestId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'reject_redeem_by_admin',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Rejects a pending WLP redeem request as redeem operator and repays the LP back
+ * to the original recipient's wxa account.
+ */
+function rejectRedeemByRedeemOperator(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "globalConfig", "wxaRegistry", "operatorRequest", "requestId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'reject_redeem_by_redeem_operator',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Settles a WLP redeem request using pool-level AUM pricing. The payout is repaid
+ * back into the recipient's wxa account as `Balance<TOKEN>` via
+ * `wxa_account::put<TOKEN, WaterXPerp>`.
+ */
+function settleRedeem(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig", "wxaRegistry", "operatorRequest", "aum", "requestId", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'settle_redeem',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function settleRedeemWithPricingTvl(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig", "requestId", "oracle", "ticker", "pricingTvlUsd"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'settle_redeem_with_pricing_tvl',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Updates borrow rates for all token pools. */
+function updateBorrowRates(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'update_borrow_rates',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function updateTokenValue(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'update_token_value',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function aumPoolId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["aum"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_pool_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function aumMarketCount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["aum"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_market_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function aumTotalTraderProfitUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["aum"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_total_trader_profit_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function aumTotalTraderLossUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["aum"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_total_trader_loss_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function aumMarketContribution(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["aum", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_market_contribution',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function aumMarketContributionByIndex(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["aum", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_market_contribution_by_index',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function aumContributionIsTraderProfit(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["c"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_contribution_is_trader_profit',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function aumContributionPnlUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["c"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_contribution_pnl_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function aumContributionLastRefreshTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["c"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_contribution_last_refresh_timestamp',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Registers a market contribution for this WLP AUM object. */
+function registerMarketAum(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'bool',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["aum", "Cap", "marketId", "isTraderProfit", "pnlUsd"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'register_market_aum',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Refreshes an existing market's AUM contribution. */
+function refreshMarketAum(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x2::object::ID',
+        'bool',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["aum", "marketId", "isTraderProfit", "pnlUsd"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'refresh_market_aum',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns WLP equity after applying all registered market unrealized PnL. */
+function aumEquityUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "aum", "globalConfig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'aum_equity_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets cumulative borrow rate for a token. */
+function cumulativeBorrowRate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'cumulative_borrow_rate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets TVL in USD. */
+function tvlUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tvl_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Checks if OI is within cap (reads from global_config.oi_cap_bps; 0 = no cap). */
+function checkOiCap(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "globalConfig", "totalOiUsd"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'check_oi_cap',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Checks if reserve is within max ratio. */
+function checkReserveValid(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "tokenType", "additionalReserve"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'check_reserve_valid',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Increases reserved amount. */
+function increaseReserve(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "tokenType", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'increase_reserve',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Decreases reserved amount. */
+function decreaseReserve(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "tokenType", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'decrease_reserve',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Puts collateral back into the pool (from fees/losses). */
+function putCollateral(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "globalConfig", "collateral", "price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'put_collateral',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Requests collateral from the pool (for profit payout). */
+function requestCollateral(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        null
+    ];
+    const parameterNames = ["pool", "globalConfig", "amount", "price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'request_collateral',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets token pool info (copy). */
+function tokenPoolInfo(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'token_pool_info',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets token decimal. */
+function tokenDecimal(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'token_decimal',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns the oracle ticker bound to `TOKEN` at `add_token` time. This is the only
+ * source of truth for "what ticker do I price TOKEN at?" — perp + lp_pool
+ * callsites look it up here instead of accepting a free-form string from the
+ * caller. Aborts if TOKEN is not a supported token in this pool.
+ */
+function tokenTicker(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'token_ticker',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Suspend/resume pool. */
+function suspendPool(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "Cap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'suspend_pool',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function resumePool(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "Cap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'resume_pool',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Whether the pool is active. */
+function isActive(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'is_active',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** LP token decimal. */
+function lpDecimal(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'lp_decimal',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Total LP supply (derived from treasury cap). */
+function totalLpSupply(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'total_lp_supply',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowRedeemRequests(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'borrow_redeem_requests',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** TVL in USD as Float. */
+function poolTvlUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'pool_tvl_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Number of supported tokens. */
+function tokenCount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'token_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a TokenPoolInfo by index. */
+function borrowTokenPoolByIndex(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'borrow_token_pool_by_index',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** TokenPoolInfo field accessors. */
+function tpiTokenType(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_token_type',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiTicker(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_ticker',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiTokenDecimal(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_token_decimal',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiLiquidityAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_liquidity_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiReservedAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_reserved_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiValueUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_value_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiTargetWeightBps(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_target_weight_bps',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiMintFeeBps(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_mint_fee_bps',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiBurnFeeBps(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_burn_fee_bps',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiCumulativeBorrowRate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_cumulative_borrow_rate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function tpiLastPriceRefreshTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["tp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'tpi_last_price_refresh_timestamp',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function redeemRecipientAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'redeem_recipient_account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function redeemLpAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'redeem_lp_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function redeemTokenType(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'redeem_token_type',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function redeemRequestTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["r"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'redeem_request_timestamp',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function findTokenPoolIndex(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'find_token_pool_index',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowTokenPool(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'borrow_token_pool',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowMutTokenPool(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'borrow_mut_token_pool',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function refreshTokenValueWithPrice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "price", "refreshTimestamp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'refresh_token_value_with_price',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function addAumContribution(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["aum", "contribution"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'add_aum_contribution',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function removeAumContribution(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["aum", "contribution"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'remove_aum_contribution',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function assertAumFresh(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["aum", "globalConfig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_aum_fresh',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function assertPricesFresh(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "globalConfig"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_prices_fresh',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function assertRedeemAllowed(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_redeem_allowed',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function assertTokenRedeemAllowed(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["pool", "tokenType"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_token_redeem_allowed',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function calculateTotalWlpUtilizationBps(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["pool"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'calculate_total_wlp_utilization_bps',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function takeRedeemRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["pool", "requestId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'take_redeem_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function returnRejectedRedeemRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'address',
+        'u64'
+    ];
+    const parameterNames = ["wxaRegistry", "request", "operator", "requestId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'return_rejected_redeem_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Calculates dynamic fee based on weight deviation. */
+function calculateDynamicFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        'bool'
+    ];
+    const parameterNames = ["tokenValueUsd", "tvlUsd", "operationValueUsd", "targetWeightBps", "baseFeeBps", "isDeposit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'calculate_dynamic_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function assertValidBorrowConfig(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["rate_0", "rate_1", "rate_2", "intervalMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_valid_borrow_config',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function assertValidMaxReserveRatio(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64'
+    ];
+    const parameterNames = ["maxReserveRatioBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'assert_valid_max_reserve_ratio',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Calculates borrow rate using 3-slope utilization curve. */
+function calculateBorrowRate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        null,
+        null,
+        null,
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["utilizationBps", "rate_0", "rate_1", "rate_2", "threshold_0", "threshold_1"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'calculate_borrow_rate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Converts the instantaneous borrow rate into a cumulative index delta using the
+ * configured interval as the time basis.
+ */
+function calculateBorrowRateAccrual(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["borrowRate", "elapsedMs", "intervalMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'lp_pool',
+        function: 'calculate_borrow_rate_accrual',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}