@waterx/sdk 2.4.0 → 3.0.0

package/dist/src/perp/tx-builders/wlp.d.ts

@@ -0,0 +1,90 @@
+/**
+ * High-level WLP composers: mint, mint+stake, unstake+request-redeem, and
+ * cancel-redeem+re-stake. The staking-coupled variants keep the product
+ * invariant that user-held WLP is always staked.
+ */
+import type { Transaction } from "@mysten/sui/transactions";
+import type { PerpClient } from "../client.ts";
+import { type CancelRedeemWlpParams, type MintWlpParams, type RequestRedeemWlpParams } from "../user/wlp.ts";
+import { type CommonBuildOpts } from "./common.ts";
+export interface BuildMintWlpParams extends MintWlpParams, CommonBuildOpts {
+    /** Oracle ticker for the deposited token (must be a registered pool token). */
+    depositTicker: string;
+}
+/**
+ * Mints WLP from a deposit asset already in the wxa account's stored
+ * balance. Refreshes every pool-token oracle + bumps each pool token's
+ * `last_price_refresh_timestamp` so `assert_prices_fresh` inside
+ * `mint_wlp` passes.
+ *
+ * Does NOT use the pyth_sponsor flow — `mint_wlp` produces no
+ * `TradingRequest`, so there's nothing for the sponsor to attach its
+ * witness to. Pyth update fees come from `tx.gas`.
+ */
+export declare function buildMintWlpTx(client: PerpClient, params: BuildMintWlpParams): Promise<Transaction>;
+export interface BuildMintAndStakeWlpParams extends BuildMintWlpParams {
+    /**
+     * Staking pool alias (key into `waterx_staking.pools`). Defaults to `"WLP"`.
+     */
+    stakeAlias?: string;
+    /**
+     * Rewarder coin types to settle on the stake deposit. Order must match the
+     * pool's on-chain `rewarder_ids`. Defaults to every rewarder configured for
+     * the stake pool in `waterx_staking.rewarders[stakeAlias]`.
+     */
+    rewarderTypes?: string[];
+}
+/**
+ * Mints WLP and immediately stakes the minted amount into the WLP staking pool
+ * in the same PTB. The mint's `lp_amount` return is piped directly into the
+ * `stake` call so no precision loss / dust can occur.
+ *
+ * Use this instead of `buildMintWlpTx` when the product flow is "deposit USD
+ * and earn rewards" — un-staked WLP sitting in the wxa account's `Balance<WLP>`
+ * slot earns nothing.
+ */
+export declare function buildMintAndStakeWlpTx(client: PerpClient, params: BuildMintAndStakeWlpParams): Promise<Transaction>;
+export interface BuildUnstakeAndRequestRedeemWlpParams extends Omit<RequestRedeemWlpParams, "lpAmount">, CommonBuildOpts {
+    /** Amount of staked WLP to unstake and enqueue for redemption. */
+    withdrawalAmount: bigint | number;
+    /** Staking pool alias. Defaults to `"WLP"`. */
+    stakeAlias?: string;
+    /**
+     * Rewarder coin types to settle on unstake. Defaults to every rewarder
+     * configured for the stake pool in `waterx_staking.rewarders[stakeAlias]`.
+     */
+    rewarderTypes?: string[];
+}
+/**
+ * Unstakes WLP from the staking pool and immediately enqueues a redeem request
+ * in the same PTB. Mirror of `buildMintAndStakeWlpTx` for withdrawals.
+ *
+ * Refreshes every WLP pool-token oracle by default — `request_redeem` runs
+ * `assert_prices_fresh` internally, so a stale oracle would abort the PTB.
+ * Pass `skipOraclePriceRefresh: true` only when the caller is composing this
+ * into a larger PTB that already pre-pumps prices.
+ */
+export declare function buildUnstakeAndRequestRedeemWlpTx(client: PerpClient, params: BuildUnstakeAndRequestRedeemWlpParams): Promise<Transaction>;
+export interface BuildCancelRedeemAndStakeWlpParams extends CancelRedeemWlpParams, CommonBuildOpts {
+    accountId: string;
+    /**
+     * WLP amount (base units) that was originally enqueued by `request_redeem`
+     * and is being returned to the wxa account by `cancel_redeem` — gets
+     * re-staked into the WLP staking pool in the same PTB.
+     */
+    stakeAmount: bigint | number;
+    /** Staking pool alias. Defaults to `"WLP"`. */
+    stakeAlias?: string;
+    /**
+     * Rewarder coin types to settle on stake. Defaults to every rewarder
+     * configured for the stake pool in `waterx_staking.rewarders[stakeAlias]`.
+     */
+    rewarderTypes?: string[];
+}
+/**
+ * Cancels a pending WLP redeem request and re-stakes the returned WLP in the
+ * same PTB. Third partner of `buildMintAndStakeWlpTx` /
+ * `buildUnstakeAndRequestRedeemWlpTx`; together they keep the product
+ * invariant that user-held WLP is always staked.
+ */
+export declare function buildCancelRedeemAndStakeWlpTx(client: PerpClient, params: BuildCancelRedeemAndStakeWlpParams): Transaction;

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

