@waterx/sdk 3.0.1 → 3.1.0

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

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRegistryAccountId = resolveRegistryAccountId;
+exports.createAccount = createAccount;
+exports.transferCoinToAccount = transferCoinToAccount;
+exports.requestDeposit = requestDeposit;
+exports.consumeDepositDirect = consumeDepositDirect;
+exports.deposit = deposit;
+exports.requestDepositFromReceivings = requestDepositFromReceivings;
+exports.requestWithdraw = requestWithdraw;
+exports.consumeWithdrawDirect = consumeWithdrawDirect;
+exports.withdraw = withdraw;
+exports.addDelegate = addDelegate;
+exports.removeDelegate = removeDelegate;
+exports.setDelegatePredictionPermission = setDelegatePredictionPermission;
+exports.whitelistPredictionProtocol = whitelistPredictionProtocol;
+exports.allowPredictionProtocolAsset = allowPredictionProtocolAsset;
+exports.disallowPredictionProtocolAsset = disallowPredictionProtocolAsset;
+const bcs_1 = require("@mysten/sui/bcs");
+const transactions_1 = require("@mysten/sui/transactions");
+const account_ts_1 = require("../account/account.js");
+const fetch_ts_1 = require("./fetch.js");
+const utils_ts_1 = require("./utils.js");
+function accountPackage(client, packageId) {
+    return packageId ?? client.waterxAccountPackageId();
+}
+/**
+ * Resolves the registry `0x2::object::ID` used by `request_deposit` / views from an on-chain
+ * `Account` object id (e.g. parsed from transaction effects).
+ */
+async function resolveRegistryAccountId(client, accountObjectId, params = {}) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::account_id`,
+        arguments: [tx.object(accountObjectId)],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs.Address.parse((0, fetch_ts_1.extractReturnBytes)(result));
+}
+function createAccount(client, tx, params) {
+    // Delegates to the shared account/ builder — `waterx_account` is a single shared
+    // contract, so the account id + registry are identical across lines. (The
+    // per-call package/registry overrides are moot with one package.)
+    return (0, account_ts_1.createAccount)(client, tx, {
+        alias: params.alias,
+        bucketAccount: params.bucketAccount,
+    });
+}
+function transferCoinToAccount(client, tx, params) {
+    (0, account_ts_1.transferToAccount)(client, tx, {
+        accountId: params.accountId,
+        coin: (0, utils_ts_1.objectArg)(tx, params.coin),
+        coinType: params.coinType ?? client.settlementCoinType(),
+    });
+    return tx;
+}
+function requestDeposit(client, tx, params) {
+    return (0, account_ts_1.requestDeposit)(client, tx, {
+        accountId: params.accountId,
+        coin: (0, utils_ts_1.objectArg)(tx, params.coin),
+        coinType: params.coinType ?? client.settlementCoinType(),
+        extraData: params.extraData == null ? undefined : Uint8Array.from(params.extraData),
+    });
+}
+/** Finishes a `request_deposit` hot potato via `direct_rule` (same-coin credit). */
+function consumeDepositDirect(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::direct_rule::consume_deposit_direct`,
+        typeArguments: [params.coinType ?? client.settlementCoinType()],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            params.depositRequest,
+        ],
+    });
+    return tx;
+}
+/**
+ * Full deposit: `request_deposit` + `consume_deposit_direct` in one PTB.
+ * Use this for testnet USD unless you implement a custom deposit policy consume path.
+ */
+function deposit(client, tx, params) {
+    const request = requestDeposit(client, tx, params);
+    consumeDepositDirect(client, tx, {
+        accountPackageId: params.accountPackageId,
+        accountRegistry: params.accountRegistry,
+        depositRequest: request,
+        coinType: params.coinType,
+    });
+    return tx;
+}
+function requestDepositFromReceivings(client, tx, params) {
+    return (0, account_ts_1.requestDepositFromReceivings)(client, tx, {
+        accountId: params.accountId,
+        receivings: params.coins.map((coin) => (0, utils_ts_1.receivingCoinArg)(tx, coin)),
+        coinType: params.coinType ?? client.settlementCoinType(),
+        extraData: params.extraData == null ? undefined : Uint8Array.from(params.extraData),
+    });
+}
+function requestWithdraw(client, tx, params) {
+    return (0, account_ts_1.requestWithdraw)(client, tx, {
+        accountId: params.accountId,
+        amount: (0, utils_ts_1.toBigInt)(params.amount),
+        recipient: params.recipient,
+        coinType: params.coinType ?? client.settlementCoinType(),
+        extraData: params.extraData == null ? undefined : Uint8Array.from(params.extraData),
+        bucketAccount: params.bucketAccount,
+    });
+}
+/** Finishes a `request_withdraw` hot potato via `direct_rule` (same-coin payout). */
+function consumeWithdrawDirect(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::direct_rule::consume_withdraw_direct`,
+        typeArguments: [params.coinType ?? client.settlementCoinType()],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            params.withdrawRequest,
+        ],
+    });
+    return tx;
+}
+/**
+ * Full withdraw: `request_withdraw` + `consume_withdraw_direct` in one PTB.
+ * Use this for testnet USD unless you implement a custom withdraw policy consume path.
+ */
+function withdraw(client, tx, params) {
+    const request = requestWithdraw(client, tx, params);
+    consumeWithdrawDirect(client, tx, {
+        accountPackageId: params.accountPackageId,
+        accountRegistry: params.accountRegistry,
+        withdrawRequest: request,
+        coinType: params.coinType,
+    });
+    return tx;
+}
+function addDelegate(client, tx, params) {
+    (0, account_ts_1.addDelegate)(client, tx, {
+        accountId: params.accountId,
+        delegateAddress: params.delegate,
+        alias: params.alias,
+        permissions: params.permissions,
+        expiresAtMs: params.expiresAtMs == null ? undefined : (0, utils_ts_1.toBigInt)(params.expiresAtMs),
+        bucketAccount: params.bucketAccount,
+    });
+    return tx;
+}
+function removeDelegate(client, tx, params) {
+    (0, account_ts_1.removeDelegate)(client, tx, {
+        accountId: params.accountId,
+        delegateAddress: params.delegate,
+        bucketAccount: params.bucketAccount,
+    });
+    return tx;
+}
+function setDelegatePredictionPermission(client, tx, params) {
+    const senderRequest = (0, utils_ts_1.createAccountRequest)(client, tx, params);
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::set_delegate_protocol_permission`,
+        typeArguments: [
+            `${(0, utils_ts_1.resolvePackageId)(client, params.predictionPackageId)}::account_data::WaterXPrediction`,
+        ],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            senderRequest,
+            (0, utils_ts_1.idArg)(tx, params.accountId),
+            tx.pure.address(params.delegate),
+            tx.pure.u32(params.permissions),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function whitelistPredictionProtocol(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::whitelist_protocol`,
+        typeArguments: [
+            `${(0, utils_ts_1.resolvePackageId)(client, params.predictionPackageId)}::account_data::WaterXPrediction`,
+        ],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            (0, utils_ts_1.objectArg)(tx, params.adminCap),
+        ],
+    });
+    return tx;
+}
+function allowPredictionProtocolAsset(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::allow_protocol_asset`,
+        typeArguments: [
+            `${(0, utils_ts_1.resolvePackageId)(client, params.predictionPackageId)}::account_data::WaterXPrediction`,
+            params.coinType ?? client.settlementCoinType(),
+        ],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            (0, utils_ts_1.objectArg)(tx, params.adminCap),
+        ],
+    });
+    return tx;
+}
+function disallowPredictionProtocolAsset(client, tx, params) {
+    tx.moveCall({
+        target: `${accountPackage(client, params.accountPackageId)}::account::disallow_protocol_asset`,
+        typeArguments: [
+            `${(0, utils_ts_1.resolvePackageId)(client, params.predictionPackageId)}::account_data::WaterXPrediction`,
+            params.coinType ?? client.settlementCoinType(),
+        ],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            (0, utils_ts_1.objectArg)(tx, params.adminCap),
+        ],
+    });
+    return tx;
+}

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

