@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/src/prediction/prediction.d.ts

@@ -0,0 +1,149 @@
+import { Transaction, type TransactionArgument } from "@mysten/sui/transactions";
+import type { PredictClient } from "./client.ts";
+import type { AccountIdentityParams, IdArgument, MarketIdInput, ObjectArgument, Outcome, Selection } from "./types.ts";
+export interface BasePredictionParams {
+    packageId?: string;
+    globalConfig?: string;
+    marketRegistry?: string;
+    accountRegistry?: string;
+    settlementCoinType?: string;
+}
+export declare function selectionArg(client: PredictClient, tx: Transaction, selection: Selection | TransactionArgument, packageId?: string): TransactionArgument;
+export declare function outcomeArg(client: PredictClient, tx: Transaction, outcome: Outcome | TransactionArgument, packageId?: string): TransactionArgument;
+export interface PlaceOrderParams extends BasePredictionParams, AccountIdentityParams {
+    accountId: IdArgument;
+    /**
+     * Registry account that owns the filled position (defaults to `accountId`).
+     * Required by on-chain `place_order` since bet-sharing: payer and receiver may differ.
+     */
+    receiverAccountId?: IdArgument;
+    maxSpend: bigint | number | string;
+    marketId: MarketIdInput;
+    selection: Selection | TransactionArgument;
+    minShares: bigint | number | string;
+    priceCapBps: bigint | number | string;
+    expiryTs: bigint | number | string;
+}
+export declare function placeOrder(client: PredictClient, tx: Transaction, params: PlaceOrderParams): Transaction;
+export interface SelfCancelOrderParams extends BasePredictionParams, AccountIdentityParams {
+    orderId: bigint | number | string;
+}
+export declare function selfCancelOrder(client: PredictClient, tx: Transaction, params: SelfCancelOrderParams): Transaction;
+export interface ClaimParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+}
+export declare function claim(client: PredictClient, tx: Transaction, params: ClaimParams): Transaction;
+export interface BatchClaimParams extends BasePredictionParams, AccountIdentityParams {
+    positionIds: readonly (bigint | number | string)[];
+}
+/** Chains multiple `claim` calls in one PTB, reusing a single account request. */
+export declare function batchClaim(client: PredictClient, tx: Transaction, params: BatchClaimParams): Transaction;
+export interface RequestCloseParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+    minProceeds: bigint | number | string;
+    expiryTs: bigint | number | string;
+}
+export declare function requestClose(client: PredictClient, tx: Transaction, params: RequestCloseParams): Transaction;
+export interface RequestPartialCloseParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+    /**
+     * Shares to peel off `positionId` into a new same-account position that is
+     * then closed. Must be `0 < closeShares < filled_shares` of the position.
+     */
+    closeShares: bigint | number | string;
+    minProceeds: bigint | number | string;
+    expiryTs: bigint | number | string;
+}
+/**
+ * Account-backed partial sell. Splits `closeShares` off `positionId` into a new
+ * same-account position and runs the close flow on it; the remainder stays
+ * `Open` under `positionId`. The on-chain call returns the new PendingClose
+ * position id (read it from events / the returned move-call result if needed).
+ */
+export declare function requestPartialClose(client: PredictClient, tx: Transaction, params: RequestPartialCloseParams): Transaction;
+export interface SelfCancelCloseParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+}
+export declare function selfCancelClose(client: PredictClient, tx: Transaction, params: SelfCancelCloseParams): Transaction;
+export interface TransferPositionParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+    /** WXA account that receives the position; future close/claim proceeds go there. */
+    recipientAccountId: IdArgument;
+}
+/**
+ * Account-backed position transfer. The source account owner moves an open
+ * prediction position to another WXA account. Aborts if the position has a
+ * pending close.
+ */
+export declare function transferPosition(client: PredictClient, tx: Transaction, params: TransferPositionParams): Transaction;
+export interface SplitPositionParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+    /** WXA account that receives the new independent position. */
+    recipientAccountId: IdArgument;
+    /**
+     * Shares to split into the recipient's new position. Must be
+     * `0 < splitShares < filled_shares` of the source position.
+     */
+    splitShares: bigint | number | string;
+}
+/**
+ * Account-backed partial transfer. Splits an open position into two independent
+ * positions: the source keeps the remainder and the recipient receives a new
+ * position with proportional cost basis. The on-chain call returns the new
+ * position id (read it from events / the returned move-call result if needed).
+ */
+export declare function splitPosition(client: PredictClient, tx: Transaction, params: SplitPositionParams): Transaction;
+export interface KeeperBaseParams extends BasePredictionParams, AccountIdentityParams {
+}
+export interface FillOrderParams extends KeeperBaseParams {
+    orderId: bigint | number | string;
+    filledShares: bigint | number | string;
+    filledCost: bigint | number | string;
+}
+export declare function fillOrder(client: PredictClient, tx: Transaction, params: FillOrderParams): Transaction;
+export interface CancelOrderParams extends KeeperBaseParams {
+    orderId: bigint | number | string;
+}
+export declare function cancelOrder(client: PredictClient, tx: Transaction, params: CancelOrderParams): Transaction;
+export interface ConfirmCloseParams extends KeeperBaseParams {
+    positionId: bigint | number | string;
+    proceeds: bigint | number | string;
+}
+export declare function confirmClose(client: PredictClient, tx: Transaction, params: ConfirmCloseParams): Transaction;
+export interface CancelCloseParams extends KeeperBaseParams {
+    positionId: bigint | number | string;
+}
+export declare function cancelClose(client: PredictClient, tx: Transaction, params: CancelCloseParams): Transaction;
+export interface ForceClaimParams extends KeeperBaseParams {
+    positionId: bigint | number | string;
+}
+export declare function forceClaim(client: PredictClient, tx: Transaction, params: ForceClaimParams): Transaction;
+export interface BatchForceClaimParams extends KeeperBaseParams {
+    positionIds: readonly (bigint | number | string)[];
+}
+/** Chains multiple `force_claim` calls in one PTB, reusing a single keeper request. */
+export declare function batchForceClaim(client: PredictClient, tx: Transaction, params: BatchForceClaimParams): Transaction;
+export interface BuildBatchForceClaimTransactionsParams extends BatchForceClaimParams {
+    chunkSize?: number;
+}
+/**
+ * Splits `positionIds` into multiple PTBs, each with up to `chunkSize` `force_claim`
+ * calls. Returns one unsigned `Transaction` per chunk for keeper signing.
+ */
+export declare function buildBatchForceClaimTransactions(client: PredictClient, params: BuildBatchForceClaimTransactionsParams): Transaction[];
+export interface ResolveMarketParams extends KeeperBaseParams {
+    marketId: MarketIdInput;
+    outcome: Outcome | TransactionArgument;
+}
+export declare function resolveMarket(client: PredictClient, tx: Transaction, params: ResolveMarketParams): Transaction;
+export interface AdminPlaceOrderForParams extends BasePredictionParams {
+    adminCap: ObjectArgument;
+    payment: ObjectArgument;
+    accountId: IdArgument;
+    marketId: MarketIdInput;
+    selection: Selection | TransactionArgument;
+    minShares: bigint | number | string;
+    priceCapBps: bigint | number | string;
+    expiryTs: bigint | number | string;
+}
+export declare function adminPlaceOrderFor(client: PredictClient, tx: Transaction, params: AdminPlaceOrderForParams): Transaction;