@@ -0,0 +1,120 @@
+/**
+ * High-level WLP composers: mint, mint+stake, unstake+request-redeem, and
+ * cancel-redeem+re-stake. The staking-coupled variants keep the product
+ * invariant that user-held WLP is always staked.
+ */
+import { stake, unstake } from "../user/staking.js";
+import { cancelRedeemWlp, mintWlp, requestRedeemWlp, } from "../user/wlp.js";
+import { maybeConsolidate, newTx, refreshWlpPoolOracles } from "./common.js";
+/**
+ * Mints WLP from a deposit asset already in the wxa account's stored
+ * balance. Refreshes every pool-token oracle + bumps each pool token's
+ * `last_price_refresh_timestamp` so `assert_prices_fresh` inside
+ * `mint_wlp` passes.
+ *
+ * Does NOT use the pyth_sponsor flow — `mint_wlp` produces no
+ * `TradingRequest`, so there's nothing for the sponsor to attach its
+ * witness to. Pyth update fees come from `tx.gas`.
+ */
+export async function buildMintWlpTx(client, params) {
+    const tx = newTx(params);
+    await maybeConsolidate(client, tx, params.accountId, params);
+    if (!params.skipOraclePriceRefresh) {
+        await refreshWlpPoolOracles(tx, client, [params.depositTicker], {
+            cache: params.pythCache,
+            lpType: params.lpType,
+        });
+    }
+    mintWlp(client, tx, params);
+    return tx;
+}
+/**
+ * Mints WLP and immediately stakes the minted amount into the WLP staking pool
+ * in the same PTB. The mint's `lp_amount` return is piped directly into the
+ * `stake` call so no precision loss / dust can occur.
+ *
+ * Use this instead of `buildMintWlpTx` when the product flow is "deposit USD
+ * and earn rewards" — un-staked WLP sitting in the wxa account's `Balance<WLP>`
+ * slot earns nothing.
+ */
+export async function buildMintAndStakeWlpTx(client, params) {
+    const tx = newTx(params);
+    await maybeConsolidate(client, tx, params.accountId, params);
+    if (!params.skipOraclePriceRefresh) {
+        await refreshWlpPoolOracles(tx, client, [params.depositTicker], {
+            cache: params.pythCache,
+            lpType: params.lpType,
+        });
+    }
+    const stakeAlias = params.stakeAlias ?? "WLP";
+    const lpAmount = mintWlp(client, tx, params);
+    stake(client, tx, {
+        accountId: params.accountId,
+        stakeAlias,
+        stakeType: params.lpType ?? client.wlpType(),
+        stakeAmount: lpAmount,
+        rewarderTypes: params.rewarderTypes ?? client.getRewarderTypes(stakeAlias),
+        bucketAccount: params.bucketAccount,
+    });
+    return tx;
+}
+/**
+ * Unstakes WLP from the staking pool and immediately enqueues a redeem request
+ * in the same PTB. Mirror of `buildMintAndStakeWlpTx` for withdrawals.
+ *
+ * Refreshes every WLP pool-token oracle by default — `request_redeem` runs
+ * `assert_prices_fresh` internally, so a stale oracle would abort the PTB.
+ * Pass `skipOraclePriceRefresh: true` only when the caller is composing this
+ * into a larger PTB that already pre-pumps prices.
+ */
+export async function buildUnstakeAndRequestRedeemWlpTx(client, params) {
+    const tx = newTx(params);
+    const stakeAlias = params.stakeAlias ?? "WLP";
+    await maybeConsolidate(client, tx, params.accountId, params);
+    if (!params.skipOraclePriceRefresh) {
+        await refreshWlpPoolOracles(tx, client, [], {
+            cache: params.pythCache,
+            lpType: params.lpType,
+        });
+    }
+    unstake(client, tx, {
+        accountId: params.accountId,
+        stakeAlias,
+        stakeType: params.lpType ?? client.wlpType(),
+        withdrawalAmount: params.withdrawalAmount,
+        rewarderTypes: params.rewarderTypes ?? client.getRewarderTypes(stakeAlias),
+        bucketAccount: params.bucketAccount,
+    });
+    requestRedeemWlp(client, tx, {
+        accountId: params.accountId,
+        redeemTokenType: params.redeemTokenType,
+        lpAmount: params.withdrawalAmount,
+        lpType: params.lpType,
+        bucketAccount: params.bucketAccount,
+    });
+    return tx;
+}
+/**
+ * Cancels a pending WLP redeem request and re-stakes the returned WLP in the
+ * same PTB. Third partner of `buildMintAndStakeWlpTx` /
+ * `buildUnstakeAndRequestRedeemWlpTx`; together they keep the product
+ * invariant that user-held WLP is always staked.
+ */
+export function buildCancelRedeemAndStakeWlpTx(client, params) {
+    const tx = newTx(params);
+    const stakeAlias = params.stakeAlias ?? "WLP";
+    cancelRedeemWlp(client, tx, {
+        requestId: params.requestId,
+        lpType: params.lpType,
+        bucketAccount: params.bucketAccount,
+    });
+    stake(client, tx, {
+        accountId: params.accountId,
+        stakeAlias,
+        stakeType: params.lpType ?? client.wlpType(),
+        stakeAmount: params.stakeAmount,
+        rewarderTypes: params.rewarderTypes ?? client.getRewarderTypes(stakeAlias),
+        bucketAccount: params.bucketAccount,
+    });
+    return tx;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * 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)
+ */
+export type { CommonBuildOpts } from "./tx-builders/common.ts";
+export * from "../account/funding/consolidate.ts";
+export * from "./tx-builders/trading.ts";
+export * from "./tx-builders/wlp.ts";
+export * from "./tx-builders/rewards.ts";
+export * from "./tx-builders/credit.ts";
+export { openPythSponsorFund, PythCache, refreshOraclePrices, reimbursePythSponsor, updatePythPrices, } from "../oracle/index.ts";

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

