@waterx/sdk 2.1.0 → 2.3.1-dev.0

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

@@ -0,0 +1,29 @@
+export { PredictClient } from "./client.ts";
+export type { CreateClientOptions } from "./client.ts";
+export { clearConfigCache, defaultConfigUrl, loadConfig } from "./config.ts";
+export type { LoadConfigOptions, WaterxAccountPackage, WaterxConfigPackageBase, WaterxPredictionConfig, WaterxPredictionConfigPackages, WaterxPredictionGiftPackage, WaterxPredictionPackage, WaterxReferralPackage, } from "./config.ts";
+export * from "./constants.ts";
+export * from "./types.ts";
+export * as user from "./user/index.ts";
+export * as utils from "./utils/index.ts";
+export { addDelegate, allowPredictionProtocolAsset, consumeDepositDirect, consumeWithdrawDirect, createAccount, deposit, disallowPredictionProtocolAsset, removeDelegate, resolveRegistryAccountId, requestDeposit, requestDepositFromReceivings, requestWithdraw, setDelegatePredictionPermission, transferCoinToAccount, whitelistPredictionProtocol, withdraw, } from "./account.ts";
+export type { AddDelegateParams, ConsumeDepositDirectParams, CreateAccountParams, ConsumeWithdrawDirectParams, PredictionProtocolAssetParams, RemoveDelegateParams, RequestDepositFromReceivingsParams, RequestDepositParams, RequestWithdrawParams, SetDelegatePredictionPermissionParams, TransferCoinToAccountParams, WhitelistPredictionProtocolParams, } from "./account.ts";
+export { addKeeper, adminWithdraw, createMarketRegistry, depositSettlement, pauseMarket, removeKeeper, setMinReserve, setOrderCancelCooldownMs, unpauseMarket, } from "./admin.ts";
+export type { AdminWithdrawParams, CreateMarketRegistryParams, DepositSettlementParams, KeeperAdminParams, MarketPauseParams, SetMinReserveParams, SetOrderCancelCooldownParams, } from "./admin.ts";
+export { adminPlaceOrderFor, batchClaim, batchForceClaim, buildBatchForceClaimTransactions, cancelClose, cancelOrder, claim, confirmClose, fillOrder, forceClaim, outcomeArg, placeOrder, requestClose, resolveMarket, selectionArg, selfCancelClose, selfCancelOrder, } from "./prediction.ts";
+export type { AdminPlaceOrderForParams, BatchClaimParams, BatchForceClaimParams, BuildBatchForceClaimTransactionsParams, CancelCloseParams, CancelOrderParams, ClaimParams, ConfirmCloseParams, FillOrderParams, ForceClaimParams, PlaceOrderParams, RequestCloseParams, ResolveMarketParams, SelfCancelCloseParams, SelfCancelOrderParams, } from "./prediction.ts";
+export { buildBatchClaimTx, buildPlaceOrderTx } from "./tx-builders.ts";
+export type { BuildBatchClaimTxParams, BuildPlaceOrderTxParams, PredictCommonBuildOpts, } from "./tx-builders.ts";
+export { getAccountData, getAccountIds, getAccountOrderIds, getAccountOrderIdsByMarketId, getAccountPositionIds, getAccountPositionIdsByMarketId, getKeeperAddresses, getAllowedVersions, getMarketExposure, getMarketExposureByKey, getMarketById, getMarketByKey, getOrder, getOrderCursor, getPosition, getPositionCursor, getRegistry, getResolvedMarketCursor, getUnresolvedMarketCursor, isKeeper, isPredictionProtocolAssetAllowed, } from "./fetch.ts";
+export type { GetAccountIdsParams, ViewBaseParams } from "./fetch.ts";
+export { base64UrlNoPadDecode, base64UrlNoPadEncode, buildClaimShareFlow, buildCreateGiftFlow, buildGiftClaimMessage, claimShare, createGift, deleteGift, deriveGiftAddress, deriveGiftKeypair, encodeGiftUrl, generateGiftSeed, getCreatorGiftCount, getCreatorGiftIds, getGift, getGiftConfigPaused, getGiftControllerAddress, getGiftHasClaimed, parseGiftUrl, signGiftClaim, } from "./gift.ts";
+export type { BuildClaimShareFlowParams, BuildClaimShareFlowResult, BuildCreateGiftFlowResult, ClaimShareParams, CreateGiftParams, DeleteGiftParams, GiftBaseParams, GiftReferralParams, GiftUrlParts, GiftView, } from "./gift.ts";
+export * as bucketFrameworkAccountCalls from "./generated/bucket_v2_framework/account.ts";
+export * as waterxAccountCalls from "./generated/waterx_account/account.ts";
+export * as predictionAccountDataCalls from "./generated/waterx_prediction/account_data.ts";
+export * as predictionGlobalConfigCalls from "./generated/waterx_prediction/global_config.ts";
+export * as predictionOutcomeCalls from "./generated/waterx_prediction/outcome.ts";
+export * as predictionPositionCalls from "./generated/waterx_prediction/position.ts";
+export * as predictionVersionCalls from "./generated/waterx_prediction/version.ts";
+export * as predictionViewCalls from "./generated/waterx_prediction/view.ts";
+export * as predictionCalls from "./generated/waterx_prediction/waterx_prediction.ts";

