@waterx/sdk 3.0.1 → 3.1.0

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;
+}

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

@@ -0,0 +1,95 @@
+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;
+    nextPositionId: bigint;
+    orderCount: bigint;
+    positionCount: bigint;
+    unresolvedMarketCount: bigint;
+    resolvedMarketCount: bigint;
+}
+export interface OrderView {
+    orderId: bigint;
+    kind: OrderKind;
+    accountId: string;
+    receiverAccountId: 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/cjs/src/prediction/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+export { addDelegate, allowPredictionProtocolAsset, consumeDepositDirect, createAccount, deposit, disallowPredictionProtocolAsset, removeDelegate, requestDeposit, requestDepositFromReceivings, requestWithdraw, setDelegatePredictionPermission, transferCoinToAccount, whitelistPredictionProtocol, } from "../account.ts";
+export type { AddDelegateParams, ConsumeDepositDirectParams, CreateAccountParams, PredictionProtocolAssetParams, RemoveDelegateParams, RequestDepositFromReceivingsParams, RequestDepositParams, RequestWithdrawParams, SetDelegatePredictionPermissionParams, TransferCoinToAccountParams, WhitelistPredictionProtocolParams, } from "../account.ts";

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whitelistPredictionProtocol = exports.transferCoinToAccount = exports.setDelegatePredictionPermission = exports.requestWithdraw = exports.requestDepositFromReceivings = exports.requestDeposit = exports.removeDelegate = exports.disallowPredictionProtocolAsset = exports.deposit = exports.createAccount = exports.consumeDepositDirect = exports.allowPredictionProtocolAsset = exports.addDelegate = void 0;
+var account_ts_1 = require("../account.js");
+Object.defineProperty(exports, "addDelegate", { enumerable: true, get: function () { return account_ts_1.addDelegate; } });
+Object.defineProperty(exports, "allowPredictionProtocolAsset", { enumerable: true, get: function () { return account_ts_1.allowPredictionProtocolAsset; } });
+Object.defineProperty(exports, "consumeDepositDirect", { enumerable: true, get: function () { return account_ts_1.consumeDepositDirect; } });
+Object.defineProperty(exports, "createAccount", { enumerable: true, get: function () { return account_ts_1.createAccount; } });
+Object.defineProperty(exports, "deposit", { enumerable: true, get: function () { return account_ts_1.deposit; } });
+Object.defineProperty(exports, "disallowPredictionProtocolAsset", { enumerable: true, get: function () { return account_ts_1.disallowPredictionProtocolAsset; } });
+Object.defineProperty(exports, "removeDelegate", { enumerable: true, get: function () { return account_ts_1.removeDelegate; } });
+Object.defineProperty(exports, "requestDeposit", { enumerable: true, get: function () { return account_ts_1.requestDeposit; } });
+Object.defineProperty(exports, "requestDepositFromReceivings", { enumerable: true, get: function () { return account_ts_1.requestDepositFromReceivings; } });
+Object.defineProperty(exports, "requestWithdraw", { enumerable: true, get: function () { return account_ts_1.requestWithdraw; } });
+Object.defineProperty(exports, "setDelegatePredictionPermission", { enumerable: true, get: function () { return account_ts_1.setDelegatePredictionPermission; } });
+Object.defineProperty(exports, "transferCoinToAccount", { enumerable: true, get: function () { return account_ts_1.transferCoinToAccount; } });
+Object.defineProperty(exports, "whitelistPredictionProtocol", { enumerable: true, get: function () { return account_ts_1.whitelistPredictionProtocol; } });

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

@@ -0,0 +1,6 @@
+export { adminPlaceOrderFor } from "../prediction.ts";
+export type { AdminPlaceOrderForParams } from "../prediction.ts";
+export { allowPredictionProtocolAsset, disallowPredictionProtocolAsset, whitelistPredictionProtocol, } from "../account.ts";
+export type { PredictionProtocolAssetParams, 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";

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpauseMarket = exports.setOrderCancelCooldownMs = exports.setMinReserve = exports.removeKeeper = exports.pauseMarket = exports.depositSettlement = exports.createMarketRegistry = exports.adminWithdraw = exports.addKeeper = exports.whitelistPredictionProtocol = exports.disallowPredictionProtocolAsset = exports.allowPredictionProtocolAsset = exports.adminPlaceOrderFor = void 0;
+var prediction_ts_1 = require("../prediction.js");
+Object.defineProperty(exports, "adminPlaceOrderFor", { enumerable: true, get: function () { return prediction_ts_1.adminPlaceOrderFor; } });
+var account_ts_1 = require("../account.js");
+Object.defineProperty(exports, "allowPredictionProtocolAsset", { enumerable: true, get: function () { return account_ts_1.allowPredictionProtocolAsset; } });
+Object.defineProperty(exports, "disallowPredictionProtocolAsset", { enumerable: true, get: function () { return account_ts_1.disallowPredictionProtocolAsset; } });
+Object.defineProperty(exports, "whitelistPredictionProtocol", { enumerable: true, get: function () { return account_ts_1.whitelistPredictionProtocol; } });
+var admin_ts_1 = require("../admin.js");
+Object.defineProperty(exports, "addKeeper", { enumerable: true, get: function () { return admin_ts_1.addKeeper; } });
+Object.defineProperty(exports, "adminWithdraw", { enumerable: true, get: function () { return admin_ts_1.adminWithdraw; } });
+Object.defineProperty(exports, "createMarketRegistry", { enumerable: true, get: function () { return admin_ts_1.createMarketRegistry; } });
+Object.defineProperty(exports, "depositSettlement", { enumerable: true, get: function () { return admin_ts_1.depositSettlement; } });
+Object.defineProperty(exports, "pauseMarket", { enumerable: true, get: function () { return admin_ts_1.pauseMarket; } });
+Object.defineProperty(exports, "removeKeeper", { enumerable: true, get: function () { return admin_ts_1.removeKeeper; } });
+Object.defineProperty(exports, "setMinReserve", { enumerable: true, get: function () { return admin_ts_1.setMinReserve; } });
+Object.defineProperty(exports, "setOrderCancelCooldownMs", { enumerable: true, get: function () { return admin_ts_1.setOrderCancelCooldownMs; } });
+Object.defineProperty(exports, "unpauseMarket", { enumerable: true, get: function () { return admin_ts_1.unpauseMarket; } });

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

@@ -0,0 +1,2 @@
+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";