@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * High-level perp transaction builders — barrel.
+ *
+ * Each `build*Tx` composer creates (or appends to) a `Transaction`, refreshes
+ * the on-chain `Oracle` via Pyth, optionally pre-sweeps parked balances
+ * (`consolidateToUsd`), wires the `pyth_sponsor_rule` flow when enabled, and
+ * calls the matching `*_request` + `execute`. Implementations are split by
+ * domain under `tx-builders/`:
+ *
+ *   common.ts       CommonBuildOpts + request/execute envelope + oracle refresh
+ *   consolidate.ts  parked-balance → wxUSD pre-sweep (appendConsolidate*)
+ *   trading.ts      position lifecycle + collateral + order lifecycle
+ *   wlp.ts          mint / mint+stake / unstake+redeem / cancel-redeem+restake
+ *   rewards.ts      claim staking rewards to the wxa account
+ *   credit.ts       cross-chain credit / bridge (redeem VAA, withdraw, drain)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePythPrices = exports.reimbursePythSponsor = exports.refreshOraclePrices = exports.PythCache = exports.openPythSponsorFund = void 0;
+__exportStar(require("../account/funding/consolidate.js"), exports);
+__exportStar(require("./tx-builders/trading.js"), exports);
+__exportStar(require("./tx-builders/wlp.js"), exports);
+__exportStar(require("./tx-builders/rewards.js"), exports);
+__exportStar(require("./tx-builders/credit.js"), exports);
+// Oracle helpers re-exported for callers composing custom PTBs.
+var index_ts_1 = require("../oracle/index.js");
+Object.defineProperty(exports, "openPythSponsorFund", { enumerable: true, get: function () { return index_ts_1.openPythSponsorFund; } });
+Object.defineProperty(exports, "PythCache", { enumerable: true, get: function () { return index_ts_1.PythCache; } });
+Object.defineProperty(exports, "refreshOraclePrices", { enumerable: true, get: function () { return index_ts_1.refreshOraclePrices; } });
+Object.defineProperty(exports, "reimbursePythSponsor", { enumerable: true, get: function () { return index_ts_1.reimbursePythSponsor; } });
+Object.defineProperty(exports, "updatePythPrices", { enumerable: true, get: function () { return index_ts_1.updatePythPrices; } });

package/dist/cjs/src/perp/user/index.d.ts

@@ -0,0 +1,8 @@
+export * from "../../account/account.ts";
+export * from "../../account/funding/credit.ts";
+export * from "../../account/funding/custody.ts";
+export * from "./order.ts";
+export * from "../../account/referral.ts";
+export * from "./staking.ts";
+export * from "./trading.ts";
+export * from "./wlp.ts";

package/dist/cjs/src/perp/user/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../../account/account.js"), exports);
+__exportStar(require("../../account/funding/credit.js"), exports);
+__exportStar(require("../../account/funding/custody.js"), exports);
+__exportStar(require("./order.js"), exports);
+__exportStar(require("../../account/referral.js"), exports);
+__exportStar(require("./staking.js"), exports);
+__exportStar(require("./trading.js"), exports);
+__exportStar(require("./wlp.js"), exports);

