@waterx/sdk 2.4.1 → 3.0.1

package/dist/src/perp/fetch/bridge.js

@@ -0,0 +1,127 @@
+/**
+ * Bridge reads: `wormhole_bridge` rate-limit / cap snapshot and the
+ * `withdrawal_queue` (Sui → EVM) fee estimate.
+ */
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { bridgeFeeAmount as bridgeFeeAmountCall, bridgeFeeRate as bridgeFeeRateCall, bridgeMinFee as bridgeMinFeeCall, wouldExecuteWormhole as wouldExecuteWormholeCall, } from "../../generated/withdrawal_queue/withdrawal_queue.js";
+import { dailyBurned as dailyBurnedCall, dailyBurnLimit as dailyBurnLimitCall, dailyMinted as dailyMintedCall, dailyMintLimit as dailyMintLimitCall, maxBurnPerTx as maxBurnPerTxCall, maxMintPerTx as maxMintPerTxCall, mintedFor as mintedForCall, paused as pausedCall, personalBurnCapAmount as personalBurnCapAmountCall, personalBurned as personalBurnedCall, } from "../../generated/wormhole_bridge/wormhole_bridge.js";
+import { extractAt, simulateRaw } from "./simulate.js";
+/**
+ * Batched read of the bridge's rate-limit / cap state in a single simulate.
+ * Pass `accountId` to also fetch the per-account burn usage, and `backing`
+ * to also fetch the destination-chain backing (`minted_for`).
+ *
+ * Throws if `wormhole_bridge` (or its `Bridge` object id) is absent from the
+ * canonical config — e.g. on a network where the Sui bridge isn't published.
+ */
+export async function getBridgeLimits(client, args = {}) {
+    const pkg = client.config.packages.wormhole_bridge;
+    if (!pkg?.bridge) {
+        throw new Error("wormhole_bridge is not deployed on this network (no `bridge` object id in config)");
+    }
+    const packageId = pkg.published_at;
+    const bridge = pkg.bridge;
+    const tx = new Transaction();
+    // Fixed-order view calls; indices tracked below.
+    pausedCall({ package: packageId, arguments: { bridge } })(tx); // 0
+    dailyMintLimitCall({ package: packageId, arguments: { bridge } })(tx); // 1
+    dailyMintedCall({ package: packageId, arguments: { bridge } })(tx); // 2
+    maxMintPerTxCall({ package: packageId, arguments: { bridge } })(tx); // 3
+    dailyBurnLimitCall({ package: packageId, arguments: { bridge } })(tx); // 4
+    dailyBurnedCall({ package: packageId, arguments: { bridge } })(tx); // 5
+    maxBurnPerTxCall({ package: packageId, arguments: { bridge } })(tx); // 6
+    personalBurnCapAmountCall({ package: packageId, arguments: { bridge } })(tx); // 7
+    let backingIdx = -1;
+    if (args.backing) {
+        backingIdx = 8;
+        mintedForCall({
+            package: packageId,
+            arguments: {
+                bridge,
+                chainId: args.backing.wormholeChainId,
+                token: Array.from(args.backing.token),
+            },
+        })(tx);
+    }
+    let personalIdx = -1;
+    if (args.accountId) {
+        personalIdx = backingIdx === -1 ? 8 : 9;
+        // Clock (0x6) is auto-injected by the generated wrapper.
+        personalBurnedCall({
+            package: packageId,
+            arguments: { bridge, user: args.accountId },
+        })(tx);
+    }
+    const sim = await simulateRaw(client, tx);
+    const u64At = (i) => BigInt(bcs.u64().parse(extractAt(sim, i)));
+    const view = {
+        paused: bcs.bool().parse(extractAt(sim, 0)),
+        dailyMintLimit: u64At(1),
+        dailyMinted: u64At(2),
+        maxMintPerTx: u64At(3),
+        dailyBurnLimit: u64At(4),
+        dailyBurned: u64At(5),
+        maxBurnPerTx: u64At(6),
+        personalBurnCapAmount: u64At(7),
+    };
+    if (backingIdx >= 0)
+        view.backingMinted = u64At(backingIdx);
+    if (personalIdx >= 0)
+        view.personalBurned = u64At(personalIdx);
+    return view;
+}
+function requireWithdrawalQueue(client) {
+    const wq = client.config.packages.withdrawal_queue;
+    if (!wq?.queue) {
+        throw new Error("withdrawal_queue is not deployed on this network (no `queue` object id in config)");
+    }
+    return { pkg: wq.published_at, queue: wq.queue };
+}
+/**
+ * Estimate the bridge fee for a wormhole (Sui → EVM) CREDIT exit of `amount`
+ * to `evmDestinationChain`, read in a single simulate from the on-chain
+ * `withdrawal_queue` views. The charged fee is
+ * `max(ceil(effectiveRate * amount), effectiveMinFee)`.
+ *
+ * Surface UI off `wouldExecute`, NOT `feeAmount` alone — `feeAmount` is the raw
+ * fee and can equal/exceed `amount` (ceil rounding on a dust entry, or a min-fee
+ * floor larger than the entry), in which case the on-chain exit aborts its
+ * net-zero guard (audit L1). `netAmount` is `0n` whenever `wouldExecute` is
+ * false.
+ *
+ * @param args.amount             CREDIT base units (the bridged coin's smallest unit).
+ * @param args.evmDestinationChain WORMHOLE chain id of the destination EVM.
+ * @param args.creditType         CREDIT coin type; defaults to `client.creditType()`.
+ */
+export async function getBridgeFee(client, args) {
+    const { pkg, queue } = requireWithdrawalQueue(client);
+    const amount = BigInt(args.amount);
+    const common = {
+        package: pkg,
+        typeArguments: [args.creditType ?? client.creditType()],
+    };
+    const chain = args.evmDestinationChain;
+    const tx = new Transaction();
+    // Fixed-order view calls; indices tracked below.
+    bridgeFeeAmountCall({
+        ...common,
+        arguments: { queue, evmDestinationChain: chain, amount },
+    })(tx); // 0
+    wouldExecuteWormholeCall({
+        ...common,
+        arguments: { queue, evmDestinationChain: chain, amount },
+    })(tx); // 1
+    bridgeFeeRateCall({ ...common, arguments: { queue, evmDestinationChain: chain } })(tx); // 2
+    bridgeMinFeeCall({ ...common, arguments: { queue, evmDestinationChain: chain } })(tx); // 3
+    const sim = await simulateRaw(client, tx);
+    const feeAmount = BigInt(bcs.u64().parse(extractAt(sim, 0)));
+    const wouldExecute = bcs.bool().parse(extractAt(sim, 1));
+    return {
+        feeAmount,
+        wouldExecute,
+        effectiveRate: BigInt(bcs.u128().parse(extractAt(sim, 2))),
+        effectiveMinFee: BigInt(bcs.u64().parse(extractAt(sim, 3))),
+        netAmount: wouldExecute ? amount - feeAmount : 0n,
+    };
+}

