@waterx/sdk 2.4.0 → 3.0.0

package/dist/src/prediction/account.js

@@ -1,6 +1,6 @@
 import { bcs } from "@mysten/sui/bcs";
 import { Transaction } from "@mysten/sui/transactions";
-import { createAccountCall } from "../core/waterx-account.js";
+import { addDelegate as sharedAddDelegate, createAccount as sharedCreateAccount, removeDelegate as sharedRemoveDelegate, requestDeposit as sharedRequestDeposit, requestDepositFromReceivings as sharedRequestDepositFromReceivings, requestWithdraw as sharedRequestWithdraw, transferToAccount as sharedTransferToAccount, } from "../account/account.js";
 import { extractReturnBytes } from "./fetch.js";
 import { clockArg, createAccountRequest, idArg, objectArg, receivingCoinArg, resolveAccountRegistry, resolvePackageId, toBigInt, } from "./utils.js";
 function accountPackage(client, packageId) {
@@ -20,36 +20,29 @@ export async function resolveRegistryAccountId(client, accountObjectId, params =
     return bcs.Address.parse(extractReturnBytes(result));
 }
 export function createAccount(client, tx, params) {
-    const senderRequest = createAccountRequest(client, tx, params);
-    return createAccountCall(tx, {
-        packageId: accountPackage(client, params.accountPackageId),
-        registry: resolveAccountRegistry(client, params.accountRegistry),
-    }, { senderRequest, alias: params.alias });
+    // 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 sharedCreateAccount(client, tx, {
+        alias: params.alias,
+        bucketAccount: params.bucketAccount,
+    });
 }
 export function transferCoinToAccount(client, tx, params) {
-    tx.moveCall({
-        target: `${accountPackage(client, params.accountPackageId)}::account::transfer_coin`,
-        typeArguments: [params.coinType ?? client.settlementCoinType()],
-        arguments: [
-            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
-            idArg(tx, params.accountId),
-            objectArg(tx, params.coin),
-        ],
+    sharedTransferToAccount(client, tx, {
+        accountId: params.accountId,
+        coin: objectArg(tx, params.coin),
+        coinType: params.coinType ?? client.settlementCoinType(),
     });
     return tx;
 }
 export function requestDeposit(client, tx, params) {
-    const [request] = tx.moveCall({
-        target: `${accountPackage(client, params.accountPackageId)}::account::request_deposit`,
-        typeArguments: [params.coinType ?? client.settlementCoinType()],
-        arguments: [
-            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
-            idArg(tx, params.accountId),
-            objectArg(tx, params.coin),
-            tx.pure.vector("u8", Array.from(params.extraData ?? [])),
-        ],
+    return sharedRequestDeposit(client, tx, {
+        accountId: params.accountId,
+        coin: objectArg(tx, params.coin),
+        coinType: params.coinType ?? client.settlementCoinType(),
+        extraData: params.extraData == null ? undefined : Uint8Array.from(params.extraData),
     });
-    return request;
 }
 /** Finishes a `request_deposit` hot potato via `direct_rule` (same-coin credit). */
 export function consumeDepositDirect(client, tx, params) {
@@ -78,39 +71,22 @@ export function deposit(client, tx, params) {
     return tx;
 }
 export function requestDepositFromReceivings(client, tx, params) {
-    const coinType = params.coinType ?? client.settlementCoinType();
-    const receivings = params.coins.map((coin) => receivingCoinArg(tx, coin));
-    const [request] = tx.moveCall({
-        target: `${accountPackage(client, params.accountPackageId)}::account::request_deposit_from_receivings`,
-        typeArguments: [coinType],
-        arguments: [
-            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
-            idArg(tx, params.accountId),
-            tx.makeMoveVec({
-                type: `0x2::transfer::Receiving<0x2::coin::Coin<${coinType}>>`,
-                elements: receivings,
-            }),
-            tx.pure.vector("u8", Array.from(params.extraData ?? [])),
-        ],
+    return sharedRequestDepositFromReceivings(client, tx, {
+        accountId: params.accountId,
+        receivings: params.coins.map((coin) => receivingCoinArg(tx, coin)),
+        coinType: params.coinType ?? client.settlementCoinType(),
+        extraData: params.extraData == null ? undefined : Uint8Array.from(params.extraData),
     });
-    return request;
 }
 export function requestWithdraw(client, tx, params) {
-    const senderRequest = createAccountRequest(client, tx, params);
-    const [request] = tx.moveCall({
-        target: `${accountPackage(client, params.accountPackageId)}::account::request_withdraw`,
-        typeArguments: [params.coinType ?? client.settlementCoinType()],
-        arguments: [
-            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
-            senderRequest,
-            idArg(tx, params.accountId),
-            tx.pure.u64(toBigInt(params.amount)),
-            tx.pure.address(params.recipient),
-            tx.pure.vector("u8", Array.from(params.extraData ?? [])),
-            clockArg(tx),
-        ],
+    return sharedRequestWithdraw(client, tx, {
+        accountId: params.accountId,
+        amount: toBigInt(params.amount),
+        recipient: params.recipient,
+        coinType: params.coinType ?? client.settlementCoinType(),
+        extraData: params.extraData == null ? undefined : Uint8Array.from(params.extraData),
+        bucketAccount: params.bucketAccount,
     });
-    return request;
 }
 /** Finishes a `request_withdraw` hot potato via `direct_rule` (same-coin payout). */
 export function consumeWithdrawDirect(client, tx, params) {
@@ -139,33 +115,21 @@ export function withdraw(client, tx, params) {
     return tx;
 }
 export function addDelegate(client, tx, params) {
-    const senderRequest = createAccountRequest(client, tx, params);
-    tx.moveCall({
-        target: `${accountPackage(client, params.accountPackageId)}::account::add_delegate`,
-        arguments: [
-            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
-            senderRequest,
-            idArg(tx, params.accountId),
-            tx.pure.address(params.delegate),
-            tx.pure.string(params.alias),
-            tx.pure.u32(params.permissions),
-            tx.pure.option("u64", params.expiresAtMs == null ? null : toBigInt(params.expiresAtMs)),
-            clockArg(tx),
-        ],
+    sharedAddDelegate(client, tx, {
+        accountId: params.accountId,
+        delegateAddress: params.delegate,
+        alias: params.alias,
+        permissions: params.permissions,
+        expiresAtMs: params.expiresAtMs == null ? undefined : toBigInt(params.expiresAtMs),
+        bucketAccount: params.bucketAccount,
     });
     return tx;
 }
 export function removeDelegate(client, tx, params) {
-    const senderRequest = createAccountRequest(client, tx, params);
-    tx.moveCall({
-        target: `${accountPackage(client, params.accountPackageId)}::account::remove_delegate`,
-        arguments: [
-            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
-            senderRequest,
-            idArg(tx, params.accountId),
-            tx.pure.address(params.delegate),
-            clockArg(tx),
-        ],
+    sharedRemoveDelegate(client, tx, {
+        accountId: params.accountId,
+        delegateAddress: params.delegate,
+        bucketAccount: params.bucketAccount,
     });
     return tx;
 }

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

@@ -1,7 +1,5 @@
-import type { SuiClientTypes } from "@mysten/sui/client";
-import type { Signer } from "@mysten/sui/cryptography";
-import { SuiGrpcClient } from "@mysten/sui/grpc";
 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 {
@@ -9,13 +7,7 @@ export interface CreateClientOptions extends LoadConfigOptions {
     /** Settlement alias in `packages.waterx_prediction.*` maps. Default: "USD". */
     settlement?: string;
 }
-export declare class PredictClient {
-    /** gRPC client - all RPC including `simulateTransaction`. */
-    grpcClient: SuiGrpcClient;
-    /** Network identifier in upper case (`MAINNET` / `TESTNET`). */
-    network: Network;
-    /** Parsed canonical `waterx-config` JSON. */
-    config: WaterxPredictionConfig;
+export declare class PredictClient extends BaseLineClient<WaterxPredictionConfig> {
     /** Default settlement alias for prediction registry lookups. */
     settlement: string;
     constructor(network: Network, config: WaterxPredictionConfig, opts?: {
@@ -29,36 +21,14 @@ export declare class PredictClient {
      * a ready-to-use client. Pass `opts.cache=true` to memoize the JSON.
      */
     static create(network?: Network, opts?: CreateClientOptions): Promise<PredictClient>;
-    getObject(objectId: string): Promise<SuiClientTypes.GetObjectResponse<{}>>;
-    getObjects(objectIds: string[]): Promise<SuiClientTypes.GetObjectsResponse<{}>>;
-    listOwnedObjects(owner: string): Promise<SuiClientTypes.ListOwnedObjectsResponse<{}>>;
-    listCoins(params: {
-        owner: string;
-        coinType?: string;
-    }): Promise<SuiClientTypes.ListCoinsResponse>;
-    getBalance(params: {
-        owner: string;
-        coinType?: string;
-    }): Promise<SuiClientTypes.GetBalanceResponse>;
-    listDynamicFields(parentId: string): ReturnType<SuiGrpcClient["listDynamicFields"]>;
-    getDynamicField(parentId: string, name: {
-        type: string;
-        bcs: Uint8Array;
-    }): Promise<SuiClientTypes.GetDynamicFieldResponse>;
-    waitForTransaction(digest: string): Promise<SuiClientTypes.TransactionResult<{}>>;
-    simulate(tx: Transaction): Promise<SuiClientTypes.SimulateTransactionResult<{
+    /**
+     * 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;
     }>>;
-    signAndExecuteTransaction<Include extends SuiClientTypes.TransactionInclude = object>(params: {
-        signer: {
-            toSuiAddress: () => string;
-        } & Signer;
-        transaction: Transaction | Uint8Array;
-        additionalSignatures?: string[];
-        include?: Include & SuiClientTypes.TransactionInclude;
-    }): Promise<SuiClientTypes.TransactionResult<Include & SuiClientTypes.TransactionInclude>>;
-    /** All package IDs (`published_at`) keyed by package name. */
-    packageIds(): Record<string, string>;
     packageId(): string;
     bucketFrameworkPackageId(): string;
     waterxAccountPackageId(): string;

package/dist/src/prediction/client.js

@@ -1,27 +1,11 @@
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-import { loadConfig, } from "./config.js";
-const GRPC_URLS = {
-    MAINNET: "https://fullnode.mainnet.sui.io:443",
-    TESTNET: "https://fullnode.testnet.sui.io:443",
-};
-export class PredictClient {
-    /** gRPC client - all RPC including `simulateTransaction`. */
-    grpcClient;
-    /** Network identifier in upper case (`MAINNET` / `TESTNET`). */
-    network;
-    /** Parsed canonical `waterx-config` JSON. */
-    config;
+import { BaseLineClient } from "../base-client.js";
+import { loadConfig } from "./config.js";
+export class PredictClient extends BaseLineClient {
     /** Default settlement alias for prediction registry lookups. */
     settlement;
     constructor(network, config, opts = {}) {
-        this.network = network;
-        this.config = config;
+        super(network, config, opts);
         this.settlement = opts.settlement ?? "USD";
-        const baseUrl = opts.grpcUrl ?? config.grpcUrl ?? GRPC_URLS[network];
-        this.grpcClient = new SuiGrpcClient({
-            baseUrl,
-            network: network.toLowerCase(),
-        });
     }
     static testnet(params = {}) {
         return PredictClient.create("TESTNET", params);
@@ -40,51 +24,17 @@ export class PredictClient {
             settlement: opts.settlement,
         });
     }
-    getObject(objectId) {
-        return this.grpcClient.getObject({ objectId });
-    }
-    getObjects(objectIds) {
-        return this.grpcClient.getObjects({ objectIds });
-    }
-    listOwnedObjects(owner) {
-        return this.grpcClient.listOwnedObjects({ owner });
-    }
-    listCoins(params) {
-        return this.grpcClient.listCoins(params);
-    }
-    getBalance(params) {
-        return this.grpcClient.getBalance(params);
-    }
-    listDynamicFields(parentId) {
-        return this.grpcClient.listDynamicFields({ parentId });
-    }
-    getDynamicField(parentId, name) {
-        return this.grpcClient.getDynamicField({ parentId, name });
-    }
-    waitForTransaction(digest) {
-        return this.grpcClient.waitForTransaction({ digest });
-    }
+    /**
+     * 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.
+     */
     async simulate(tx) {
-        return withRpcRetry(() => this.grpcClient.simulateTransaction({
-            transaction: tx,
-            include: { commandResults: true },
-        }));
-    }
-    async signAndExecuteTransaction(params) {
-        return this.grpcClient.signAndExecuteTransaction(params);
+        return withRpcRetry(() => super.simulate(tx));
     }
     // ========================================================
-    // Shorthand accessors (canonical-schema lookups)
+    // Config-schema lookups (prediction-specific)
     // ========================================================
-    /** All package IDs (`published_at`) keyed by package name. */
-    packageIds() {
-        const out = {};
-        for (const [name, pkg] of Object.entries(this.config.packages)) {
-            if (isPublishedPackage(pkg))
-                out[name] = pkg.published_at;
-        }
-        return out;
-    }
     packageId() {
         return this.config.packages.waterx_prediction.published_at;
     }
@@ -125,12 +75,6 @@ export class PredictClient {
         return requireConfigValue(this.config.packages.waterx_referral, "referral_table", "packages.waterx_referral.referral_table");
     }
 }
-function isPublishedPackage(value) {
-    return (!!value &&
-        typeof value === "object" &&
-        "published_at" in value &&
-        typeof value.published_at === "string");
-}
 function requireConfigValue(map, key, path) {
     const value = map?.[key];
     if (typeof value !== "string" || value.length === 0) {

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

@@ -46,8 +46,18 @@ export interface WaterxPredictionConfig {
     packages: WaterxPredictionConfigPackages;
 }
 export interface LoadConfigOptions {
-    /** Override the default waterx-config raw JSON URL. */
+    /**
+     * Override the default waterx-config raw JSON URL. Use this to point at a
+     * local mirror during development. Takes precedence over {@link configRef}.
+     */
     configUrl?: string;
+    /**
+     * Pin the canonical config to a specific git ref — a commit SHA, branch, or
+     * tag — instead of the default `main` branch. Resolves to
+     * `https://raw.githubusercontent.com/WaterXProtocol/waterx-config/<ref>/<network>.json`.
+     * Ignored when {@link configUrl} is set.
+     */
+    configRef?: string;
     /** Reuse a previously fetched config in memory. Default: false. */
     cache?: boolean;
     /** Optional fetch implementation for tests or runtimes without global fetch. */
@@ -55,6 +65,10 @@ export interface LoadConfigOptions {
     /** Request timeout in ms. Default: 10_000. */
     timeoutMs?: number;
 }
-export declare function defaultConfigUrl(network: Network): string;
+/**
+ * Build the canonical config URL for `network`, optionally pinned to a
+ * specific git `ref` (commit SHA, branch, or tag). Defaults to `main`.
+ */
+export declare function defaultConfigUrl(network: Network, ref?: string): string;
 export declare function clearConfigCache(): void;
 export declare function loadConfig(network: Network, opts?: LoadConfigOptions): Promise<WaterxPredictionConfig>;

package/dist/src/prediction/config.js

@@ -4,16 +4,22 @@
  * Mirrors the canonical `waterx-config` JSON for the packages used by this SDK
  * and fetches it from GitHub raw by default.
  */
-const DEFAULT_CONFIG_URL_BASE = "https://raw.githubusercontent.com/WaterXProtocol/waterx-config/main";
-export function defaultConfigUrl(network) {
-    return `${DEFAULT_CONFIG_URL_BASE}/${network.toLowerCase()}.json`;
+const CONFIG_REPO_RAW_BASE = "https://raw.githubusercontent.com/WaterXProtocol/waterx-config";
+/** Default git ref for the canonical config when none is pinned. */
+const DEFAULT_CONFIG_REF = "main";
+/**
+ * Build the canonical config URL for `network`, optionally pinned to a
+ * specific git `ref` (commit SHA, branch, or tag). Defaults to `main`.
+ */
+export function defaultConfigUrl(network, ref = DEFAULT_CONFIG_REF) {
+    return `${CONFIG_REPO_RAW_BASE}/${ref}/${network.toLowerCase()}.json`;
 }
 const configCache = new Map();
 export function clearConfigCache() {
     configCache.clear();
 }
 export async function loadConfig(network, opts = {}) {
-    const url = opts.configUrl ?? defaultConfigUrl(network);
+    const url = opts.configUrl ?? defaultConfigUrl(network, opts.configRef);
     if (opts.cache && configCache.has(url)) {
         return configCache.get(url);
     }

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

@@ -10,20 +10,20 @@ export { addDelegate, allowPredictionProtocolAsset, consumeDepositDirect, consum
 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 { adminPlaceOrderFor, batchClaim, batchForceClaim, buildBatchForceClaimTransactions, cancelClose, cancelOrder, claim, confirmClose, fillOrder, forceClaim, outcomeArg, placeOrder, requestClose, requestPartialClose, resolveMarket, selectionArg, selfCancelClose, selfCancelOrder, splitPosition, transferPosition, } from "./prediction.ts";
+export type { AdminPlaceOrderForParams, BatchClaimParams, BatchForceClaimParams, BuildBatchForceClaimTransactionsParams, CancelCloseParams, CancelOrderParams, ClaimParams, ConfirmCloseParams, FillOrderParams, ForceClaimParams, PlaceOrderParams, RequestCloseParams, RequestPartialCloseParams, ResolveMarketParams, SelfCancelCloseParams, SelfCancelOrderParams, SplitPositionParams, TransferPositionParams, } 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";
+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

@@ -6,16 +6,16 @@ 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 { adminPlaceOrderFor, batchClaim, batchForceClaim, buildBatchForceClaimTransactions, cancelClose, cancelOrder, claim, confirmClose, fillOrder, forceClaim, outcomeArg, placeOrder, requestClose, requestPartialClose, resolveMarket, selectionArg, selfCancelClose, selfCancelOrder, splitPosition, transferPosition, } 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";
+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

@@ -44,10 +44,55 @@ export interface RequestCloseParams extends BasePredictionParams, AccountIdentit
     expiryTs: bigint | number | string;
 }
 export declare function requestClose(client: PredictClient, tx: Transaction, params: RequestCloseParams): Transaction;
+export interface RequestPartialCloseParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+    /**
+     * Shares to peel off `positionId` into a new same-account position that is
+     * then closed. Must be `0 < closeShares < filled_shares` of the position.
+     */
+    closeShares: bigint | number | string;
+    minProceeds: bigint | number | string;
+    expiryTs: bigint | number | string;
+}
+/**
+ * Account-backed partial sell. Splits `closeShares` off `positionId` into a new
+ * same-account position and runs the close flow on it; the remainder stays
+ * `Open` under `positionId`. The on-chain call returns the new PendingClose
+ * position id (read it from events / the returned move-call result if needed).
+ */
+export declare function requestPartialClose(client: PredictClient, tx: Transaction, params: RequestPartialCloseParams): Transaction;
 export interface SelfCancelCloseParams extends BasePredictionParams, AccountIdentityParams {
     positionId: bigint | number | string;
 }
 export declare function selfCancelClose(client: PredictClient, tx: Transaction, params: SelfCancelCloseParams): Transaction;
+export interface TransferPositionParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+    /** WXA account that receives the position; future close/claim proceeds go there. */
+    recipientAccountId: IdArgument;
+}
+/**
+ * Account-backed position transfer. The source account owner moves an open
+ * prediction position to another WXA account. Aborts if the position has a
+ * pending close.
+ */
+export declare function transferPosition(client: PredictClient, tx: Transaction, params: TransferPositionParams): Transaction;
+export interface SplitPositionParams extends BasePredictionParams, AccountIdentityParams {
+    positionId: bigint | number | string;
+    /** WXA account that receives the new independent position. */
+    recipientAccountId: IdArgument;
+    /**
+     * Shares to split into the recipient's new position. Must be
+     * `0 < splitShares < filled_shares` of the source position.
+     */
+    splitShares: bigint | number | string;
+}
+/**
+ * Account-backed partial transfer. Splits an open position into two independent
+ * positions: the source keeps the remainder and the recipient receives a new
+ * position with proportional cost basis. The on-chain call returns the new
+ * position id (read it from events / the returned move-call result if needed).
+ */
+export declare function splitPosition(client: PredictClient, tx: Transaction, params: SplitPositionParams): Transaction;
 export interface KeeperBaseParams extends BasePredictionParams, AccountIdentityParams {
 }
 export interface FillOrderParams extends KeeperBaseParams {

package/dist/src/prediction/prediction.js

@@ -124,6 +124,31 @@ export function requestClose(client, tx, params) {
     });
     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).
+ */
+export function requestPartialClose(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::request_partial_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.closeShares)),
+            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({
@@ -140,6 +165,52 @@ export function selfCancelClose(client, tx, params) {
     });
     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.
+ */
+export function transferPosition(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::transfer_position`,
+        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)),
+            idArg(tx, params.recipientAccountId),
+            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).
+ */
+export function splitPosition(client, tx, params) {
+    const senderRequest = createAccountRequest(client, tx, params);
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::waterx_prediction::split_position`,
+        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)),
+            idArg(tx, params.recipientAccountId),
+            tx.pure.u64(toBigInt(params.splitShares)),
+            clockArg(tx),
+        ],
+    });
+    return tx;
+}
 export function fillOrder(client, tx, params) {
     const keeperRequest = createAccountRequest(client, tx, params);
     tx.moveCall({

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

@@ -2,14 +2,14 @@
  * 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`
+ * 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 { WaterXClient } from "../client.ts";
+import type { AccountClientLike } from "../account/client.ts";
 import type { PredictClient } from "./client.ts";
 import { type BatchClaimParams, type PlaceOrderParams } from "./prediction.ts";
 export interface PredictCommonBuildOpts {
@@ -37,8 +37,8 @@ export interface BuildBatchClaimTxParams extends BatchClaimParams, PredictCommon
  * @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>;
+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: WaterXClient, predictClient: PredictClient, params: BuildBatchClaimTxParams): Promise<Transaction>;
+export declare function buildBatchClaimTx(perpClient: AccountClientLike, predictClient: PredictClient, params: BuildBatchClaimTxParams): Promise<Transaction>;

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

@@ -2,14 +2,14 @@
  * 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`
+ * 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 { appendConsolidateForSpend } from "../tx-builders.js";
+import { appendConsolidateForSpend } from "../account/funding/consolidate.js";
 import { batchClaim, placeOrder, } from "./prediction.js";
 function newTx(opts) {
     return opts?.tx ?? new Transaction();