package/dist/src/prediction/index.js

@@ -0,0 +1,21 @@
+export { PredictClient } from "./client.js";
+export { clearConfigCache, defaultConfigUrl, loadConfig } from "./config.js";
+export * from "./constants.js";
+export * from "./types.js";
+export * as user from "./user/index.js";
+export * as utils from "./utils/index.js";
+export { addDelegate, allowPredictionProtocolAsset, consumeDepositDirect, consumeWithdrawDirect, createAccount, deposit, disallowPredictionProtocolAsset, removeDelegate, resolveRegistryAccountId, requestDeposit, requestDepositFromReceivings, requestWithdraw, setDelegatePredictionPermission, transferCoinToAccount, whitelistPredictionProtocol, withdraw, } from "./account.js";
+export { addKeeper, adminWithdraw, createMarketRegistry, depositSettlement, pauseMarket, removeKeeper, setMinReserve, setOrderCancelCooldownMs, unpauseMarket, } from "./admin.js";
+export { adminPlaceOrderFor, batchClaim, batchForceClaim, buildBatchForceClaimTransactions, cancelClose, cancelOrder, claim, confirmClose, fillOrder, forceClaim, outcomeArg, placeOrder, requestClose, resolveMarket, selectionArg, selfCancelClose, selfCancelOrder, } from "./prediction.js";
+export { buildBatchClaimTx, buildPlaceOrderTx } from "./tx-builders.js";
+export { getAccountData, getAccountIds, getAccountOrderIds, getAccountOrderIdsByMarketId, getAccountPositionIds, getAccountPositionIdsByMarketId, getKeeperAddresses, getAllowedVersions, getMarketExposure, getMarketExposureByKey, getMarketById, getMarketByKey, getOrder, getOrderCursor, getPosition, getPositionCursor, getRegistry, getResolvedMarketCursor, getUnresolvedMarketCursor, isKeeper, isPredictionProtocolAssetAllowed, } from "./fetch.js";
+export { base64UrlNoPadDecode, base64UrlNoPadEncode, buildClaimShareFlow, buildCreateGiftFlow, buildGiftClaimMessage, claimShare, createGift, deleteGift, deriveGiftAddress, deriveGiftKeypair, encodeGiftUrl, generateGiftSeed, getCreatorGiftCount, getCreatorGiftIds, getGift, getGiftConfigPaused, getGiftControllerAddress, getGiftHasClaimed, parseGiftUrl, signGiftClaim, } from "./gift.js";
+export * as bucketFrameworkAccountCalls from "./generated/bucket_v2_framework/account.js";
+export * as waterxAccountCalls from "./generated/waterx_account/account.js";
+export * as predictionAccountDataCalls from "./generated/waterx_prediction/account_data.js";
+export * as predictionGlobalConfigCalls from "./generated/waterx_prediction/global_config.js";
+export * as predictionOutcomeCalls from "./generated/waterx_prediction/outcome.js";
+export * as predictionPositionCalls from "./generated/waterx_prediction/position.js";
+export * as predictionVersionCalls from "./generated/waterx_prediction/version.js";
+export * as predictionViewCalls from "./generated/waterx_prediction/view.js";
+export * as predictionCalls from "./generated/waterx_prediction/waterx_prediction.js";

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