@@ -0,0 +1,47 @@
+import { Transaction } from "@mysten/sui/transactions";
+import type { PredictClient } from "./client.ts";
+import type { MarketIdInput, ObjectArgument } from "./types.ts";
+export interface AdminBaseParams {
+    packageId?: string;
+    marketRegistry?: string;
+    settlementCoinType?: string;
+}
+export interface CreateMarketRegistryParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+}
+export declare function createMarketRegistry(client: PredictClient, tx: Transaction, params: CreateMarketRegistryParams): Transaction;
+export interface DepositSettlementParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    payment: ObjectArgument;
+}
+export declare function depositSettlement(client: PredictClient, tx: Transaction, params: DepositSettlementParams): Transaction;
+export interface AdminWithdrawParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    amount: bigint | number | string;
+    recipient: string;
+}
+export declare function adminWithdraw(client: PredictClient, tx: Transaction, params: AdminWithdrawParams): Transaction;
+export interface SetMinReserveParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    newReserve: bigint | number | string;
+}
+export declare function setMinReserve(client: PredictClient, tx: Transaction, params: SetMinReserveParams): Transaction;
+export interface SetOrderCancelCooldownParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    cooldownMs: bigint | number | string;
+}
+export declare function setOrderCancelCooldownMs(client: PredictClient, tx: Transaction, params: SetOrderCancelCooldownParams): Transaction;
+export interface MarketPauseParams extends AdminBaseParams {
+    adminCap: ObjectArgument;
+    marketId: MarketIdInput;
+}
+export declare function pauseMarket(client: PredictClient, tx: Transaction, params: MarketPauseParams): Transaction;
+export declare function unpauseMarket(client: PredictClient, tx: Transaction, params: MarketPauseParams): Transaction;
+export interface KeeperAdminParams {
+    packageId?: string;
+    globalConfig?: string;
+    adminCap: ObjectArgument;
+    keeper: string;
+}
+export declare function addKeeper(client: PredictClient, tx: Transaction, params: KeeperAdminParams): Transaction;
+export declare function removeKeeper(client: PredictClient, tx: Transaction, params: KeeperAdminParams): Transaction;

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMarketRegistry = createMarketRegistry;
+exports.depositSettlement = depositSettlement;
+exports.adminWithdraw = adminWithdraw;
+exports.setMinReserve = setMinReserve;
+exports.setOrderCancelCooldownMs = setOrderCancelCooldownMs;
+exports.pauseMarket = pauseMarket;
+exports.unpauseMarket = unpauseMarket;
+exports.addKeeper = addKeeper;
+exports.removeKeeper = removeKeeper;
+const utils_ts_1 = require("./utils.js");
+function createMarketRegistry(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::create_market_registry`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [(0, utils_ts_1.objectArg)(tx, params.adminCap)],
+    });
+    return tx;
+}
+function depositSettlement(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::deposit_settlement`,
+        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)),
+            (0, utils_ts_1.objectArg)(tx, params.payment),
+        ],
+    });
+    return tx;
+}
+function adminWithdraw(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::admin_withdraw`,
+        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.pure.u64((0, utils_ts_1.toBigInt)(params.amount)),
+            tx.pure.address(params.recipient),
+        ],
+    });
+    return tx;
+}
+function setMinReserve(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::set_min_reserve`,
+        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.pure.u64((0, utils_ts_1.toBigInt)(params.newReserve)),
+        ],
+    });
+    return tx;
+}
+function setOrderCancelCooldownMs(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::set_order_cancel_cooldown_ms`,
+        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.pure.u64((0, utils_ts_1.toBigInt)(params.cooldownMs)),
+        ],
+    });
+    return tx;
+}
+function pauseMarket(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::pause_market`,
+        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)),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+            (0, utils_ts_1.clockArg)(tx),
+        ],
+    });
+    return tx;
+}
+function unpauseMarket(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::unpause_market`,
+        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)),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+        ],
+    });
+    return tx;
+}
+function addKeeper(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::global_config::add_keeper`,
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            (0, utils_ts_1.objectArg)(tx, params.adminCap),
+            tx.pure.address(params.keeper),
+        ],
+    });
+    return tx;
+}
+function removeKeeper(client, tx, params) {
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::global_config::remove_keeper`,
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            (0, utils_ts_1.objectArg)(tx, params.adminCap),
+            tx.pure.address(params.keeper),
+        ],
+    });
+    return tx;
+}

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

@@ -0,0 +1,28 @@
+import { OrderKind as OrderKindBcs } from "../generated/waterx_prediction/order.ts";
+import { Outcome as OutcomeBcs } from "../generated/waterx_prediction/outcome.ts";
+import { Selection as SelectionBcs, Status as StatusBcs } from "../generated/waterx_prediction/position.ts";
+import { AccountDataView as AccountDataViewBcs, MarketView as MarketViewBcs, OrderView as OrderViewBcs, PositionView as PositionViewBcs, RegistryView as RegistryViewBcs } from "../generated/waterx_prediction/view.ts";
+import type { AccountDataView, CursorView, MarketExposure, MarketView, OrderKind, OrderView, Outcome, PositionStatus, PositionView, RegistryView, Selection } from "./types.ts";
+/**
+ * The prediction line decodes its `view::*` simulate reads with the codegen
+ * schemas in `../generated/waterx_prediction/*` — the single source of truth,
+ * regenerated by `pnpm codegen` from the deployed Move ABI. They are re-exported
+ * here under the legacy `*Bcs` names for back-compat (the public
+ * `@waterx/sdk/prediction/utils/bcs` subpath + tests). There is NO hand-written
+ * BCS mirror to keep in sync — a contract field add/remove/reorder flows in via
+ * `pnpm codegen`; the `map*` helpers below only translate the raw parse output
+ * to the public camelCase view types.
+ */
+export { AccountDataViewBcs, MarketViewBcs, OrderKindBcs, OrderViewBcs, OutcomeBcs, PositionViewBcs, RegistryViewBcs, SelectionBcs, StatusBcs, };
+export declare function decodeEnumVariant(raw: unknown): string;
+export declare function mapSelection(raw: unknown): Selection;
+export declare function mapOutcome(raw: unknown): Outcome;
+export declare function mapOrderKind(raw: unknown): OrderKind;
+export declare function mapStatus(raw: unknown): PositionStatus;
+export declare function mapRegistryView(raw: any): RegistryView;
+export declare function mapOrderView(raw: any): OrderView;
+export declare function mapPositionView(raw: any): PositionView;
+export declare function mapMarketView(raw: any): MarketView;
+export declare function mapMarketExposure(yesShares: unknown, yesCost: unknown, noShares: unknown, noCost: unknown): MarketExposure;
+export declare function mapAccountDataView(raw: any): AccountDataView;
+export declare function mapCursorView(count: unknown, front: unknown, back: unknown): CursorView;

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

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusBcs = exports.SelectionBcs = exports.RegistryViewBcs = exports.PositionViewBcs = exports.OutcomeBcs = exports.OrderViewBcs = exports.OrderKindBcs = exports.MarketViewBcs = exports.AccountDataViewBcs = void 0;
+exports.decodeEnumVariant = decodeEnumVariant;
+exports.mapSelection = mapSelection;
+exports.mapOutcome = mapOutcome;
+exports.mapOrderKind = mapOrderKind;
+exports.mapStatus = mapStatus;
+exports.mapRegistryView = mapRegistryView;
+exports.mapOrderView = mapOrderView;
+exports.mapPositionView = mapPositionView;
+exports.mapMarketView = mapMarketView;
+exports.mapMarketExposure = mapMarketExposure;
+exports.mapAccountDataView = mapAccountDataView;
+exports.mapCursorView = mapCursorView;
+const order_ts_1 = require("../generated/waterx_prediction/order.js");
+Object.defineProperty(exports, "OrderKindBcs", { enumerable: true, get: function () { return order_ts_1.OrderKind; } });
+const outcome_ts_1 = require("../generated/waterx_prediction/outcome.js");
+Object.defineProperty(exports, "OutcomeBcs", { enumerable: true, get: function () { return outcome_ts_1.Outcome; } });
+const position_ts_1 = require("../generated/waterx_prediction/position.js");
+Object.defineProperty(exports, "SelectionBcs", { enumerable: true, get: function () { return position_ts_1.Selection; } });
+Object.defineProperty(exports, "StatusBcs", { enumerable: true, get: function () { return position_ts_1.Status; } });
+const view_ts_1 = require("../generated/waterx_prediction/view.js");
+Object.defineProperty(exports, "AccountDataViewBcs", { enumerable: true, get: function () { return view_ts_1.AccountDataView; } });
+Object.defineProperty(exports, "MarketViewBcs", { enumerable: true, get: function () { return view_ts_1.MarketView; } });
+Object.defineProperty(exports, "OrderViewBcs", { enumerable: true, get: function () { return view_ts_1.OrderView; } });
+Object.defineProperty(exports, "PositionViewBcs", { enumerable: true, get: function () { return view_ts_1.PositionView; } });
+Object.defineProperty(exports, "RegistryViewBcs", { enumerable: true, get: function () { return view_ts_1.RegistryView; } });
+const utils_ts_1 = require("./utils.js");
+function decodeEnumVariant(raw) {
+    if (typeof raw === "string")
+        return raw;
+    if (raw && typeof raw === "object") {
+        const record = raw;
+        if (typeof record.$kind === "string")
+            return record.$kind;
+        const variant = record["@variant"];
+        if (typeof variant === "string")
+            return variant;
+        if (variant && typeof variant === "object") {
+            const innerKey = Object.keys(variant)[0];
+            if (innerKey)
+                return innerKey;
+        }
+        const key = Object.keys(record).find((k) => k !== "$kind" && k !== "@variant");
+        if (key)
+            return key;
+    }
+    throw new Error(`Unable to decode enum variant: ${JSON.stringify(raw)}`);
+}
+function enumKind(raw) {
+    return decodeEnumVariant(raw);
+}
+function mapSelection(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "yes")
+        return "YES";
+    if (kind === "no")
+        return "NO";
+    throw new Error(`Unknown Selection variant: ${kind}`);
+}
+function mapOutcome(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "yes")
+        return "YES";
+    if (kind === "no")
+        return "NO";
+    if (kind === "invalid")
+        return "INVALID";
+    throw new Error(`Unknown Outcome variant: ${kind}`);
+}
+function mapOrderKind(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "open")
+        return "OPEN";
+    if (kind === "close")
+        return "CLOSE";
+    throw new Error(`Unknown OrderKind variant: ${kind}`);
+}
+function mapStatus(raw) {
+    const kind = enumKind(raw).toLowerCase();
+    if (kind === "open")
+        return "OPEN";
+    if (kind === "pendingclose" || kind === "pending_close")
+        return "PENDING_CLOSE";
+    throw new Error(`Unknown Status variant: ${kind}`);
+}
+function mapOptionalU64(raw) {
+    return raw == null ? null : BigInt(raw);
+}
+function asBytes(raw) {
+    return (0, utils_ts_1.marketIdBytesFromUnknown)(raw);
+}
+function mapRegistryView(raw) {
+    return {
+        balance: BigInt(raw.balance),
+        minReserve: BigInt(raw.min_reserve),
+        orderCancelCooldownMs: BigInt(raw.order_cancel_cooldown_ms),
+        nextOrderId: BigInt(raw.next_order_id),
+        nextPositionId: BigInt(raw.next_position_id),
+        orderCount: BigInt(raw.order_count),
+        positionCount: BigInt(raw.position_count),
+        unresolvedMarketCount: BigInt(raw.unresolved_market_count),
+        resolvedMarketCount: BigInt(raw.resolved_market_count),
+    };
+}
+function mapOrderView(raw) {
+    const marketId = asBytes(raw.market_id);
+    return {
+        orderId: BigInt(raw.order_id),
+        kind: mapOrderKind(raw.kind),
+        accountId: raw.account_id,
+        receiverAccountId: raw.receiver_account_id,
+        marketId,
+        marketIdHex: (0, utils_ts_1.bytesToHex)(marketId),
+        selection: mapSelection(raw.selection),
+        positionId: mapOptionalU64(raw.position_id),
+        maxSpend: BigInt(raw.max_spend),
+        minShares: BigInt(raw.min_shares),
+        priceCapBps: BigInt(raw.price_cap),
+        minProceeds: BigInt(raw.min_proceeds),
+        expiryTs: BigInt(raw.expiry_ts),
+        selfCancelAfterTs: BigInt(raw.self_cancel_after_ts),
+        createdTs: BigInt(raw.created_ts),
+        byAdmin: raw.by_admin,
+    };
+}
+function mapPositionView(raw) {
+    const marketId = asBytes(raw.market_id);
+    return {
+        positionId: BigInt(raw.position_id),
+        accountId: raw.account_id,
+        marketId,
+        marketIdHex: (0, utils_ts_1.bytesToHex)(marketId),
+        selection: mapSelection(raw.selection),
+        status: mapStatus(raw.status),
+        filledShares: BigInt(raw.filled_shares),
+        filledCost: BigInt(raw.filled_cost),
+        openedTs: BigInt(raw.opened_ts),
+        payout: BigInt(raw.payout),
+        closeOrderId: mapOptionalU64(raw.close_order_id),
+        closeMinProceeds: BigInt(raw.close_min_proceeds),
+        closeExpiryTs: BigInt(raw.close_expiry_ts),
+        closeSelfCancelAfterTs: BigInt(raw.close_self_cancel_after_ts),
+    };
+}
+function mapMarketView(raw) {
+    const marketId = asBytes(raw.market_id);
+    return {
+        marketKey: BigInt(raw.market_key),
+        marketId,
+        marketIdHex: (0, utils_ts_1.bytesToHex)(marketId),
+        resolved: raw.resolved,
+        paused: raw.paused,
+        outcome: raw.outcome == null ? null : mapOutcome(raw.outcome),
+        unclaimedCount: BigInt(raw.unclaimed_count),
+        yesShares: BigInt(raw.yes_shares),
+        yesCost: BigInt(raw.yes_cost),
+        noShares: BigInt(raw.no_shares),
+        noCost: BigInt(raw.no_cost),
+    };
+}
+function mapMarketExposure(yesShares, yesCost, noShares, noCost) {
+    return {
+        yesShares: BigInt(yesShares),
+        yesCost: BigInt(yesCost),
+        noShares: BigInt(noShares),
+        noCost: BigInt(noCost),
+    };
+}
+function mapAccountDataView(raw) {
+    return {
+        accountId: raw.account_id,
+        hasData: raw.has_data,
+        orderCount: BigInt(raw.order_count),
+        positionCount: BigInt(raw.position_count),
+        orderFront: mapOptionalU64(raw.order_front),
+        orderBack: mapOptionalU64(raw.order_back),
+        positionFront: mapOptionalU64(raw.position_front),
+        positionBack: mapOptionalU64(raw.position_back),
+    };
+}
+function mapCursorView(count, front, back) {
+    return {
+        count: BigInt(count),
+        front: mapOptionalU64(front),
+        back: mapOptionalU64(back),
+    };
+}

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

