@waterx/sdk 2.1.0

package/dist/src/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 { WaterXClient } 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: WaterXClient, 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: WaterXClient, 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 interface DepositCollateralRequestParams extends CommonTradingParams {
+    positionId: bigint | number;
+    collateralAmount: bigint | number;
+}
+export declare function depositCollateralRequest(client: WaterXClient, 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 interface ExecuteTradingParams extends TradingTypeArgs {
+    ticker: string;
+    request: TransactionArgument;
+}
+export declare function executeTrading(client: WaterXClient, 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 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 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: WaterXClient, 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 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: WaterXClient, 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 const ORDER_TAG_WILDCARD_VALUE = 255;

package/dist/src/user/trading.js

@@ -0,0 +1,262 @@
+/**
+ * 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 { 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()];
+}
+function commonObjects(client) {
+    const perp = client.config.packages.waterx_perp;
+    return {
+        perpPackage: perp.published_at,
+        globalConfig: perp.global_config,
+        wxaRegistry: client.config.packages.waterx_account.account_registry,
+        marketRegistry: perp.market_registry_wlp,
+        wlpPool: client.config.packages.wlp.wlp_pool,
+        oracle: client.config.packages.waterx_oracle.oracle,
+    };
+}
+export function closePositionRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    const [tr] = trading.closePositionRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            positionId: params.positionId,
+            acceptablePrice: params.acceptablePrice,
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+    return tr;
+}
+export function increasePositionRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    const [tr] = trading.increasePositionRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            orderId: params.orderId ?? null,
+            positionId: params.positionId,
+            collateralAmount: params.collateralAmount,
+            size: params.size,
+            acceptablePrice: params.acceptablePrice,
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+    return tr;
+}
+export function decreasePositionRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    const [tr] = trading.decreasePositionRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            positionId: params.positionId,
+            size: params.size,
+            acceptablePrice: params.acceptablePrice,
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+    return tr;
+}
+export function depositCollateralRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    const [tr] = trading.depositCollateralRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            positionId: params.positionId,
+            collateralAmount: params.collateralAmount,
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+    return tr;
+}
+export function withdrawCollateralRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    const [tr] = trading.withdrawCollateralRequest({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            senderRequest: req,
+            accountId: params.accountId,
+            positionId: params.positionId,
+            amount: params.amount,
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+    return tr;
+}
+export function executeTrading(client, tx, params) {
+    const obj = commonObjects(client);
+    trading.execute({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            pool: tx.object(obj.wlpPool),
+            req: params.request,
+            oracle: tx.object(obj.oracle),
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+}
+export function liquidate(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    trading.liquidate({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            pool: tx.object(obj.wlpPool),
+            senderRequest: req,
+            positionId: params.positionId,
+            oracle: tx.object(obj.oracle),
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+}
+export function batchLiquidate(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    trading.batchLiquidate({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            pool: tx.object(obj.wlpPool),
+            senderRequest: req,
+            oracle: tx.object(obj.oracle),
+            pageSize: params.pageSize,
+            pageIndex: params.pageIndex,
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+}
+export function matchOrders(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    trading.matchOrders({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            pool: tx.object(obj.wlpPool),
+            senderRequest: req,
+            oracle: tx.object(obj.oracle),
+            orderTypeTag: params.orderTypeTag,
+            triggerPrice: params.triggerPrice,
+            maxFills: params.maxFills,
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+}
+export function updateFundingRate(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    trading.updateFundingRate({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            pool: tx.object(obj.wlpPool),
+            oracle: tx.object(obj.oracle),
+            senderRequest: req,
+        },
+        typeArguments: [params.lpType ?? client.wlpType()],
+    })(tx);
+}
+export function openPositionByKeeper(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    trading.openPositionByKeeper({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            pool: tx.object(obj.wlpPool),
+            keeperRequest: req,
+            accountObjectAddress: params.accountObjectAddress,
+            collateralCoin: params.collateralCoin,
+            isLong: params.isLong,
+            size: params.size,
+            acceptablePrice: params.acceptablePrice,
+            oracle: tx.object(obj.oracle),
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+}
+export function closePositionByKeeper(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    trading.closePositionByKeeper({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            globalConfig: tx.object(obj.globalConfig),
+            wxaRegistry: tx.object(obj.wxaRegistry),
+            marketRegistry: tx.object(obj.marketRegistry),
+            ticker: params.ticker,
+            pool: tx.object(obj.wlpPool),
+            keeperRequest: req,
+            positionId: params.positionId,
+            acceptablePrice: params.acceptablePrice,
+            oracle: tx.object(obj.oracle),
+        },
+        typeArguments: typeArgs(client, params),
+    })(tx);
+}
+// ============================================================================
+// Cancel order wildcard helper (re-exported for symmetry with v2)
+// ============================================================================
+export const ORDER_TAG_WILDCARD_VALUE = ORDER_TAG_WILDCARD;

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

@@ -0,0 +1,58 @@
+/**
+ * WLP pool builders for `waterx_perp::lp_pool`.
+ *
+ * Auth + collateral flow goes through `waterx_account::take`/`put` —
+ * the user must have already deposited the input asset into their wxa
+ * account (use `requestDeposit` from `./account.ts`).
+ *
+ * `mintWlp` / `settleRedeem` require fresh oracle prices; call
+ * `refreshOraclePrices` (see `utils/pyth.ts`) 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";
+export interface MintWlpParams {
+    /** wxa account holding the input balance and receiving the minted WLP. */
+    accountId: string;
+    /** Input asset coin type (e.g. USDC). */
+    depositTokenType: string;
+    /** Defaults to `client.wlpType()`. */
+    lpType?: string;
+    /** Amount of `depositTokenType` to draw from the wxa account. */
+    depositAmount: bigint | number;
+    /** Slippage floor for minted LP amount. */
+    minLpAmount: bigint | number;
+    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 interface RequestRedeemWlpParams {
+    accountId: string;
+    /** Defaults to `client.wlpType()`. */
+    lpType?: string;
+    /** Token type to settle the redeem into (must match `lp_pool` settings). */
+    redeemTokenType: string;
+    /** Amount of LP tokens to enqueue. */
+    lpAmount: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function requestRedeemWlp(client: WaterXClient, 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 interface SettleRedeemWlpParams {
+    requestId: bigint | number;
+    redeemTokenType: string;
+    lpType?: string;
+    /** Optional Bucket Account for the operator caller. */
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function settleRedeemWlp(client: WaterXClient, 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: {
+    tokenType: string;
+    lpType?: string;
+}): void;

package/dist/src/user/wlp.js

@@ -0,0 +1,99 @@
+/**
+ * WLP pool builders for `waterx_perp::lp_pool`.
+ *
+ * Auth + collateral flow goes through `waterx_account::take`/`put` —
+ * the user must have already deposited the input asset into their wxa
+ * account (use `requestDeposit` from `./account.ts`).
+ *
+ * `mintWlp` / `settleRedeem` require fresh oracle prices; call
+ * `refreshOraclePrices` (see `utils/pyth.ts`) 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";
+/** 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);
+    const lpAmount = lp.mintWlp({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            aum: tx.object(requireWlpAum(client)),
+            senderRequest: req,
+            accountId: params.accountId,
+            depositAmount: params.depositAmount,
+            minLpAmount: params.minLpAmount,
+            oracle: tx.object(client.config.packages.waterx_oracle.oracle),
+        },
+        typeArguments: [params.lpType ?? client.wlpType(), params.depositTokenType],
+    })(tx);
+    return lpAmount;
+}
+function requireWlpAum(client) {
+    const aum = client.config.packages.wlp.wlp_aum;
+    if (!aum) {
+        throw new Error("wlp.wlp_aum is not configured — mintWlp/settleRedeem require WlpAum");
+    }
+    return aum;
+}
+export function requestRedeemWlp(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    lp.requestRedeem({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            lpAmount: params.lpAmount,
+        },
+        typeArguments: [params.lpType ?? client.wlpType(), params.redeemTokenType],
+    })(tx);
+}
+export function cancelRedeemWlp(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    lp.cancelRedeem({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            requestId: params.requestId,
+        },
+        typeArguments: [params.lpType ?? client.wlpType()],
+    })(tx);
+}
+export function settleRedeemWlp(client, tx, params) {
+    const req = makeSenderRequest(client, tx, params.bucketAccount);
+    lp.settleRedeem({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            globalConfig: tx.object(client.config.packages.waterx_perp.global_config),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            operatorRequest: req,
+            aum: tx.object(requireWlpAum(client)),
+            requestId: params.requestId,
+            oracle: tx.object(client.config.packages.waterx_oracle.oracle),
+        },
+        typeArguments: [params.lpType ?? client.wlpType(), params.redeemTokenType],
+    })(tx);
+}
+// ============================================================================
+// update_token_value (housekeeping — refresh per-token TVL)
+// ============================================================================
+/** Recompute one token pool's TVL using the current Oracle price. */
+export function updateTokenValue(client, tx, args) {
+    lp.updateTokenValue({
+        package: client.config.packages.waterx_perp.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            oracle: tx.object(client.config.packages.waterx_oracle.oracle),
+        },
+        typeArguments: [args.lpType ?? client.wlpType(), args.tokenType],
+    })(tx);
+}

package/dist/src/utils/account-request.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Helper for building `bucket_v2_framework::account::AccountRequest` (or
+ * `request_with_account`) with the configured `bucket_framework` package id
+ * injected. Used by every user/* builder to authenticate the caller.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { WaterXClient } from "../client.ts";
+export type BucketAccount = string | TransactionArgument | undefined;
+export declare function makeSenderRequest(client: WaterXClient, tx: Transaction, bucketAccount: BucketAccount): TransactionArgument;

package/dist/src/utils/account-request.js

@@ -0,0 +1,17 @@
+/**
+ * Helper for building `bucket_v2_framework::account::AccountRequest` (or
+ * `request_with_account`) with the configured `bucket_framework` package id
+ * injected. Used by every user/* builder to authenticate the caller.
+ */
+import { request as accountRequest, requestWithAccount as accountRequestWithAccount, } from "../generated/bucket_v2_framework/account.js";
+export function makeSenderRequest(client, tx, bucketAccount) {
+    const pkg = client.config.packages.bucket_framework.published_at;
+    if (bucketAccount === undefined) {
+        return accountRequest({ package: pkg })(tx);
+    }
+    const accArg = typeof bucketAccount === "string" ? tx.object(bucketAccount) : bucketAccount;
+    return accountRequestWithAccount({
+        package: pkg,
+        arguments: { account: accArg },
+    })(tx);
+}

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

@@ -0,0 +1,11 @@
+import type { WaterXConfig } from "../config.ts";
+/** Returns all registered market tickers (e.g. "BTCUSD") from waterx-config. */
+export declare function getMarketTickers(config: WaterXConfig): string[];
+/**
+ * Returns WLP pool-token tickers that also have a registered pyth_rule feed —
+ * the canonical testnet config keys `pool_tokens` by coin symbol (e.g. `"USD"`)
+ * while `pyth_rule.feeds` is keyed by oracle ticker (e.g. `"USDCUSD"`), so a
+ * naive `Object.keys(pool_tokens)` blows up at `refreshOraclePrices` for any
+ * key without a feed. Filter so the auto-refresh path stays tolerant.
+ */
+export declare function getCollateralAssets(config: WaterXConfig): string[];

package/dist/src/utils/config.js

@@ -0,0 +1,15 @@
+/** Returns all registered market tickers (e.g. "BTCUSD") from waterx-config. */
+export function getMarketTickers(config) {
+    return Object.keys(config.packages.waterx_perp.markets);
+}
+/**
+ * Returns WLP pool-token tickers that also have a registered pyth_rule feed —
+ * the canonical testnet config keys `pool_tokens` by coin symbol (e.g. `"USD"`)
+ * while `pyth_rule.feeds` is keyed by oracle ticker (e.g. `"USDCUSD"`), so a
+ * naive `Object.keys(pool_tokens)` blows up at `refreshOraclePrices` for any
+ * key without a feed. Filter so the auto-refresh path stays tolerant.
+ */
+export function getCollateralAssets(config) {
+    const feeds = config.packages.pyth_rule?.feeds ?? {};
+    return Object.keys(config.packages.wlp.pool_tokens).filter((t) => feeds[t] !== undefined);
+}