@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/generated/waterx_prediction/waterx_prediction.js

@@ -0,0 +1,1972 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceSettlementKey = exports.PriceSettlement = exports.MarketPointer = exports.Market = exports.MarketRegistry = void 0;
+exports.createMarketRegistry = createMarketRegistry;
+exports.placeOrder = placeOrder;
+exports.selfCancelOrder = selfCancelOrder;
+exports.claim = claim;
+exports.requestClose = requestClose;
+exports.requestPartialClose = requestPartialClose;
+exports.selfCancelClose = selfCancelClose;
+exports.transferPosition = transferPosition;
+exports.splitPosition = splitPosition;
+exports.adminPlaceOrderFor = adminPlaceOrderFor;
+exports.fillOrder = fillOrder;
+exports.cancelOrder = cancelOrder;
+exports.confirmClose = confirmClose;
+exports.cancelClose = cancelClose;
+exports.forceClaim = forceClaim;
+exports.depositSettlement = depositSettlement;
+exports.adminWithdraw = adminWithdraw;
+exports.setMinReserve = setMinReserve;
+exports.setOrderCancelCooldownMs = setOrderCancelCooldownMs;
+exports.resolveMarket = resolveMarket;
+exports.setPriceSettlement = setPriceSettlement;
+exports.resolveWithOracle = resolveWithOracle;
+exports.pauseMarket = pauseMarket;
+exports.unpauseMarket = unpauseMarket;
+exports.positionStatus = positionStatus;
+exports.positionAccountId = positionAccountId;
+exports.positionMarketId = positionMarketId;
+exports.positionSelection = positionSelection;
+exports.positionPayout = positionPayout;
+exports.positionFilled = positionFilled;
+exports.positionOpenedTs = positionOpenedTs;
+exports.positionCloseExpiry = positionCloseExpiry;
+exports.positionCloseOrderId = positionCloseOrderId;
+exports.positionCloseSelfCancelAfterTs = positionCloseSelfCancelAfterTs;
+exports.positionCloseMinProceeds = positionCloseMinProceeds;
+exports.positionExists = positionExists;
+exports.marketRegistryBalance = marketRegistryBalance;
+exports.marketRegistryMinReserve = marketRegistryMinReserve;
+exports.marketRegistryOrderCancelCooldownMs = marketRegistryOrderCancelCooldownMs;
+exports.nextOrderId = nextOrderId;
+exports.nextPositionId = nextPositionId;
+exports.positionIdForOrder = positionIdForOrder;
+exports.isMarketResolved = isMarketResolved;
+exports.isMarketPaused = isMarketPaused;
+exports.isMarketPausedByKey = isMarketPausedByKey;
+exports.marketExists = marketExists;
+exports.marketOutcome = marketOutcome;
+exports.marketOutcomeByKey = marketOutcomeByKey;
+exports.marketUnclaimedCount = marketUnclaimedCount;
+exports.marketExposure = marketExposure;
+exports.orders = orders;
+exports.orderCount = orderCount;
+exports.orderKeyAt = orderKeyAt;
+exports.orderFront = orderFront;
+exports.orderBack = orderBack;
+exports.orderNext = orderNext;
+exports.orderPrev = orderPrev;
+exports.orderExists = orderExists;
+exports.orderId = orderId;
+exports.orderKind = orderKind;
+exports.orderAccountId = orderAccountId;
+exports.orderReceiverAccountId = orderReceiverAccountId;
+exports.orderMarketId = orderMarketId;
+exports.orderSelection = orderSelection;
+exports.orderPositionId = orderPositionId;
+exports.orderMaxSpend = orderMaxSpend;
+exports.orderMinShares = orderMinShares;
+exports.orderPriceCap = orderPriceCap;
+exports.orderMinProceeds = orderMinProceeds;
+exports.orderExpiry = orderExpiry;
+exports.orderSelfCancelAfterTs = orderSelfCancelAfterTs;
+exports.orderCreatedTs = orderCreatedTs;
+exports.orderIsByAdmin = orderIsByAdmin;
+exports.positions = positions;
+exports.positionCount = positionCount;
+exports.positionKeyAt = positionKeyAt;
+exports.positionFront = positionFront;
+exports.positionBack = positionBack;
+exports.positionNext = positionNext;
+exports.positionPrev = positionPrev;
+exports.marketCount = marketCount;
+exports.marketKey = marketKey;
+exports.marketKeyAt = marketKeyAt;
+exports.marketIdByKey = marketIdByKey;
+exports.marketExistsByKey = marketExistsByKey;
+exports.marketIsResolvedByKey = marketIsResolvedByKey;
+exports.marketUnclaimedCountByKey = marketUnclaimedCountByKey;
+exports.marketExposureByKey = marketExposureByKey;
+exports.unresolvedMarkets = unresolvedMarkets;
+exports.resolvedMarkets = resolvedMarkets;
+exports.unresolvedMarketCount = unresolvedMarketCount;
+exports.resolvedMarketCount = resolvedMarketCount;
+exports.unresolvedMarketFront = unresolvedMarketFront;
+exports.unresolvedMarketBack = unresolvedMarketBack;
+exports.resolvedMarketFront = resolvedMarketFront;
+exports.resolvedMarketBack = resolvedMarketBack;
+exports.unresolvedMarketNext = unresolvedMarketNext;
+exports.unresolvedMarketPrev = unresolvedMarketPrev;
+exports.resolvedMarketNext = resolvedMarketNext;
+exports.resolvedMarketPrev = resolvedMarketPrev;
+exports.statusIsOpen = statusIsOpen;
+exports.statusIsPendingClose = statusIsPendingClose;
+exports.orderKindIsOpen = orderKindIsOpen;
+exports.orderKindIsClose = orderKindIsClose;
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const balance = __importStar(require("./deps/sui/balance.js"));
+const table = __importStar(require("./deps/sui/table.js"));
+const linked_table = __importStar(require("./deps/bucket_v2_framework/linked_table.js"));
+const outcome = __importStar(require("./outcome.js"));
+const $moduleName = '@waterx/prediction::waterx_prediction';
+exports.MarketRegistry = new index_ts_1.MoveStruct({ name: `${$moduleName}::MarketRegistry<phantom T>`, fields: {
+        id: bcs_1.bcs.Address,
+        /** One shared settlement pool for all markets using coin type `T`. */
+        balance: balance.Balance,
+        /** Exact market lookup: external market id bytes -> linked-table key. */
+        market_id_map: table.Table,
+        unresolved_markets: linked_table.LinkedTable(bcs_1.bcs.u64()),
+        resolved_markets: linked_table.LinkedTable(bcs_1.bcs.u64()),
+        /** Set of market keys where new opens are blocked. Presence = paused. */
+        paused_markets: table.Table,
+        /** Pending open and close orders waiting for broker/keeper execution. */
+        orders: linked_table.LinkedTable(bcs_1.bcs.u64()),
+        /** Filled positions with active Polymarket exposure. */
+        positions: linked_table.LinkedTable(bcs_1.bcs.u64()),
+        /**
+         * Filled order id -> filled position id. Split positions are independent positions
+         * and are not indexed here.
+         */
+        position_id_by_order: table.Table,
+        /**
+         * Reverse index for cleaning `position_id_by_order` when the filled position is
+         * claimed or closed.
+         */
+        order_id_by_position: table.Table,
+        next_order_id: bcs_1.bcs.u64(),
+        next_position_id: bcs_1.bcs.u64(),
+        next_market_key: bcs_1.bcs.u64(),
+        /** Minimum time after order placement before user self-cancel is allowed. */
+        order_cancel_cooldown_ms: bcs_1.bcs.u64(),
+        /** Floor balance that `admin_withdraw` must respect. */
+        min_reserve: bcs_1.bcs.u64()
+    } });
+exports.Market = new index_ts_1.MoveStruct({ name: `${$moduleName}::Market`, fields: {
+        market_id: bcs_1.bcs.vector(bcs_1.bcs.u8()),
+        outcome: bcs_1.bcs.option(outcome.Outcome),
+        /**
+         * Number of `Open` positions referencing this market. Incremented on `fill_order`;
+         * decremented on `claim` / `confirm_close`. The market entry remains queryable
+         * even after this reaches zero.
+         */
+        unclaimed_count: bcs_1.bcs.u64(),
+        /** Active YES-side exposure still open in broker custody. */
+        yes_shares: bcs_1.bcs.u64(),
+        yes_cost: bcs_1.bcs.u64(),
+        /** Active NO-side exposure still open in broker custody. */
+        no_shares: bcs_1.bcs.u64(),
+        no_cost: bcs_1.bcs.u64()
+    } });
+exports.MarketPointer = new index_ts_1.MoveStruct({ name: `${$moduleName}::MarketPointer`, fields: {
+        key: bcs_1.bcs.u64(),
+        resolved: bcs_1.bcs.bool()
+    } });
+exports.PriceSettlement = new index_ts_1.MoveStruct({ name: `${$moduleName}::PriceSettlement`, fields: {
+        /** Oracle ticker to read, e.g. "BTCUSD". */
+        settle_ticker: bcs_1.bcs.string(),
+        /**
+         * Exact snapshot timestamp to read (must already be registered on-chain via
+         * `oracle::register_price_at_timestamp`).
+         */
+        settle_timestamp_ms: bcs_1.bcs.u64(),
+        /** 1e9-scaled `Float` raw value the price is compared against. */
+        threshold: bcs_1.bcs.u128(),
+        /** One of CMP_GT / CMP_GTE / CMP_LT / CMP_LTE. */
+        comparison: bcs_1.bcs.u8()
+    } });
+exports.PriceSettlementKey = new index_ts_1.MoveStruct({ name: `${$moduleName}::PriceSettlementKey`, fields: {
+        market_id: bcs_1.bcs.vector(bcs_1.bcs.u8())
+    } });
+/**
+ * Admin-only: spin up the shared market registry object for coin type `T`. All
+ * markets for this coin type should settle through this object.
+ */
+function createMarketRegistry(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["_"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'create_market_registry',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-backed variant: debits `max_spend` from `account_id` in
+ * `waterx_account`, records pending-order/refunds against that payer, and gives
+ * the filled position to `receiver_account_id`.
+ */
+function placeOrder(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        '0x2::object::ID',
+        'u64',
+        'vector<u8>',
+        null,
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "accountId", "receiverAccountId", "maxSpend", "marketId", "selection", "minShares", "priceCap", "expiryTs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'place_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-backed rescue for a stuck open order. Refunds go back into the
+ * waterx_account stored balance.
+ */
+function selfCancelOrder(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'self_cancel_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Account-backed claim. Payout is credited to the owning waterx_account balance. */
+function claim(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'claim',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-backed close request. Auth is checked against the owning waterx_account.
+ * The position is locked in PendingClose until a keeper confirms the sell, a
+ * keeper cancels it, or the user self-cancels past `self_cancel_after_ts`. Aborts
+ * if the market has already resolved.
+ */
+function requestClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "positionId", "minProceeds", "expiryTs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'request_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-backed partial close. Splits `close_shares` off `position_id` into a new
+ * same-account position and runs the close flow on it; the remainder stays `Open`
+ * under `position_id`. Auth `PERM_REQUEST_CLOSE` — value stays in the account, so
+ * unlike `split_position` it is not transfer-equivalent. Emits a dedicated
+ * `PartialCloseRequested` plus `PositionSplit` (from == to) and `CloseRequested`
+ * for the new position. Returns the new PendingClose position id.
+ */
+function requestPartialClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "positionId", "closeShares", "minProceeds", "expiryTs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'request_partial_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Account-backed PendingClose rescue. Reverts the position to Open. */
+function selfCancelClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'self_cancel_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-backed position transfer. The source account owner moves an open
+ * prediction position to another WXA account; future close/claim proceeds go to
+ * the recipient account.
+ */
+function transferPosition(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::object::ID',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "positionId", "recipientAccountId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'transfer_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Account-backed partial transfer. Splits an open position into two normal
+ * positions: the source keeps the remainder and the recipient receives a new
+ * independent position with proportional cost basis.
+ */
+function splitPosition(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::object::ID',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "marketRegistry", "wxaRegistry", "senderRequest", "positionId", "recipientAccountId", "splitShares"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'split_position',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin-funded account position. The admin supplies the payment coin, while future
+ * user exits and admin refunds/claims return value to `account_id` in
+ * `waterx_account`.
+ */
+function adminPlaceOrderFor(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        '0x2::object::ID',
+        'vector<u8>',
+        null,
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["_", "marketRegistry", "wxaRegistry", "payment", "accountId", "marketId", "selection", "minShares", "priceCap", "expiryTs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'admin_place_order_for',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper reports the Polymarket fill back to chain. Account-backed fill
+ * confirmation. Any unspent max_spend is credited back to the payer account, then
+ * a new independent position id is allocated.
+ */
+function fillOrder(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "wxaRegistry", "orderId", "filledShares", "filledCost"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'fill_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper-initiated cancel. Used when Polymarket couldn't fill at all.
+ * Account-backed keeper cancel. Full refund is credited to the owning
+ * waterx_account.
+ */
+function cancelOrder(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "wxaRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'cancel_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper reports the Polymarket sell back to chain. Pays user `proceeds` and
+ * closes the position. Aborts if `proceeds < close_min_proceeds`. Account-backed
+ * close confirmation. Proceeds are credited to the owning waterx_account.
+ */
+function confirmClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "wxaRegistry", "positionId", "proceeds"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'confirm_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper-initiated cancel of a PendingClose request. Used when the
+ * waterx_prediction couldn't sell on Polymarket. Reverts position to Open — shares
+ * are intact.
+ */
+function cancelClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "wxaRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'cancel_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper settles a position for the owning waterx_account. Same payout math as
+ * `claim`; keeper just pays the gas.
+ *
+ * Two main use cases:
+ *
+ * 1.  **Batch payout distribution** — after `resolve_market`, chain multiple
+ *     `force_claim` calls in one PTB to settle every position on that market in a
+ *     single tx. Users get paid without spending gas.
+ * 2.  **Zombie cleanup** - losing-side positions where payout = 0 give the account
+ *     no incentive to call `claim`. Force-claim removes the position while leaving
+ *     market metadata available for indexed queries.
+ *
+ * Only operates on open positions. Pending open orders and pending close orders
+ * have their own resolution paths (`fill_order` / `confirm_close`). Account-backed
+ * keeper claim. Used for gas-sponsored settlement and zombie cleanup when the
+ * position belongs to a waterx_account.
+ */
+function forceClaim(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'u64',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "wxaRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'force_claim',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function depositSettlement(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null
+    ];
+    const parameterNames = ["_", "marketRegistry", "payment"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'deposit_settlement',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin pulls capital out of the market_registry — used to realise
+ * waterx_prediction spread/profit or rebalance working capital. Aborts if the
+ * post-balance would dip below `min_reserve`, providing a kill-switch against
+ * accidental drains.
+ */
+function adminWithdraw(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64',
+        'address'
+    ];
+    const parameterNames = ["_", "marketRegistry", "amount", "recipient"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'admin_withdraw',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin sets the minimum reserve floor. Future `admin_withdraw` calls abort if
+ * they would leave `market_registry.balance` below this. Does NOT block user
+ * payouts — `claim` and refunds bypass `min_reserve` entirely (those are user
+ * funds).
+ */
+function setMinReserve(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["_", "marketRegistry", "newReserve"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'set_min_reserve',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin sets the minimum account-owner self-cancel cooldown for newly created open
+ * and close orders. Existing orders keep their stored self-cancel time.
+ */
+function setOrderCancelCooldownMs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["_", "marketRegistry", "newCooldownMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'set_order_cancel_cooldown_ms',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Keeper records the market outcome. Aborts if already resolved. */
+function resolveMarket(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        'vector<u8>',
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "marketId", "outcome"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolve_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin pre-commits the price-settlement config for a market. Stored as a dynamic
+ * field on the registry; re-calling overwrites (until resolved).
+ */
+function setPriceSettlement(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<u8>',
+        '0x1::string::String',
+        'u64',
+        'u128',
+        'u8',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["_", "marketRegistry", "marketId", "settleTicker", "settleTimestampMs", "threshold", "comparison"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'set_price_settlement',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Keeper resolves a price-settled market from an on-chain oracle snapshot. The
+ * price at `settle_timestamp_ms` must already be registered on the oracle (the
+ * keeper PTB submits `waterx_rule::quote_for_timestamp` →
+ * `oracle::register_price_at_timestamp` before calling this). The outcome is
+ * derived from the pre-committed threshold + comparison, so the keeper cannot
+ * influence the result beyond triggering it. Aborts if no settlement is set or the
+ * market is already resolved.
+ */
+function resolveWithOracle(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        null,
+        null,
+        'vector<u8>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["globalConfig", "keeperRequest", "marketRegistry", "oracle", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolve_with_oracle',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Admin pauses new opens for a specific market. Existing positions unaffected. If
+ * the market does not exist yet, this creates market metadata and emits
+ * `MarketCreated { by_admin: true }` before `MarketPaused`.
+ */
+function pauseMarket(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<u8>',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["_", "marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'pause_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin re-enables opens for a previously paused market. */
+function unpauseMarket(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["_", "marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'unpause_market',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionStatus(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_status',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionMarketId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_market_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionSelection(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_selection',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionPayout(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_payout',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionFilled(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_filled',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionOpenedTs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_opened_ts',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionCloseExpiry(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_close_expiry',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionCloseOrderId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_close_order_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionCloseSelfCancelAfterTs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_close_self_cancel_after_ts',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionCloseMinProceeds(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_close_min_proceeds',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionExists(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_exists',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketRegistryBalance(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_registry_balance',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketRegistryMinReserve(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_registry_min_reserve',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketRegistryOrderCancelCooldownMs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_registry_order_cancel_cooldown_ms',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function nextOrderId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'next_order_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function nextPositionId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'next_position_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionIdForOrder(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_id_for_order',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function isMarketResolved(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'is_market_resolved',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function isMarketPaused(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'is_market_paused',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function isMarketPausedByKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'is_market_paused_by_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketExists(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_exists',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Aborts if the market is unresolved or doesn't exist. */
+function marketOutcome(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_outcome',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketOutcomeByKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_outcome_by_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketUnclaimedCount(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_unclaimed_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketExposure(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_exposure',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orders(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'orders',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderCount(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderKeyAt(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_key_at',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderFront(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderBack(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderNext(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_next',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderPrev(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_prev',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderExists(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_exists',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "lookupOrderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderKind(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_kind',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderReceiverAccountId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_receiver_account_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderMarketId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_market_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderSelection(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_selection',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderPositionId(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_position_id',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderMaxSpend(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_max_spend',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderMinShares(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_min_shares',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderPriceCap(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_price_cap',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderMinProceeds(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_min_proceeds',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderExpiry(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_expiry',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderSelfCancelAfterTs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_self_cancel_after_ts',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderCreatedTs(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_created_ts',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function orderIsByAdmin(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "orderId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_is_by_admin',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positions(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'positions',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionCount(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionKeyAt(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_key_at',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionFront(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionBack(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionNext(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_next',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function positionPrev(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "positionId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'position_prev',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketCount(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'vector<u8>'
+    ];
+    const parameterNames = ["marketRegistry", "marketId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Compatibility helper for indexed reads. Returns unresolved market keys first,
+ * then resolved market keys. Prefer the linked-table cursor helpers for canonical
+ * traversal.
+ */
+function marketKeyAt(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "index"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_key_at',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketIdByKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_id_by_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketExistsByKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_exists_by_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketIsResolvedByKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_is_resolved_by_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketUnclaimedCountByKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_unclaimed_count_by_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function marketExposureByKey(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'market_exposure_by_key',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function unresolvedMarkets(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'unresolved_markets',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function resolvedMarkets(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolved_markets',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function unresolvedMarketCount(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'unresolved_market_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function resolvedMarketCount(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolved_market_count',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function unresolvedMarketFront(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'unresolved_market_front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function unresolvedMarketBack(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'unresolved_market_back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function resolvedMarketFront(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolved_market_front',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function resolvedMarketBack(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["marketRegistry"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolved_market_back',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function unresolvedMarketNext(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'unresolved_market_next',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function unresolvedMarketPrev(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'unresolved_market_prev',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function resolvedMarketNext(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolved_market_next',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function resolvedMarketPrev(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["marketRegistry", "marketKey"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'resolved_market_prev',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+function statusIsOpen(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["s"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'status_is_open',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function statusIsPendingClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["s"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'status_is_pending_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function orderKindIsOpen(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kind"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_kind_is_open',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+function orderKindIsClose(options) {
+    const packageAddress = options.package ?? '@waterx/prediction';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kind"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'waterx_prediction',
+        function: 'order_kind_is_close',
+        arguments: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}