@waterx/sdk 2.1.0

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

@@ -0,0 +1,1103 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Position and Order structs and lifecycle management. All functions are
+ * package-internal, used by trading.move. Collateral balances are stored in
+ * GlobalVault (global_config.move), not in Position/Order.
+ */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as float from "./deps/bucket_v2_framework/float.js";
+import * as type_name from "./deps/std/type_name.js";
+import * as float_1 from "./deps/bucket_v2_framework/float.js";
+import * as float_2 from "./deps/bucket_v2_framework/float.js";
+import * as double from "./deps/bucket_v2_framework/double.js";
+import * as type_name_1 from "./deps/std/type_name.js";
+import * as float_3 from "./deps/bucket_v2_framework/float.js";
+import * as float_4 from "./deps/bucket_v2_framework/float.js";
+import * as float_5 from "./deps/bucket_v2_framework/float.js";
+const $moduleName = '@waterx/perp::position';
+export const Position = new MoveStruct({ name: `${$moduleName}::Position`, fields: {
+        id: bcs.Address,
+        /** Position ID (unique within market). */
+        position_id: bcs.u64(),
+        /** Owner address. */
+        account_object_address: bcs.Address,
+        /** Market ID. */
+        market_id: bcs.Address,
+        /** Whether this is a long position. */
+        is_long: bcs.bool(),
+        /** Position size as Float (fixed 9 decimals). */
+        size: float.Float,
+        /** Collateral token type. */
+        collateral_token: type_name.TypeName,
+        /** Collateral token decimal. */
+        collateral_decimal: bcs.u8(),
+        /** Collateral amount (tracked; actual balance in GlobalVault). */
+        collateral_amount: bcs.u64(),
+        /** Average entry price (Float). */
+        average_price: float_1.Float,
+        /** Entry cumulative borrow rate index as Float. */
+        entry_borrow_index: float_2.Float,
+        /** Pool reserve snapshot in collateral token units. */
+        pool_reserve_amount: bcs.u64(),
+        /** Borrow reserve snapshot in collateral token units. */
+        borrow_reserve_amount: bcs.u64(),
+        /** Entry cumulative funding rate sign (true = longs pay). */
+        entry_funding_sign: bcs.bool(),
+        /** Entry cumulative funding rate index (Double). */
+        entry_funding_index: double.Double,
+        /** Unrealized borrow fee in collateral token. */
+        unrealized_borrow_fee: bcs.u64(),
+        /** Unrealized funding fee sign (true = should pay). */
+        unrealized_funding_sign: bcs.bool(),
+        /** Unrealized funding fee in collateral token. */
+        unrealized_funding_fee: bcs.u64(),
+        /** Unrealized trading fee in collateral token. */
+        unrealized_trading_fee: bcs.u64(),
+        /** Linked order IDs. */
+        linked_order_ids: bcs.vector(bcs.u64()),
+        /** Linked order trigger price bucket keys paired with linked_order_ids. */
+        linked_order_price_keys: bcs.vector(bcs.u128()),
+        /** Creation timestamp. */
+        create_timestamp: bcs.u64(),
+        /** Last update timestamp. */
+        update_timestamp: bcs.u64()
+    } });
+export const Order = new MoveStruct({ name: `${$moduleName}::Order`, fields: {
+        id: bcs.Address,
+        /** Order ID (unique within market). */
+        order_id: bcs.u64(),
+        /**
+         * Owner account object address (UserAccount ID, same as
+         * Position.account_object_address).
+         */
+        account_object_address: bcs.Address,
+        /** Market ID. */
+        market_id: bcs.Address,
+        /** Linked position ID (for reduce-only). */
+        linked_position_id: bcs.option(bcs.u64()),
+        /** Collateral token type. */
+        collateral_token: type_name_1.TypeName,
+        /** Collateral token decimal. */
+        collateral_decimal: bcs.u8(),
+        /** Collateral amount (tracked; actual balance in GlobalVault). */
+        collateral_amount: bcs.u64(),
+        /** Whether this is a long order. */
+        is_long: bcs.bool(),
+        /** Whether this is a reduce-only order. */
+        reduce_only: bcs.bool(),
+        /** Whether this is a stop order (vs limit). */
+        is_stop_order: bcs.bool(),
+        /** Order size as Float (fixed 9 decimals). */
+        size: float_3.Float,
+        /**
+         * Trigger price (Float). A value of zero marks the order as a market order: it
+         * sits at price tick 0 in the limit book and matches at any oracle price (see
+         * `check_order_fillable`).
+         */
+        trigger_price: float_4.Float,
+        /**
+         * Slippage limit (scaled `Float`) checked at match time. Zero disables the check.
+         * Only carries meaning on market orders — limit/stop orders always pass it through
+         * as zero.
+         */
+        acceptable_price: bcs.u64(),
+        /** Leverage in bps. */
+        leverage_bps: bcs.u64(),
+        /** Oracle price when order was placed. */
+        oracle_price_at_creation: float_5.Float,
+        /** Creation timestamp. */
+        create_timestamp: bcs.u64()
+    } });
+/**
+ * Creates a new trading order. Collateral is deposited into the vault.
+ * `acceptable_price = 0` means no slippage check; non-zero values are only carried
+ * by market orders (trigger_price == 0) and consulted by `match_orders` at fill
+ * time.
+ */
+export function createOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'address',
+        '0x2::object::ID',
+        '0x1::option::Option<u64>',
+        null,
+        null,
+        'u8',
+        'bool',
+        'bool',
+        'bool',
+        null,
+        null,
+        'u64',
+        'u64',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["orderId", "accountObjectAddress", "marketId", "linkedPositionId", "collateral", "vault", "collateralDecimal", "isLong", "reduceOnly", "isStopOrder", "size", "triggerPrice", "acceptablePrice", "leverageBps", "oraclePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'create_order',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Removes an order and returns its collateral from the vault. */
+export function removeOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["order", "vault"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'remove_order',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function updateOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["order", "size", "triggerPrice", "leverageBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'update_order',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Stamp the resolved linked position ID on an order whose `linked_position_id` is
+ * currently `None`. Used by the pre-order activation path: when a main with
+ * reserved pre-orders fills, the perp fills in the freshly-minted `position_id` on
+ * each reserved `Order` before moving it onto the live book.
+ */
+export function setLinkedPositionId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["order", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'set_linked_position_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Creates a new position. Collateral is deposited into the vault. */
+export function createPosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u64',
+        'address',
+        '0x2::object::ID',
+        'bool',
+        null,
+        null,
+        null,
+        'u8',
+        null,
+        null,
+        null,
+        'bool',
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["positionId", "accountObjectAddress", "marketId", "isLong", "size", "collateral", "vault", "collateralDecimal", "averagePrice", "collateralPrice", "entryBorrowIndex", "entryFundingSign", "entryFundingIndex", "tradingFee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'create_position',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Deposits collateral into position via the vault. */
+export function depositCollateral(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["position", "vault", "collateral"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'deposit_collateral',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Withdraws collateral from a position via the vault. */
+export function withdrawCollateral(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["position", "vault", "amount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'withdraw_collateral',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Removes a position, returning its collateral from the vault and linked order
+ * metadata.
+ */
+export function removePosition(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["position", "vault"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'remove_position',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function assertPositionCollateralType(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["position"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'assert_position_collateral_type',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function assertOrderCollateralType(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["order"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'assert_order_collateral_type',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function calculatePoolReserveAmountFromValues(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u8',
+        null
+    ];
+    const parameterNames = ["size", "price", "collateralDecimal", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'calculate_pool_reserve_amount_from_values',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function calculateReserveAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["position", "price", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'calculate_reserve_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function calculateReserveAmountFromValues(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'u8',
+        null
+    ];
+    const parameterNames = ["size", "price", "collateralAmount", "collateralDecimal", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'calculate_reserve_amount_from_values',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function refreshBorrowReserve(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["position", "price", "collateralPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'refresh_borrow_reserve',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function addPoolReserve(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["position", "reserveAmount"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'add_pool_reserve',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function realizePoolReserve(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["position", "reduceSize", "originalSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'realize_pool_reserve',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Updates position size and average price (on partial fill / increase). */
+export function updatePositionSize(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["position", "newSize", "newAvgPrice", "newSide"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'update_position_size',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Updates position borrow and funding fee state. */
+export function updateFees(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'bool',
+        null
+    ];
+    const parameterNames = ["position", "collateralPrice", "cumulativeBorrowRate", "cumulativeFundingSign", "cumulativeFundingIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'update_fees',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Adds trading fee to unrealized. */
+export function addTradingFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["position", "fee"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'add_trading_fee',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Realizes a proportional share of fees for a partial reduction. Returns
+ * (borrow_fee, funding_sign, funding_fee, trading_fee).
+ */
+export function realizePartialFees(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["position", "reduceSize", "originalSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'realize_partial_fees',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Adds a linked order to a position. */
+export function addLinkedOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64',
+        'u128'
+    ];
+    const parameterNames = ["position", "orderId", "priceKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'add_linked_order',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function maxLinkedOrders(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'max_linked_orders',
+    });
+}
+/** Removes a linked order from a position. */
+export function removeLinkedOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["position", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'remove_linked_order',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Calculates unrealized PnL. Returns (is_profit, pnl as Float in USD). */
+export function unrealizedPnl(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["position", "currentPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'unrealized_pnl',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns true if the order should be filled at the given oracle price. */
+export function checkOrderFillable(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["order", "oraclePrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'check_order_fillable',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns true if the position is liquidatable. `maintenance_margin` is a Float
+ * rate (e.g. 0.015 = 1.5%).
+ */
+export function isLiquidatable(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        null,
+        null,
+        'bool',
+        null
+    ];
+    const parameterNames = ["position", "currentPrice", "collateralPrice", "closingFee", "maintenanceMargin", "cumulativeBorrowRate", "cumulativeFundingSign", "cumulativeFundingIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'is_liquidatable',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function calculateBorrowFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["position", "cumulativeBorrowRate"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'calculate_borrow_fee',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function calculateFundingFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        null,
+        'bool',
+        null
+    ];
+    const parameterNames = ["position", "collateralPrice", "cumulativeFundingSign", "cumulativeFundingIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'calculate_funding_fee',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getPositionId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'get_position_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionAccountObjectAddress(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_account_object_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionMarketId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_market_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionIsLong(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_is_long',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionSize(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_size',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionCollateralToken(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_collateral_token',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionCollateralDecimal(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_collateral_decimal',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_collateral_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionAveragePrice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_average_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionEntryBorrowIndex(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_entry_borrow_index',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionPoolReserveAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_pool_reserve_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionBorrowReserveAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_borrow_reserve_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionLinkedOrderIds(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_linked_order_ids',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionLinkedOrderPriceKeys(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_linked_order_price_keys',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionUnrealizedBorrowFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_unrealized_borrow_fee',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionUnrealizedTradingFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_unrealized_trading_fee',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionUnrealizedFundingSign(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_unrealized_funding_sign',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionUnrealizedFundingFee(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_unrealized_funding_fee',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionUpdateTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_update_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionEntryFundingSign(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_entry_funding_sign',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionEntryFundingIndex(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_entry_funding_index',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionFeeState(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_fee_state',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function positionCreateTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["p"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'position_create_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getOrderId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'get_order_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderAccountObjectAddress(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_account_object_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderMarketId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_market_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderIsLong(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_is_long',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderIsStopOrder(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_is_stop_order',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderReduceOnly(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_reduce_only',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderSize(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_size',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderTriggerPrice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_trigger_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderAcceptablePrice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_acceptable_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderLinkedPositionId(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_linked_position_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderCollateralToken(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_collateral_token',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderCollateralDecimal(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_collateral_decimal',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderCollateralAmount(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_collateral_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderLeverageBps(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_leverage_bps',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function orderCreateTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_create_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns order type tag: 0=limit_buy, 1=limit_sell, 2=stop_buy, 3=stop_sell. */
+export function orderTypeTag(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'position',
+        function: 'order_type_tag',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}