package/dist/cjs/src/perp/user/order.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Order builders for `waterx_perp::trading`.
+ *
+ * `placeOrderRequest` accepts a main `PlaceOrderArgument` plus an optional
+ * `preOrder: PlaceOrderArgument[]` of reduce-only TP/SL legs to reserve
+ * against the freshly opened position.
+ *
+ * Use `triggerPrice === undefined` (market form) to park an order at
+ * tick 0 in the limit book; a keeper picks it up via `match_orders`.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { PerpClient } from "../client.ts";
+export interface PlaceOrderArgumentParams {
+    isLong: boolean;
+    isStopOrder: boolean;
+    reduceOnly: boolean;
+    /** Raw 1e9-scaled `Float` size. */
+    size: bigint | number;
+    /** Raw 1e9-scaled `Float` trigger price. `undefined` = market form. */
+    triggerPrice?: bigint | number;
+    linkedPositionId?: bigint | number;
+    /** Raw 1e9-scaled `Float` slippage cap (only used by market form). */
+    acceptablePrice?: bigint | number;
+    collateralAmount: bigint | number;
+}
+/** Build a `request::PlaceOrderArgument` Move struct in the PTB. */
+export declare function buildPlaceOrderArgument(client: PerpClient, tx: Transaction, p: PlaceOrderArgumentParams): TransactionArgument;
+export interface PlaceOrderRequestParams {
+    ticker: string;
+    accountId: string;
+    collateralType: string;
+    lpType?: string;
+    /** Main order. */
+    main: PlaceOrderArgumentParams;
+    /** Optional TP/SL legs (length ≤ market.config.max_pre_orders). */
+    preOrders?: PlaceOrderArgumentParams[];
+    bucketAccount?: string | TransactionArgument;
+}
+/** Build `trading::place_order_request`. Returns the `TradingRequest<C_TOKEN>` argument. */
+export declare function placeOrderRequest(client: PerpClient, tx: Transaction, params: PlaceOrderRequestParams): TransactionArgument;
+export interface CancelOrderRequestParams {
+    ticker: string;
+    accountId: string;
+    collateralType: string;
+    lpType?: string;
+    orderId: bigint | number;
+    /** Raw 1e9-scaled `Float`. `0n` scans all trigger price buckets in the selected book(s). */
+    triggerPrice?: bigint | number;
+    /** Defaults to `ORDER_TAG_WILDCARD` (255) — scans all 4 books by `orderId`. */
+    orderTypeTag?: number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function cancelOrderRequest(client: PerpClient, tx: Transaction, params: CancelOrderRequestParams): TransactionArgument;
+export interface UpdateOrderRequestParams {
+    ticker: string;
+    accountId: string;
+    collateralType: string;
+    lpType?: string;
+    orderId: bigint | number;
+    /** Existing trigger price (raw 1e9-scaled), used to locate the order. */
+    currentTriggerPrice: bigint | number;
+    orderTypeTag: number;
+    /** New raw 1e9-scaled size. */
+    newSize: bigint | number;
+    /** New raw 1e9-scaled trigger price. */
+    newTriggerPrice: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function updateOrderRequest(client: PerpClient, tx: Transaction, params: UpdateOrderRequestParams): TransactionArgument;
+export interface CancelPreOrderRequestParams {
+    ticker: string;
+    accountId: string;
+    collateralType: string;
+    lpType?: string;
+    mainOrderId: bigint | number;
+    preOrderId: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function cancelPreOrderRequest(client: PerpClient, tx: Transaction, params: CancelPreOrderRequestParams): TransactionArgument;
+export interface AddPreOrderRequestParams {
+    ticker: string;
+    accountId: string;
+    collateralType: string;
+    lpType?: string;
+    mainOrderId: bigint | number;
+    preOrder: PlaceOrderArgumentParams;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function addPreOrderRequest(client: PerpClient, tx: Transaction, params: AddPreOrderRequestParams): TransactionArgument;

package/dist/cjs/src/perp/user/order.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * Order builders for `waterx_perp::trading`.
+ *
+ * `placeOrderRequest` accepts a main `PlaceOrderArgument` plus an optional
+ * `preOrder: PlaceOrderArgument[]` of reduce-only TP/SL legs to reserve
+ * against the freshly opened position.
+ *
+ * Use `triggerPrice === undefined` (market form) to park an order at
+ * tick 0 in the limit book; a keeper picks it up via `match_orders`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPlaceOrderArgument = buildPlaceOrderArgument;
+exports.placeOrderRequest = placeOrderRequest;
+exports.cancelOrderRequest = cancelOrderRequest;
+exports.updateOrderRequest = updateOrderRequest;
+exports.cancelPreOrderRequest = cancelPreOrderRequest;
+exports.addPreOrderRequest = addPreOrderRequest;
+const account_request_ts_1 = require("../../account/account-request.js");
+const request_ts_1 = require("../../generated/waterx_perp/request.js");
+const trading = __importStar(require("../../generated/waterx_perp/trading.js"));
+const constants_ts_1 = require("../constants.js");
+/** Build a `request::PlaceOrderArgument` Move struct in the PTB. */
+function buildPlaceOrderArgument(client, tx, p) {
+    const [arg] = (0, request_ts_1.newPlaceOrderArgument)({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            isLong: p.isLong,
+            isStopOrder: p.isStopOrder,
+            reduceOnly: p.reduceOnly,
+            size: p.size,
+            triggerPrice: p.triggerPrice ?? null,
+            linkedPositionId: p.linkedPositionId ?? null,
+            acceptablePrice: p.acceptablePrice ?? null,
+            collateralAmount: p.collateralAmount,
+        },
+    })(tx);
+    return arg;
+}
+/** Build `trading::place_order_request`. Returns the `TradingRequest<C_TOKEN>` argument. */
+function placeOrderRequest(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const mainArg = buildPlaceOrderArgument(client, tx, params.main);
+    const preArgs = (params.preOrders ?? []).map((p) => buildPlaceOrderArgument(client, tx, p));
+    const preOrderType = `${client.config.packages.waterx_perp.published_at}::request::PlaceOrderArgument`;
+    const preVec = tx.makeMoveVec({
+        type: preOrderType,
+        elements: preArgs,
+    });
+    const [tr] = trading.placeOrderRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            main: mainArg,
+            preOrder: preVec,
+        },
+        typeArguments: [params.collateralType, params.lpType ?? client.wlpType()],
+    })(tx);
+    return tr;
+}
+function cancelOrderRequest(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const [tr] = trading.cancelOrderRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            orderId: params.orderId,
+            triggerPrice: params.triggerPrice ?? 0n,
+            orderTypeTag: params.orderTypeTag ?? constants_ts_1.ORDER_TAG_WILDCARD,
+        },
+        typeArguments: [params.collateralType, params.lpType ?? client.wlpType()],
+    })(tx);
+    return tr;
+}
+function updateOrderRequest(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const [tr] = trading.updateOrderRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            orderId: params.orderId,
+            currentTriggerPrice: params.currentTriggerPrice,
+            orderTypeTag: params.orderTypeTag,
+            newSize: params.newSize,
+            newTriggerPrice: params.newTriggerPrice,
+        },
+        typeArguments: [params.collateralType, params.lpType ?? client.wlpType()],
+    })(tx);
+    return tr;
+}
+function cancelPreOrderRequest(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const [tr] = trading.cancelPreOrderRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            mainOrderId: params.mainOrderId,
+            preOrderId: params.preOrderId,
+        },
+        typeArguments: [params.collateralType, params.lpType ?? client.wlpType()],
+    })(tx);
+    return tr;
+}
+function addPreOrderRequest(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const preArg = buildPlaceOrderArgument(client, tx, params.preOrder);
+    const [tr] = trading.addPreOrderRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            mainOrderId: params.mainOrderId,
+            preOrder: preArg,
+        },
+        typeArguments: [params.collateralType, params.lpType ?? client.wlpType()],
+    })(tx);
+    return tr;
+}

