@waterx/sdk 2.1.0 → 2.3.1-dev.0

package/dist/src/fetch.d.ts

@@ -7,6 +7,7 @@
  */
 import type { WaterXClient } from "./client.ts";
 import { AccountData, GlobalConfigData, MarketData, OrderData, PoolData, PositionData, RedeemRequestData, TokenPoolData } from "./generated/waterx_perp_view/view.ts";
+import { type ParkedBackingAssetBalance } from "./utils/consolidate-balance.ts";
 export type AccountDataView = ReturnType<typeof AccountData.parse>;
 /**
  * Look up the registered AccountData for a given wxa account ID.
@@ -114,6 +115,30 @@ export declare function getAccountsByOwner(client: WaterXClient, owner: string):
  * balance available to withdraw. Returns `0n` for an unknown coin type.
  */
 export declare function getAccountBalance(client: WaterXClient, accountId: string, coinType?: string): Promise<bigint>;
+/**
+ * Inclusive wxUSD credit an account can spend after the default async tx-builder
+ * pre-sweep ({@link 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 {@link appendConsolidateToUsd}).
+ * - `pendingCreditAtAddressRaw` — CREDIT at the account address (accumulator +
+ *   owned coins). Swept into the internal slot by
+ *   {@link appendConsolidateAddressCredit} via `consumeDepositDirect`.
+ * - `totalRaw` — sum of the three components; matches post-
+ *   {@link 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: WaterXClient, accountId: string): Promise<SpendableCreditBalance>;
 /** Vault-wide native-custody state. */
 export interface CustodyVaultData {
     /** Total CREDIT minted by the custody vault (`credit_supply`). */
@@ -142,3 +167,88 @@ export interface CustodyAssetData {
  * `&SingleVault<T>` reference, which a PTB simulate cannot read.
  */
 export declare function getCustodyAssetData(client: WaterXClient, assetType: string): Promise<CustodyAssetData>;
+/**
+ * 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: WaterXClient, 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: WaterXClient, args: {
+    evmDestinationChain: number;
+    amount: bigint | number;
+    creditType?: string;
+}): Promise<BridgeFeeView>;

package/dist/src/fetch.js

@@ -8,7 +8,7 @@
 import { fromBase64 } from "@mysten/bcs";
 import { bcs } from "@mysten/sui/bcs";
 import { Transaction } from "@mysten/sui/transactions";
-import { DRY_RUN_SENDER } from "./constants.js";
+import { COLLATERAL_DECIMALS, DRY_RUN_SENDER } from "./constants.js";
 import { burnFeeRate as burnFeeRateCall, creditSupply as creditSupplyCall, hasAsset as hasAssetCall, mintFeeRate as mintFeeRateCall, } from "./generated/native_custody/custody_vault.js";
 import { accountBalance as accountBalanceCall, accountIds as accountIdsCall, } from "./generated/waterx_account/account.js";
 import { AccountData, accountData as accountDataCall, getAccountOrders as getAccountOrdersCall, getAccountPositions as getAccountPositionsCall, getMarketOrders as getMarketOrdersCall, getMarketPositions as getMarketPositionsCall, getRedeemRequests as getRedeemRequestsCall, GlobalConfigData, globalConfigData as globalConfigDataCall, MarketData, marketData as marketDataCall, OrderData, orderData as orderDataCall, PoolData, poolData as poolDataCall, PositionData, positionData as positionDataCall, positionExists as positionExistsCall, RedeemRequestData, TokenPoolData, tokenPoolData as tokenPoolDataCall, } from "./generated/waterx_perp_view/view.js";
@@ -16,6 +16,9 @@ import { AccountData, accountData as accountDataCall, getAccountOrders as getAcc
 // Referral queries (waterx_referral::referral_table)
 // ============================================================================
 import { isValidReferralCode as isValidReferralCodeCall, referralCodeExists as referralCodeExistsCall, tryGetRefer as tryGetReferCall, } from "./generated/waterx_referral/referral_table.js";
+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 { probeAddressCreditBalance, probeParkedBackingAssets, sumParkedBackingAsCreditRaw, } from "./utils/consolidate-balance.js";
 function toBytes(b) {
     if (!b)
         return undefined;
@@ -27,21 +30,27 @@ function toBytes(b) {
         return b;
     return new Uint8Array(Object.values(b));
 }
-async function simulateAndExtract(client, tx, commandIndex = 0, returnIndex = 0) {
+async function simulateRaw(client, tx) {
     tx.setSender(DRY_RUN_SENDER);
     const sim = (await client.simulate(tx));
     if (sim.$kind === "FailedTransaction") {
         const err = sim.FailedTransaction?.status?.error?.message ?? "FailedTransaction";
         throw new Error(`simulate aborted: ${err}`);
     }
-    const cmd = sim.commandResults?.[commandIndex];
-    const ret = cmd?.returnValues?.[returnIndex];
+    return sim;
+}
+function extractAt(sim, commandIndex, returnIndex = 0) {
+    const ret = sim.commandResults?.[commandIndex]?.returnValues?.[returnIndex];
     const bytes = toBytes(ret?.bcs) ?? toBytes(ret?.value?.bcs);
     if (!bytes) {
         throw new Error(`simulate returned no BCS value at commandResults[${commandIndex}].returnValues[${returnIndex}]`);
     }
     return bytes;
 }
+async function simulateAndExtract(client, tx, commandIndex = 0, returnIndex = 0) {
+    const sim = await simulateRaw(client, tx);
+    return extractAt(sim, commandIndex, returnIndex);
+}
 function withLp(client, lpType) {
     return lpType ?? client.wlpType();
 }
@@ -360,6 +369,24 @@ export async function getAccountBalance(client, accountId, coinType) {
     const bytes = await simulateAndExtract(client, tx);
     return BigInt(bcs.u64().parse(bytes));
 }
+export async function getSpendableCreditBalance(client, accountId) {
+    const creditType = client.creditType();
+    const [internalRaw, parkedBacking, addressCredit] = await Promise.all([
+        getAccountBalance(client, accountId, creditType),
+        probeParkedBackingAssets(client, accountId),
+        probeAddressCreditBalance(client, accountId),
+    ]);
+    const pendingBackingRaw = sumParkedBackingAsCreditRaw(parkedBacking, COLLATERAL_DECIMALS);
+    const pendingCreditAtAddressRaw = addressCredit.fundsRaw + addressCredit.coinsRaw;
+    const totalRaw = internalRaw + pendingBackingRaw + pendingCreditAtAddressRaw;
+    return {
+        internalRaw,
+        pendingBackingRaw,
+        pendingCreditAtAddressRaw,
+        totalRaw,
+        parkedBacking,
+    };
+}
 // ============================================================================
 // Native custody (custody_vault)
 // ============================================================================
@@ -417,3 +444,121 @@ export async function getCustodyAssetData(client, assetType) {
     const burnFeeRate = BigInt(bcs.u128().parse(await simulateAndExtract(client, burnTx)));
     return { registered: true, mintFeeRate, burnFeeRate };
 }
+/**
+ * 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/generated/bucket_v2_framework/account.d.ts

@@ -3,7 +3,7 @@
  **************************************************************/
 /** Module for Account Abstraction */
 import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
-import { type Transaction } from '@mysten/sui/transactions';
+import { type Transaction, type TransactionArgument } from '@mysten/sui/transactions';
 export declare const ACCOUNT: MoveStruct<{
     dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
 }, "@bucket/framework::account::ACCOUNT">;
@@ -43,13 +43,13 @@ export interface RequestWithAccountOptions {
 export declare function requestWithAccount(options: RequestWithAccountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface ReceiveArguments {
     account: RawTransactionArgument<string>;
-    receiving: RawTransactionArgument<string>;
+    receiving: TransactionArgument;
 }
 export interface ReceiveOptions {
     package?: string;
     arguments: ReceiveArguments | [
         account: RawTransactionArgument<string>,
-        receiving: RawTransactionArgument<string>
+        receiving: TransactionArgument
     ];
     typeArguments: [
         string
@@ -90,12 +90,12 @@ export interface AccountAddressOptions {
 }
 export declare function accountAddress(options: AccountAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
 export interface RequestAddressArguments {
-    req: RawTransactionArgument<string>;
+    req: TransactionArgument;
 }
 export interface RequestAddressOptions {
     package?: string;
     arguments: RequestAddressArguments | [
-        req: RawTransactionArgument<string>
+        req: TransactionArgument
     ];
 }
 export declare function requestAddress(options: RequestAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;