package/dist/cjs/src/prediction/prediction.js

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectionArg = selectionArg;
+exports.outcomeArg = outcomeArg;
+exports.placeOrder = placeOrder;
+exports.selfCancelOrder = selfCancelOrder;
+exports.claim = claim;
+exports.batchClaim = batchClaim;
+exports.requestClose = requestClose;
+exports.requestPartialClose = requestPartialClose;
+exports.selfCancelClose = selfCancelClose;
+exports.transferPosition = transferPosition;
+exports.splitPosition = splitPosition;
+exports.fillOrder = fillOrder;
+exports.cancelOrder = cancelOrder;
+exports.confirmClose = confirmClose;
+exports.cancelClose = cancelClose;
+exports.forceClaim = forceClaim;
+exports.batchForceClaim = batchForceClaim;
+exports.buildBatchForceClaimTransactions = buildBatchForceClaimTransactions;
+exports.resolveMarket = resolveMarket;
+exports.adminPlaceOrderFor = adminPlaceOrderFor;
+const transactions_1 = require("@mysten/sui/transactions");
+const constants_ts_1 = require("./constants.js");
+const utils_ts_1 = require("./utils.js");
+function selectionArg(client, tx, selection, packageId) {
+    if (typeof selection !== "string")
+        return selection;
+    const validated = (0, utils_ts_1.assertSelection)(selection);
+    const fn = validated === "YES" ? "selection_yes" : "selection_no";
+    const [arg] = tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, packageId)}::position::${fn}`,
+    });
+    return arg;
+}
+function outcomeArg(client, tx, outcome, packageId) {
+    if (typeof outcome !== "string")
+        return outcome;
+    const validated = (0, utils_ts_1.assertOutcome)(outcome);
+    const fn = validated === "YES" ? "yes" : validated === "NO" ? "no" : "invalid";
+    const [arg] = tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, packageId)}::outcome::${fn}`,
+    });
+    return arg;
+}
+function placeOrder(client, tx, params) {
+    const pkg = (0, utils_ts_1.resolvePackageId)(client, params.packageId);
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    const receiverAccountId = params.receiverAccountId ?? params.accountId;
+    tx.moveCall({
+        target: `${pkg}::waterx_prediction::place_order`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            (0, utils_ts_1.idArg)(tx, params.accountId),
+            (0, utils_ts_1.idArg)(tx, receiverAccountId),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.maxSpend)),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+            selectionArg(client, tx, params.selection, params.packageId),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.minShares)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.priceCapBps)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.expiryTs)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function selfCancelOrder(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::self_cancel_order`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.orderId)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function claim(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::claim`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+/** Chains multiple `claim` calls in one PTB, reusing a single account request. */
+function batchClaim(client, tx, params) {
+    if (params.positionIds.length === 0) {
+        throw new Error("batchClaim: positionIds must not be empty");
+    }
+    const pkg = (0, utils_ts_1.resolvePackageId)(client, params.packageId);
+    const coinType = (0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType);
+    const globalConfig = tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig));
+    const marketRegistry = tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry));
+    const accountRegistry = tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry));
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    const clock = (0, utils_ts_1.clockArg)(tx);
+    for (const positionId of params.positionIds) {
+        tx.moveCall({
+            target: `${pkg}::waterx_prediction::claim`,
+            typeArguments: [coinType],
+            arguments: [
+                globalConfig,
+                marketRegistry,
+                accountRegistry,
+                senderRequest,
+                tx.pure.u64((0, utils_ts_1.toBigInt)(positionId)),
+                clock,
+            ],
+        });
+    }
+    return tx;
+}
+function requestClose(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::request_close`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.minProceeds)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.expiryTs)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+/**
+ * Account-backed partial sell. Splits `closeShares` off `positionId` into a new
+ * same-account position and runs the close flow on it; the remainder stays
+ * `Open` under `positionId`. The on-chain call returns the new PendingClose
+ * position id (read it from events / the returned move-call result if needed).
+ */
+function requestPartialClose(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::request_partial_close`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.closeShares)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.minProceeds)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.expiryTs)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function selfCancelClose(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::self_cancel_close`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+/**
+ * Account-backed position transfer. The source account owner moves an open
+ * prediction position to another WXA account. Aborts if the position has a
+ * pending close.
+ */
+function transferPosition(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::transfer_position`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            (0, utils_ts_1.idArg)(tx, params.recipientAccountId),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+/**
+ * Account-backed partial transfer. Splits an open position into two independent
+ * positions: the source keeps the remainder and the recipient receives a new
+ * position with proportional cost basis. The on-chain call returns the new
+ * position id (read it from events / the returned move-call result if needed).
+ */
+function splitPosition(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::split_position`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            (0, utils_ts_1.idArg)(tx, params.recipientAccountId),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.splitShares)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function fillOrder(client, tx, params) {
+    const keeperRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::fill_order`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            keeperRequest,
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.orderId)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.filledShares)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.filledCost)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function cancelOrder(client, tx, params) {
+    const keeperRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::cancel_order`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            keeperRequest,
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.orderId)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function confirmClose(client, tx, params) {
+    const keeperRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::confirm_close`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            keeperRequest,
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.proceeds)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function cancelClose(client, tx, params) {
+    const keeperRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::cancel_close`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            keeperRequest,
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function forceClaim(client, tx, params) {
+    const keeperRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::force_claim`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            keeperRequest,
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+/** Chains multiple `force_claim` calls in one PTB, reusing a single keeper request. */
+function batchForceClaim(client, tx, params) {
+    if (params.positionIds.length === 0) {
+        throw new Error("batchForceClaim: positionIds must not be empty");
+    }
+    const pkg = (0, utils_ts_1.resolvePackageId)(client, params.packageId);
+    const coinType = (0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType);
+    const globalConfig = tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig));
+    const marketRegistry = tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry));
+    const accountRegistry = tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry));
+    const keeperRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    const clock = (0, utils_ts_1.clockArg)(tx);
+    for (const positionId of params.positionIds) {
+        tx.moveCall({
+            target: `${pkg}::waterx_prediction::force_claim`,
+            typeArguments: [coinType],
+            arguments: [
+                globalConfig,
+                keeperRequest,
+                marketRegistry,
+                accountRegistry,
+                tx.pure.u64((0, utils_ts_1.toBigInt)(positionId)),
+                clock,
+            ],
+        });
+    }
+    return tx;
+}
+function assertPositiveIntegerChunkSize(chunkSize, fn) {
+    if (!Number.isInteger(chunkSize) || chunkSize <= 0) {
+        throw new Error(`${fn}: chunkSize must be a positive integer`);
+    }
+}
+function chunkPositionIds(items, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < items.length; i += chunkSize) {
+        chunks.push(items.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+/**
+ * Splits `positionIds` into multiple PTBs, each with up to `chunkSize` `force_claim`
+ * calls. Returns one unsigned `Transaction` per chunk for keeper signing.
+ */
+function buildBatchForceClaimTransactions(client, params) {
+    if (params.positionIds.length === 0) {
+        throw new Error("buildBatchForceClaimTransactions: positionIds must not be empty");
+    }
+    const { positionIds, chunkSize = constants_ts_1.DEFAULT_FORCE_CLAIM_CHUNK_SIZE, ...batchParams } = params;
+    assertPositiveIntegerChunkSize(chunkSize, "buildBatchForceClaimTransactions");
+    return chunkPositionIds(positionIds, chunkSize).map((ids) => {
+        const tx = new transactions_1.Transaction();
+        batchForceClaim(client, tx, { ...batchParams, positionIds: ids });
+        return tx;
+    });
+}
+function resolveMarket(client, tx, params) {
+    const keeperRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::resolve_market`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            keeperRequest,
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+            outcomeArg(client, tx, params.outcome, params.packageId),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function adminPlaceOrderFor(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::admin_place_order_for`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            (0, utils_ts_1.objectArg)(tx, params.adminCap),
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            (0, utils_ts_1.objectArg)(tx, params.payment),
+            (0, utils_ts_1.idArg)(tx, params.accountId),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+            selectionArg(client, tx, params.selection, params.packageId),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.minShares)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.priceCapBps)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.expiryTs)),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}