@@ -0,0 +1,23 @@
+/**
+ * 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)
+ */
+export * from "../account/funding/consolidate.js";
+export * from "./tx-builders/trading.js";
+export * from "./tx-builders/wlp.js";
+export * from "./tx-builders/rewards.js";
+export * from "./tx-builders/credit.js";
+// Oracle helpers re-exported for callers composing custom PTBs.
+export { openPythSponsorFund, PythCache, refreshOraclePrices, reimbursePythSponsor, updatePythPrices, } from "../oracle/index.js";

package/dist/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/src/perp/user/index.js

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

package/dist/src/{user → perp/user}/order.d.ts

@@ -9,7 +9,7 @@
  * tick 0 in the limit book; a keeper picks it up via `match_orders`.
  */
 import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
-import type { WaterXClient } from "../client.ts";
+import type { PerpClient } from "../client.ts";
 export interface PlaceOrderArgumentParams {
     isLong: boolean;
     isStopOrder: boolean;
@@ -24,7 +24,7 @@ export interface PlaceOrderArgumentParams {
     collateralAmount: bigint | number;
 }
 /** Build a `request::PlaceOrderArgument` Move struct in the PTB. */
-export declare function buildPlaceOrderArgument(client: WaterXClient, tx: Transaction, p: PlaceOrderArgumentParams): TransactionArgument;
+export declare function buildPlaceOrderArgument(client: PerpClient, tx: Transaction, p: PlaceOrderArgumentParams): TransactionArgument;
 export interface PlaceOrderRequestParams {
     ticker: string;
     accountId: string;
@@ -37,7 +37,7 @@ export interface PlaceOrderRequestParams {
     bucketAccount?: string | TransactionArgument;
 }
 /** Build `trading::place_order_request`. Returns the `TradingRequest<C_TOKEN>` argument. */
-export declare function placeOrderRequest(client: WaterXClient, tx: Transaction, params: PlaceOrderRequestParams): TransactionArgument;
+export declare function placeOrderRequest(client: PerpClient, tx: Transaction, params: PlaceOrderRequestParams): TransactionArgument;
 export interface CancelOrderRequestParams {
     ticker: string;
     accountId: string;
@@ -50,7 +50,7 @@ export interface CancelOrderRequestParams {
     orderTypeTag?: number;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function cancelOrderRequest(client: WaterXClient, tx: Transaction, params: CancelOrderRequestParams): TransactionArgument;
+export declare function cancelOrderRequest(client: PerpClient, tx: Transaction, params: CancelOrderRequestParams): TransactionArgument;
 export interface UpdateOrderRequestParams {
     ticker: string;
     accountId: string;
@@ -66,7 +66,7 @@ export interface UpdateOrderRequestParams {
     newTriggerPrice: bigint | number;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function updateOrderRequest(client: WaterXClient, tx: Transaction, params: UpdateOrderRequestParams): TransactionArgument;
+export declare function updateOrderRequest(client: PerpClient, tx: Transaction, params: UpdateOrderRequestParams): TransactionArgument;
 export interface CancelPreOrderRequestParams {
     ticker: string;
     accountId: string;
@@ -76,7 +76,7 @@ export interface CancelPreOrderRequestParams {
     preOrderId: bigint | number;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function cancelPreOrderRequest(client: WaterXClient, tx: Transaction, params: CancelPreOrderRequestParams): TransactionArgument;
+export declare function cancelPreOrderRequest(client: PerpClient, tx: Transaction, params: CancelPreOrderRequestParams): TransactionArgument;
 export interface AddPreOrderRequestParams {
     ticker: string;
     accountId: string;
@@ -86,4 +86,4 @@ export interface AddPreOrderRequestParams {
     preOrder: PlaceOrderArgumentParams;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function addPreOrderRequest(client: WaterXClient, tx: Transaction, params: AddPreOrderRequestParams): TransactionArgument;
+export declare function addPreOrderRequest(client: PerpClient, tx: Transaction, params: AddPreOrderRequestParams): TransactionArgument;

package/dist/src/{user → perp/user}/order.js

@@ -8,10 +8,10 @@
  * 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 { makeSenderRequest } from "../../account/account-request.js";
+import { newPlaceOrderArgument } from "../../generated/waterx_perp/request.js";
+import * as trading from "../../generated/waterx_perp/trading.js";
 import { ORDER_TAG_WILDCARD } from "../constants.js";
-import { newPlaceOrderArgument } from "../generated/waterx_perp/request.js";
-import * as trading from "../generated/waterx_perp/trading.js";
-import { makeSenderRequest } from "../utils/account-request.js";
 /** Build a `request::PlaceOrderArgument` Move struct in the PTB. */
 export function buildPlaceOrderArgument(client, tx, p) {
     const [arg] = newPlaceOrderArgument({

package/dist/src/{user → perp/user}/staking.d.ts

@@ -16,7 +16,7 @@
  * `StakingPool<STAKE>` shared object.
  */
 import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
-import type { WaterXClient } from "../client.ts";
+import type { PerpClient } from "../client.ts";
 export interface StakeParams {
     accountId: string;
     /** Stake-type alias (key into `waterx_staking.pools`, e.g. `"WLP"`). */
@@ -33,7 +33,7 @@ export interface StakeParams {
     rewarderTypes?: string[];
     bucketAccount?: string | TransactionArgument;
 }
-export declare function stake(client: WaterXClient, tx: Transaction, params: StakeParams): void;
+export declare function stake(client: PerpClient, tx: Transaction, params: StakeParams): void;
 export interface UnstakeParams {
     accountId: string;
     stakeAlias: string;
@@ -42,7 +42,7 @@ export interface UnstakeParams {
     rewarderTypes?: string[];
     bucketAccount?: string | TransactionArgument;
 }
-export declare function unstake(client: WaterXClient, tx: Transaction, params: UnstakeParams): void;
+export declare function unstake(client: PerpClient, tx: Transaction, params: UnstakeParams): void;
 export interface ClaimRewardParams {
     accountId: string;
     stakeAlias: string;
@@ -51,4 +51,4 @@ export interface ClaimRewardParams {
     rewardType: string;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function claimReward(client: WaterXClient, tx: Transaction, params: ClaimRewardParams): void;
+export declare function claimReward(client: PerpClient, tx: Transaction, params: ClaimRewardParams): void;

package/dist/src/{user → perp/user}/staking.js

@@ -15,8 +15,8 @@
  * `config.packages.waterx_staking.pools` to find the actual
  * `StakingPool<STAKE>` shared object.
  */
-import * as staking from "../generated/waterx_staking/waterx_staking.js";
-import { makeSenderRequest } from "../utils/account-request.js";
+import { makeSenderRequest } from "../../account/account-request.js";
+import * as staking from "../../generated/waterx_staking/waterx_staking.js";
 function pool(client, stakeAlias) {
     const id = client.config.packages.waterx_staking?.pools?.[stakeAlias];
     if (!id) {

package/dist/src/{user → perp/user}/trading.d.ts

@@ -11,7 +11,7 @@
  * they do the work inline and return `()`.
  */
 import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
-import type { WaterXClient } from "../client.ts";
+import type { PerpClient } from "../client.ts";
 export interface TradingTypeArgs {
     /** Collateral coin type (e.g. `0x…::usdc::USDC`). */
     collateralType: string;
@@ -31,7 +31,7 @@ export interface ClosePositionRequestParams extends CommonTradingParams {
     /** Raw scaled `Float` (1e9). Use `rawPrice(usd)` to convert. */
     acceptablePrice: bigint | number;
 }
-export declare function closePositionRequest(client: WaterXClient, tx: Transaction, params: ClosePositionRequestParams): TransactionArgument;
+export declare function closePositionRequest(client: PerpClient, tx: Transaction, params: ClosePositionRequestParams): TransactionArgument;
 export interface IncreasePositionRequestParams extends CommonTradingParams {
     positionId: bigint | number;
     collateralAmount: bigint | number;
@@ -42,43 +42,43 @@ export interface IncreasePositionRequestParams extends CommonTradingParams {
     /** Optional opener order id (rare). */
     orderId?: bigint | number;
 }
-export declare function increasePositionRequest(client: WaterXClient, tx: Transaction, params: IncreasePositionRequestParams): TransactionArgument;
+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: WaterXClient, tx: Transaction, params: DecreasePositionRequestParams): TransactionArgument;
+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: WaterXClient, tx: Transaction, params: DepositCollateralRequestParams): TransactionArgument;
+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: WaterXClient, tx: Transaction, params: WithdrawCollateralRequestParams): TransactionArgument;
+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: WaterXClient, tx: Transaction, params: ExecuteTradingParams): void;
+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: WaterXClient, tx: Transaction, params: LiquidateParams): void;
+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: WaterXClient, tx: Transaction, params: BatchLiquidateParams): void;
+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. */
@@ -88,14 +88,14 @@ export interface MatchOrdersParams extends TradingTypeArgs {
     maxFills: bigint | number;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function matchOrders(client: WaterXClient, tx: Transaction, params: MatchOrdersParams): void;
+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: WaterXClient, tx: Transaction, params: UpdateFundingRateParams): void;
+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). */
@@ -108,12 +108,12 @@ export interface OpenPositionByKeeperParams extends TradingTypeArgs {
     acceptablePrice: bigint | number;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function openPositionByKeeper(client: WaterXClient, tx: Transaction, params: OpenPositionByKeeperParams): void;
+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: WaterXClient, tx: Transaction, params: ClosePositionByKeeperParams): void;
+export declare function closePositionByKeeper(client: PerpClient, tx: Transaction, params: ClosePositionByKeeperParams): void;
 export declare const ORDER_TAG_WILDCARD_VALUE = 255;

package/dist/src/{user → perp/user}/trading.js

@@ -10,9 +10,9 @@
  * `updateFundingRate`, `openByKeeper`, `closeByKeeper`) are single-call:
  * they do the work inline and return `()`.
  */
+import { makeSenderRequest } from "../../account/account-request.js";
+import * as trading from "../../generated/waterx_perp/trading.js";
 import { ORDER_TAG_WILDCARD } from "../constants.js";
-import * as trading from "../generated/waterx_perp/trading.js";
-import { makeSenderRequest } from "../utils/account-request.js";
 function typeArgs(client, t) {
     return [t.collateralType, t.lpType ?? client.wlpType()];
 }

package/dist/src/{user → perp/user}/wlp.d.ts

@@ -6,11 +6,11 @@
  * account (use `requestDeposit` from `./account.ts`).
  *
  * `mintWlp` / `settleRedeem` require fresh oracle prices; call
- * `refreshOraclePrices` (see `utils/pyth.ts`) for every pool token
+ * `refreshOraclePrices` (see `oracle/`) for every pool token
  * before invoking these builders in the same PTB.
  */
 import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
-import type { WaterXClient } from "../client.ts";
+import type { PerpClient } from "../client.ts";
 export interface MintWlpParams {
     /** wxa account holding the input balance and receiving the minted WLP. */
     accountId: string;
@@ -25,7 +25,7 @@ export interface MintWlpParams {
     bucketAccount?: string | TransactionArgument;
 }
 /** Returns the minted `lp_amount` so it can be chained into e.g. `stake`. */
-export declare function mintWlp(client: WaterXClient, tx: Transaction, params: MintWlpParams): TransactionArgument;
+export declare function mintWlp(client: PerpClient, tx: Transaction, params: MintWlpParams): TransactionArgument;
 export interface RequestRedeemWlpParams {
     accountId: string;
     /** Defaults to `client.wlpType()`. */
@@ -36,13 +36,13 @@ export interface RequestRedeemWlpParams {
     lpAmount: bigint | number;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function requestRedeemWlp(client: WaterXClient, tx: Transaction, params: RequestRedeemWlpParams): void;
+export declare function requestRedeemWlp(client: PerpClient, tx: Transaction, params: RequestRedeemWlpParams): void;
 export interface CancelRedeemWlpParams {
     requestId: bigint | number;
     lpType?: string;
     bucketAccount?: string | TransactionArgument;
 }
-export declare function cancelRedeemWlp(client: WaterXClient, tx: Transaction, params: CancelRedeemWlpParams): void;
+export declare function cancelRedeemWlp(client: PerpClient, tx: Transaction, params: CancelRedeemWlpParams): void;
 export interface SettleRedeemWlpParams {
     requestId: bigint | number;
     redeemTokenType: string;
@@ -50,9 +50,9 @@ export interface SettleRedeemWlpParams {
     /** Optional Bucket Account for the operator caller. */
     bucketAccount?: string | TransactionArgument;
 }
-export declare function settleRedeemWlp(client: WaterXClient, tx: Transaction, params: SettleRedeemWlpParams): void;
+export declare function settleRedeemWlp(client: PerpClient, tx: Transaction, params: SettleRedeemWlpParams): void;
 /** Recompute one token pool's TVL using the current Oracle price. */
-export declare function updateTokenValue(client: WaterXClient, tx: Transaction, args: {
+export declare function updateTokenValue(client: PerpClient, tx: Transaction, args: {
     tokenType: string;
     lpType?: string;
 }): void;

package/dist/src/{user → perp/user}/wlp.js

@@ -6,11 +6,11 @@
  * account (use `requestDeposit` from `./account.ts`).
  *
  * `mintWlp` / `settleRedeem` require fresh oracle prices; call
- * `refreshOraclePrices` (see `utils/pyth.ts`) for every pool token
+ * `refreshOraclePrices` (see `oracle/`) for every pool token
  * before invoking these builders in the same PTB.
  */
-import * as lp from "../generated/waterx_perp/lp_pool.js";
-import { makeSenderRequest } from "../utils/account-request.js";
+import { makeSenderRequest } from "../../account/account-request.js";
+import * as lp from "../../generated/waterx_perp/lp_pool.js";
 /** Returns the minted `lp_amount` so it can be chained into e.g. `stake`. */
 export function mintWlp(client, tx, params) {
     const req = makeSenderRequest(client, tx, params.bucketAccount);