@waterx/sdk 3.0.1 → 3.0.3

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

@@ -0,0 +1,43 @@
+/**
+ * wxa account reads (`waterx_account`) — work on credit-only deployments
+ * (which have no `waterx_perp_view`). Plus the inclusive spendable-credit read.
+ */
+import { type ParkedBackingAssetBalance } from "../../account/funding/balance.ts";
+import type { PerpClient } from "../client.ts";
+/**
+ * List the wxa account IDs owned by `owner` (`account::account_ids`).
+ * Returns `[]` when the owner has never created an account. Use this to
+ * resolve the `account_id` a cross-chain deposit must target before
+ * filling the EVM `suiRecipient` field.
+ */
+export declare function getAccountsByOwner(client: PerpClient, owner: string): Promise<string[]>;
+/**
+ * A wxa account's stored `Balance<T>` (`account::account_balance<T>`).
+ * `coinType` defaults to the deployment's CREDIT type — i.e. the bridged
+ * balance available to withdraw. Returns `0n` for an unknown coin type.
+ */
+export declare function getAccountBalance(client: PerpClient, accountId: string, coinType?: string): Promise<bigint>;
+/**
+ * Inclusive wxUSD credit an account can spend after the default async tx-builder
+ * pre-sweep (`appendConsolidateForSpend`).
+ *
+ * - `internalRaw` — stored `Balance<CREDIT>` (`getAccountBalance`).
+ * - `pendingBackingRaw` — native-custody backing assets (USDC, USDSUI, …)
+ *   parked at the account's Sui address, rescaled to CREDIT decimals at the
+ *   1:1 PSM peg (same probe as `appendConsolidateToUsd`).
+ * - `pendingCreditAtAddressRaw` — CREDIT at the account address (accumulator +
+ *   owned coins). Swept into the internal slot by `appendConsolidateAddressCredit`
+ *   via `consumeDepositDirect`.
+ * - `totalRaw` — sum of the three components; matches post-
+ *   `appendConsolidateForSpend` spendable balance for predict / perp
+ *   builders with `consolidateToUsd: true` (default).
+ */
+export interface SpendableCreditBalance {
+    internalRaw: bigint;
+    pendingBackingRaw: bigint;
+    pendingCreditAtAddressRaw: bigint;
+    totalRaw: bigint;
+    /** Per-asset breakdown for the backing-asset probe (empty when nothing parked). */
+    parkedBacking: ParkedBackingAssetBalance[];
+}
+export declare function getSpendableCreditBalance(client: PerpClient, accountId: string): Promise<SpendableCreditBalance>;