package/dist/src/perp/fetch/custody.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Native-custody PSM reads (`custody_vault`).
+ */
+import type { PerpClient } from "../client.ts";
+/** Vault-wide native-custody state. */
+export interface CustodyVaultData {
+    /** Total CREDIT minted by the custody vault (`credit_supply`). */
+    creditSupply: bigint;
+}
+/** Reads vault-wide native-custody state via `custody_vault::credit_supply`. */
+export declare function getCustodyVaultData(client: PerpClient): Promise<CustodyVaultData>;
+/** Per-asset native-custody state for one backing asset. */
+export interface CustodyAssetData {
+    /** Whether the asset is registered as a `SingleVault` on the custody vault. */
+    registered: boolean;
+    /** 1e9-scaled default mint fee rate (`0n` when the asset is not registered). */
+    mintFeeRate: bigint;
+    /** 1e9-scaled default burn fee rate (`0n` when the asset is not registered). */
+    burnFeeRate: bigint;
+}
+/**
+ * Reads per-asset native-custody state for backing asset `assetType`.
+ *
+ * Fee rates are the vault's default config — queried with the zero address as
+ * caller, so no partner discount is applied — as 1e9-scaled `Float` values.
+ * When the asset is not registered, returns `registered: false` with `0n` rates.
+ *
+ * Note: the `SingleVault` balance / decimal / backing / min-burn / deprecated
+ * fields are not exposed here — the contract's getters for those return a
+ * `&SingleVault<T>` reference, which a PTB simulate cannot read.
+ */
+export declare function getCustodyAssetData(client: PerpClient, assetType: string): Promise<CustodyAssetData>;

