@waterx/sdk 3.0.1 → 3.0.3

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Helper for building `bucket_v2_framework::account::AccountRequest` (or
+ * `request_with_account`) with the configured `bucket_framework` package id
+ * injected. Used by every user/* builder to authenticate the caller.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSenderRequest = makeSenderRequest;
+const account_ts_1 = require("../generated/bucket_v2_framework/account.js");
+function makeSenderRequest(client, tx, bucketAccount) {
+    const pkg = client.config.packages.bucket_framework.published_at;
+    if (bucketAccount === undefined) {
+        return (0, account_ts_1.request)({ package: pkg })(tx);
+    }
+    const accArg = typeof bucketAccount === "string" ? tx.object(bucketAccount) : bucketAccount;
+    return (0, account_ts_1.requestWithAccount)({
+        package: pkg,
+        arguments: { account: accArg },
+    })(tx);
+}

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

@@ -0,0 +1,158 @@
+/**
+ * Account-side builders for the `waterx_account` framework.
+ *
+ * In v3, `waterx_account` is the only account abstraction — `waterx_perp`
+ * stores per-account state under `ProtocolDataKey<WaterXPerp>()` on a wxa
+ * `Account` and uses witness-gated `take` / `put` for collateral.
+ *
+ * All builders that mutate the account pass `account::request()` or
+ * `account::request_with_account(&Account)` internally. To act through
+ * a Bucket `Account` object, pass `bucketAccount` (an object ID string
+ * or a `TransactionArgument`).
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { WxaClientLike } from "./client.ts";
+export interface CreateAccountParams {
+    /** Alias / display name for the new account (max length checked on-chain). */
+    alias: string;
+    /** Optional Bucket Account to act through (otherwise tx.sender). */
+    bucketAccount?: string | TransactionArgument;
+}
+/** Build `waterx_account::create_account`. Returns the new account ID (Move return value). */
+export declare function createAccount(client: WxaClientLike, tx: Transaction, params: CreateAccountParams): TransactionArgument;
+export interface SetAliasParams {
+    accountId: string;
+    alias: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function setAlias(client: WxaClientLike, tx: Transaction, params: SetAliasParams): void;
+export interface AddDelegateParams {
+    /** Account ID — an `0x2::object::ID` string or a PTB argument. */
+    accountId: string | TransactionArgument;
+    delegateAddress: string;
+    alias: string;
+    /** Bitmask matching `waterx_account` permission constants. */
+    permissions: number;
+    /** Optional millisecond timestamp at which the delegate expires. */
+    expiresAtMs?: bigint | number;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function addDelegate(client: WxaClientLike, tx: Transaction, params: AddDelegateParams): void;
+export interface RemoveDelegateParams {
+    /** Account ID — an `0x2::object::ID` string or a PTB argument. */
+    accountId: string | TransactionArgument;
+    delegateAddress: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function removeDelegate(client: WxaClientLike, tx: Transaction, params: RemoveDelegateParams): void;
+export interface SetDelegateProtocolPermissionParams {
+    accountId: string;
+    delegateAddress: string;
+    /** Bitmask of per-protocol permissions (e.g. perm_open_position | perm_close_position). */
+    permissions: number;
+    /** Fully-qualified Move type of the protocol witness (e.g. `0x…::account_data::WaterXPerp`). */
+    protocolType: string;
+    bucketAccount?: string | TransactionArgument;
+}
+export declare function setDelegateProtocolPermission(client: WxaClientLike, tx: Transaction, params: SetDelegateProtocolPermissionParams): void;
+export interface RequestDepositParams {
+    /** wxa account ID receiving the deposit (ID string or PTB argument). */
+    accountId: string | TransactionArgument;
+    /** Coin or coin transaction argument to deposit. */
+    coin: TransactionArgument;
+    /** Fully-qualified coin type. */
+    coinType: string;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+}
+/** Build `account::request_deposit<T>`. Returns the `DepositRequest<T>` argument. */
+export declare function requestDeposit(client: WxaClientLike, tx: Transaction, params: RequestDepositParams): TransactionArgument;
+export interface RequestDepositFromReceivingsParams {
+    /** wxa account ID receiving the deposit (ID string or PTB argument). */
+    accountId: string | TransactionArgument;
+    /**
+     * `Receiving<Coin<T>>` arguments — one per `Coin<T>` previously transferred
+     * onto the account's address. Build each with
+     * `tx.receivingRef({ objectId, version, digest })`.
+     */
+    receivings: TransactionArgument[];
+    /** Fully-qualified coin type `T`. */
+    coinType: string;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+}
+/**
+ * Build `account::request_deposit_from_receivings<T>` — drains `Coin<T>`
+ * objects previously transferred onto the account's address (the
+ * transfer-to-object path) into a single `DepositRequest<T>`. Returns the
+ * `DepositRequest<T>` argument.
+ */
+export declare function requestDepositFromReceivings(client: WxaClientLike, tx: Transaction, params: RequestDepositFromReceivingsParams): TransactionArgument;
+export interface RequestDepositFromFundsParams {
+    /** wxa account ID receiving the deposit. */
+    accountId: string;
+    /** Fully-qualified coin type `T`. */
+    coinType: string;
+    /**
+     * Sui native funds-accumulator root shared object. Defaults to the
+     * well-known `ACCUMULATOR_ROOT` (`0xacc`); override only for a custom
+     * deployment.
+     */
+    accumulatorRoot?: string | TransactionArgument;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+}
+/**
+ * Build `account::request_deposit_from_funds<T>` — drains every `Balance<T>`
+ * parked at the account's address in Sui's native funds accumulator (the
+ * path taken by `transfer_coin` / `0x2::balance::send_funds<T>`) into a
+ * single `DepositRequest<T>`. Returns the `DepositRequest<T>` argument.
+ *
+ * The drained total reflects the balance as of the last consensus commit,
+ * so the value isn't readable within the same PTB — treat it as a
+ * between-tx drain. Returns a zero-balance request when the address holds
+ * no `T`, so check `settled_funds_value<T>` off-chain first if you want to
+ * skip empty drains.
+ */
+export declare function requestDepositFromFunds(client: WxaClientLike, tx: Transaction, params: RequestDepositFromFundsParams): TransactionArgument;
+export interface RequestWithdrawParams {
+    accountId: string | TransactionArgument;
+    amount: bigint | number;
+    /** Recipient for the eventual coin payout (policy decides exact mechanics). */
+    recipient: string;
+    /** Fully-qualified coin type. */
+    coinType: string;
+    /** Optional opaque extra data forwarded to the policy. */
+    extraData?: Uint8Array;
+    bucketAccount?: string | TransactionArgument;
+}
+/** Build `account::request_withdraw<T>`. Returns the `WithdrawRequest<T>` argument. */
+export declare function requestWithdraw(client: WxaClientLike, tx: Transaction, params: RequestWithdrawParams): TransactionArgument;
+export interface TransferToAccountParams {
+    accountId: string | TransactionArgument;
+    coin: TransactionArgument;
+    coinType: string;
+}
+export declare function transferToAccount(client: WxaClientLike, tx: Transaction, params: TransferToAccountParams): void;
+export interface ReceiveParams {
+    accountId: string;
+    /**
+     * `Receiving<T>` argument for the TTO'd object. Construct via
+     * `tx.receivingRef({ objectId, version, digest })` from the on-chain
+     * object's ID/version/digest (e.g. from
+     * `FundsReaderService.listUnreceivedRewardCoins` on the BE).
+     */
+    receiving: TransactionArgument;
+    /** Fully-qualified `T` Move type — typically `Coin<R>` for reward coins. */
+    receivingType: string;
+    bucketAccount?: string | TransactionArgument;
+}
+/**
+ * Calls `waterx_account::receive<T>` to drain a TTO'd object on the
+ * account's UID. Returns the received object to the caller's PTB so it
+ * can be merged / transferred / consumed downstream in the same tx.
+ *
+ * Bypasses the deposit-policy flow — use for reward coins (and other
+ * tokens / objects) that have no registered deposit policy.
+ */
+export declare function receive(client: WxaClientLike, tx: Transaction, params: ReceiveParams): TransactionArgument;

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

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * Account-side builders for the `waterx_account` framework.
+ *
+ * In v3, `waterx_account` is the only account abstraction — `waterx_perp`
+ * stores per-account state under `ProtocolDataKey<WaterXPerp>()` on a wxa
+ * `Account` and uses witness-gated `take` / `put` for collateral.
+ *
+ * All builders that mutate the account pass `account::request()` or
+ * `account::request_with_account(&Account)` internally. To act through
+ * a Bucket `Account` object, pass `bucketAccount` (an object ID string
+ * or a `TransactionArgument`).
+ */
+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.createAccount = createAccount;
+exports.setAlias = setAlias;
+exports.addDelegate = addDelegate;
+exports.removeDelegate = removeDelegate;
+exports.setDelegateProtocolPermission = setDelegateProtocolPermission;
+exports.requestDeposit = requestDeposit;
+exports.requestDepositFromReceivings = requestDepositFromReceivings;
+exports.requestDepositFromFunds = requestDepositFromFunds;
+exports.requestWithdraw = requestWithdraw;
+exports.transferToAccount = transferToAccount;
+exports.receive = receive;
+const wxa = __importStar(require("../generated/waterx_account/account.js"));
+const account_request_ts_1 = require("./account-request.js");
+const constants_ts_1 = require("./constants.js");
+const waterx_account_ts_1 = require("./waterx-account.js");
+/** Build `waterx_account::create_account`. Returns the new account ID (Move return value). */
+function createAccount(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    return (0, waterx_account_ts_1.createAccountCall)(tx, {
+        packageId: client.config.packages.waterx_account.published_at,
+        registry: client.config.packages.waterx_account.account_registry,
+    }, { senderRequest: req, alias: params.alias });
+}
+function setAlias(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    wxa.setAlias({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            alias: params.alias,
+        },
+    })(tx);
+}
+function addDelegate(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    wxa.addDelegate({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            delegateAddress: params.delegateAddress,
+            alias: params.alias,
+            permissions: params.permissions,
+            expiresAtMs: params.expiresAtMs ?? null,
+        },
+    })(tx);
+}
+function removeDelegate(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    wxa.removeDelegate({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            delegateAddress: params.delegateAddress,
+        },
+    })(tx);
+}
+function setDelegateProtocolPermission(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    wxa.setDelegateProtocolPermission({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            delegateAddress: params.delegateAddress,
+            permissions: params.permissions,
+        },
+        typeArguments: [params.protocolType],
+    })(tx);
+}
+/** Build `account::request_deposit<T>`. Returns the `DepositRequest<T>` argument. */
+function requestDeposit(client, tx, params) {
+    const [req] = wxa.requestDeposit({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            coin: params.coin,
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+    return req;
+}
+/**
+ * Build `account::request_deposit_from_receivings<T>` — drains `Coin<T>`
+ * objects previously transferred onto the account's address (the
+ * transfer-to-object path) into a single `DepositRequest<T>`. Returns the
+ * `DepositRequest<T>` argument.
+ */
+function requestDepositFromReceivings(client, tx, params) {
+    const receivings = tx.makeMoveVec({
+        type: `0x2::transfer::Receiving<0x2::coin::Coin<${params.coinType}>>`,
+        elements: params.receivings,
+    });
+    const [req] = wxa.requestDepositFromReceivings({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            receivings: receivings,
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+    return req;
+}
+/**
+ * Build `account::request_deposit_from_funds<T>` — drains every `Balance<T>`
+ * parked at the account's address in Sui's native funds accumulator (the
+ * path taken by `transfer_coin` / `0x2::balance::send_funds<T>`) into a
+ * single `DepositRequest<T>`. Returns the `DepositRequest<T>` argument.
+ *
+ * The drained total reflects the balance as of the last consensus commit,
+ * so the value isn't readable within the same PTB — treat it as a
+ * between-tx drain. Returns a zero-balance request when the address holds
+ * no `T`, so check `settled_funds_value<T>` off-chain first if you want to
+ * skip empty drains.
+ */
+function requestDepositFromFunds(client, tx, params) {
+    const root = params.accumulatorRoot ?? constants_ts_1.ACCUMULATOR_ROOT;
+    const [req] = wxa.requestDepositFromFunds({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            accumulatorRoot: (typeof root === "string"
+                ? tx.object(root)
+                : root),
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+    return req;
+}
+/** Build `account::request_withdraw<T>`. Returns the `WithdrawRequest<T>` argument. */
+function requestWithdraw(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const [out] = wxa.requestWithdraw({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            amount: params.amount,
+            recipient: params.recipient,
+            extraData: Array.from(params.extraData ?? new Uint8Array()),
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+    return out;
+}
+function transferToAccount(client, tx, params) {
+    wxa.transferCoin({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId: params.accountId,
+            coin: params.coin,
+        },
+        typeArguments: [params.coinType],
+    })(tx);
+}
+/**
+ * Calls `waterx_account::receive<T>` to drain a TTO'd object on the
+ * account's UID. Returns the received object to the caller's PTB so it
+ * can be merged / transferred / consumed downstream in the same tx.
+ *
+ * Bypasses the deposit-policy flow — use for reward coins (and other
+ * tokens / objects) that have no registered deposit policy.
+ */
+function receive(client, tx, params) {
+    const req = (0, account_request_ts_1.makeSenderRequest)(client, tx, params.bucketAccount);
+    const out = wxa.receive({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            senderRequest: req,
+            accountId: params.accountId,
+            receiving: params.receiving,
+        },
+        typeArguments: [params.receivingType],
+    })(tx);
+    return out;
+}

package/dist/cjs/src/account/client.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `AccountClientLike` — the narrow capability slice the account/funding builders
+ * read, instead of the concrete `PerpClient`.
+ *
+ * The account framework + funding (credit / custody / bridge / consolidate) is
+ * the contract's **base** layer: both product lines depend down onto it. Typing
+ * these builders to `PerpClient` inverted that — so they take this structural
+ * interface instead. `PerpClient` satisfies it without an `implements` clause
+ * (it `extends BaseLineClient<WaterXConfig>` and carries the config-view slice +
+ * the `wormhole` infra block); a future funding-capable client can too.
+ *
+ * The config schema it reads lives in `account/config.ts` (the base layer), so
+ * this file imports **nothing** from `perp/` — `account/` no longer depends on the
+ * perp line even at the type level. `PerpClient`'s `WaterXConfig` is assignable to
+ * the narrower `AccountConfig` (`WaterXPackages extends AccountPackages`).
+ */
+import type { BaseLineClient } from "../base-client.ts";
+import type { AccountConfig, NativeCustodyAsset, WaterxCreditPackage, WormholeBridgePackage, WormholeInfraConfig, WxaConfig } from "./config.ts";
+/**
+ * The slice the **generic wxa builders** (create account / delegates / alias /
+ * deposit-request) read — just the `waterx_account` + `bucket_framework` package
+ * ids and transport. Both `PerpClient` and `PredictClient` satisfy it (their full
+ * configs are assignable to {@link WxaConfig}), so these builders are shared by
+ * both lines. The funding-capable {@link AccountClientLike} is a superset.
+ */
+export type WxaClientLike = BaseLineClient<WxaConfig>;
+export interface AccountClientLike extends BaseLineClient<AccountConfig> {
+    /** External Wormhole infra (network default, overridable via config). */
+    readonly wormhole: WormholeInfraConfig;
+    /** Fully-qualified CREDIT coin Move type; throws if `waterx_credit.credit_type` is unset. */
+    creditType(): string;
+    /** `waterx_credit` package entry; throws if absent. */
+    getCredit(): WaterxCreditPackage;
+    /** `wormhole_bridge` package entry; throws if absent. */
+    getBridge(): WormholeBridgePackage;
+    /** Sui Wormhole `State` object id (per-deployment, falls back to `wormhole` infra). */
+    wormholeStateId(): string;
+    /** All native-custody backing-asset rows; throws if no custody vault. */
+    getNativeAssets(): readonly NativeCustodyAsset[];
+    /** A native-custody asset row by its fully-qualified Move type; throws if unknown. */
+    getNativeAsset(moveType: string): NativeCustodyAsset;
+}

package/dist/cjs/src/account/client.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * `AccountClientLike` — the narrow capability slice the account/funding builders
+ * read, instead of the concrete `PerpClient`.
+ *
+ * The account framework + funding (credit / custody / bridge / consolidate) is
+ * the contract's **base** layer: both product lines depend down onto it. Typing
+ * these builders to `PerpClient` inverted that — so they take this structural
+ * interface instead. `PerpClient` satisfies it without an `implements` clause
+ * (it `extends BaseLineClient<WaterXConfig>` and carries the config-view slice +
+ * the `wormhole` infra block); a future funding-capable client can too.
+ *
+ * The config schema it reads lives in `account/config.ts` (the base layer), so
+ * this file imports **nothing** from `perp/` — `account/` no longer depends on the
+ * perp line even at the type level. `PerpClient`'s `WaterXConfig` is assignable to
+ * the narrower `AccountConfig` (`WaterXPackages extends AccountPackages`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/account/config.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Account-layer config schema — the package entries + config slice the base
+ * (`waterx_account` framework + funding: credit / custody / bridge / queue +
+ * referral) reads. This is the **base**: `perp/config.ts` imports these and
+ * `WaterXPackages extends AccountPackages`; nothing here imports `perp/` or
+ * `prediction/`. Snake_case mirrors the canonical `waterx-config` JSON 1:1.
+ */
+import type { BaseLineConfig } from "../base-client.ts";
+export interface BasePackageEntry {
+    published_at: string;
+    original_id: string;
+    version: number;
+    upgrade_capability?: string;
+}
+export interface WxaAccountPackage extends BasePackageEntry {
+    admin_cap: string;
+    account_registry: string;
+}
+export interface WaterxReferralPackage extends BasePackageEntry {
+    /** Shared `ReferralTable`. */
+    referral_table: string;
+}
+export interface WaterxCreditPackage {
+    published_at: string;
+    /** Shared `CreditRegistry<CREDIT>` (phase-1 output). */
+    credit_registry?: string;
+    /**
+     * Fully-qualified CREDIT coin Move type, e.g. `0x..::usd::USD`. Required for
+     * any credit/bridge flow — `client.creditType()` returns it as-is.
+     */
+    credit_type?: string;
+}
+/** One backing-asset row on the native custody vault (PSM). */
+export interface NativeCustodyAsset {
+    /** Human-readable asset label, e.g. `"MOCK_USDC"` / `"USDC"` (from `add_asset`). */
+    name?: string;
+    /** Fully-qualified backing asset Move type `T`. */
+    type: string;
+    decimal: number;
+    mint_fee_scaled: string;
+    burn_fee_scaled: string;
+    min_burn_amount: string;
+}
+export interface NativeCustodyPackage {
+    published_at: string;
+    /** Shared `CustodyVault<CREDIT>` (phase-4 output). */
+    vault?: string;
+    /** Backing assets registered via `add_asset` (array, identified by `type`). */
+    assets: NativeCustodyAsset[];
+}
+export interface TrustedEmitterRow {
+    /** Source EVM chain's Wormhole chain id (e.g. 10002 = Sepolia). */
+    chain_id: number;
+    /** 32-byte left-padded EVM bridge address (0x form). */
+    evm_bridge_address_32b: string;
+    /** Whitelisted 20-byte EVM token addresses (0x form). */
+    evm_tokens_20b: string[];
+}
+export interface WormholeBridgePackage {
+    published_at: string;
+    /** Shared Sui Wormhole `State` object id for this deployment. */
+    wormhole_state: string;
+    hourly_mint_limit?: string;
+    max_mint_per_tx?: string;
+    hourly_burn_limit?: string;
+    max_burn_per_tx?: string;
+    /**
+     * @deprecated EVM emitter↔token config now lives solely under `evm.bridge.chains`
+     * (deposit_vault = emitter, wormhole_chain_id = chain key). The runtime allowlist is
+     * read from the on-chain `Bridge` object, not from config. Kept optional for back-compat.
+     */
+    trusted_emitters?: TrustedEmitterRow[];
+    /** Shared `Bridge` (phase-5 output). */
+    bridge?: string;
+    /**
+     * The bridge's `EmitterCap` object id (Sui-side Wormhole emitter address
+     * for burn-relay Wormholescan lookups). Not written by the deploy script
+     * — resolve from the on-chain `Bridge` object if absent.
+     */
+    emitter_cap?: string;
+}
+export interface WithdrawalQueuePackage {
+    published_at: string;
+    /** Addresses on the queue executor allowlist (keepers). */
+    executors?: string[];
+    /** Shared `Queue<CREDIT>` (phase-6 output). */
+    queue?: string;
+}
+/**
+ * Wormhole infra for the cross-chain credit bridge. `state_id` is the same
+ * shared Sui Wormhole `State` object Pyth uses (kept in sync with
+ * `PYTH_DEFAULTS[*].wormhole_state_id`). Override per-deployment via
+ * `WaterXConfig.wormhole` if a deployment ever points elsewhere.
+ */
+export interface WormholeInfraConfig {
+    /** Shared Sui Wormhole `State` object. */
+    state_id: string;
+    /** Wormhole core package id on Sui. */
+    core_package: string;
+    /** Sui's Wormhole chain id (21 on both mainnet and testnet). */
+    sui_chain_id: number;
+    /** Wormholescan REST base for VAA lookups (no trailing slash). */
+    wormholescan_api: string;
+}
+/**
+ * The minimal package slice the **generic wxa builders** (create / delegate /
+ * alias …) read — only the fields BOTH the perp and prediction line configs are
+ * guaranteed to carry (prediction makes `original_id` / `version` / `admin_cap`
+ * optional, so the strict {@link WxaAccountPackage} is too narrow a target here).
+ */
+export interface WxaPackages {
+    bucket_framework: {
+        published_at: string;
+    };
+    waterx_account: {
+        published_at: string;
+        account_registry: string;
+    };
+    waterx_referral?: {
+        published_at: string;
+        referral_table: string;
+    };
+}
+/** Narrow config for the generic wxa builders — both line configs are assignable. */
+export interface WxaConfig extends BaseLineConfig {
+    packages: WxaPackages;
+}
+/**
+ * The package subset the account base + funding builders read. The full
+ * line config (`WaterXPackages`) **extends** this, so any line client's config
+ * is structurally an account config.
+ */
+export interface AccountPackages extends WxaPackages {
+    bucket_framework: BasePackageEntry;
+    waterx_account: WxaAccountPackage;
+    waterx_referral?: WaterxReferralPackage;
+    waterx_credit?: WaterxCreditPackage;
+    wormhole_bridge?: WormholeBridgePackage;
+    withdrawal_queue?: WithdrawalQueuePackage;
+    native_custody?: NativeCustodyPackage;
+}
+/**
+ * The narrow config shape the account/funding builders need. `WaterXConfig`
+ * (the perp line's full config) is assignable to this, so `PerpClient` satisfies
+ * {@link import("./client.ts").AccountClientLike} without importing `perp/`.
+ */
+export interface AccountConfig extends BaseLineConfig {
+    packages: AccountPackages;
+    /** Wormhole infra override (defaults from `WORMHOLE_DEFAULTS[network]`). */
+    wormhole?: WormholeInfraConfig;
+}

package/dist/cjs/src/account/config.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Account-layer config schema — the package entries + config slice the base
+ * (`waterx_account` framework + funding: credit / custody / bridge / queue +
+ * referral) reads. This is the **base**: `perp/config.ts` imports these and
+ * `WaterXPackages extends AccountPackages`; nothing here imports `perp/` or
+ * `prediction/`. Snake_case mirrors the canonical `waterx-config` JSON 1:1.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/src/account/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Account-framework constants (shared base — neither perp- nor prediction-specific).
+ */
+/** Sentinel "accumulator root" address passed to `waterx_account` add-position/order. */
+export declare const ACCUMULATOR_ROOT = "0xacc";

package/dist/cjs/src/account/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Account-framework constants (shared base — neither perp- nor prediction-specific).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACCUMULATOR_ROOT = void 0;
+/** Sentinel "accumulator root" address passed to `waterx_account` add-position/order. */
+exports.ACCUMULATOR_ROOT = "0xacc";