@waterx/sdk 2.1.0

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

@@ -0,0 +1,1521 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * 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.
+ */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as type_name from "./deps/std/type_name.js";
+import * as float from "./deps/bucket_v2_framework/float.js";
+import * as float_1 from "./deps/bucket_v2_framework/float.js";
+import * as float_2 from "./deps/bucket_v2_framework/float.js";
+import * as float_3 from "./deps/bucket_v2_framework/float.js";
+import * as float_4 from "./deps/bucket_v2_framework/float.js";
+import * as vec_set from "./deps/sui/vec_set.js";
+import * as coin from "./deps/sui/coin.js";
+import * as type_name_1 from "./deps/std/type_name.js";
+import * as float_5 from "./deps/bucket_v2_framework/float.js";
+import * as keyed_big_vector from "./keyed_big_vector.js";
+import * as balance from "./deps/sui/balance.js";
+import * as type_name_2 from "./deps/std/type_name.js";
+import * as keyed_big_vector_1 from "./keyed_big_vector.js";
+import * as float_6 from "./deps/bucket_v2_framework/float.js";
+import * as float_7 from "./deps/bucket_v2_framework/float.js";
+import * as float_8 from "./deps/bucket_v2_framework/float.js";
+const $moduleName = '@waterx/perp::lp_pool';
+export const TokenPoolInfo = new 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.string(),
+        /** Token decimal. */
+        token_decimal: bcs.u8(),
+        /** Target weight in bps (e.g., 5000 = 50%). */
+        target_weight_bps: bcs.u64(),
+        /** Mint fee in bps. */
+        mint_fee_bps: bcs.u64(),
+        /** Burn fee in bps. */
+        burn_fee_bps: bcs.u64(),
+        /** Max capacity. */
+        max_capacity: bcs.u64(),
+        /** Min deposit. */
+        min_deposit: 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_1.Float,
+        /** Per-interval borrow rate at utilization threshold_1 (Float). */
+        basic_borrow_rate_2: float_2.Float,
+        utilization_threshold_0_bps: bcs.u64(),
+        utilization_threshold_1_bps: bcs.u64(),
+        borrow_interval_ms: bcs.u64(),
+        max_reserve_ratio_bps: bcs.u64(),
+        /** Liquidity amount in token units. */
+        liquidity_amount: bcs.u64(),
+        /** Value in USD. */
+        value_usd: float_3.Float,
+        /** Reserved amount for open positions. */
+        reserved_amount: bcs.u64(),
+        /** Last borrow rate update timestamp. */
+        last_borrow_timestamp: bcs.u64(),
+        /** Cumulative borrow rate as Float (1e9 scale). */
+        cumulative_borrow_rate: float_4.Float,
+        /** Last timestamp when this token price was refreshed via oracle. */
+        last_price_refresh_timestamp: bcs.u64()
+    } });
+export const WlpPool = new MoveStruct({ name: `${$moduleName}::WlpPool<phantom LP_TOKEN>`, fields: {
+        id: bcs.Address,
+        /** Whether this pool is active. */
+        is_active: bcs.bool(),
+        /** Allowed protocol versions (admin-managed). */
+        allowed_versions: vec_set.VecSet(bcs.u16()),
+        /** LP token treasury cap. */
+        lp_treasury_cap: coin.TreasuryCap,
+        /** LP token decimal. */
+        lp_decimal: bcs.u8(),
+        /** Supported token types. */
+        token_types: bcs.vector(type_name_1.TypeName),
+        /** Token pool configs and states. */
+        token_pools: bcs.vector(TokenPoolInfo),
+        /** Total value locked in USD (Float). */
+        tvl_usd: float_5.Float,
+        /** Redeem requests. */
+        redeem_requests: keyed_big_vector.KeyedBigVector,
+        /** Next redeem request ID. */
+        next_redeem_id: bcs.u64()
+    } });
+export const RedeemRequest = new MoveStruct({ name: `${$moduleName}::RedeemRequest<phantom LP_TOKEN>`, fields: {
+        /** Wxa account ID to repay into at settlement. */
+        recipient_account_id: bcs.Address,
+        /** LP balance held pending settlement. */
+        lp_balance: balance.Balance,
+        /** Requested token type to receive. */
+        token_type: type_name_2.TypeName,
+        /** Request timestamp. */
+        request_timestamp: bcs.u64()
+    } });
+export const WlpAum = new MoveStruct({ name: `${$moduleName}::WlpAum<phantom LP_TOKEN>`, fields: {
+        id: bcs.Address,
+        /** WLP pool this AUM object prices. */
+        pool_id: bcs.Address,
+        /** Registered market PnL contributions keyed by market ID. */
+        market_contributions: keyed_big_vector_1.KeyedBigVector,
+        /** Sum of registered markets where traders are in profit. */
+        total_trader_profit_usd: float_6.Float,
+        /** Sum of registered markets where traders are in loss. */
+        total_trader_loss_usd: float_7.Float
+    } });
+export const AumMarketContribution = new MoveStruct({ name: `${$moduleName}::AumMarketContribution`, fields: {
+        /** Whether the market's aggregate unrealized PnL is trader profit. */
+        is_trader_profit: bcs.bool(),
+        /** Absolute aggregate unrealized PnL in USD. */
+        pnl_usd: float_8.Float,
+        /** Timestamp of the oracle price used to refresh this contribution. */
+        last_refresh_timestamp: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new WLP pool (AdminCap-gated). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a pool-level AUM object used for multi-market WLP share pricing. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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).
+ */
+export 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: 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).
+ */
+export 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: 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`).
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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>`.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Updates borrow rates for all token pools. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Registers a market contribution for this WLP AUM object. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Refreshes an existing market's AUM contribution. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns WLP equity after applying all registered market unrealized PnL. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets cumulative borrow rate for a token. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets TVL in USD. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Checks if OI is within cap (reads from global_config.oi_cap_bps; 0 = no cap). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Checks if reserve is within max ratio. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Increases reserved amount. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Decreases reserved amount. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Puts collateral back into the pool (from fees/losses). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Requests collateral from the pool (for profit payout). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets token pool info (copy). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Gets token decimal. */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Suspend/resume pool. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Whether the pool is active. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** LP token decimal. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Total LP supply (derived from treasury cap). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** TVL in USD as Float. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Number of supported tokens. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a TokenPoolInfo by index. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** TokenPoolInfo field accessors. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Calculates dynamic fee based on weight deviation. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Calculates borrow rate using 3-slope utilization curve. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Converts the instantaneous borrow rate into a cumulative index delta using the
+ * configured interval as the time basis.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}