package/dist/src/perp/fetch/custody.js

@@ -0,0 +1,62 @@
+/**
+ * Native-custody PSM reads (`custody_vault`).
+ */
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { burnFeeRate as burnFeeRateCall, creditSupply as creditSupplyCall, hasAsset as hasAssetCall, mintFeeRate as mintFeeRateCall, } from "../../generated/native_custody/custody_vault.js";
+import { DRY_RUN_SENDER } from "../constants.js";
+import { simulateAndExtract } from "./simulate.js";
+function requireCustody(client) {
+    const nc = client.config.packages.native_custody;
+    if (!nc?.vault) {
+        throw new Error("native_custody not configured — set config.packages.native_custody.vault");
+    }
+    return { pkg: nc.published_at, vault: nc.vault, creditType: client.creditType() };
+}
+/** Reads vault-wide native-custody state via `custody_vault::credit_supply`. */
+export async function getCustodyVaultData(client) {
+    const { pkg, vault, creditType } = requireCustody(client);
+    const tx = new Transaction();
+    creditSupplyCall({
+        package: pkg,
+        arguments: { vault: tx.object(vault) },
+        typeArguments: [creditType],
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return { creditSupply: BigInt(bcs.u64().parse(bytes)) };
+}
+/**
+ * Reads per-asset native-custody state for backing asset `assetType`.
+ *
+ * Fee rates are the vault's default config — queried with the zero address as
+ * caller, so no partner discount is applied — as 1e9-scaled `Float` values.
+ * When the asset is not registered, returns `registered: false` with `0n` rates.
+ *
+ * Note: the `SingleVault` balance / decimal / backing / min-burn / deprecated
+ * fields are not exposed here — the contract's getters for those return a
+ * `&SingleVault<T>` reference, which a PTB simulate cannot read.
+ */
+export async function getCustodyAssetData(client, assetType) {
+    const { pkg, vault, creditType } = requireCustody(client);
+    const typeArguments = [assetType, creditType];
+    const hasTx = new Transaction();
+    hasAssetCall({ package: pkg, arguments: { vault: hasTx.object(vault) }, typeArguments })(hasTx);
+    const registered = bcs.bool().parse(await simulateAndExtract(client, hasTx));
+    if (!registered)
+        return { registered: false, mintFeeRate: 0n, burnFeeRate: 0n };
+    const mintTx = new Transaction();
+    mintFeeRateCall({
+        package: pkg,
+        arguments: { vault: mintTx.object(vault), caller: DRY_RUN_SENDER },
+        typeArguments,
+    })(mintTx);
+    const mintFeeRate = BigInt(bcs.u128().parse(await simulateAndExtract(client, mintTx)));
+    const burnTx = new Transaction();
+    burnFeeRateCall({
+        package: pkg,
+        arguments: { vault: burnTx.object(vault), caller: DRY_RUN_SENDER },
+        typeArguments,
+    })(burnTx);
+    const burnFeeRate = BigInt(bcs.u128().parse(await simulateAndExtract(client, burnTx)));
+    return { registered: true, mintFeeRate, burnFeeRate };
+}

package/dist/src/perp/fetch/market.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Market / pool / token-pool / global-config + account-data reads
+ * (`waterx_perp_view`).
+ */
+import { AccountData, GlobalConfigData, MarketData, PoolData, TokenPoolData } from "../../generated/waterx_perp_view/view.ts";
+import type { PerpClient } from "../client.ts";
+export type AccountDataView = ReturnType<typeof AccountData.parse>;
+/**
+ * Look up the registered AccountData for a given wxa account ID.
+ * Returns `undefined` if the account has no perp data slot installed yet
+ * (the slot auto-installs on the first `add_position` / `add_order`).
+ * The underlying view fn returns `Option<AccountData>`.
+ */
+export declare function getAccountData(client: PerpClient, accountId: string): Promise<AccountDataView | undefined>;
+export type MarketDataView = ReturnType<typeof MarketData.parse>;
+export type PoolDataView = ReturnType<typeof PoolData.parse>;
+export type TokenPoolDataView = ReturnType<typeof TokenPoolData.parse>;
+export type GlobalConfigDataView = ReturnType<typeof GlobalConfigData.parse>;
+export declare function getMarketData(client: PerpClient, args: {
+    ticker: string;
+    lpType?: string;
+}): Promise<MarketDataView>;
+export declare function getPoolData(client: PerpClient, args?: {
+    lpType?: string;
+}): Promise<PoolDataView>;
+export declare function getTokenPoolData(client: PerpClient, args: {
+    tokenIndex: bigint | number;
+    lpType?: string;
+}): Promise<TokenPoolDataView>;
+export declare function getGlobalConfigData(client: PerpClient): Promise<GlobalConfigDataView>;

package/dist/src/perp/fetch/market.js

@@ -0,0 +1,68 @@
+/**
+ * Market / pool / token-pool / global-config + account-data reads
+ * (`waterx_perp_view`).
+ */
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { AccountData, accountData as accountDataCall, GlobalConfigData, globalConfigData as globalConfigDataCall, MarketData, marketData as marketDataCall, PoolData, poolData as poolDataCall, TokenPoolData, tokenPoolData as tokenPoolDataCall, } from "../../generated/waterx_perp_view/view.js";
+import { simulateAndExtract, withLp } from "./simulate.js";
+/**
+ * Look up the registered AccountData for a given wxa account ID.
+ * Returns `undefined` if the account has no perp data slot installed yet
+ * (the slot auto-installs on the first `add_position` / `add_order`).
+ * The underlying view fn returns `Option<AccountData>`.
+ */
+export async function getAccountData(client, accountId) {
+    const tx = new Transaction();
+    accountDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId,
+        },
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    const opt = bcs.option(AccountData).parse(bytes);
+    return opt ?? undefined;
+}
+export async function getMarketData(client, args) {
+    const tx = new Transaction();
+    marketDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return MarketData.parse(await simulateAndExtract(client, tx));
+}
+export async function getPoolData(client, args = {}) {
+    const tx = new Transaction();
+    poolDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: { pool: tx.object(client.config.packages.wlp.wlp_pool) },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return PoolData.parse(await simulateAndExtract(client, tx));
+}
+export async function getTokenPoolData(client, args) {
+    const tx = new Transaction();
+    tokenPoolDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            tokenIndex: args.tokenIndex,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return TokenPoolData.parse(await simulateAndExtract(client, tx));
+}
+export async function getGlobalConfigData(client) {
+    const tx = new Transaction();
+    globalConfigDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: { cfg: tx.object(client.config.packages.waterx_perp.global_config) },
+    })(tx);
+    return GlobalConfigData.parse(await simulateAndExtract(client, tx));
+}