@@ -0,0 +1,56 @@
+import type { Transaction } from "@mysten/sui/transactions";
+import { BaseLineClient } from "../base-client.ts";
+import { type LoadConfigOptions, type WaterxPredictionConfig } from "./config.ts";
+import type { Network } from "./constants.ts";
+export interface CreateClientOptions extends LoadConfigOptions {
+    grpcUrl?: string;
+    /** Settlement alias in `packages.waterx_prediction.*` maps. Default: "USD". */
+    settlement?: string;
+}
+export declare class PredictClient extends BaseLineClient<WaterxPredictionConfig> {
+    /** Default settlement alias for prediction registry lookups. */
+    settlement: string;
+    constructor(network: Network, config: WaterxPredictionConfig, opts?: {
+        grpcUrl?: string;
+        settlement?: string;
+    });
+    static testnet(params?: CreateClientOptions): Promise<PredictClient>;
+    static mainnet(params?: CreateClientOptions): Promise<PredictClient>;
+    /**
+     * Async factory: fetches the deployment config for `network` and returns
+     * a ready-to-use client. Pass `opts.cache=true` to memoize the JSON.
+     */
+    static create(network?: Network, opts?: CreateClientOptions): Promise<PredictClient>;
+    /**
+     * Simulate with rate-limit retry — the prediction line hammers the public
+     * testnet RPC harder (batch claims / dual-path reads), so it backs off on
+     * `RESOURCE_EXHAUSTED` where the base client does not.
+     */
+    simulate(tx: Transaction): Promise<import("@mysten/sui/client").SuiClientTypes.SimulateTransactionResult<{
+        commandResults: true;
+    }>>;
+    packageId(): string;
+    bucketFrameworkPackageId(): string;
+    waterxAccountPackageId(): string;
+    globalConfigId(): string;
+    marketRegistry(settlement?: string): string;
+    accountRegistry(): string;
+    settlementCoinType(settlement?: string): string;
+    predictionAdminCap(): string;
+    waterxAccountAdminCap(): string;
+    waterxPredictionGiftPackageId(): string;
+    claimableLinkConfigId(): string;
+    /**
+     * Original (first-published) id of the gift package. Used ONLY for the
+     * `GiftKey` type tag in derived-object address computation
+     * (`deriveGiftAddress`). Sui pins a struct's type identity to its
+     * defining package's *original* id — it never advances across upgrades,
+     * unlike `published_at`. So the off-chain `gift_id` derivation must key
+     * on this, or it diverges from the on-chain `derive_gift_address` after
+     * the first upgrade. Falls back to `published_at` when `original_id` is
+     * absent (fresh deployments where the two are equal).
+     */
+    waterxPredictionGiftTypeOriginId(): string;
+    waterxReferralPackageId(): string;
+    referralTableId(): string;
+}