@waterx/sdk 2.1.0 → 2.4.0

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

@@ -0,0 +1,1733 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as balance from "./deps/sui/balance.js";
+import * as table from "./deps/sui/table.js";
+import * as linked_table from "./deps/bucket_v2_framework/linked_table.js";
+import * as outcome from "./outcome.js";
+const $moduleName = '@waterx/prediction::waterx_prediction';
+export const MarketRegistry = new MoveStruct({ name: `${$moduleName}::MarketRegistry<phantom T>`, fields: {
+        id: 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.u64()),
+        resolved_markets: linked_table.LinkedTable(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.u64()),
+        /** Filled positions with active Polymarket exposure. */
+        positions: linked_table.LinkedTable(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.u64(),
+        next_position_id: bcs.u64(),
+        next_market_key: bcs.u64(),
+        /** Minimum time after order placement before user self-cancel is allowed. */
+        order_cancel_cooldown_ms: bcs.u64(),
+        /** Floor balance that `admin_withdraw` must respect. */
+        min_reserve: bcs.u64()
+    } });
+export const Market = new MoveStruct({ name: `${$moduleName}::Market`, fields: {
+        market_id: bcs.vector(bcs.u8()),
+        outcome: 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.u64(),
+        /** Active YES-side exposure still open in broker custody. */
+        yes_shares: bcs.u64(),
+        yes_cost: bcs.u64(),
+        /** Active NO-side exposure still open in broker custody. */
+        no_shares: bcs.u64(),
+        no_cost: bcs.u64()
+    } });
+export const MarketPointer = new MoveStruct({ name: `${$moduleName}::MarketPointer`, fields: {
+        key: bcs.u64(),
+        resolved: bcs.bool()
+    } });
+/**
+ * Admin-only: spin up the shared market registry object for coin type `T`. All
+ * markets for this coin type should settle through this object.
+ */
+export 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: 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`.
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Account-backed claim. Payout is credited to the owning waterx_account balance. */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Account-backed PendingClose rescue. Reverts the position to Open. */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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`.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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.
+ */
+export 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: 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).
+ */
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Keeper records the market outcome. Aborts if already resolved. */
+export 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: 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`.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Admin re-enables opens for a previously paused market. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Aborts if the market is unresolved or doesn't exist. */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: 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.
+ */
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export 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: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}