package/dist/src/perp/fetch/positions.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Position / order reads + paginated market & account lists + redeem-request
+ * list (`waterx_perp_view`).
+ */
+import { OrderData, PositionData, RedeemRequestData } from "../../generated/waterx_perp_view/view.ts";
+import type { PerpClient } from "../client.ts";
+export type PositionDataView = ReturnType<typeof PositionData.parse>;
+export declare function positionExists(client: PerpClient, args: {
+    ticker: string;
+    positionId: bigint | number;
+    lpType?: string;
+}): Promise<boolean>;
+export declare function getPosition(client: PerpClient, args: {
+    ticker: string;
+    positionId: bigint | number;
+    /** Human-readable USD prices for Pnl / liq price calc; pass 0n if unsure. */
+    basePriceUsd: bigint | number;
+    collateralPriceUsd: bigint | number;
+    lpType?: string;
+}): Promise<PositionDataView>;
+export type OrderDataView = ReturnType<typeof OrderData.parse>;
+export declare function getOrder(client: PerpClient, args: {
+    ticker: string;
+    orderId: bigint | number;
+    orderTypeTag: number;
+    triggerPrice: bigint | number;
+    basePriceUsd: bigint | number;
+    lpType?: string;
+}): Promise<OrderDataView>;
+export interface PageOpts {
+    cursor?: bigint | number;
+    pageSize?: bigint | number;
+}
+export declare function getMarketOrders(client: PerpClient, args: {
+    ticker: string;
+    basePriceUsd?: bigint | number;
+    lpType?: string;
+} & PageOpts): Promise<{
+    orders: OrderDataView[];
+    nextCursor?: bigint;
+}>;
+export declare function getMarketPositions(client: PerpClient, args: {
+    ticker: string;
+    basePriceUsd: bigint | number;
+    collateralPriceUsd?: bigint | number;
+    lpType?: string;
+} & PageOpts): Promise<{
+    positions: PositionDataView[];
+    nextCursor?: bigint;
+}>;
+export declare function getAccountPositions(client: PerpClient, args: {
+    ticker: string;
+    accountObjectAddress: string;
+    basePriceUsd: bigint | number;
+    collateralPriceUsd?: bigint | number;
+    lpType?: string;
+}): Promise<PositionDataView[]>;
+export declare function getAccountOrders(client: PerpClient, args: {
+    ticker: string;
+    accountObjectAddress: string;
+    basePriceUsd?: bigint | number;
+    lpType?: string;
+}): Promise<OrderDataView[]>;
+export type RedeemRequestDataView = ReturnType<typeof RedeemRequestData.parse>;
+export declare function getRedeemRequests(client: PerpClient, args?: {
+    lpType?: string;
+} & PageOpts): Promise<{
+    requests: RedeemRequestDataView[];
+    nextCursor?: bigint;
+}>;