@@ -0,0 +1,104 @@
+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 SelfCancelCloseParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+}
+export declare function selfCancelClose(client: PredictClient, tx: Transaction, params: SelfCancelCloseParams): 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/src/prediction/prediction.js

@@ -0,0 +1,317 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { DEFAULT_FORCE_CLAIM_CHUNK_SIZE } from "./constants.js";
+import { assertOutcome, assertSelection, clockArg, createAccountRequest, idArg, marketIdArg, objectArg, resolveAccountRegistry, resolveGlobalConfig, resolveMarketRegistry, resolvePackageId, resolveSettlementCoinType, toBigInt, } from "./utils.js";
+export function selectionArg(client, tx, selection, packageId) {
+    if (typeof selection !== "string")
+        return selection;
+    const validated = assertSelection(selection);
+    const fn = validated === "YES" ? "selection_yes" : "selection_no";
+    const [arg] = tx.moveCall({
+        target: `${resolvePackageId(client, packageId)}::position::${fn}`,
+    });
+    return arg;
+}
+export function outcomeArg(client, tx, outcome, packageId) {
+    if (typeof outcome !== "string")
+        return outcome;
+    const validated = assertOutcome(outcome);
+    const fn = validated === "YES" ? "yes" : validated === "NO" ? "no" : "invalid";
+    const [arg] = tx.moveCall({
+        target: `${resolvePackageId(client, packageId)}::outcome::${fn}`,
+    });
+    return arg;
+}
+export function placeOrder(client, tx, params) {
+    const pkg = resolvePackageId(client, params.packageId);
+    const senderRequest = createAccountRequest(client, tx, params);
+    const receiverAccountId = params.receiverAccountId ?? params.accountId;
+    tx.moveCall({
+        target: `${pkg}::waterx_prediction::place_order`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            idArg(tx, params.accountId),
+            idArg(tx, receiverAccountId),
+            tx.pure.u64(toBigInt(params.maxSpend)),
+            marketIdArg(tx, params.marketId),
+            selectionArg(client, tx, params.selection, params.packageId),
+            tx.pure.u64(toBigInt(params.minShares)),
+            tx.pure.u64(toBigInt(params.priceCapBps)),
+            tx.pure.u64(toBigInt(params.expiryTs)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function selfCancelOrder(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::self_cancel_order`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64(toBigInt(params.orderId)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function claim(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::claim`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64(toBigInt(params.positionId)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+/** Chains multiple `claim` calls in one PTB, reusing a single account request. */
+export function batchClaim(client, tx, params) {
+    if (params.positionIds.length === 0) {
+        throw new Error("batchClaim: positionIds must not be empty");
+    }
+    const pkg = resolvePackageId(client, params.packageId);
+    const coinType = resolveSettlementCoinType(client, params.settlementCoinType);
+    const globalConfig = tx.object(resolveGlobalConfig(client, params.globalConfig));
+    const marketRegistry = tx.object(resolveMarketRegistry(client, params.marketRegistry));
+    const accountRegistry = tx.object(resolveAccountRegistry(client, params.accountRegistry));
+    const senderRequest = createAccountRequest(client, tx, params);
+    const clock = 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(toBigInt(positionId)),
+                clock,
+            ],
+        });
+    }
+    return tx;
+}
+export function requestClose(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::request_close`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64(toBigInt(params.positionId)),
+            tx.pure.u64(toBigInt(params.minProceeds)),
+            tx.pure.u64(toBigInt(params.expiryTs)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function selfCancelClose(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::self_cancel_close`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            senderRequest,
+            tx.pure.u64(toBigInt(params.positionId)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function fillOrder(client, tx, params) {
+    const keeperRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::fill_order`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            keeperRequest,
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.u64(toBigInt(params.orderId)),
+            tx.pure.u64(toBigInt(params.filledShares)),
+            tx.pure.u64(toBigInt(params.filledCost)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function cancelOrder(client, tx, params) {
+    const keeperRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::cancel_order`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            keeperRequest,
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.u64(toBigInt(params.orderId)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function confirmClose(client, tx, params) {
+    const keeperRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::confirm_close`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            keeperRequest,
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.u64(toBigInt(params.positionId)),
+            tx.pure.u64(toBigInt(params.proceeds)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function cancelClose(client, tx, params) {
+    const keeperRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::cancel_close`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            keeperRequest,
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.u64(toBigInt(params.positionId)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function forceClaim(client, tx, params) {
+    const keeperRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::force_claim`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            keeperRequest,
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.u64(toBigInt(params.positionId)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+/** Chains multiple `force_claim` calls in one PTB, reusing a single keeper request. */
+export function batchForceClaim(client, tx, params) {
+    if (params.positionIds.length === 0) {
+        throw new Error("batchForceClaim: positionIds must not be empty");
+    }
+    const pkg = resolvePackageId(client, params.packageId);
+    const coinType = resolveSettlementCoinType(client, params.settlementCoinType);
+    const globalConfig = tx.object(resolveGlobalConfig(client, params.globalConfig));
+    const marketRegistry = tx.object(resolveMarketRegistry(client, params.marketRegistry));
+    const accountRegistry = tx.object(resolveAccountRegistry(client, params.accountRegistry));
+    const keeperRequest = createAccountRequest(client, tx, params);
+    const clock = 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(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.
+ */
+export function buildBatchForceClaimTransactions(client, params) {
+    if (params.positionIds.length === 0) {
+        throw new Error("buildBatchForceClaimTransactions: positionIds must not be empty");
+    }
+    const { positionIds, chunkSize = DEFAULT_FORCE_CLAIM_CHUNK_SIZE, ...batchParams } = params;
+    assertPositiveIntegerChunkSize(chunkSize, "buildBatchForceClaimTransactions");
+    return chunkPositionIds(positionIds, chunkSize).map((ids) => {
+        const tx = new Transaction();
+        batchForceClaim(client, tx, { ...batchParams, positionIds: ids });
+        return tx;
+    });
+}
+export function resolveMarket(client, tx, params) {
+    const keeperRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::resolve_market`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            keeperRequest,
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            marketIdArg(tx, params.marketId),
+            outcomeArg(client, tx, params.outcome, params.packageId),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
+export function adminPlaceOrderFor(client, tx, params) {
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::admin_place_order_for`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            objectArg(tx, params.adminCap),
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            objectArg(tx, params.payment),
+            idArg(tx, params.accountId),
+            marketIdArg(tx, params.marketId),
+            selectionArg(client, tx, params.selection, params.packageId),
+            tx.pure.u64(toBigInt(params.minShares)),
+            tx.pure.u64(toBigInt(params.priceCapBps)),
+            tx.pure.u64(toBigInt(params.expiryTs)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}

package/dist/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 `WaterXClient` (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 { WaterXClient } from "../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: WaterXClient, predictClient: PredictClient, params: BuildPlaceOrderTxParams): Promise<Transaction>;
+/**
+ * Optional pre-sweep + {@link batchClaim} in one PTB.
+ */
+export declare function buildBatchClaimTx(perpClient: WaterXClient, predictClient: PredictClient, params: BuildBatchClaimTxParams): Promise<Transaction>;

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

@@ -0,0 +1,52 @@
+/**
+ * Async high-level prediction PTB builders with optional pre-sweep of parked
+ * backing assets into wxUSD credit ({@link appendConsolidateForSpend}).
+ *
+ * Takes both `WaterXClient` (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 { appendConsolidateForSpend } from "../tx-builders.js";
+import { batchClaim, placeOrder, } from "./prediction.js";
+function newTx(opts) {
+    return opts?.tx ?? new Transaction();
+}
+async function maybeConsolidate(perpClient, tx, accountId, opts) {
+    if (opts?.consolidateToUsd === false)
+        return;
+    if (typeof accountId !== "string")
+        return;
+    await 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)
+ */
+export async function buildPlaceOrderTx(perpClient, predictClient, params) {
+    const tx = newTx(params);
+    await maybeConsolidate(perpClient, tx, params.accountId, params);
+    placeOrder(predictClient, tx, stripPlaceOrderParams(params));
+    return tx;
+}
+/**
+ * Optional pre-sweep + {@link batchClaim} in one PTB.
+ */
+export async function buildBatchClaimTx(perpClient, predictClient, params) {
+    const tx = newTx(params);
+    await maybeConsolidate(perpClient, tx, params.accountId, params);
+    batchClaim(predictClient, tx, stripBatchClaimParams(params));
+    return tx;
+}

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

@@ -0,0 +1,93 @@
+import type { TransactionArgument } from "@mysten/sui/transactions";
+export type ObjectArgument = string | TransactionArgument;
+export type IdArgument = string | TransactionArgument;
+export type Selection = "NO" | "YES";
+export type Outcome = "NO" | "YES" | "INVALID";
+export type OrderKind = "OPEN" | "CLOSE";
+export type PositionStatus = "OPEN" | "PENDING_CLOSE";
+export type MarketIdInput = string | Uint8Array | number[];
+export interface AccountIdentityParams {
+    bucketAccount?: ObjectArgument;
+}
+export interface RegistryView {
+    balance: bigint;
+    minReserve: bigint;
+    orderCancelCooldownMs: bigint;
+    nextOrderId: bigint;
+    orderCount: bigint;
+    positionCount: bigint;
+    unresolvedMarketCount: bigint;
+    resolvedMarketCount: bigint;
+}
+export interface OrderView {
+    orderId: bigint;
+    kind: OrderKind;
+    accountId: string;
+    marketId: Uint8Array;
+    marketIdHex: string;
+    selection: Selection;
+    positionId: bigint | null;
+    maxSpend: bigint;
+    minShares: bigint;
+    priceCapBps: bigint;
+    minProceeds: bigint;
+    expiryTs: bigint;
+    selfCancelAfterTs: bigint;
+    createdTs: bigint;
+    byAdmin: boolean;
+}
+export interface PositionView {
+    positionId: bigint;
+    accountId: string;
+    marketId: Uint8Array;
+    marketIdHex: string;
+    selection: Selection;
+    status: PositionStatus;
+    filledShares: bigint;
+    filledCost: bigint;
+    openedTs: bigint;
+    payout: bigint;
+    closeOrderId: bigint | null;
+    closeMinProceeds: bigint;
+    closeExpiryTs: bigint;
+    closeSelfCancelAfterTs: bigint;
+}
+export interface MarketView {
+    marketKey: bigint;
+    marketId: Uint8Array;
+    marketIdHex: string;
+    resolved: boolean;
+    paused: boolean;
+    outcome: Outcome | null;
+    unclaimedCount: bigint;
+    yesShares: bigint;
+    yesCost: bigint;
+    noShares: bigint;
+    noCost: bigint;
+}
+export interface MarketExposure {
+    yesShares: bigint;
+    yesCost: bigint;
+    noShares: bigint;
+    noCost: bigint;
+}
+export interface AccountDataView {
+    accountId: string;
+    hasData: boolean;
+    orderCount: bigint;
+    positionCount: bigint;
+    orderFront: bigint | null;
+    orderBack: bigint | null;
+    positionFront: bigint | null;
+    positionBack: bigint | null;
+}
+export interface CursorView {
+    count: bigint;
+    front: bigint | null;
+    back: bigint | null;
+}
+export interface CoinRef {
+    objectId: string;
+    version: string | bigint | number;
+    digest: string;
+}

package/dist/src/prediction/types.js

@@ -0,0 +1 @@
+export {};