@waterx/sdk 2.1.0

package/dist/src/user/custody.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Builders for `native_custody::custody_vault` — the Sui-native PSM that
+ * mints the protocol CREDIT CoinType 1:1 against backing stable assets `T`
+ * (CCTP USDC, USDT, …) and burns it back the other way.
+ *
+ * `mintCredit` / `mintCreditFromRequest` return a `DepositRequest<CREDIT>`
+ * hot potato — it must be consumed in the same PTB by the deposit policy
+ * registered for CREDIT (the canonical policy is `direct_rule::DirectRule`).
+ * `mintCreditToAccount` chains that consume for you.
+ *
+ * `burnCredit` returns the redeemed `Coin<T>`; the caller decides where it
+ * goes (transfer, fold back into a wxa account, …).
+ *
+ * Requires `waterx_credit` + `native_custody` in the loaded config — both
+ * are optional in `WaterXConfig` since not every deployment ships the
+ * credit pipeline.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { WaterXClient } from "../client.ts";
+export interface MintCreditParams {
+    /** wxa account ID the minted CREDIT is deposited into (also the partner-fee key). */
+    accountId: string;
+    /** `Coin<T>` of the backing asset to convert. */
+    assetCoin: TransactionArgument;
+    /** Fully-qualified backing-asset Move type `T` (must be registered on the vault). */
+    assetType: string;
+    /** CREDIT CoinType. Defaults to `client.creditType()`. */
+    creditType?: string;
+    /** Opaque bytes forwarded onto the returned `DepositRequest<CREDIT>`. */
+    extraData?: Uint8Array;
+}
+/**
+ * Build `custody_vault::mint<T, CREDIT>`. Returns the `DepositRequest<CREDIT>`
+ * argument — consume it in the same PTB (see `mintCreditToAccount`).
+ */
+export declare function mintCredit(client: WaterXClient, tx: Transaction, params: MintCreditParams): TransactionArgument;
+export interface MintCreditFromRequestParams {
+    /** `DepositRequest<T>` from `account::request_deposit<T>` (T must have `NativeCustody` as its deposit policy). */
+    depositRequest: TransactionArgument;
+    /** Fully-qualified backing-asset Move type `T`. */
+    assetType: string;
+    /** CREDIT CoinType. Defaults to `client.creditType()`. */
+    creditType?: string;
+}
+/**
+ * Build `custody_vault::mint_from_request<T, CREDIT>`. The returned
+ * `DepositRequest<CREDIT>` inherits the input request's `accountId` /
+ * `extraData`. Consume it in the same PTB.
+ */
+export declare function mintCreditFromRequest(client: WaterXClient, tx: Transaction, params: MintCreditFromRequestParams): TransactionArgument;
+/**
+ * `mintCredit` followed by `direct_rule::consume_deposit_direct<CREDIT>`, so
+ * the freshly minted CREDIT settles straight into `accountId`'s wxa balance.
+ * Assumes CREDIT's deposit policy is `DirectRule` (the canonical setup).
+ */
+export declare function mintCreditToAccount(client: WaterXClient, tx: Transaction, params: MintCreditParams): void;
+export interface BurnCreditParams {
+    /** wxa account ID the burned CREDIT belongs to (burn-cap + partner-fee key). */
+    accountId: string;
+    /** `Coin<CREDIT>` to redeem. */
+    creditCoin: TransactionArgument;
+    /** Fully-qualified backing-asset Move type `T` to redeem into. */
+    assetType: string;
+    /** CREDIT CoinType. Defaults to `client.creditType()`. */
+    creditType?: string;
+}
+/**
+ * Build `custody_vault::burn<T, CREDIT>`. Returns the redeemed `Coin<T>`
+ * argument for the caller to forward.
+ */
+export declare function burnCredit(client: WaterXClient, tx: Transaction, params: BurnCreditParams): TransactionArgument;

package/dist/src/user/custody.js