package/dist/cjs/src/prediction/tx-builders.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Async high-level prediction PTB builders with optional pre-sweep of parked
+ * backing assets into wxUSD credit ({@link appendConsolidateForSpend}).
+ *
+ * Takes both `AccountClientLike` (native_custody / consolidate) and `PredictClient`
+ * because sync prediction builders only target the prediction deployment.
+ *
+ * FE/BE tx services should call these instead of hand-composing
+ * `appendConsolidateForSpend` before `placeOrder` / `batchClaim`.
+ */
+import { Transaction } from "@mysten/sui/transactions";
+import type { AccountClientLike } from "../account/client.ts";
+import type { PredictClient } from "./client.ts";
+import { type BatchClaimParams, type PlaceOrderParams } from "./prediction.ts";
+export interface PredictCommonBuildOpts {
+    tx?: Transaction;
+    /**
+     * Pre-sweep parked backing assets (USDC, USDsui, …) and address CREDIT at
+     * the wxa account's address into spendable wxUSD before the main action —
+     * same semantics as perp {@link CommonBuildOpts.consolidateToUsd}. Default:
+     * `true`.
+     *
+     * Requires `accountId` to be a plain address string (not a PTB argument).
+     * When `accountId` is a dynamic `TransactionArgument`, the sweep is skipped.
+     */
+    consolidateToUsd?: boolean;
+}
+export type BuildPlaceOrderTxParams = PlaceOrderParams & PredictCommonBuildOpts;
+/** Same as {@link BatchClaimParams} plus `accountId` for the consolidate probe. */
+export interface BuildBatchClaimTxParams extends BatchClaimParams, PredictCommonBuildOpts {
+    /** wxa account object id — owner address for the pre-sweep probe. */
+    accountId: string;
+}
+/**
+ * Optional pre-sweep + {@link placeOrder} in one PTB.
+ *
+ * @param perpClient — perp deployment (native_custody probe + PSM mint legs)
+ * @param predictClient — prediction deployment (place_order MoveCall)
+ */
+export declare function buildPlaceOrderTx(perpClient: AccountClientLike, predictClient: PredictClient, params: BuildPlaceOrderTxParams): Promise<Transaction>;
+/**
+ * Optional pre-sweep + {@link batchClaim} in one PTB.
+ */
+export declare function buildBatchClaimTx(perpClient: AccountClientLike, predictClient: PredictClient, params: BuildBatchClaimTxParams): Promise<Transaction>;

