@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * 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 `()`.
+ */
+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.ORDER_TAG_WILDCARD_VALUE = void 0;
+exports.closePositionRequest = closePositionRequest;
+exports.increasePositionRequest = increasePositionRequest;
+exports.decreasePositionRequest = decreasePositionRequest;
+exports.depositCollateralRequest = depositCollateralRequest;
+exports.withdrawCollateralRequest = withdrawCollateralRequest;
+exports.executeTrading = executeTrading;
+exports.liquidate = liquidate;
+exports.batchLiquidate = batchLiquidate;
+exports.matchOrders = matchOrders;
+exports.updateFundingRate = updateFundingRate;
+exports.openPositionByKeeper = openPositionByKeeper;
+exports.closePositionByKeeper = closePositionByKeeper;
+const account_request_ts_1 = require("../../account/account-request.js");
+const trading = __importStar(require("../../generated/waterx_perp/trading.js"));
+const constants_ts_1 = require("../constants.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,
+    };
+}
+function closePositionRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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;
+}
+function increasePositionRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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;
+}
+function decreasePositionRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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;
+}
+function depositCollateralRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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;
+}
+function withdrawCollateralRequest(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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;
+}
+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);
+}
+function liquidate(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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);
+}
+function batchLiquidate(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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);
+}
+function matchOrders(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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);
+}
+function updateFundingRate(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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);
+}
+function openPositionByKeeper(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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);
+}
+function closePositionByKeeper(client, tx, params) {
+    const obj = commonObjects(client);
+    const req = (0, account_request_ts_1.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)
+// ============================================================================
+exports.ORDER_TAG_WILDCARD_VALUE = constants_ts_1.ORDER_TAG_WILDCARD;

package/dist/cjs/src/perp/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 `oracle/`) for every pool token
+ * before invoking these builders in the same PTB.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { PerpClient } 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: PerpClient, 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: PerpClient, tx: Transaction, params: RequestRedeemWlpParams): void;
+export interface CancelRedeemWlpParams {
+    requestId: bigint | number;
+    lpType?: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function cancelRedeemWlp(client: PerpClient, 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: PerpClient, tx: Transaction, params: SettleRedeemWlpParams): void;
+/** Recompute one token pool's TVL using the current Oracle price. */
+export declare function updateTokenValue(client: PerpClient, tx: Transaction, args: {
+    tokenType: string;
+    lpType?: string;
+}): void;

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

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * 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 `oracle/`) for every pool token
+ * before invoking these builders in the same PTB.
+ */
+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.mintWlp = mintWlp;
+exports.requestRedeemWlp = requestRedeemWlp;
+exports.cancelRedeemWlp = cancelRedeemWlp;
+exports.settleRedeemWlp = settleRedeemWlp;
+exports.updateTokenValue = updateTokenValue;
+const account_request_ts_1 = require("../../account/account-request.js");
+const lp = __importStar(require("../../generated/waterx_perp/lp_pool.js"));
+/** Returns the minted `lp_amount` so it can be chained into e.g. `stake`. */
+function mintWlp(client, tx, params) {
+    const req = (0, account_request_ts_1.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;
+}
+function requestRedeemWlp(client, tx, params) {
+    const req = (0, account_request_ts_1.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);
+}
+function cancelRedeemWlp(client, tx, params) {
+    const req = (0, account_request_ts_1.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);
+}
+function settleRedeemWlp(client, tx, params) {
+    const req = (0, account_request_ts_1.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. */
+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/cjs/src/prediction/account.d.ts

@@ -0,0 +1,96 @@
+import { Transaction, type TransactionArgument } from "@mysten/sui/transactions";
+import type { PredictClient } from "./client.ts";
+import type { AccountIdentityParams, CoinRef, IdArgument, ObjectArgument } from "./types.ts";
+export interface AccountBaseParams {
+    accountPackageId?: string;
+    accountRegistry?: string;
+}
+export interface CreateAccountParams extends AccountBaseParams, AccountIdentityParams {
+    alias: string;
+}
+/**
+ * Resolves the registry `0x2::object::ID` used by `request_deposit` / views from an on-chain
+ * `Account` object id (e.g. parsed from transaction effects).
+ */
+export declare function resolveRegistryAccountId(client: PredictClient, accountObjectId: string, params?: AccountBaseParams): Promise<string>;
+export declare function createAccount(client: PredictClient, tx: Transaction, params: CreateAccountParams): TransactionArgument;
+export interface TransferCoinToAccountParams extends AccountBaseParams {
+    accountId: IdArgument;
+    coin: ObjectArgument;
+    coinType?: string;
+}
+export declare function transferCoinToAccount(client: PredictClient, tx: Transaction, params: TransferCoinToAccountParams): Transaction;
+export interface RequestDepositParams extends AccountBaseParams {
+    accountId: IdArgument;
+    coin: ObjectArgument;
+    coinType?: string;
+    extraData?: Uint8Array | number[];
+}
+export declare function requestDeposit(client: PredictClient, tx: Transaction, params: RequestDepositParams): TransactionArgument;
+export interface ConsumeDepositDirectParams extends AccountBaseParams {
+    depositRequest: TransactionArgument;
+    coinType?: string;
+}
+/** Finishes a `request_deposit` hot potato via `direct_rule` (same-coin credit). */
+export declare function consumeDepositDirect(client: PredictClient, tx: Transaction, params: ConsumeDepositDirectParams): Transaction;
+/**
+ * Full deposit: `request_deposit` + `consume_deposit_direct` in one PTB.
+ * Use this for testnet USD unless you implement a custom deposit policy consume path.
+ */
+export declare function deposit(client: PredictClient, tx: Transaction, params: RequestDepositParams): Transaction;
+export interface RequestDepositFromReceivingsParams extends AccountBaseParams {
+    accountId: IdArgument;
+    coins: CoinRef[];
+    coinType?: string;
+    extraData?: Uint8Array | number[];
+}
+export declare function requestDepositFromReceivings(client: PredictClient, tx: Transaction, params: RequestDepositFromReceivingsParams): TransactionArgument;
+export interface RequestWithdrawParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    amount: bigint | number | string;
+    recipient: string;
+    coinType?: string;
+    extraData?: Uint8Array | number[];
+}
+export declare function requestWithdraw(client: PredictClient, tx: Transaction, params: RequestWithdrawParams): TransactionArgument;
+export interface ConsumeWithdrawDirectParams extends AccountBaseParams {
+    withdrawRequest: TransactionArgument;
+    coinType?: string;
+}
+/** Finishes a `request_withdraw` hot potato via `direct_rule` (same-coin payout). */
+export declare function consumeWithdrawDirect(client: PredictClient, tx: Transaction, params: ConsumeWithdrawDirectParams): Transaction;
+/**
+ * Full withdraw: `request_withdraw` + `consume_withdraw_direct` in one PTB.
+ * Use this for testnet USD unless you implement a custom withdraw policy consume path.
+ */
+export declare function withdraw(client: PredictClient, tx: Transaction, params: RequestWithdrawParams): Transaction;
+export interface AddDelegateParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    delegate: string;
+    alias: string;
+    permissions: number;
+    expiresAtMs?: bigint | number | string | null;
+}
+export declare function addDelegate(client: PredictClient, tx: Transaction, params: AddDelegateParams): Transaction;
+export interface RemoveDelegateParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    delegate: string;
+}
+export declare function removeDelegate(client: PredictClient, tx: Transaction, params: RemoveDelegateParams): Transaction;
+export interface SetDelegatePredictionPermissionParams extends AccountBaseParams, AccountIdentityParams {
+    accountId: IdArgument;
+    delegate: string;
+    permissions: number;
+    predictionPackageId?: string;
+}
+export declare function setDelegatePredictionPermission(client: PredictClient, tx: Transaction, params: SetDelegatePredictionPermissionParams): Transaction;
+export interface WhitelistPredictionProtocolParams extends AccountBaseParams {
+    adminCap: ObjectArgument;
+    predictionPackageId?: string;
+}
+export declare function whitelistPredictionProtocol(client: PredictClient, tx: Transaction, params: WhitelistPredictionProtocolParams): Transaction;
+export interface PredictionProtocolAssetParams extends WhitelistPredictionProtocolParams {
+    coinType?: string;
+}
+export declare function allowPredictionProtocolAsset(client: PredictClient, tx: Transaction, params: PredictionProtocolAssetParams): Transaction;
+export declare function disallowPredictionProtocolAsset(client: PredictClient, tx: Transaction, params: PredictionProtocolAssetParams): Transaction;