@waterx/sdk 2.1.0

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

@@ -0,0 +1,2372 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * 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);
+ */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as market_config from "./market_config.js";
+import * as keyed_big_vector from "./keyed_big_vector.js";
+import * as order_book from "./order_book.js";
+import * as order_book_1 from "./order_book.js";
+import * as order_book_2 from "./order_book.js";
+import * as order_book_3 from "./order_book.js";
+import * as keyed_big_vector_1 from "./keyed_big_vector.js";
+import * as keyed_big_vector_2 from "./keyed_big_vector.js";
+import * as vec_set from "./deps/sui/vec_set.js";
+const $moduleName = '@waterx/perp::trading';
+export const Market = new MoveStruct({ name: `${$moduleName}::Market<phantom LP_TOKEN>`, fields: {
+        id: 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_1.OrderBook,
+        /** Stop buy orders: price_key → vector<Order> */
+        stop_buys: order_book_2.OrderBook,
+        /** Stop sell orders: price_key → vector<Order> */
+        stop_sells: order_book_3.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_1.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_2.KeyedBigVector
+    } });
+export const MarketRegistry = new MoveStruct({ name: `${$moduleName}::MarketRegistry<phantom LP_TOKEN>`, fields: {
+        id: bcs.Address,
+        /** Allowed protocol versions (admin-managed). */
+        allowed_versions: vec_set.VecSet(bcs.u16()),
+        /** Tickers of registered markets, mirrored from the DOF for cheap iteration. */
+        listed_tickers: bcs.vector(bcs.string())
+    } });
+export function actionOpenPosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_open_position',
+    });
+}
+export function actionClosePosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_close_position',
+    });
+}
+export function actionPlaceOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_place_order',
+    });
+}
+export function actionCancelOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_cancel_order',
+    });
+}
+export function actionDepositCollateral(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_deposit_collateral',
+    });
+}
+export function actionWithdrawCollateral(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_withdraw_collateral',
+    });
+}
+export function actionLiquidate(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_liquidate',
+    });
+}
+export function actionIncreasePosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_increase_position',
+    });
+}
+export function actionDecreasePosition(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_decrease_position',
+    });
+}
+export function actionUpdateOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_update_order',
+    });
+}
+export function actionCancelPreOrder(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'action_cancel_pre_order',
+    });
+}
+export 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`.
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin: settles accrued funding under the old funding parameters, then updates
+ * funding parameters for future intervals.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: suspend the market (halts trading). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: resume the market. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: add witness type `W` to the request checklist. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin: remove witness type `W` from the request checklist. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Registers a market in the pool-level WLP AUM object. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Refreshes one registered market's contribution to pool-level WLP AUM. */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to close a position. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to increase an existing position at market. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to partially reduce an existing position at market. */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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`.
+ */
+export 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: 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).
+ */
+export 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: 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.
+ */
+export 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: 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`.
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to deposit collateral on a position. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates a request to withdraw collateral from a position. */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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 }`.
+ */
+export 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: 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`.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Keeper: updates funding rate for a market. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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`).
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function settleFundingToBalance(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        'u64',
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["globalConfig", "pool", "collateral", "fundingSign", "fundingFee", "collateralPrice", "marketTicker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_funding_to_balance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function settleFundingToPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        'u64',
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["globalConfig", "pool", "position", "fundingSign", "fundingFee", "collateralPrice", "marketTicker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'trading',
+        function: 'settle_funding_to_position',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** View: whether `main_order_id` has reserved pre-orders pending in `market`. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * View: how many pre-orders are reserved against `main_order_id`. `0` if no entry
+ * exists.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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).
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the object ID of this Market (trading vault). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a position by ID. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Checks if a position exists. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a single order by type, price key, and order id. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows the positions KeyedBigVector (for paginated iteration). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an order book by type tag (0-3), read-only. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows the market config (for view.move). */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Creates and shares a new `MarketRegistry`. Admin-gated. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Stores `market` in the registry under `ticker`. Aborts if already taken. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Removes a market from the registry and returns it. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}