package/dist/cjs/src/prediction/tx-builders.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlaceOrderTx = buildPlaceOrderTx;
+exports.buildBatchClaimTx = buildBatchClaimTx;
+/**
+ * Async high-level prediction PTB builders with optional pre-sweep of parked
+ * backing assets into wxUSD credit ({@link appendConsolidateForSpend}).
+ *
+ * Takes both `AccountClientLike` (native_custody / consolidate) and `PredictClient`
+ * because sync prediction builders only target the prediction deployment.
+ *
+ * FE/BE tx services should call these instead of hand-composing
+ * `appendConsolidateForSpend` before `placeOrder` / `batchClaim`.
+ */
+const transactions_1 = require("@mysten/sui/transactions");
+const consolidate_ts_1 = require("../account/funding/consolidate.js");
+const prediction_ts_1 = require("./prediction.js");
+function newTx(opts) {
+    return opts?.tx ?? new transactions_1.Transaction();
+}
+async function maybeConsolidate(perpClient, tx, accountId, opts) {
+    if (opts?.consolidateToUsd === false)
+        return;
+    if (typeof accountId !== "string")
+        return;
+    await (0, consolidate_ts_1.appendConsolidateForSpend)(perpClient, tx, accountId);
+}
+function stripPlaceOrderParams(params) {
+    const { tx: _tx, consolidateToUsd: _consolidate, ...rest } = params;
+    return rest;
+}
+function stripBatchClaimParams(params) {
+    const { tx: _tx, consolidateToUsd: _consolidate, accountId: _accountId, ...rest } = params;
+    return rest;
+}
+/**
+ * Optional pre-sweep + {@link placeOrder} in one PTB.
+ *
+ * @param perpClient — perp deployment (native_custody probe + PSM mint legs)
+ * @param predictClient — prediction deployment (place_order MoveCall)
+ */
+async function buildPlaceOrderTx(perpClient, predictClient, params) {
+    const tx = newTx(params);
+    await maybeConsolidate(perpClient, tx, params.accountId, params);
+    (0, prediction_ts_1.placeOrder)(predictClient, tx, stripPlaceOrderParams(params));
+    return tx;
+}
+/**
+ * Optional pre-sweep + {@link batchClaim} in one PTB.
+ */
+async function buildBatchClaimTx(perpClient, predictClient, params) {
+    const tx = newTx(params);
+    await maybeConsolidate(perpClient, tx, params.accountId, params);
+    (0, prediction_ts_1.batchClaim)(predictClient, tx, stripBatchClaimParams(params));
+    return tx;
+}