package/dist/cjs/src/perp/fetch/account.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * wxa account reads (`waterx_account`) — work on credit-only deployments
+ * (which have no `waterx_perp_view`). Plus the inclusive spendable-credit read.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountsByOwner = getAccountsByOwner;
+exports.getAccountBalance = getAccountBalance;
+exports.getSpendableCreditBalance = getSpendableCreditBalance;
+const bcs_1 = require("@mysten/sui/bcs");
+const transactions_1 = require("@mysten/sui/transactions");
+const balance_ts_1 = require("../../account/funding/balance.js");
+const account_ts_1 = require("../../generated/waterx_account/account.js");
+const constants_ts_1 = require("../constants.js");
+const simulate_ts_1 = require("./simulate.js");
+/**
+ * List the wxa account IDs owned by `owner` (`account::account_ids`).
+ * Returns `[]` when the owner has never created an account. Use this to
+ * resolve the `account_id` a cross-chain deposit must target before
+ * filling the EVM `suiRecipient` field.
+ */
+async function getAccountsByOwner(client, owner) {
+    const tx = new transactions_1.Transaction();
+    (0, account_ts_1.accountIds)({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            owner,
+        },
+    })(tx);
+    const bytes = await (0, simulate_ts_1.simulateAndExtract)(client, tx);
+    return bcs_1.bcs.vector(bcs_1.bcs.Address).parse(bytes);
+}
+/**
+ * A wxa account's stored `Balance<T>` (`account::account_balance<T>`).
+ * `coinType` defaults to the deployment's CREDIT type — i.e. the bridged
+ * balance available to withdraw. Returns `0n` for an unknown coin type.
+ */
+async function getAccountBalance(client, accountId, coinType) {
+    const tx = new transactions_1.Transaction();
+    (0, account_ts_1.accountBalance)({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId,
+        },
+        typeArguments: [coinType ?? client.creditType()],
+    })(tx);
+    const bytes = await (0, simulate_ts_1.simulateAndExtract)(client, tx);
+    return BigInt(bcs_1.bcs.u64().parse(bytes));
+}
+async function getSpendableCreditBalance(client, accountId) {
+    const creditType = client.creditType();
+    const [internalRaw, parkedBacking, addressCredit] = await Promise.all([
+        getAccountBalance(client, accountId, creditType),
+        (0, balance_ts_1.probeParkedBackingAssets)(client, accountId),
+        (0, balance_ts_1.probeAddressCreditBalance)(client, accountId),
+    ]);
+    const pendingBackingRaw = (0, balance_ts_1.sumParkedBackingAsCreditRaw)(parkedBacking, constants_ts_1.COLLATERAL_DECIMALS);
+    const pendingCreditAtAddressRaw = addressCredit.fundsRaw + addressCredit.coinsRaw;
+    const totalRaw = internalRaw + pendingBackingRaw + pendingCreditAtAddressRaw;
+    return {
+        internalRaw,
+        pendingBackingRaw,
+        pendingCreditAtAddressRaw,
+        totalRaw,
+        parkedBacking,
+    };
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Bridge reads: `wormhole_bridge` rate-limit / cap snapshot and the
+ * `withdrawal_queue` (Sui → EVM) fee estimate.
+ */
+import type { PerpClient } from "../client.ts";
+/**
+ * Live rate-limit / cap snapshot read from the `wormhole_bridge::Bridge`
+ * shared object. All amounts are raw base units of the bridged credit coin.
+ *
+ * `dailyMinted` / `dailyBurned` are the sliding-window sums as the on-chain
+ * `daily_minted` / `daily_burned` views report them — buckets that rotated
+ * out of the trailing window are evicted lazily on the next mint/burn, so
+ * these can read slightly high until then (conservative).
+ */
+export interface BridgeLimitsView {
+    paused: boolean;
+    dailyMintLimit: bigint;
+    dailyMinted: bigint;
+    maxMintPerTx: bigint;
+    dailyBurnLimit: bigint;
+    dailyBurned: bigint;
+    maxBurnPerTx: bigint;
+    /** Per-account 24h burn cap; 0n means the gate is disabled. */
+    personalBurnCapAmount: bigint;
+    /** Present only when `accountId` is supplied — burn counted in that
+     *  account's current window (the per-account cap key is the account id). */
+    personalBurned?: bigint;
+    /** Present only when `backing` is supplied — `minted_for(chainId, token)`,
+     *  the amount currently withdrawable to that EVM (chain, token). */
+    backingMinted?: bigint;
+}
+export interface BridgeLimitsArgs {
+    /** wxa trading account id — enables the per-account `personalBurned` read. */
+    accountId?: string;
+    /** Wormhole destination chain id + 20-byte EVM token — enables the
+     *  `mintedFor` backing read. */
+    backing?: {
+        wormholeChainId: number;
+        token: Uint8Array | number[];
+    };
+}
+/**
+ * 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 declare function getBridgeLimits(client: PerpClient, args?: BridgeLimitsArgs): Promise<BridgeLimitsView>;
+export interface BridgeFeeView {
+    /** Raw fee charged on a wormhole (Sui → EVM) exit of `amount`:
+     *  `max(ceil(effectiveRate * amount), effectiveMinFee)`. */
+    feeAmount: bigint;
+    /** Whether the exit clears the on-chain net-zero guard — i.e. a strictly
+     *  positive amount remains after the fee. Gate "estimated fee" UI on THIS,
+     *  not `feeAmount` alone: a dust `amount`, or a min-fee floor ≥ `amount`,
+     *  makes `feeAmount >= amount` and the exit would abort (audit L1). */
+    wouldExecute: boolean;
+    /** Effective % rate for the chain (per-chain override → default → 0),
+     *  1e9-scaled (the `Float`-as-`u128` ABI convention). */
+    effectiveRate: bigint;
+    /** Effective minimum-fee floor for the chain (override → default → 0),
+     *  in CREDIT base units. */
+    effectiveMinFee: bigint;
+    /** Net CREDIT the recipient receives after the fee; `0n` when the exit
+     *  wouldn't execute (`wouldExecute === false`). */
+    netAmount: bigint;
+}
+/**
+ * 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 declare function getBridgeFee(client: PerpClient, args: {
+    evmDestinationChain: number;
+    amount: bigint | number;
+    creditType?: string;
+}): Promise<BridgeFeeView>;

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

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Bridge reads: `wormhole_bridge` rate-limit / cap snapshot and the
+ * `withdrawal_queue` (Sui → EVM) fee estimate.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBridgeLimits = getBridgeLimits;
+exports.getBridgeFee = getBridgeFee;
+const bcs_1 = require("@mysten/sui/bcs");
+const transactions_1 = require("@mysten/sui/transactions");
+const withdrawal_queue_ts_1 = require("../../generated/withdrawal_queue/withdrawal_queue.js");
+const wormhole_bridge_ts_1 = require("../../generated/wormhole_bridge/wormhole_bridge.js");
+const simulate_ts_1 = require("./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.
+ */
+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 transactions_1.Transaction();
+    // Fixed-order view calls; indices tracked below.
+    (0, wormhole_bridge_ts_1.paused)({ package: packageId, arguments: { bridge } })(tx); // 0
+    (0, wormhole_bridge_ts_1.dailyMintLimit)({ package: packageId, arguments: { bridge } })(tx); // 1
+    (0, wormhole_bridge_ts_1.dailyMinted)({ package: packageId, arguments: { bridge } })(tx); // 2
+    (0, wormhole_bridge_ts_1.maxMintPerTx)({ package: packageId, arguments: { bridge } })(tx); // 3
+    (0, wormhole_bridge_ts_1.dailyBurnLimit)({ package: packageId, arguments: { bridge } })(tx); // 4
+    (0, wormhole_bridge_ts_1.dailyBurned)({ package: packageId, arguments: { bridge } })(tx); // 5
+    (0, wormhole_bridge_ts_1.maxBurnPerTx)({ package: packageId, arguments: { bridge } })(tx); // 6
+    (0, wormhole_bridge_ts_1.personalBurnCapAmount)({ package: packageId, arguments: { bridge } })(tx); // 7
+    let backingIdx = -1;
+    if (args.backing) {
+        backingIdx = 8;
+        (0, wormhole_bridge_ts_1.mintedFor)({
+            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.
+        (0, wormhole_bridge_ts_1.personalBurned)({
+            package: packageId,
+            arguments: { bridge, user: args.accountId },
+        })(tx);
+    }
+    const sim = await (0, simulate_ts_1.simulateRaw)(client, tx);
+    const u64At = (i) => BigInt(bcs_1.bcs.u64().parse((0, simulate_ts_1.extractAt)(sim, i)));
+    const view = {
+        paused: bcs_1.bcs.bool().parse((0, simulate_ts_1.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()`.
+ */
+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 transactions_1.Transaction();
+    // Fixed-order view calls; indices tracked below.
+    (0, withdrawal_queue_ts_1.bridgeFeeAmount)({
+        ...common,
+        arguments: { queue, evmDestinationChain: chain, amount },
+    })(tx); // 0
+    (0, withdrawal_queue_ts_1.wouldExecuteWormhole)({
+        ...common,
+        arguments: { queue, evmDestinationChain: chain, amount },
+    })(tx); // 1
+    (0, withdrawal_queue_ts_1.bridgeFeeRate)({ ...common, arguments: { queue, evmDestinationChain: chain } })(tx); // 2
+    (0, withdrawal_queue_ts_1.bridgeMinFee)({ ...common, arguments: { queue, evmDestinationChain: chain } })(tx); // 3
+    const sim = await (0, simulate_ts_1.simulateRaw)(client, tx);
+    const feeAmount = BigInt(bcs_1.bcs.u64().parse((0, simulate_ts_1.extractAt)(sim, 0)));
+    const wouldExecute = bcs_1.bcs.bool().parse((0, simulate_ts_1.extractAt)(sim, 1));
+    return {
+        feeAmount,
+        wouldExecute,
+        effectiveRate: BigInt(bcs_1.bcs.u128().parse((0, simulate_ts_1.extractAt)(sim, 2))),
+        effectiveMinFee: BigInt(bcs_1.bcs.u64().parse((0, simulate_ts_1.extractAt)(sim, 3))),
+        netAmount: wouldExecute ? amount - feeAmount : 0n,
+    };
+}

package/dist/cjs/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/cjs/src/perp/fetch/custody.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Native-custody PSM reads (`custody_vault`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCustodyVaultData = getCustodyVaultData;
+exports.getCustodyAssetData = getCustodyAssetData;
+const bcs_1 = require("@mysten/sui/bcs");
+const transactions_1 = require("@mysten/sui/transactions");
+const custody_vault_ts_1 = require("../../generated/native_custody/custody_vault.js");
+const constants_ts_1 = require("../constants.js");
+const simulate_ts_1 = require("./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`. */
+async function getCustodyVaultData(client) {
+    const { pkg, vault, creditType } = requireCustody(client);
+    const tx = new transactions_1.Transaction();
+    (0, custody_vault_ts_1.creditSupply)({
+        package: pkg,
+        arguments: { vault: tx.object(vault) },
+        typeArguments: [creditType],
+    })(tx);
+    const bytes = await (0, simulate_ts_1.simulateAndExtract)(client, tx);
+    return { creditSupply: BigInt(bcs_1.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.
+ */
+async function getCustodyAssetData(client, assetType) {
+    const { pkg, vault, creditType } = requireCustody(client);
+    const typeArguments = [assetType, creditType];
+    const hasTx = new transactions_1.Transaction();
+    (0, custody_vault_ts_1.hasAsset)({ package: pkg, arguments: { vault: hasTx.object(vault) }, typeArguments })(hasTx);
+    const registered = bcs_1.bcs.bool().parse(await (0, simulate_ts_1.simulateAndExtract)(client, hasTx));
+    if (!registered)
+        return { registered: false, mintFeeRate: 0n, burnFeeRate: 0n };
+    const mintTx = new transactions_1.Transaction();
+    (0, custody_vault_ts_1.mintFeeRate)({
+        package: pkg,
+        arguments: { vault: mintTx.object(vault), caller: constants_ts_1.DRY_RUN_SENDER },
+        typeArguments,
+    })(mintTx);
+    const mintFeeRate = BigInt(bcs_1.bcs.u128().parse(await (0, simulate_ts_1.simulateAndExtract)(client, mintTx)));
+    const burnTx = new transactions_1.Transaction();
+    (0, custody_vault_ts_1.burnFeeRate)({
+        package: pkg,
+        arguments: { vault: burnTx.object(vault), caller: constants_ts_1.DRY_RUN_SENDER },
+        typeArguments,
+    })(burnTx);
+    const burnFeeRate = BigInt(bcs_1.bcs.u128().parse(await (0, simulate_ts_1.simulateAndExtract)(client, burnTx)));
+    return { registered: true, mintFeeRate, burnFeeRate };
+}

package/dist/cjs/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/cjs/src/perp/fetch/market.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Market / pool / token-pool / global-config + account-data reads
+ * (`waterx_perp_view`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountData = getAccountData;
+exports.getMarketData = getMarketData;
+exports.getPoolData = getPoolData;
+exports.getTokenPoolData = getTokenPoolData;
+exports.getGlobalConfigData = getGlobalConfigData;
+const bcs_1 = require("@mysten/sui/bcs");
+const transactions_1 = require("@mysten/sui/transactions");
+const view_ts_1 = require("../../generated/waterx_perp_view/view.js");
+const simulate_ts_1 = require("./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>`.
+ */
+async function getAccountData(client, accountId) {
+    const tx = new transactions_1.Transaction();
+    (0, view_ts_1.accountData)({
+        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 (0, simulate_ts_1.simulateAndExtract)(client, tx);
+    const opt = bcs_1.bcs.option(view_ts_1.AccountData).parse(bytes);
+    return opt ?? undefined;
+}
+async function getMarketData(client, args) {
+    const tx = new transactions_1.Transaction();
+    (0, view_ts_1.marketData)({
+        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: [(0, simulate_ts_1.withLp)(client, args.lpType)],
+    })(tx);
+    return view_ts_1.MarketData.parse(await (0, simulate_ts_1.simulateAndExtract)(client, tx));
+}
+async function getPoolData(client, args = {}) {
+    const tx = new transactions_1.Transaction();
+    (0, view_ts_1.poolData)({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: { pool: tx.object(client.config.packages.wlp.wlp_pool) },
+        typeArguments: [(0, simulate_ts_1.withLp)(client, args.lpType)],
+    })(tx);
+    return view_ts_1.PoolData.parse(await (0, simulate_ts_1.simulateAndExtract)(client, tx));
+}
+async function getTokenPoolData(client, args) {
+    const tx = new transactions_1.Transaction();
+    (0, view_ts_1.tokenPoolData)({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            tokenIndex: args.tokenIndex,
+        },
+        typeArguments: [(0, simulate_ts_1.withLp)(client, args.lpType)],
+    })(tx);
+    return view_ts_1.TokenPoolData.parse(await (0, simulate_ts_1.simulateAndExtract)(client, tx));
+}
+async function getGlobalConfigData(client) {
+    const tx = new transactions_1.Transaction();
+    (0, view_ts_1.globalConfigData)({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: { cfg: tx.object(client.config.packages.waterx_perp.global_config) },
+    })(tx);
+    return view_ts_1.GlobalConfigData.parse(await (0, simulate_ts_1.simulateAndExtract)(client, tx));
+}

package/dist/cjs/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;
+}>;