@waterx/sdk 3.0.1 → 3.1.0

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

@@ -0,0 +1,2616 @@
+"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.MarketRegistry = exports.Market = void 0;
+exports.actionOpenPosition = actionOpenPosition;
+exports.actionClosePosition = actionClosePosition;
+exports.actionPlaceOrder = actionPlaceOrder;
+exports.actionCancelOrder = actionCancelOrder;
+exports.actionDepositCollateral = actionDepositCollateral;
+exports.actionWithdrawCollateral = actionWithdrawCollateral;
+exports.actionLiquidate = actionLiquidate;
+exports.actionIncreasePosition = actionIncreasePosition;
+exports.actionDecreasePosition = actionDecreasePosition;
+exports.actionUpdateOrder = actionUpdateOrder;
+exports.actionCancelPreOrder = actionCancelPreOrder;
+exports.actionAddPreOrder = actionAddPreOrder;
+exports.createMarket = createMarket;
+exports.updateMarketConfig = updateMarketConfig;
+exports.updateMarketFundingConfig = updateMarketFundingConfig;
+exports.pauseMarket = pauseMarket;
+exports.unpauseMarket = unpauseMarket;
+exports.addRequestRule = addRequestRule;
+exports.removeRequestRule = removeRequestRule;
+exports.registerMarketAum = registerMarketAum;
+exports.refreshMarketAum = refreshMarketAum;
+exports.assertProtocolPerm = assertProtocolPerm;
+exports.closePositionRequest = closePositionRequest;
+exports.increasePositionRequest = increasePositionRequest;
+exports.decreasePositionRequest = decreasePositionRequest;
+exports.placeOrderRequest = placeOrderRequest;
+exports.validatePreOrders = validatePreOrders;
+exports.validatePreOrderEntries = validatePreOrderEntries;
+exports.assertPreOrderCount = assertPreOrderCount;
+exports.cancelOrderRequest = cancelOrderRequest;
+exports.updateOrderRequest = updateOrderRequest;
+exports.cancelPreOrderRequest = cancelPreOrderRequest;
+exports.addPreOrderRequest = addPreOrderRequest;
+exports.depositCollateralRequest = depositCollateralRequest;
+exports.withdrawCollateralRequest = withdrawCollateralRequest;
+exports.liquidate = liquidate;
+exports.batchLiquidate = batchLiquidate;
+exports.execute = execute;
+exports.executeOpenPosition = executeOpenPosition;
+exports.executeIncreasePosition = executeIncreasePosition;
+exports.executeClosePosition = executeClosePosition;
+exports.executeDecreasePosition = executeDecreasePosition;
+exports.executePlaceOrder = executePlaceOrder;
+exports.executeCancelOrder = executeCancelOrder;
+exports.executeUpdateOrder = executeUpdateOrder;
+exports.executeCancelPreOrder = executeCancelPreOrder;
+exports.executeAddPreOrder = executeAddPreOrder;
+exports.executeDepositCollateral = executeDepositCollateral;
+exports.executeWithdrawCollateral = executeWithdrawCollateral;
+exports.executeLiquidate = executeLiquidate;
+exports.matchOrders = matchOrders;
+exports.updateFundingRate = updateFundingRate;
+exports.settleFundingRate = settleFundingRate;
+exports.openPositionByKeeper = openPositionByKeeper;
+exports.closePositionByKeeper = closePositionByKeeper;
+exports.resolveSize = resolveSize;
+exports.resolveOrderSize = resolveOrderSize;
+exports.checkOpenSlippage = checkOpenSlippage;
+exports.assertOpenSlippage = assertOpenSlippage;
+exports.assertCloseSlippage = assertCloseSlippage;
+exports.calculateTotalTradingFee = calculateTotalTradingFee;
+exports.emitLpEquity = emitLpEquity;
+exports.distributeTradingFee = distributeTradingFee;
+exports.calculateEffectiveCollateralAmount = calculateEffectiveCollateralAmount;
+exports.calculateLossAdjustedEffectiveCollateralAmount = calculateLossAdjustedEffectiveCollateralAmount;
+exports.settleLossToBalance = settleLossToBalance;
+exports.settleLossToPosition = settleLossToPosition;
+exports.settleFeesToBalance = settleFeesToBalance;
+exports.settleFeesToPosition = settleFeesToPosition;
+exports.settleFundingToBalance = settleFundingToBalance;
+exports.settleFundingToPosition = settleFundingToPosition;
+exports.calculateImpactFee = calculateImpactFee;
+exports.impactFeeCostUsd = impactFeeCostUsd;
+exports.calculatePositionLeverageBps = calculatePositionLeverageBps;
+exports.hasMinPositionCollateralValue = hasMinPositionCollateralValue;
+exports.assertMinPositionCollateralValue = assertMinPositionCollateralValue;
+exports.proportionalAmount = proportionalAmount;
+exports.debitCollateralAmount = debitCollateralAmount;
+exports.creditCollateralAmount = creditCollateralAmount;
+exports.calculateRemainingCollateralAfterPartialReduce = calculateRemainingCollateralAfterPartialReduce;
+exports.canPositionGrow = canPositionGrow;
+exports.validatePositionGrowth = validatePositionGrowth;
+exports.weightedAveragePrice = weightedAveragePrice;
+exports.normalizeTriggerPrice = normalizeTriggerPrice;
+exports.hasPendingPreOrders = hasPendingPreOrders;
+exports.pendingPreOrdersCount = pendingPreOrdersCount;
+exports.reservePreOrders = reservePreOrders;
+exports.dropPendingPreOrdersIfExists = dropPendingPreOrdersIfExists;
+exports.activatePendingPreOrders = activatePendingPreOrders;
+exports.assertPositionOwner = assertPositionOwner;
+exports.assertPositionCollateralType = assertPositionCollateralType;
+exports.borrowOwnedPosition = borrowOwnedPosition;
+exports.borrowOwnedPositionMut = borrowOwnedPositionMut;
+exports.takeOwnedPosition = takeOwnedPosition;
+exports.findOrderTypeTag = findOrderTypeTag;
+exports.findCancelOrderLocation = findCancelOrderLocation;
+exports.findOrderLocationById = findOrderLocationById;
+exports.findOrderPriceKeyInBook = findOrderPriceKeyInBook;
+exports.levelContainsOrder = levelContainsOrder;
+exports.hasOrderInBook = hasOrderInBook;
+exports.takeLinkedOrderAtKey = takeLinkedOrderAtKey;
+exports.cancelLinkedOrdersToBalance = cancelLinkedOrdersToBalance;
+exports.borrowMutOrderBook = borrowMutOrderBook;
+exports.takeOrderDirect = takeOrderDirect;
+exports.returnToUser = returnToUser;
+exports.marketId = marketId;
+exports.borrowPosition = borrowPosition;
+exports.hasPosition = hasPosition;
+exports.borrowOrder = borrowOrder;
+exports.borrowPositions = borrowPositions;
+exports.borrowOrderBook = borrowOrderBook;
+exports.borrowConfig = borrowConfig;
+exports.marketSymbol = marketSymbol;
+exports.createMarketRegistry = createMarketRegistry;
+exports.registryAssertVersion = registryAssertVersion;
+exports.registryAllowVersion = registryAllowVersion;
+exports.registryDisallowVersion = registryDisallowVersion;
+exports.addMarket = addMarket;
+exports.removeMarket = removeMarket;
+exports.hasMarket = hasMarket;
+exports.listedTickers = listedTickers;
+exports.borrowMarket = borrowMarket;
+exports.borrowMarketMut = borrowMarketMut;
+/**
+ * Core trading engine for WaterX Perp DEX.
+ *
+ * User-side path uses a hot-potato `TradingRequest<C_TOKEN>` (no abilities),
+ * consumed in the same PTB by `trading::execute`. `execute` does the work inline
+ * and returns droppable `TradingResponse` receipts — user payouts route through
+ * `wxa_account::put`, not back out as a `Coin<C_TOKEN>`.
+ *
+ * PTB flow:
+ *
+ * 1.  let request = trading::place_order_request(...);
+ * 2.  // External rules add witnesses: my_rule::check(&mut request, ...);
+ * 3.  let responses = trading::execute(global_config, wxa_registry,
+ *     market_registry, ticker, pool, request, oracle, clock, ctx);
+ */
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const market_config = __importStar(require("./market_config.js"));
+const keyed_big_vector = __importStar(require("./keyed_big_vector.js"));
+const order_book = __importStar(require("./order_book.js"));
+const vec_set = __importStar(require("./deps/sui/vec_set.js"));
+const $moduleName = '@waterx/perp::trading';
+exports.Market = new index_ts_1.MoveStruct({ name: `${$moduleName}::Market<phantom LP_TOKEN>`, fields: {
+        id: bcs_1.bcs.Address,
+        /** Per-market configuration and state. */
+        config: market_config.MarketConfig,
+        /** Positions indexed by position_id. */
+        positions: keyed_big_vector.KeyedBigVector,
+        /** Limit buy orders: price_key → vector<Order> */
+        limit_buys: order_book.OrderBook,
+        /** Limit sell orders: price_key → vector<Order> */
+        limit_sells: order_book.OrderBook,
+        /** Stop buy orders: price_key → vector<Order> */
+        stop_buys: order_book.OrderBook,
+        /** Stop sell orders: price_key → vector<Order> */
+        stop_sells: order_book.OrderBook,
+        /**
+         * Reserved TP / SL pre-orders, keyed by the **pre-order's own `order_id`** (not
+         * the main order's id). Each entry is a single fully-formed reduce-only `Order`
+         * with `linked_position_id =  None`; on main fill `activate_pending_pre_orders`
+         * stamps in the new position id and moves the order onto the live book.
+         */
+        pending_pre_orders: keyed_big_vector.KeyedBigVector,
+        /**
+         * Secondary index: `main_order_id → vector<pre_order_id>` listing the pre-orders
+         * reserved against each unfilled main. Used by activation / cancellation to
+         * enumerate the pre-orders that belong to a given main.
+         */
+        pending_pre_order_index: keyed_big_vector.KeyedBigVector
+    } });
+exports.MarketRegistry = new index_ts_1.MoveStruct({ name: `${$moduleName}::MarketRegistry<phantom LP_TOKEN>`, fields: {
+        id: bcs_1.bcs.Address,
+        /** Allowed protocol versions (admin-managed). */
+        allowed_versions: vec_set.VecSet(bcs_1.bcs.u16()),
+        /** Tickers of registered markets, mirrored from the DOF for cheap iteration. */
+        listed_tickers: bcs_1.bcs.vector(bcs_1.bcs.string())
+    } });
+function actionOpenPosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_open_position',
+    });
+}
+function actionClosePosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_close_position',
+    });
+}
+function actionPlaceOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_place_order',
+    });
+}
+function actionCancelOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_cancel_order',
+    });
+}
+function actionDepositCollateral(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_deposit_collateral',
+    });
+}
+function actionWithdrawCollateral(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_withdraw_collateral',
+    });
+}
+function actionLiquidate(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_liquidate',
+    });
+}
+function actionIncreasePosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_increase_position',
+    });
+}
+function actionDecreasePosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_decrease_position',
+    });
+}
+function actionUpdateOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_update_order',
+    });
+}
+function actionCancelPreOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_cancel_pre_order',
+    });
+}
+function actionAddPreOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_add_pre_order',
+    });
+}
+/**
+ * Creates a trading market with full configuration. `trading_fee`,
+ * `maintenance_margin`, and `basic_funding_rate` are scaled Float values (1e9
+ * scale). For example, a 5 bps fee = `500_000`.
+ */
+function createMarket(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String',
+        'u64',
+        'u64',
+        'u128',
+        'u128',
+        'u128',
+        'u128',
+        'u64',
+        'u128',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["Cap", "symbol", "maxLeverageBps", "minCollValue", "tradingFee", "maintenanceMargin", "maxLongOi", "maxShortOi", "cooldownMs", "basicFundingRate", "fundingIntervalMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'create_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: forwards to `market_config::update_market_config` through the shared
+ * `Market`. Needed because `MarketConfig` is embedded inside `Market` and can't be
+ * borrowed mutably from a PTB directly. Funding parameters must be updated with
+ * `update_market_funding_config` so accrued funding is settled under the old
+ * parameters before the new parameters take effect.
+ */
+function updateMarketConfig(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u64>',
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u64>'
+    ];
+    const parameterNames = ["marketRegistry", "cap", "ticker", "maxLeverageBps", "minCollValue", "tradingFee", "maxImpactFee", "allocatedLpExposureBps", "impactFeeCurvature", "impactFeeScale", "maintenanceMargin", "maxLongOi", "maxShortOi", "cooldownMs", "orderPriceTick", "maxPreOrders", "basicFundingRate", "fundingIntervalMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'update_market_config',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: settles accrued funding under the old funding parameters, then updates
+ * funding parameters for future intervals.
+ */
+function updateMarketFundingConfig(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        '0x1::option::Option<u128>',
+        '0x1::option::Option<u64>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "cap", "marketRegistry", "ticker", "pool", "oracle", "basicFundingRate", "fundingIntervalMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'update_market_funding_config',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: suspend the market (halts trading). */
+function pauseMarket(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["marketRegistry", "cap", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'pause_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: resume the market. */
+function unpauseMarket(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["marketRegistry", "cap", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'unpause_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: add witness type `W` to the request checklist. */
+function addRequestRule(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["marketRegistry", "cap", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'add_request_rule',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: remove witness type `W` from the request checklist. */
+function removeRequestRule(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["marketRegistry", "cap", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'remove_request_rule',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Registers a market in the pool-level WLP AUM object. */
+function registerMarketAum(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["marketRegistry", "aum", "cap", "ticker", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'register_market_aum',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Refreshes one registered market's contribution to pool-level WLP AUM. */
+function refreshMarketAum(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["marketRegistry", "aum", "ticker", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'refresh_market_aum',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Permission check on the wxa account for the trading entrypoints. Reads
+ * `effective_protocol_permissions<TradingRequest<C_TOKEN>>` so per-collateral
+ * granularity is preserved (`PERM_OPEN_POSITION` etc. are bits on that bitmap).
+ * Must be called _before_ any `wxa_account::take` so a failed auth doesn't leave
+ * the user drained.
+ */
+function assertProtocolPerm(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: 'trading',
+        function: 'assert_protocol_perm',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to close a position. */
+function closePositionRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "positionId", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'close_position_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to increase an existing position at market. */
+function increasePositionRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        '0x1::option::Option<u64>',
+        'u64',
+        'u64',
+        'u128',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "orderId", "positionId", "collateralAmount", "size", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'increase_position_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to partially reduce an existing position at market. */
+function decreasePositionRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u128',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "positionId", "size", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'decrease_position_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Creates a request to place a limit, stop, or market order, optionally with TP/SL
+ * pre-orders reserved against the freshly opened position.
+ *
+ * `main: PlaceOrderArgument` describes the order that hits the book immediately.
+ * `pre_order: vector<PlaceOrderArgument>` (length 0..=2) describes reduce-only
+ * orders that will be promoted to real linked orders on the new position when the
+ * main fills via `match_orders`.
+ *
+ * `main.trigger_price = None` is the market form: the order is parked at tick 0 in
+ * the limit book and a keeper fills it via `match_orders` at the live oracle.
+ * `acceptable_price` is carried on the order and consulted at match time — if the
+ * oracle moves past it the order is cancelled and collateral refunded. Limit/stop
+ * orders ignore `acceptable_price`.
+ *
+ * Validation runs _before_ the wxa take so a malformed request never drains the
+ * user's balance.
+ */
+function placeOrderRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        null,
+        'vector<null>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "main", "preOrder"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'place_order_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Validates `(main, pre_order)` at place-order request creation. Combines the
+ * main-eligibility check (must be a fresh opening order), the count check against
+ * the market-level cap, and per-entry structural rules.
+ */
+function validatePreOrders(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'vector<null>',
+        'u64'
+    ];
+    const parameterNames = ["main", "preOrder", "maxPreOrders"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'validate_pre_orders',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Per-entry structural validation only: reduce-only, real trigger, no collateral,
+ * no pre-picked link target, opposite side of main, non-zero size. The total-count
+ * check is the caller's responsibility (`assert_pre_order_count`) so this can be
+ * reused from per-leg add / cancel paths.
+ */
+function validatePreOrderEntries(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'bool',
+        'vector<null>'
+    ];
+    const parameterNames = ["mainIsLong", "preOrder"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'validate_pre_order_entries',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Caps the **total** pre-orders reserved against a single main at the
+ * market-config `max_pre_orders`. Aborts with `ETooManyPreOrders`.
+ */
+function assertPreOrderCount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["newTotal", "maxPreOrders"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'assert_pre_order_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Creates a request to cancel an order. `order_type_tag = 255` scans all 4 books
+ * for the matching `order_id`. `trigger_price` is the scaled `Float` value; `0`
+ * scans all trigger price buckets in the selected book(s).
+ */
+function cancelOrderRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u128',
+        'u8',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "orderId", "triggerPrice", "orderTypeTag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'cancel_order_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Creates a request to update a live order's size and trigger price. The order
+ * keeps its direction, reduce-only flag, linked position, collateral, and
+ * limit/stop book. `order_type_tag = 255` and `current_trigger_price = 0` scan for
+ * the current order location.
+ */
+function updateOrderRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u128',
+        'u8',
+        'u128',
+        'u128',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "orderId", "currentTriggerPrice", "orderTypeTag", "newSize", "newTriggerPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'update_order_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Cancels a single TP / SL pre-order reserved against an unfilled main.
+ * `pre_order_id` is the pre-order's own `order_id`, returned in the `OrderCreated`
+ * event when it activates (also enumerable from `pending_pre_order_index` keyed by
+ * `main_order_id`). The pair must be consistent — i.e. `pre_order_id` must appear
+ * in the index entry for `main_order_id`, otherwise the call aborts with
+ * `EOrderNotFound`. Pre-orders never hold collateral, so this only adjusts
+ * bookkeeping; no payout. Emits `PreOrderCancelled` with `pre_order_count = 1`.
+ */
+function cancelPreOrderRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "mainOrderId", "preOrderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'cancel_pre_order_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Adds one TP / SL pre-order to an unfilled main. The main must still be on the
+ * book, owned by `account_id`, of collateral type `C_TOKEN`, and a fresh opening
+ * order. The per-entry rules (`validate_pre_order_entries`) and the market-level
+ * total cap (`market.config.max_pre_orders()`) are enforced — existing reserved
+ *
+ * - 1 must stay within cap.
+ */
+function addPreOrderRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "mainOrderId", "preOrder"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'add_pre_order_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to deposit collateral on a position. */
+function depositCollateralRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "positionId", "collateralAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'deposit_collateral_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to withdraw collateral from a position. */
+function withdrawCollateralRequest(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        '0x2::object::ID',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "senderRequest", "accountId", "positionId", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'withdraw_collateral_request',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Creates a request to liquidate a position (keeper only). Reads
+ * account_object_address from the position directly. Keeper-only: liquidate an
+ * undercollateralized position. Single-call — no `TradingRequest` hot potato to
+ * manage. Returns a droppable receipt vector for PTB composition.
+ */
+function liquidate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "pool", "senderRequest", "positionId", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'liquidate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper-only: scans a page of positions and liquidates every liquidatable one.
+ * Iterates positions by internal index `[page_index * page_size, ...)`. No-op if
+ * the page is out of range or no positions qualify. Returns droppable receipts for
+ * every liquidated position.
+ */
+function batchLiquidate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "pool", "senderRequest", "oracle", "pageSize", "pageIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'batch_liquidate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Executes a trading request. All `*_request` creators return raw
+ * `TradingRequest<C>`; pass it straight to `execute` after attaching any witness
+ * rules (e.g. `pyth_rule::feed(&mut req, ...)`). Used by both user happy paths and
+ * keeper paths.
+ */
+function execute(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "pool", "req", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeOpenPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'u64',
+        'address',
+        'address',
+        null,
+        'bool',
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "pool", "oracle", "marketId", "accountId", "orderId", "accountObjectAddress", "sender", "collateral", "isLong", "size", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_open_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeIncreasePosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'u64',
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "market", "pool", "oracle", "marketId", "accountObjectAddress", "orderId", "positionId", "collateral", "size", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_increase_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeClosePosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "pool", "oracle", "marketId", "accountId", "accountObjId", "orderId", "positionId", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_close_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeDecreasePosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'u64',
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "pool", "oracle", "marketId", "accountId", "accountObjId", "orderId", "positionId", "requestedSize", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_decrease_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executePlaceOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'address',
+        null,
+        'bool',
+        'bool',
+        'bool',
+        null,
+        null,
+        'u64',
+        '0x1::option::Option<u64>',
+        'vector<null>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "pool", "oracle", "marketId", "accountId", "accountObjectAddress", "collateral", "isLong", "isStopOrder", "reduceOnly", "size", "triggerPrice", "acceptablePrice", "linkedPositionId", "preOrders"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_place_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeCancelOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'u128',
+        'u8'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "marketId", "accountId", "accountObjId", "orderId", "triggerPriceKey", "orderTypeTag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_cancel_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeUpdateOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'u128',
+        'u8',
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "market", "pool", "oracle", "marketId", "accountObjectAddress", "orderId", "triggerPriceKey", "orderTypeTag", "newSize", "newTriggerPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_update_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Cancels a single pre-order by id. Validates ownership / collateral type on the
+ * reserved `Order`, then verifies `pre_order_id` actually belongs to
+ * `main_order_id` via the index. Destroys the `Order` through
+ * `position::remove_order<C_TOKEN>` and emits
+ * `PreOrderCancelled { main_order_id, pre_order_count: 1 }`.
+ */
+function executeCancelPreOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["globalConfig", "market", "marketId", "accountObjectAddress", "mainOrderId", "preOrderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_cancel_pre_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Appends a single pre-order to an existing or empty reservation for
+ * `main_order_id`. Locates the main on a book, verifies eligibility, then
+ * `assert_pre_order_count(existing + 1, cap)` and per-entry validation before
+ * delegating to `reserve_pre_orders`.
+ */
+function executeAddPreOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'vector<null>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "market", "marketId", "accountObjectAddress", "mainOrderId", "newPreOrder"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_add_pre_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeDepositCollateral(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "market", "pool", "oracle", "marketId", "accountObjectAddress", "positionId", "collateral"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_deposit_collateral',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns `(returned_collateral_amount, position_collateral_amount)`: the first is
+ * the amount actually credited back to the wxa account (read off the `Balance`
+ * rather than echoing the requested `amount`, so the response field can't drift if
+ * `pos.withdraw_collateral` ever gains clamping semantics); the second is the
+ * post-action position collateral.
+ */
+function executeWithdrawCollateral(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "pool", "oracle", "marketId", "accountObjId", "positionId", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_withdraw_collateral',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function executeLiquidate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'address',
+        'address',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "pool", "oracle", "marketId", "accountId", "accountObjectAddress", "sender", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'execute_liquidate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function matchOrders(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        null,
+        'u8',
+        'u128',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "pool", "senderRequest", "oracle", "orderTypeTag", "triggerPrice", "maxFills"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'match_orders',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Keeper: updates funding rate for a market. */
+function updateFundingRate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "ticker", "pool", "oracle", "senderRequest"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'update_funding_rate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function settleFundingRate(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "market", "pool", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_funding_rate',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper-only: open a new position for an account, funded by the keeper's own
+ * `Coin<C_TOKEN>` (campaign / airdrop use case). The keeper bypasses
+ * `min_coll_value` on this path — `increase_position` and `place_order` still
+ * enforce it for all callers including keepers. Returns a droppable receipt vector
+ * so the keeper or a composing protocol can reference the position in the same
+ * PTB.
+ */
+function openPositionByKeeper(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        'address',
+        null,
+        'bool',
+        'u128',
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "pool", "keeperRequest", "accountObjectAddress", "collateralCoin", "isLong", "size", "acceptablePrice", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'open_position_by_keeper',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Risk-manager-only: force-close a position (emergency use). Reads
+ * `account_object_address` from the position directly, like `liquidate`. Returns a
+ * droppable receipt vector for PTB composition.
+ */
+function closePositionByKeeper(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x1::string::String',
+        null,
+        null,
+        'u64',
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "marketRegistry", "ticker", "pool", "keeperRequest", "positionId", "acceptablePrice", "oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'close_position_by_keeper',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Computes the scaled size (u128, 9 decimals) for a given collateral amount,
+ * leverage, and actual collateral price. Compatible with non-dollar-pegged
+ * collateral. Base ticker comes from `market.symbol()`, collateral ticker from
+ * `pool.token_ticker<LP, C>()` — callers cannot mis-price by lying about either.
+ */
+function resolveSize(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["market", "pool", "oracle", "collateralAmount", "leverageBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'resolve_size',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Like `resolve_size` but uses a trigger price instead of the base oracle price.
+ * Use this to compute the `size` parameter for `place_order_request`.
+ * `trigger_price` is a scaled Float value (the same u128 you pass to
+ * `place_order_request`).
+ */
+function resolveOrderSize(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u128',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["pool", "oracle", "triggerPrice", "collateralAmount", "leverageBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'resolve_order_size',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function checkOpenSlippage(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'bool',
+        null,
+        'u64'
+    ];
+    const parameterNames = ["isLong", "price", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'check_open_slippage',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function assertOpenSlippage(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'bool',
+        null,
+        'u64'
+    ];
+    const parameterNames = ["isLong", "price", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'assert_open_slippage',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function assertCloseSlippage(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'bool',
+        null,
+        'u64'
+    ];
+    const parameterNames = ["isLong", "price", "acceptablePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'assert_close_slippage',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculateTotalTradingFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        null
+    ];
+    const parameterNames = ["marketConfig", "pool", "executionPrice", "orderIsLong", "orderSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'calculate_total_trading_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Emits a `WlpEquityChanged` event for a settlement that moves `amount` of
+ * `collateral_token` to/from the LP pool. No-op when `amount == 0`. Centralizes
+ * the `market.symbol()` / `with_defining_ids<LP_TOKEN>()` lookups so call sites
+ * stay short.
+ */
+function emitLpEquity(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'bool',
+        '0x1::string::String'
+    ];
+    const parameterNames = ["market", "collateralToken", "amount", "isProfit", "memo"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'emit_lp_equity',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Splits an already-collected trading-fee balance into the protocol's cut (sent to
+ * `GlobalVault.protocol_fee_balance`) and the LP pool's cut (joined into the pool,
+ * emitted as a `WlpEquityChanged` "fee" event). Used by every closing/liquidation
+ * path that realizes a fee.
+ */
+function distributeTradingFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::object::ID',
+        null,
+        null
+    ];
+    const parameterNames = ["globalConfig", "pool", "market", "feeBalance", "protocolShareBps", "marketId", "collateralToken", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'distribute_trading_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function calculateEffectiveCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'u64',
+        'bool',
+        'u64',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["grossCollateralAmount", "borrowFee", "fundingSign", "fundingFee", "tradingFee", "projectedTradingFee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'calculate_effective_collateral_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculateLossAdjustedEffectiveCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        'bool',
+        'u64',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["position", "currentPrice", "collateralPrice", "grossCollateralAmount", "borrowFee", "fundingSign", "fundingFee", "tradingFee", "projectedTradingFee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'calculate_loss_adjusted_effective_collateral_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function settleLossToBalance(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        null,
+        'u128'
+    ];
+    const parameterNames = ["globalConfig", "pool", "market", "collateral", "collateralToken", "lossAmount", "collateralPrice", "deficit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_loss_to_balance',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function settleLossToPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        null,
+        'u128'
+    ];
+    const parameterNames = ["globalConfig", "pool", "market", "position", "collateralToken", "lossAmount", "collateralPrice", "deficit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_loss_to_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function settleFeesToBalance(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::object::ID',
+        null,
+        null,
+        'u64',
+        'u128'
+    ];
+    const parameterNames = ["globalConfig", "pool", "market", "collateral", "protocolShareBps", "marketId", "collateralToken", "collateralPrice", "feeAmount", "deficit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_fees_to_balance',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function settleFeesToPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::object::ID',
+        null,
+        null,
+        'u64',
+        'u128'
+    ];
+    const parameterNames = ["globalConfig", "pool", "market", "position", "protocolShareBps", "marketId", "collateralToken", "collateralPrice", "feeAmount", "deficit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_fees_to_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function settleFundingToBalance(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        'u64',
+        null,
+        '0x1::string::String',
+        'u128'
+    ];
+    const parameterNames = ["globalConfig", "pool", "collateral", "fundingSign", "fundingFee", "collateralPrice", "marketTicker", "deficit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_funding_to_balance',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function settleFundingToPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        'u64',
+        null,
+        '0x1::string::String',
+        'u128'
+    ];
+    const parameterNames = ["globalConfig", "pool", "position", "fundingSign", "fundingFee", "collateralPrice", "marketTicker", "deficit"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_funding_to_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function calculateImpactFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        null
+    ];
+    const parameterNames = ["marketConfig", "pool", "executionPrice", "orderIsLong", "orderSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'calculate_impact_fee',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function impactFeeCostUsd(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["maxImpactFee", "allocatedExposureUsd", "exposureUsd", "impactFeeCurvature", "impactFeeScale"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'impact_fee_cost_usd',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculatePositionLeverageBps(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64',
+        'u8',
+        null,
+        null
+    ];
+    const parameterNames = ["totalSize", "totalCollateralAmount", "collateralDecimal", "executionPrice", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'calculate_position_leverage_bps',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function hasMinPositionCollateralValue(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'u64',
+        'u8',
+        null
+    ];
+    const parameterNames = ["minCollateralValue", "collateralAmount", "collateralDecimal", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'has_min_position_collateral_value',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function assertMinPositionCollateralValue(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'u64',
+        'u8',
+        null
+    ];
+    const parameterNames = ["minCollateralValue", "collateralAmount", "collateralDecimal", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'assert_min_position_collateral_value',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function proportionalAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        null,
+        null
+    ];
+    const parameterNames = ["total", "partial", "base"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'proportional_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function debitCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'u128',
+        'u64'
+    ];
+    const parameterNames = ["remaining", "deficit", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'debit_collateral_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function creditCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'u128',
+        'u64'
+    ];
+    const parameterNames = ["remaining", "deficit", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'credit_collateral_amount',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function calculateRemainingCollateralAfterPartialReduce(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["position", "reduceSize", "closeFee", "currentPrice", "collateralPrice", "addedCollateralAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'calculate_remaining_collateral_after_partial_reduce',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Non-aborting growth check used by keeper order matching. Invalid standalone
+ * orders are rotated behind valid orders at the same trigger price.
+ */
+function canPositionGrow(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        null,
+        null,
+        'u64',
+        'u8',
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["globalConfig", "marketConfig", "pool", "isLong", "currentSize", "addedSize", "effectiveCollateralAmount", "collateralDecimal", "collateralToken", "executionPrice", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'can_position_grow',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function validatePositionGrowth(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        null,
+        null,
+        'u64',
+        'u8',
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["globalConfig", "marketConfig", "pool", "isLong", "currentSize", "addedSize", "effectiveCollateralAmount", "collateralDecimal", "collateralToken", "executionPrice", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'validate_position_growth',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function weightedAveragePrice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["currentSize", "currentAveragePrice", "addSize", "fillPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'weighted_average_price',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function normalizeTriggerPrice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["triggerPrice", "orderPriceTick"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'normalize_trigger_price',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** View: whether `main_order_id` has reserved pre-orders pending in `market`. */
+function hasPendingPreOrders(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["market", "mainOrderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'has_pending_pre_orders',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * View: how many pre-orders are reserved against `main_order_id`. `0` if no entry
+ * exists.
+ */
+function pendingPreOrdersCount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["market", "mainOrderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'pending_pre_orders_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Mints fresh order ids for every `PlaceOrderArgument` in `pre_orders`, builds a
+ * real `Order` per entry (reduce-only, zero-collateral,
+ * `linked_position_id = None`), stashes each one in `pending_pre_orders` under its
+ * own id, and records the id list in `pending_pre_order_index` under
+ * `main_order_id` — appending to any existing entry so this helper also works for
+ * the per-leg `add_pre_order` path. Emits one `PreOrderCreated` per reserved
+ * pre-order. No-op when `pre_orders` is empty.
+ */
+function reservePreOrders(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'address',
+        '0x2::object::ID',
+        'u8',
+        'vector<null>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "market", "mainOrderId", "accountObjectAddress", "marketId", "collateralDecimal", "preOrders"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'reserve_pre_orders',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Drops every pre-order reserved against `main_order_id` (if any), destroying each
+ * via `position::remove_order` (which splits the zero collateral back into the
+ * vault and deletes the order UID) and emitting one `PreOrderCancelled` per
+ * dropped pre-order.
+ */
+function dropPendingPreOrdersIfExists(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::object::ID',
+        'address',
+        'u64'
+    ];
+    const parameterNames = ["globalConfig", "market", "marketId", "accountObjectAddress", "mainOrderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'drop_pending_pre_orders_if_exists',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Promotes reserved pre-orders to real reduce-only linked orders on the freshly
+ * opened position. Called from the standalone-fill branch of `match_orders` right
+ * before the new position is pushed to the market. Each reserved `Order` was
+ * created at place time with `linked_position_id = None`; here we stamp in the new
+ * `position_id` and move the order onto the live book.
+ */
+function activatePendingPreOrders(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        'address',
+        '0x2::object::ID'
+    ];
+    const parameterNames = ["wxaRegistry", "market", "pos", "positionId", "mainOrderId", "accountObjectAddress", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'activate_pending_pre_orders',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function assertPositionOwner(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'address'
+    ];
+    const parameterNames = ["position", "accountObjectAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'assert_position_owner',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function assertPositionCollateralType(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["position"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'assert_position_collateral_type',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowOwnedPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64',
+        'address'
+    ];
+    const parameterNames = ["market", "positionId", "accountObjectAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_owned_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowOwnedPositionMut(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64',
+        'address'
+    ];
+    const parameterNames = ["market", "positionId", "accountObjectAddress"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_owned_position_mut',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function takeOwnedPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64',
+        'address',
+        'u64',
+        'bool'
+    ];
+    const parameterNames = ["market", "positionId", "accountObjectAddress", "now", "requireCooldown"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'take_owned_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function findOrderTypeTag(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u128',
+        'u64'
+    ];
+    const parameterNames = ["market", "triggerPriceKey", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'find_order_type_tag',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function findCancelOrderLocation(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u8',
+        'u128',
+        'u64'
+    ];
+    const parameterNames = ["market", "orderTypeTag", "triggerPrice", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'find_cancel_order_location',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function findOrderLocationById(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u8',
+        'u64'
+    ];
+    const parameterNames = ["market", "orderTypeTag", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'find_order_location_by_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function findOrderPriceKeyInBook(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["book", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'find_order_price_key_in_book',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function levelContainsOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["level", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'level_contains_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function hasOrderInBook(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u128',
+        'u64'
+    ];
+    const parameterNames = ["book", "priceKey", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'has_order_in_book',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function takeLinkedOrderAtKey(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u128',
+        'u64'
+    ];
+    const parameterNames = ["market", "triggerPriceKey", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'take_linked_order_at_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function cancelLinkedOrdersToBalance(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'vector<u64>',
+        'vector<u128>',
+        'u8'
+    ];
+    const parameterNames = ["globalConfig", "wxaRegistry", "market", "accountId", "linkedOrderIds", "linkedOrderPriceKeys", "memoCode"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'cancel_linked_orders_to_balance',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowMutOrderBook(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u8'
+    ];
+    const parameterNames = ["market", "tag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_mut_order_book',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function takeOrderDirect(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u128',
+        'u64',
+        'address',
+        'u8'
+    ];
+    const parameterNames = ["market", "triggerPriceKey", "orderId", "user", "orderTypeTag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'take_order_direct',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Returns `balance` to the user's wxa stored balance under the `WaterXPerp`
+ * witness. `account_obj_addr` is the wxa account's UID address (i.e.
+ * `account_id.to_address()`), so `.to_id()` recovers the account_id. Zero balances
+ * are silently destroyed (no event).
+ */
+function returnToUser(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'address'
+    ];
+    const parameterNames = ["wxaRegistry", "balance", "accountObjAddr"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'return_to_user',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the object ID of this Market (trading vault). */
+function marketId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["market"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'market_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a position by ID. */
+function borrowPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["market", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Checks if a position exists. */
+function hasPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["market", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'has_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a single order by type, price key, and order id. */
+function borrowOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u8',
+        'u128',
+        'u64'
+    ];
+    const parameterNames = ["market", "orderTypeTag", "triggerPriceKey", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows the positions KeyedBigVector (for paginated iteration). */
+function borrowPositions(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["market"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_positions',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an order book by type tag (0-3), read-only. */
+function borrowOrderBook(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u8'
+    ];
+    const parameterNames = ["market", "orderTypeTag"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_order_book',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows the market config (for view.move). */
+function borrowConfig(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["market"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_config',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketSymbol(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["market"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'market_symbol',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates and shares a new `MarketRegistry`. Admin-gated. */
+function createMarketRegistry(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["Cap"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'create_market_registry',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function registryAssertVersion(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'registry_assert_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function registryAllowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'registry_allow_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function registryDisallowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["registry", "_", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'registry_disallow_version',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Stores `market` in the registry under `ticker`. Aborts if already taken. */
+function addMarket(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        null
+    ];
+    const parameterNames = ["registry", "Cap", "ticker", "market"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'add_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Removes a market from the registry and returns it. */
+function removeMarket(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["registry", "Cap", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'remove_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function hasMarket(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["registry", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'has_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function listedTickers(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["registry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'listed_tickers',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowMarket(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["registry", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function borrowMarketMut(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["registry", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'borrow_market_mut',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}