@@ -0,0 +1,112 @@
+/**
+ * Builders for `native_custody::custody_vault` — the Sui-native PSM that
+ * mints the protocol CREDIT CoinType 1:1 against backing stable assets `T`
+ * (CCTP USDC, USDT, …) and burns it back the other way.
+ *
+ * `mintCredit` / `mintCreditFromRequest` return a `DepositRequest<CREDIT>`
+ * hot potato — it must be consumed in the same PTB by the deposit policy
+ * registered for CREDIT (the canonical policy is `direct_rule::DirectRule`).
+ * `mintCreditToAccount` chains that consume for you.
+ *
+ * `burnCredit` returns the redeemed `Coin<T>`; the caller decides where it
+ * goes (transfer, fold back into a wxa account, …).
+ *
+ * Requires `waterx_credit` + `native_custody` in the loaded config — both
+ * are optional in `WaterXConfig` since not every deployment ships the
+ * credit pipeline.
+ */
+import * as custody from "../generated/native_custody/custody_vault.js";
+import { consumeDepositDirect } from "../generated/waterx_account/direct_rule.js";
+function requireCredit(client) {
+    const credit = client.config.packages.waterx_credit;
+    if (!credit?.credit_registry) {
+        throw new Error("waterx_credit is not configured — set packages.waterx_credit.credit_registry");
+    }
+    return { credit_registry: credit.credit_registry };
+}
+function requireCustody(client) {
+    const nc = client.config.packages.native_custody;
+    if (!nc?.vault) {
+        throw new Error("native_custody is not configured — set packages.native_custody.vault");
+    }
+    return { published_at: nc.published_at, vault: nc.vault };
+}
+/**
+ * Build `custody_vault::mint<T, CREDIT>`. Returns the `DepositRequest<CREDIT>`
+ * argument — consume it in the same PTB (see `mintCreditToAccount`).
+ */
+export function mintCredit(client, tx, params) {
+    const credit = requireCredit(client);
+    const nc = requireCustody(client);
+    const [req] = custody.mint({
+        package: nc.published_at,
+        arguments: {
+            vault: tx.object(nc.vault),
+            registry: tx.object(credit.credit_registry),
+            accountRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            assetCoin: params.assetCoin,
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.assetType, params.creditType ?? client.creditType()],
+    })(tx);
+    return req;
+}
+/**
+ * Build `custody_vault::mint_from_request<T, CREDIT>`. The returned
+ * `DepositRequest<CREDIT>` inherits the input request's `accountId` /
+ * `extraData`. Consume it in the same PTB.
+ */
+export function mintCreditFromRequest(client, tx, params) {
+    const credit = requireCredit(client);
+    const nc = requireCustody(client);
+    const [req] = custody.mintFromRequest({
+        package: nc.published_at,
+        arguments: {
+            vault: tx.object(nc.vault),
+            registry: tx.object(credit.credit_registry),
+            accountRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            depositRequest: params.depositRequest,
+        },
+        typeArguments: [params.assetType, params.creditType ?? client.creditType()],
+    })(tx);
+    return req;
+}
+// ============================================================================
+// mint + consume — credit lands directly in the wxa account
+// ============================================================================
+/**
+ * `mintCredit` followed by `direct_rule::consume_deposit_direct<CREDIT>`, so
+ * the freshly minted CREDIT settles straight into `accountId`'s wxa balance.
+ * Assumes CREDIT's deposit policy is `DirectRule` (the canonical setup).
+ */
+export function mintCreditToAccount(client, tx, params) {
+    const req = mintCredit(client, tx, params);
+    consumeDepositDirect({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            req: req,
+        },
+        typeArguments: [params.creditType ?? client.creditType()],
+    })(tx);
+}
+/**
+ * Build `custody_vault::burn<T, CREDIT>`. Returns the redeemed `Coin<T>`
+ * argument for the caller to forward.
+ */
+export function burnCredit(client, tx, params) {
+    const credit = requireCredit(client);
+    const nc = requireCustody(client);
+    const [coin] = custody.burn({
+        package: nc.published_at,
+        arguments: {
+            vault: tx.object(nc.vault),
+            registry: tx.object(credit.credit_registry),
+            accountId: params.accountId,
+            creditCoin: params.creditCoin,
+        },
+        typeArguments: [params.assetType, params.creditType ?? client.creditType()],
+    })(tx);
+    return coin;
+}

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

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