package/dist/cjs/src/perp/user/staking.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Staking builders for `waterx_staking::waterx_staking`.
+ *
+ * Deposit / redeem produce a "checker" hot potato keyed by the set of
+ * rewarders configured on the pool. The PTB shape is:
+ *
+ *   checker = deposit(...) | redeem(...)
+ *   for each rewarder_R:
+ *     settle_rewarder_on_<deposit|withdraw><STAKE, R>(checker, pool, clock)
+ *   destroy_<deposit|withdraw>_checker(checker)
+ *
+ * `claim<STAKE, R>` is single-call (no checker).
+ *
+ * Each builder takes a `stakeAlias` (e.g. `"WLP"`) that keys into
+ * `config.packages.waterx_staking.pools` to find the actual
+ * `StakingPool<STAKE>` shared object.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { PerpClient } from "../client.ts";
+export interface StakeParams {
+    accountId: string;
+    /** Stake-type alias (key into `waterx_staking.pools`, e.g. `"WLP"`). */
+    stakeAlias: string;
+    /** Fully-qualified `STAKE` coin type for the type argument. */
+    stakeType: string;
+    /**
+     * Amount to take from the wxa account into the staking pool. Accepts a
+     * `TransactionArgument` so callers can chain it from a previous PTB call
+     * (e.g. the `lp_amount` returned by `mintWlp`).
+     */
+    stakeAmount: bigint | number | TransactionArgument;
+    /** Rewarder types to settle on this deposit. Order matters and must match the pool's `rewarder_ids` set on-chain. */
+    rewarderTypes?: string[];
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function stake(client: PerpClient, tx: Transaction, params: StakeParams): void;
+export interface UnstakeParams {
+    accountId: string;
+    stakeAlias: string;
+    stakeType: string;
+    withdrawalAmount: bigint | number | TransactionArgument;
+    rewarderTypes?: string[];
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function unstake(client: PerpClient, tx: Transaction, params: UnstakeParams): void;
+export interface ClaimRewardParams {
+    accountId: string;
+    stakeAlias: string;
+    stakeType: string;
+    /** Reward coin type to claim. */
+    rewardType: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function claimReward(client: PerpClient, tx: Transaction, params: ClaimRewardParams): void;

package/dist/cjs/src/perp/user/staking.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Staking builders for `waterx_staking::waterx_staking`.
+ *
+ * Deposit / redeem produce a "checker" hot potato keyed by the set of
+ * rewarders configured on the pool. The PTB shape is:
+ *
+ *   checker = deposit(...) | redeem(...)
+ *   for each rewarder_R:
+ *     settle_rewarder_on_<deposit|withdraw><STAKE, R>(checker, pool, clock)
+ *   destroy_<deposit|withdraw>_checker(checker)
+ *
+ * `claim<STAKE, R>` is single-call (no checker).
+ *
+ * Each builder takes a `stakeAlias` (e.g. `"WLP"`) that keys into
+ * `config.packages.waterx_staking.pools` to find the actual
+ * `StakingPool<STAKE>` shared object.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stake = stake;
+exports.unstake = unstake;
+exports.claimReward = claimReward;
+const account_request_ts_1 = require("../../account/account-request.js");
+const staking = __importStar(require("../../generated/waterx_staking/waterx_staking.js"));
+function pool(client, stakeAlias) {
+    const id = client.config.packages.waterx_staking?.pools?.[stakeAlias];
+    if (!id) {
+        throw new Error(`config.packages.waterx_staking.pools[${stakeAlias}] is not set — staking is not deployed for this stake type`);
+    }
+    return id;
+}
+function stakingPackage(client) {
+    const pkg = client.config.packages.waterx_staking?.published_at;
+    if (!pkg)
+        throw new Error("config.packages.waterx_staking is not configured");
+    return pkg;
+}
+function stake(client, tx, params) {
+    const pkg = stakingPackage(client);
+    const poolId = pool(client, params.stakeAlias);
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const [checker] = staking.deposit({
+        package: pkg,
+        arguments: {
+            self: tx.object(poolId),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            accReq: req,
+            stakeAmount: params.stakeAmount,
+        },
+        typeArguments: [params.stakeType],
+    })(tx);
+    for (const r of params.rewarderTypes ?? []) {
+        staking.settleRewarderOnDeposit({
+            package: pkg,
+            arguments: {
+                checker: checker,
+                self: tx.object(poolId),
+            },
+            typeArguments: [params.stakeType, r],
+        })(tx);
+    }
+    staking.destroyDepositChecker({
+        package: pkg,
+        arguments: { checker: checker },
+        typeArguments: [params.stakeType],
+    })(tx);
+}
+function unstake(client, tx, params) {
+    const pkg = stakingPackage(client);
+    const poolId = pool(client, params.stakeAlias);
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const [checker] = staking.redeem({
+        package: pkg,
+        arguments: {
+            self: tx.object(poolId),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            accReq: req,
+            withdrawalAmount: params.withdrawalAmount,
+        },
+        typeArguments: [params.stakeType],
+    })(tx);
+    for (const r of params.rewarderTypes ?? []) {
+        staking.settleRewarderOnWithdraw({
+            package: pkg,
+            arguments: {
+                checker: checker,
+                self: tx.object(poolId),
+            },
+            typeArguments: [params.stakeType, r],
+        })(tx);
+    }
+    staking.destroyWithdrawChecker({
+        package: pkg,
+        arguments: { checker: checker },
+        typeArguments: [params.stakeType],
+    })(tx);
+}
+function claimReward(client, tx, params) {
+    const pkg = stakingPackage(client);
+    const poolId = pool(client, params.stakeAlias);
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    staking.claim({
+        package: pkg,
+        arguments: {
+            self: tx.object(poolId),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            request: req,
+        },
+        typeArguments: [params.stakeType, params.rewardType],
+    })(tx);
+}

package/dist/cjs/src/perp/user/trading.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Trading builders for `waterx_perp`.
+ *
+ * Each user-side flow has two phases:
+ *   1. `*Request(...)` constructs a `TradingRequest<C_TOKEN>` hot potato
+ *      and returns the raw transaction argument.
+ *   2. `executeTrading(...)` consumes the hot potato via `trading::execute`.
+ *
+ * Keeper flows (`liquidate`, `batchLiquidate`, `matchOrders`,
+ * `updateFundingRate`, `openByKeeper`, `closeByKeeper`) are single-call:
+ * they do the work inline and return `()`.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { PerpClient } from "../client.ts";
+export interface TradingTypeArgs {
+    /** Collateral coin type (e.g. `0x…::usdc::USDC`). */
+    collateralType: string;
+    /** Defaults to `client.wlpType()`. */
+    lpType?: string;
+}
+export interface CommonTradingParams extends TradingTypeArgs {
+    /** Market ticker (e.g. `"BTCUSD"`). */
+    ticker: string;
+    /** wxa `Account` ID acting as sender / collateral source. */
+    accountId: string;
+    /** Optional Bucket Account to act through (`request_with_account(&Account)`). */
+    bucketAccount?: string | TransactionArgument;
+}
+export interface ClosePositionRequestParams extends CommonTradingParams {
+    positionId: bigint | number;
+    /** Raw scaled `Float` (1e9). Use `rawPrice(usd)` to convert. */
+    acceptablePrice: bigint | number;
+}
+export declare function closePositionRequest(client: PerpClient, tx: Transaction, params: ClosePositionRequestParams): TransactionArgument;
+export interface IncreasePositionRequestParams extends CommonTradingParams {
+    positionId: bigint | number;
+    collateralAmount: bigint | number;
+    /** Raw 1e9-scaled `Float` size. */
+    size: bigint | number;
+    /** Raw 1e9-scaled `Float` slippage cap. */
+    acceptablePrice: bigint | number;
+    /** Optional opener order id (rare). */
+    orderId?: bigint | number;
+}
+export declare function increasePositionRequest(client: PerpClient, tx: Transaction, params: IncreasePositionRequestParams): TransactionArgument;
+export interface DecreasePositionRequestParams extends CommonTradingParams {
+    positionId: bigint | number;
+    /** Raw 1e9-scaled `Float` size to reduce by. */
+    size: bigint | number;
+    acceptablePrice: bigint | number;
+}
+export declare function decreasePositionRequest(client: PerpClient, tx: Transaction, params: DecreasePositionRequestParams): TransactionArgument;
+export interface DepositCollateralRequestParams extends CommonTradingParams {
+    positionId: bigint | number;
+    collateralAmount: bigint | number;
+}
+export declare function depositCollateralRequest(client: PerpClient, tx: Transaction, params: DepositCollateralRequestParams): TransactionArgument;
+export interface WithdrawCollateralRequestParams extends CommonTradingParams {
+    positionId: bigint | number;
+    amount: bigint | number;
+}
+export declare function withdrawCollateralRequest(client: PerpClient, tx: Transaction, params: WithdrawCollateralRequestParams): TransactionArgument;
+export interface ExecuteTradingParams extends TradingTypeArgs {
+    ticker: string;
+    request: TransactionArgument;
+}
+export declare function executeTrading(client: PerpClient, tx: Transaction, params: ExecuteTradingParams): void;
+export interface LiquidateParams extends TradingTypeArgs {
+    ticker: string;
+    positionId: bigint | number;
+    /** Optional Bucket Account to act through. */
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function liquidate(client: PerpClient, tx: Transaction, params: LiquidateParams): void;
+export interface BatchLiquidateParams extends TradingTypeArgs {
+    ticker: string;
+    pageSize: bigint | number;
+    pageIndex: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function batchLiquidate(client: PerpClient, tx: Transaction, params: BatchLiquidateParams): void;
+export interface MatchOrdersParams extends TradingTypeArgs {
+    ticker: string;
+    /** Order book to scan: `ORDER_LIMIT_BUY` / `ORDER_LIMIT_SELL` / etc. */
+    orderTypeTag: number;
+    /** Raw 1e9-scaled trigger price to start from (`0` = scan from best). */
+    triggerPrice: bigint | number;
+    maxFills: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function matchOrders(client: PerpClient, tx: Transaction, params: MatchOrdersParams): void;
+export interface UpdateFundingRateParams {
+    ticker: string;
+    /** Defaults to `client.wlpType()`. */
+    lpType?: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function updateFundingRate(client: PerpClient, tx: Transaction, params: UpdateFundingRateParams): void;
+export interface OpenPositionByKeeperParams extends TradingTypeArgs {
+    ticker: string;
+    /** Address of the user-side account (the position will be owned by this address). */
+    accountObjectAddress: string;
+    /** Collateral `Coin<C_TOKEN>` argument the keeper is funding from its treasury. */
+    collateralCoin: TransactionArgument;
+    isLong: boolean;
+    /** Raw 1e9-scaled `Float`. */
+    size: bigint | number;
+    acceptablePrice: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function openPositionByKeeper(client: PerpClient, tx: Transaction, params: OpenPositionByKeeperParams): void;
+export interface ClosePositionByKeeperParams extends TradingTypeArgs {
+    ticker: string;
+    positionId: bigint | number;
+    acceptablePrice: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function closePositionByKeeper(client: PerpClient, tx: Transaction, params: ClosePositionByKeeperParams): void;
+export declare const ORDER_TAG_WILDCARD_VALUE = 255;