package/dist/src/perp/fetch/positions.js

@@ -0,0 +1,185 @@
+/**
+ * Position / order reads + paginated market & account lists + redeem-request
+ * list (`waterx_perp_view`).
+ */
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { getAccountOrders as getAccountOrdersCall, getAccountPositions as getAccountPositionsCall, getMarketOrders as getMarketOrdersCall, getMarketPositions as getMarketPositionsCall, getRedeemRequests as getRedeemRequestsCall, OrderData, orderData as orderDataCall, PositionData, positionData as positionDataCall, positionExists as positionExistsCall, RedeemRequestData, } from "../../generated/waterx_perp_view/view.js";
+import { DRY_RUN_SENDER } from "../constants.js";
+import { simulateAndExtract, toBytes, withLp } from "./simulate.js";
+export async function positionExists(client, args) {
+    const tx = new Transaction();
+    positionExistsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            positionId: args.positionId,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return bcs.bool().parse(bytes);
+}
+export async function getPosition(client, args) {
+    const tx = new Transaction();
+    positionDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            basePriceUsd: args.basePriceUsd,
+            collateralPriceUsd: args.collateralPriceUsd,
+            positionId: args.positionId,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return PositionData.parse(await simulateAndExtract(client, tx));
+}
+export async function getOrder(client, args) {
+    const tx = new Transaction();
+    orderDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            basePriceUsd: args.basePriceUsd,
+            orderTypeTag: args.orderTypeTag,
+            triggerPrice: args.triggerPrice,
+            orderId: args.orderId,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return OrderData.parse(await simulateAndExtract(client, tx));
+}
+export async function getMarketOrders(client, args) {
+    const tx = new Transaction();
+    getMarketOrdersCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            basePriceUsd: args.basePriceUsd ?? 0n,
+            cursor: args.cursor ?? 0n,
+            pageSize: args.pageSize ?? 100n,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    tx.setSender(DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    const ret = sim.commandResults?.[0]?.returnValues;
+    if (!ret)
+        return { orders: [] };
+    const ordersBytes = toBytes(ret[0]?.bcs) ?? toBytes(ret[0]?.value?.bcs);
+    const cursorBytes = toBytes(ret[1]?.bcs) ?? toBytes(ret[1]?.value?.bcs);
+    if (!ordersBytes)
+        return { orders: [] };
+    const ordersBuf = ordersBytes;
+    const orders = bcs.vector(OrderData).parse(ordersBuf);
+    let nextCursor;
+    if (cursorBytes) {
+        const cb = cursorBytes;
+        const opt = bcs.option(bcs.u64()).parse(cb);
+        if (opt)
+            nextCursor = BigInt(opt);
+    }
+    return { orders, nextCursor };
+}
+export async function getMarketPositions(client, args) {
+    const tx = new Transaction();
+    getMarketPositionsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            basePriceUsd: args.basePriceUsd,
+            collateralPriceUsd: args.collateralPriceUsd ?? 0n,
+            cursor: args.cursor ?? 0n,
+            pageSize: args.pageSize ?? 100n,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    tx.setSender(DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    const ret = sim.commandResults?.[0]?.returnValues;
+    if (!ret)
+        return { positions: [] };
+    const positionsBytes = toBytes(ret[0]?.bcs) ?? toBytes(ret[0]?.value?.bcs);
+    const cursorBytes = toBytes(ret[1]?.bcs) ?? toBytes(ret[1]?.value?.bcs);
+    if (!positionsBytes)
+        return { positions: [] };
+    const buf = positionsBytes;
+    const positions = bcs.vector(PositionData).parse(buf);
+    let nextCursor;
+    if (cursorBytes) {
+        const cb = cursorBytes;
+        const opt = bcs.option(bcs.u64()).parse(cb);
+        if (opt)
+            nextCursor = BigInt(opt);
+    }
+    return { positions, nextCursor };
+}
+export async function getAccountPositions(client, args) {
+    const tx = new Transaction();
+    getAccountPositionsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            basePriceUsd: args.basePriceUsd,
+            collateralPriceUsd: args.collateralPriceUsd ?? 0n,
+            accountObjectAddress: args.accountObjectAddress,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return bcs.vector(PositionData).parse(await simulateAndExtract(client, tx));
+}
+export async function getAccountOrders(client, args) {
+    const tx = new Transaction();
+    getAccountOrdersCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            basePriceUsd: args.basePriceUsd ?? 0n,
+            accountObjectAddress: args.accountObjectAddress,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return bcs.vector(OrderData).parse(await simulateAndExtract(client, tx));
+}
+export async function getRedeemRequests(client, args = {}) {
+    const tx = new Transaction();
+    getRedeemRequestsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            cursor: args.cursor ?? 0n,
+            pageSize: args.pageSize ?? 100n,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    tx.setSender(DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    const ret = sim.commandResults?.[0]?.returnValues;
+    if (!ret)
+        return { requests: [] };
+    const reqBytes = toBytes(ret[0]?.bcs) ?? toBytes(ret[0]?.value?.bcs);
+    const cursorBytes = toBytes(ret[1]?.bcs) ?? toBytes(ret[1]?.value?.bcs);
+    if (!reqBytes)
+        return { requests: [] };
+    const buf = reqBytes;
+    const requests = bcs.vector(RedeemRequestData).parse(buf);
+    let nextCursor;
+    if (cursorBytes) {
+        const cb = cursorBytes;
+        const opt = bcs.option(bcs.u64()).parse(cb);
+        if (opt)
+            nextCursor = BigInt(opt);
+    }
+    return { requests, nextCursor };
+}

package/dist/src/perp/fetch/simulate.d.ts

@@ -0,0 +1,12 @@
+import type { PerpClient } from "../client.ts";
+/**
+ * Perp `fetch/` simulate plumbing.
+ *
+ * The generic simulate/decode core (build one-shot PTB → `client.simulate(tx)`
+ * with the zero-address sender → decode BCS) lives in the account base
+ * (`account/fetch/simulate.ts`) so it isn't duplicated per line; re-exported
+ * here unchanged. Only `withLp` (perp's WLP-type default) is perp-specific.
+ * Internal to `fetch/` — not part of the public surface.
+ */
+export { type SimulationCommandResult, type SimulationResult, extractAt, simulateAndExtract, simulateRaw, toBytes, } from "../../account/fetch/simulate.ts";
+export declare function withLp(client: PerpClient, lpType?: string): string;

package/dist/src/perp/fetch/simulate.js

@@ -0,0 +1,13 @@
+/**
+ * Perp `fetch/` simulate plumbing.
+ *
+ * The generic simulate/decode core (build one-shot PTB → `client.simulate(tx)`
+ * with the zero-address sender → decode BCS) lives in the account base
+ * (`account/fetch/simulate.ts`) so it isn't duplicated per line; re-exported
+ * here unchanged. Only `withLp` (perp's WLP-type default) is perp-specific.
+ * Internal to `fetch/` — not part of the public surface.
+ */
+export { extractAt, simulateAndExtract, simulateRaw, toBytes, } from "../../account/fetch/simulate.js";
+export function withLp(client, lpType) {
+    return lpType ?? client.wlpType();
+}

package/dist/src/perp/fetch.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Read-only perp queries — barrel.
+ *
+ * Each helper builds a one-shot PTB, runs `client.simulate(tx)` (zero-address
+ * sender), and decodes the BCS return values. Implementations are split by
+ * domain under `fetch/`:
+ *
+ *   simulate.ts   simulate/decode plumbing (internal; core in account/fetch/)
+ *   market.ts     account data + market / pool / token-pool / global-config
+ *   positions.ts  position / order reads + paginated lists + redeem requests
+ *   account.ts    wxa account reads + inclusive spendable-credit balance
+ *   custody.ts    native-custody PSM reads
+ *   bridge.ts     wormhole_bridge limits + withdrawal_queue fee estimate
+ *
+ * Referral reads (`waterx_referral`) live in the account base
+ * (`account/fetch/referral.ts`) and are re-exported here for the perp surface.
+ */
+export * from "../account/fetch/referral.ts";
+export * from "./fetch/market.ts";
+export * from "./fetch/positions.ts";
+export * from "./fetch/account.ts";
+export * from "./fetch/custody.ts";
+export * from "./fetch/bridge.ts";

package/dist/src/perp/fetch.js

@@ -0,0 +1,23 @@
+/**
+ * Read-only perp queries — barrel.
+ *
+ * Each helper builds a one-shot PTB, runs `client.simulate(tx)` (zero-address
+ * sender), and decodes the BCS return values. Implementations are split by
+ * domain under `fetch/`:
+ *
+ *   simulate.ts   simulate/decode plumbing (internal; core in account/fetch/)
+ *   market.ts     account data + market / pool / token-pool / global-config
+ *   positions.ts  position / order reads + paginated lists + redeem requests
+ *   account.ts    wxa account reads + inclusive spendable-credit balance
+ *   custody.ts    native-custody PSM reads
+ *   bridge.ts     wormhole_bridge limits + withdrawal_queue fee estimate
+ *
+ * Referral reads (`waterx_referral`) live in the account base
+ * (`account/fetch/referral.ts`) and are re-exported here for the perp surface.
+ */
+export * from "../account/fetch/referral.js";
+export * from "./fetch/market.js";
+export * from "./fetch/positions.js";
+export * from "./fetch/account.js";
+export * from "./fetch/custody.js";
+export * from "./fetch/bridge.js";