package/dist/src/user/index.js

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

package/dist/src/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 { WaterXClient } 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: WaterXClient, 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: WaterXClient, 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: WaterXClient, 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: WaterXClient, 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: WaterXClient, 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: WaterXClient, tx: Transaction, params: AddPreOrderRequestParams): TransactionArgument;

package/dist/src/user/order.js

@@ -0,0 +1,134 @@
+/**
+ * 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 { 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: 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. */
+export function placeOrderRequest(client, tx, params) {
+    const req = 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;
+}
+export function cancelOrderRequest(client, tx, params) {
+    const req = 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 ?? ORDER_TAG_WILDCARD,
+        },
+        typeArguments: [params.collateralType, params.lpType ?? client.wlpType()],
+    })(tx);
+    return tr;
+}
+export function updateOrderRequest(client, tx, params) {
+    const req = 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;
+}
+export function cancelPreOrderRequest(client, tx, params) {
+    const req = 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;
+}
+export function addPreOrderRequest(client, tx, params) {
+    const req = 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/src/user/referral.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Referral builders — backed by the standalone `waterx_referral` package.
+ * Requires
+ * `config.packages.waterx_referral.{published_at,referral_table}` to be
+ * populated; otherwise the builder throws so misconfigured deployments fail
+ * loudly instead of silently aborting on-chain.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { WaterXClient } from "../client.ts";
+export interface SetReferralCodeParams {
+    /** Referral code string the caller wants to claim. */
+    code: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function setReferralCode(client: WaterXClient, tx: Transaction, params: SetReferralCodeParams): void;
+export interface UseReferralCodeParams {
+    /** Referral code to bind to the caller's address. */
+    code: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function useReferralCode(client: WaterXClient, tx: Transaction, params: UseReferralCodeParams): void;

package/dist/src/user/referral.js

@@ -0,0 +1,41 @@
+/**
+ * Referral builders — backed by the standalone `waterx_referral` package.
+ * Requires
+ * `config.packages.waterx_referral.{published_at,referral_table}` to be
+ * populated; otherwise the builder throws so misconfigured deployments fail
+ * loudly instead of silently aborting on-chain.
+ */
+import * as referral from "../generated/waterx_referral/referral_table.js";
+import { makeSenderRequest } from "../utils/account-request.js";
+function requireReferralConfig(client) {
+    const pkg = client.config.packages.waterx_referral?.published_at;
+    const table = client.config.packages.waterx_referral?.referral_table;
+    if (!pkg || !table) {
+        throw new Error("referral package not configured: set config.packages.waterx_referral.{published_at,referral_table}");
+    }
+    return { pkg, table };
+}
+export function setReferralCode(client, tx, params) {
+    const { pkg, table } = requireReferralConfig(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    referral.setReferralCode({
+        package: pkg,
+        arguments: {
+            table: tx.object(table),
+            req: req,
+            code: params.code,
+        },
+    })(tx);
+}
+export function useReferralCode(client, tx, params) {
+    const { pkg, table } = requireReferralConfig(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    referral.useReferralCode({
+        package: pkg,
+        arguments: {
+            table: tx.object(table),
+            req: req,
+            code: params.code,
+        },
+    })(tx);
+}

package/dist/src/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 { WaterXClient } 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: WaterXClient, 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: WaterXClient, 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: WaterXClient, tx: Transaction, params: ClaimRewardParams): void;

package/dist/src/user/staking.js

@@ -0,0 +1,109 @@
+/**
+ * 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 * as staking from "../generated/waterx_staking/waterx_staking.js";
+import { makeSenderRequest } from "../utils/account-request.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;
+}
+export function stake(client, tx, params) {
+    const pkg = stakingPackage(client);
+    const poolId = pool(client, params.stakeAlias);
+    const req = 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);
+}
+export function unstake(client, tx, params) {
+    const pkg = stakingPackage(client);
+    const poolId = pool(client, params.stakeAlias);
+    const req = 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);
+}
+export function claimReward(client, tx, params) {
+    const pkg = stakingPackage(client);
+    const poolId = pool(client, params.stakeAlias);
+    const req = 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);
+}