@waterx/sdk 2.4.0 → 3.0.0

package/dist/src/oracle/pyth.js

@@ -0,0 +1,220 @@
+/**
+ * Pyth as a price *source*: Hermes REST + the on-chain Pyth update PTB.
+ *
+ * This file knows nothing about oracle *rules* (pyth_rule / supra_rule /
+ * constant_rule / sponsor) — it only fetches price update VAAs from Hermes and
+ * appends the Pyth on-chain update block, returning the refreshed
+ * `PriceInfoObject` IDs. Feeding rules into a collector and aggregating lives in
+ * `aggregate.ts`; the rule wrappers live in `rules/`.
+ *
+ * On-chain a single PTB:
+ *   1. wormhole::vaa::parse_and_verify
+ *   2. pyth::create_authenticated_price_infos_using_accumulator
+ *   3. pyth::update_single_price_feed (one per feed)
+ *   4. hot_potato_vector::destroy
+ */
+import { fromHex, toHex } from "@mysten/bcs";
+import { bcs } from "@mysten/sui/bcs";
+export class PythCache {
+    pythStateInfo;
+    wormholePackageId;
+    priceTableInfo;
+    priceFeedObjectIdCache = new Map();
+}
+// ============================================================================
+// Hermes REST
+// ============================================================================
+export async function fetchPriceFeedsUpdateData(endpoint, priceIds) {
+    if (priceIds.length === 0)
+        return [];
+    const url = new URL("/v2/updates/price/latest", endpoint);
+    priceIds.forEach((id) => url.searchParams.append("ids[]", id));
+    const res = await fetch(url.toString(), { signal: AbortSignal.timeout(15_000) });
+    if (!res.ok)
+        throw new Error(`Hermes price fetch failed: ${res.status} ${await res.text()}`);
+    const json = (await res.json());
+    const data = json.binary?.data;
+    if (!Array.isArray(data) || data.length === 0) {
+        throw new Error("Hermes returned no binary price data");
+    }
+    return data.map((hex) => fromHex(hex));
+}
+// ============================================================================
+// On-chain helpers (cached)
+// ============================================================================
+function pkgFromUpgradeCap(json, objectId) {
+    const upgradeCap = json.upgrade_cap ??
+        json.fields?.upgrade_cap;
+    const nested = upgradeCap?.fields?.package;
+    const pkg = typeof upgradeCap?.package === "string"
+        ? upgradeCap.package
+        : typeof nested === "string"
+            ? nested
+            : undefined;
+    if (!pkg)
+        throw new Error(`Cannot resolve package id for object ${objectId}`);
+    return pkg;
+}
+async function getPythStateInfo(client, pythStateId, cache) {
+    if (cache?.pythStateInfo)
+        return cache.pythStateInfo;
+    const result = await client.getObject({ objectId: pythStateId, include: { json: true } });
+    const json = result.object?.json;
+    if (!json)
+        throw new Error("Unable to fetch pyth state");
+    const packageId = pkgFromUpgradeCap(json, pythStateId);
+    const fields = json.fields;
+    const fee = (fields?.base_update_fee ?? json.base_update_fee);
+    if (fee === undefined)
+        throw new Error("Unable to fetch pyth state base_update_fee");
+    const info = { packageId, baseUpdateFee: BigInt(fee) };
+    if (cache)
+        cache.pythStateInfo = info;
+    return info;
+}
+async function getWormholePackageId(client, wormholeStateId, cache) {
+    if (cache?.wormholePackageId)
+        return cache.wormholePackageId;
+    const result = await client.getObject({ objectId: wormholeStateId, include: { json: true } });
+    const json = result.object?.json;
+    if (!json)
+        throw new Error(`Cannot resolve wormhole package id from ${wormholeStateId}`);
+    const pkg = pkgFromUpgradeCap(json, wormholeStateId);
+    if (cache)
+        cache.wormholePackageId = pkg;
+    return pkg;
+}
+async function getPriceTableInfo(client, pythStateId, cache) {
+    if (cache?.priceTableInfo)
+        return cache.priceTableInfo;
+    const list = await client.listDynamicFields({ parentId: pythStateId });
+    const entry = list.dynamicFields.find((e) => {
+        const vt = e.valueType || e.objectType || "";
+        return vt.includes("PriceIdentifier") || vt.includes("price_info");
+    });
+    if (!entry)
+        throw new Error("Price table not found in Pyth state dynamic fields");
+    const childId = entry.childId ?? entry.objectId;
+    const typeStr = entry.valueType || entry.objectType || "";
+    if (!childId)
+        throw new Error("Price table missing childId");
+    const pkgMatch = typeStr.match(/(0x[a-fA-F0-9]+)::price_identifier::PriceIdentifier/);
+    if (!pkgMatch)
+        throw new Error(`Cannot extract package from price table type: ${typeStr}`);
+    const info = { id: childId, fieldType: pkgMatch[1] };
+    if (cache)
+        cache.priceTableInfo = info;
+    return info;
+}
+async function getPriceFeedObjectId(client, table, feedId, cache, pythStateId) {
+    const normalized = feedId.replace(/^0x/, "");
+    const cacheKey = pythStateId ? `${pythStateId}:${normalized}` : normalized;
+    if (cache?.priceFeedObjectIdCache.has(cacheKey)) {
+        return cache.priceFeedObjectIdCache.get(cacheKey);
+    }
+    const keyBytes = bcs
+        .struct("PriceIdentifier", { bytes: bcs.vector(bcs.u8()) })
+        .serialize({ bytes: fromHex(normalized) })
+        .toBytes();
+    const result = await client.getDynamicField({
+        parentId: table.id,
+        name: { type: `${table.fieldType}::price_identifier::PriceIdentifier`, bcs: keyBytes },
+    });
+    const value = result.dynamicField?.value;
+    const objectId = !value?.bcs || value.bcs.length < 32 ? undefined : "0x" + toHex(value.bcs);
+    if (cache)
+        cache.priceFeedObjectIdCache.set(cacheKey, objectId);
+    return objectId;
+}
+// ============================================================================
+// Accumulator parsing
+// ============================================================================
+function extractVaaBytes(accumulatorMessage) {
+    const view = new DataView(accumulatorMessage.buffer, accumulatorMessage.byteOffset, accumulatorMessage.byteLength);
+    const trailingPayloadSize = view.getUint8(6);
+    const vaaSizeOffset = 7 + trailingPayloadSize + 1; // +1 for proof_type
+    const vaaSize = view.getUint16(vaaSizeOffset, false);
+    const vaaOffset = vaaSizeOffset + 2;
+    return accumulatorMessage.subarray(vaaOffset, vaaOffset + vaaSize);
+}
+// ============================================================================
+// Pyth update calls
+// ============================================================================
+/**
+ * Append the on-chain Pyth update PTB block. Returns `PriceInfoObject` IDs
+ * (one per `feedIds`, same order). After this you can feed `pyth_rule` per
+ * ticker against the matching `PriceInfoObject` (see `rules/pyth-rule.ts`).
+ *
+ * If `sponsorFund` is provided, the per-feed update fee comes from the
+ * sponsor pool (`pyth_sponsor_rule::split`) instead of `tx.gas`. Opening and
+ * reimbursing that fund is the sponsor rule's job (`rules/sponsor.ts`); here we
+ * only draw a fee coin from the already-open `fund` hot potato.
+ */
+export async function buildPythPriceUpdateCalls(tx, host, updates, feedIds, cache, sponsorFund) {
+    if (updates.length === 0) {
+        throw new Error("No price update data provided; Hermes returned empty results");
+    }
+    if (updates.length > 1) {
+        throw new Error("Only a single accumulator message is supported per transaction");
+    }
+    const pyth = host.pyth;
+    const [stateInfo, wormholePackageId, table] = await Promise.all([
+        getPythStateInfo(host.grpcClient, pyth.state_id, cache),
+        getWormholePackageId(host.grpcClient, pyth.wormhole_state_id, cache),
+        getPriceTableInfo(host.grpcClient, pyth.state_id, cache),
+    ]);
+    const priceInfoObjectIds = await Promise.all(feedIds.map((feedId) => getPriceFeedObjectId(host.grpcClient, table, feedId, cache, pyth.state_id)));
+    const { packageId: pythPackageId, baseUpdateFee } = stateInfo;
+    // 1. Verify VAA
+    const vaa = extractVaaBytes(updates[0]);
+    const [verifiedVaa] = tx.moveCall({
+        target: `${wormholePackageId}::vaa::parse_and_verify`,
+        arguments: [tx.object(pyth.wormhole_state_id), tx.pure.vector("u8", vaa), tx.object.clock()],
+    });
+    // 2. Authenticate price infos
+    const [hotPotato0] = tx.moveCall({
+        target: `${pythPackageId}::pyth::create_authenticated_price_infos_using_accumulator`,
+        arguments: [
+            tx.object(pyth.state_id),
+            tx.pure.vector("u8", updates[0]),
+            verifiedVaa,
+            tx.object.clock(),
+        ],
+    });
+    // 3. Per-feed update
+    let hotPotato = hotPotato0;
+    for (let i = 0; i < feedIds.length; i++) {
+        const priceInfoObjectId = priceInfoObjectIds[i];
+        if (!priceInfoObjectId) {
+            throw new Error(`Pyth feed ${feedIds[i]} not registered on-chain in Pyth state`);
+        }
+        const feeCoin = sponsorFund
+            ? tx.moveCall({
+                target: `${sponsorFund.packageId}::pyth_sponsor_rule::split`,
+                arguments: [sponsorFund.fund],
+            })[0]
+            : tx.splitCoins(tx.gas, [tx.pure.u64(baseUpdateFee)])[0];
+        [hotPotato] = tx.moveCall({
+            target: `${pythPackageId}::pyth::update_single_price_feed`,
+            arguments: [
+                tx.object(pyth.state_id),
+                hotPotato,
+                tx.object(priceInfoObjectId),
+                feeCoin,
+                tx.object.clock(),
+            ],
+        });
+    }
+    // 4. Destroy hot potato
+    tx.moveCall({
+        target: `${pythPackageId}::hot_potato_vector::destroy`,
+        arguments: [hotPotato],
+        typeArguments: [`${pythPackageId}::price_info::PriceInfo`],
+    });
+    return priceInfoObjectIds;
+}
+/** All-in-one: fetch from Hermes, append update calls. Returns PriceInfoObject IDs. */
+export async function updatePythPrices(tx, host, feedIds, cache, sponsorFund) {
+    const updates = await fetchPriceFeedsUpdateData(host.pyth.hermes_endpoint, feedIds);
+    return buildPythPriceUpdateCalls(tx, host, updates, feedIds, cache, sponsorFund);
+}

package/dist/src/oracle/rules/constant-rule.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `constant_rule::feed` — feed a constant-pinned price into the collector. Used
+ * for constant tickers ({@link OracleHost.isConstantTicker}); the price comes
+ * from the on-chain `constant_rule::Config`, so no Pyth update is needed for a
+ * constant-only ticker.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { OracleHost } from "../host.ts";
+export declare function feedConstantRule(tx: Transaction, host: OracleHost, collector: TransactionArgument): void;

package/dist/src/oracle/rules/constant-rule.js

@@ -0,0 +1,14 @@
+/**
+ * `constant_rule::feed` — feed a constant-pinned price into the collector. Used
+ * for constant tickers ({@link OracleHost.isConstantTicker}); the price comes
+ * from the on-chain `constant_rule::Config`, so no Pyth update is needed for a
+ * constant-only ticker.
+ */
+import { feed as constantRuleFeed } from "../../generated/waterx_constant_rule/constant_rule.js";
+export function feedConstantRule(tx, host, collector) {
+    const constant = host.config.packages.constant_rule;
+    constantRuleFeed({
+        package: constant.published_at,
+        arguments: { collector, config: tx.object(constant.config) },
+    })(tx);
+}

package/dist/src/oracle/rules/pyth-rule.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `pyth_rule::feed` — feed a refreshed Pyth `PriceInfoObject` into an oracle
+ * `PriceCollector`. The rule resolves the on-chain feed by ticker via its
+ * `Config.identifier_map`, so it is not typed `<T>`.
+ *
+ * Caller must run the Pyth on-chain update first (see `../pyth.ts`) so the
+ * `PriceInfoObject` is fresh.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { OracleHost } from "../host.ts";
+export declare function feedPythRule(tx: Transaction, host: OracleHost, collector: TransactionArgument, priceInfoObjectId: string): void;

package/dist/src/oracle/rules/pyth-rule.js

@@ -0,0 +1,20 @@
+/**
+ * `pyth_rule::feed` — feed a refreshed Pyth `PriceInfoObject` into an oracle
+ * `PriceCollector`. The rule resolves the on-chain feed by ticker via its
+ * `Config.identifier_map`, so it is not typed `<T>`.
+ *
+ * Caller must run the Pyth on-chain update first (see `../pyth.ts`) so the
+ * `PriceInfoObject` is fresh.
+ */
+import { feed as pythRuleFeed } from "../../generated/waterx_pyth_rule/pyth_rule.js";
+export function feedPythRule(tx, host, collector, priceInfoObjectId) {
+    pythRuleFeed({
+        package: host.config.packages.pyth_rule.published_at,
+        arguments: {
+            collector,
+            config: tx.object(host.config.packages.pyth_rule.config),
+            pythState: tx.object(host.pyth.state_id),
+            pythPriceInfo: tx.object(priceInfoObjectId),
+        },
+    })(tx);
+}

package/dist/src/oracle/rules/sponsor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `pyth_sponsor_rule` — pay Pyth update fees from a shared sponsor pool AND
+ * attach the `PythSponsorRule` witness to a `TradingRequest`. Required when the
+ * market's `request_checklist` contains `PythSponsorRule`.
+ *
+ * Flow: {@link openPythSponsorFund} opens a `Fund` hot potato; pass the returned
+ * `{ fund, packageId }` to the Pyth update path as its `sponsorFund` (it draws
+ * per-feed fees via `pyth_sponsor_rule::split`); then {@link reimbursePythSponsor}
+ * consumes the `Fund`, returns leftover SUI, and attaches the witness.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { OracleHost } from "../host.ts";
+/**
+ * Opens a `Fund` hot potato from the shared PythSponsor pool. Pass the returned
+ * `{ fund, packageId }` straight to `refreshOraclePrices` as `sponsorFund`, then
+ * {@link reimbursePythSponsor} once the TradingRequest is built.
+ */
+export declare function openPythSponsorFund(tx: Transaction, host: OracleHost): {
+    fund: TransactionArgument;
+    packageId: string;
+};
+/**
+ * Consumes the `Fund` hot potato from {@link openPythSponsorFund}, returns any
+ * leftover SUI to the sponsor pool, and attaches the `PythSponsorRule` witness to
+ * the given `TradingRequest<C_TOKEN>` so `trading::execute` can satisfy a
+ * checklist that includes `PythSponsorRule`.
+ */
+export declare function reimbursePythSponsor(tx: Transaction, host: OracleHost, fund: TransactionArgument, tradingRequest: TransactionArgument, collateralType: string): void;

package/dist/src/oracle/rules/sponsor.js

@@ -0,0 +1,48 @@
+/**
+ * `pyth_sponsor_rule` — pay Pyth update fees from a shared sponsor pool AND
+ * attach the `PythSponsorRule` witness to a `TradingRequest`. Required when the
+ * market's `request_checklist` contains `PythSponsorRule`.
+ *
+ * Flow: {@link openPythSponsorFund} opens a `Fund` hot potato; pass the returned
+ * `{ fund, packageId }` to the Pyth update path as its `sponsorFund` (it draws
+ * per-feed fees via `pyth_sponsor_rule::split`); then {@link reimbursePythSponsor}
+ * consumes the `Fund`, returns leftover SUI, and attaches the witness.
+ */
+import { reimburse as sponsorReimburse, request as sponsorRequest, } from "../../generated/pyth_sponsor_rule/pyth_sponsor_rule.js";
+/**
+ * Opens a `Fund` hot potato from the shared PythSponsor pool. Pass the returned
+ * `{ fund, packageId }` straight to `refreshOraclePrices` as `sponsorFund`, then
+ * {@link reimbursePythSponsor} once the TradingRequest is built.
+ */
+export function openPythSponsorFund(tx, host) {
+    const entry = host.config.packages.pyth_sponsor_rule;
+    if (!entry?.published_at || !entry.pyth_sponsor) {
+        throw new Error("pyth_sponsor_rule.{published_at,pyth_sponsor} missing — sponsor flow unavailable");
+    }
+    const [fund] = sponsorRequest({
+        package: entry.published_at,
+        arguments: { self: tx.object(entry.pyth_sponsor) },
+    })(tx);
+    return { fund: fund, packageId: entry.published_at };
+}
+/**
+ * Consumes the `Fund` hot potato from {@link openPythSponsorFund}, returns any
+ * leftover SUI to the sponsor pool, and attaches the `PythSponsorRule` witness to
+ * the given `TradingRequest<C_TOKEN>` so `trading::execute` can satisfy a
+ * checklist that includes `PythSponsorRule`.
+ */
+export function reimbursePythSponsor(tx, host, fund, tradingRequest, collateralType) {
+    const entry = host.config.packages.pyth_sponsor_rule;
+    if (!entry?.published_at || !entry.pyth_sponsor) {
+        throw new Error("pyth_sponsor_rule missing from config");
+    }
+    sponsorReimburse({
+        package: entry.published_at,
+        arguments: {
+            self: tx.object(entry.pyth_sponsor),
+            fund: fund,
+            tradingReq: tradingRequest,
+        },
+        typeArguments: [collateralType],
+    })(tx);
+}

package/dist/src/oracle/rules/supra-rule.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `supra_rule::feed` — feed Supra as a second weighted rule on the same
+ * `PriceCollector` as Pyth, before `aggregate`.
+ *
+ * `maybeFeedSupra` is a no-op unless the deployment has supra enabled + wired
+ * (see {@link OracleHost.getSupraRule}), so Pyth-only deployments are unchanged.
+ * On-chain the rule abstains for symbols it has no pair for.
+ */
+import type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
+import type { OracleHost } from "../host.ts";
+export declare function maybeFeedSupra(tx: Transaction, host: OracleHost, collector: TransactionArgument): void;

package/dist/src/oracle/rules/supra-rule.js

@@ -0,0 +1,22 @@
+/**
+ * `supra_rule::feed` — feed Supra as a second weighted rule on the same
+ * `PriceCollector` as Pyth, before `aggregate`.
+ *
+ * `maybeFeedSupra` is a no-op unless the deployment has supra enabled + wired
+ * (see {@link OracleHost.getSupraRule}), so Pyth-only deployments are unchanged.
+ * On-chain the rule abstains for symbols it has no pair for.
+ */
+import { feed as supraRuleFeed } from "../../generated/waterx_supra_rule/supra_rule.js";
+export function maybeFeedSupra(tx, host, collector) {
+    const supra = host.getSupraRule();
+    if (!supra)
+        return;
+    supraRuleFeed({
+        package: supra.published_at,
+        arguments: {
+            collector,
+            config: tx.object(supra.config),
+            oracleHolder: tx.object(supra.oracle_holder),
+        },
+    })(tx);
+}

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

@@ -0,0 +1,78 @@
+/**
+ * WaterX Perp client — the perp product line (trading, orders, WLP, staking).
+ *
+ * One of the two sub-clients behind the umbrella `WaterXClient`; reachable as
+ * `client.perp` (which also carries the perp builders). Initialization is async —
+ * config is fetched from the canonical `waterx-config` JSON (default: GitHub raw).
+ * See `PerpClient.create()`.
+ *
+ * Composition: the gRPC transport half is inherited from {@link BaseLineClient}
+ * (shared with `PredictClient`); the canonical-schema lookups are delegated to a
+ * {@link PerpConfigView}. This class is just the wiring + factory between them.
+ */
+import { BaseLineClient } from "../base-client.ts";
+import { type LoadConfigOptions, type PythInfraConfig, type WaterXConfig, type WormholeInfraConfig } from "./config.ts";
+import type { Network } from "./constants.ts";
+export interface CreateClientOptions extends LoadConfigOptions {
+    grpcUrl?: string;
+}
+export declare class PerpClient extends BaseLineClient<WaterXConfig> {
+    /** Pyth infra (network defaults unless overridden in JSON). */
+    pyth: PythInfraConfig;
+    /** Wormhole infra for the credit bridge (network defaults unless overridden). */
+    wormhole: WormholeInfraConfig;
+    /** Canonical-schema lookups (delegated to below); no transport. */
+    private readonly view;
+    constructor(network: Network, config: WaterXConfig, opts?: {
+        grpcUrl?: string;
+    });
+    /**
+     * Async factory: fetches the deployment config for `network` and returns
+     * a ready-to-use client. Pass `opts.cache=true` to memoize the JSON.
+     */
+    static create(network: Network, opts?: CreateClientOptions): Promise<PerpClient>;
+    static mainnet(opts?: CreateClientOptions): Promise<PerpClient>;
+    static testnet(opts?: CreateClientOptions): Promise<PerpClient>;
+    /** @see PerpConfigView.getMarket */
+    getMarket(ticker: string): import("./config.ts").WaterxPerpMarketEntry;
+    /** @see PerpConfigView.getAggregator */
+    getAggregator(ticker: string): string;
+    /** @see PerpConfigView.getPythFeed */
+    getPythFeed(ticker: string): {
+        feed_id: string;
+        price_info_object: string;
+    };
+    /** @see PerpConfigView.isConstantTicker */
+    isConstantTicker(ticker: string): boolean;
+    /** @see PerpConfigView.getSupraRule */
+    getSupraRule(): {
+        published_at: string;
+        config: string;
+        oracle_holder: string;
+    } | undefined;
+    /** @see PerpConfigView.getPoolTokenType */
+    getPoolTokenType(tickerOrName: string): string;
+    /** @see PerpConfigView.wlpType */
+    wlpType(): string;
+    /** @see PerpConfigView.getRewarders */
+    getRewarders(stakeAlias: string): {
+        alias: string;
+        rewarder_id: string;
+        coin_type: string;
+        decimals: number;
+    }[];
+    /** @see PerpConfigView.getRewarderTypes */
+    getRewarderTypes(stakeAlias: string): string[];
+    /** @see PerpConfigView.getCredit */
+    getCredit(): import("./config.ts").WaterxCreditPackage;
+    /** @see PerpConfigView.creditType */
+    creditType(): string;
+    /** @see PerpConfigView.getBridge */
+    getBridge(): import("./config.ts").WormholeBridgePackage;
+    /** @see PerpConfigView.wormholeStateId */
+    wormholeStateId(): string;
+    /** @see PerpConfigView.getNativeAssets */
+    getNativeAssets(): readonly import("./config.ts").NativeCustodyAsset[];
+    /** @see PerpConfigView.getNativeAsset */
+    getNativeAsset(moveType: string): import("./config.ts").NativeCustodyAsset;
+}

package/dist/src/perp/client.js

@@ -0,0 +1,108 @@
+/**
+ * WaterX Perp client — the perp product line (trading, orders, WLP, staking).
+ *
+ * One of the two sub-clients behind the umbrella `WaterXClient`; reachable as
+ * `client.perp` (which also carries the perp builders). Initialization is async —
+ * config is fetched from the canonical `waterx-config` JSON (default: GitHub raw).
+ * See `PerpClient.create()`.
+ *
+ * Composition: the gRPC transport half is inherited from {@link BaseLineClient}
+ * (shared with `PredictClient`); the canonical-schema lookups are delegated to a
+ * {@link PerpConfigView}. This class is just the wiring + factory between them.
+ */
+import { BaseLineClient } from "../base-client.js";
+import { PerpConfigView } from "./config-view.js";
+import { loadConfig, PYTH_DEFAULTS, WORMHOLE_DEFAULTS, } from "./config.js";
+export class PerpClient extends BaseLineClient {
+    /** Pyth infra (network defaults unless overridden in JSON). */
+    pyth;
+    /** Wormhole infra for the credit bridge (network defaults unless overridden). */
+    wormhole;
+    /** Canonical-schema lookups (delegated to below); no transport. */
+    view;
+    constructor(network, config, opts = {}) {
+        super(network, config, opts);
+        this.pyth = config.pyth ?? PYTH_DEFAULTS[network];
+        this.wormhole = config.wormhole ?? WORMHOLE_DEFAULTS[network];
+        this.view = new PerpConfigView(() => this.config, () => this.wormhole);
+    }
+    /**
+     * Async factory: fetches the deployment config for `network` and returns
+     * a ready-to-use client. Pass `opts.cache=true` to memoize the JSON.
+     */
+    static async create(network, opts = {}) {
+        const config = await loadConfig(network, opts);
+        return new PerpClient(network, config, { grpcUrl: opts.grpcUrl });
+    }
+    static mainnet(opts = {}) {
+        return PerpClient.create("MAINNET", opts);
+    }
+    static testnet(opts = {}) {
+        return PerpClient.create("TESTNET", opts);
+    }
+    // ========================================================
+    // Config-schema lookups — delegated to PerpConfigView.
+    // (Kept on the client so the ~50 builders typed `PerpClient` call them
+    // directly, e.g. `client.wlpType()`. See perp-config-view.ts for docs.)
+    // ========================================================
+    /** @see PerpConfigView.getMarket */
+    getMarket(ticker) {
+        return this.view.getMarket(ticker);
+    }
+    /** @see PerpConfigView.getAggregator */
+    getAggregator(ticker) {
+        return this.view.getAggregator(ticker);
+    }
+    /** @see PerpConfigView.getPythFeed */
+    getPythFeed(ticker) {
+        return this.view.getPythFeed(ticker);
+    }
+    /** @see PerpConfigView.isConstantTicker */
+    isConstantTicker(ticker) {
+        return this.view.isConstantTicker(ticker);
+    }
+    /** @see PerpConfigView.getSupraRule */
+    getSupraRule() {
+        return this.view.getSupraRule();
+    }
+    /** @see PerpConfigView.getPoolTokenType */
+    getPoolTokenType(tickerOrName) {
+        return this.view.getPoolTokenType(tickerOrName);
+    }
+    /** @see PerpConfigView.wlpType */
+    wlpType() {
+        return this.view.wlpType();
+    }
+    /** @see PerpConfigView.getRewarders */
+    getRewarders(stakeAlias) {
+        return this.view.getRewarders(stakeAlias);
+    }
+    /** @see PerpConfigView.getRewarderTypes */
+    getRewarderTypes(stakeAlias) {
+        return this.view.getRewarderTypes(stakeAlias);
+    }
+    /** @see PerpConfigView.getCredit */
+    getCredit() {
+        return this.view.getCredit();
+    }
+    /** @see PerpConfigView.creditType */
+    creditType() {
+        return this.view.creditType();
+    }
+    /** @see PerpConfigView.getBridge */
+    getBridge() {
+        return this.view.getBridge();
+    }
+    /** @see PerpConfigView.wormholeStateId */
+    wormholeStateId() {
+        return this.view.wormholeStateId();
+    }
+    /** @see PerpConfigView.getNativeAssets */
+    getNativeAssets() {
+        return this.view.getNativeAssets();
+    }
+    /** @see PerpConfigView.getNativeAsset */
+    getNativeAsset(moveType) {
+        return this.view.getNativeAsset(moveType);
+    }
+}

package/dist/src/{client.d.ts → perp/config-view.d.ts}

@@ -1,65 +1,20 @@
 /**
- * WaterX Protocol client.
+ * Perp config-schema views — read-only lookups over the parsed `waterx-config`
+ * JSON, with no transport dependency.
  *
- * Initialization is async — config is fetched from the canonical
- * `waterx-config` JSON (default: GitHub raw). See `WaterXClient.create()`.
+ * Split off the transport client (`PerpClient`) so the two responsibilities stay
+ * separate: `BaseLineClient` owns the gRPC half, this class owns the
+ * canonical-schema half. `PerpClient` composes one of these and delegates, so
+ * callers keep calling `client.getMarket(...)` / `client.wlpType()` unchanged.
+ * Tested in isolation against a plain config object — no network needed.
  */
-import { SuiGrpcClient } from "@mysten/sui/grpc";
-import { Transaction } from "@mysten/sui/transactions";
-import { type LoadConfigOptions, type NativeCustodyAsset, type PythInfraConfig, type WaterXConfig, type WormholeInfraConfig } from "./config.ts";
-import type { Network } from "./constants.ts";
-export interface CreateClientOptions extends LoadConfigOptions {
-    grpcUrl?: string;
-}
-export declare class WaterXClient {
-    /** gRPC client — all RPC including `simulateTransaction`. */
-    grpcClient: SuiGrpcClient;
-    /** Network identifier in upper case (`MAINNET` / `TESTNET`). */
-    network: Network;
-    /** Parsed canonical `waterx-config` JSON. */
-    config: WaterXConfig;
-    /** Pyth infra (network defaults unless overridden in JSON). */
-    pyth: PythInfraConfig;
-    /** Wormhole infra for the credit bridge (network defaults unless overridden). */
-    wormhole: WormholeInfraConfig;
-    constructor(network: Network, config: WaterXConfig, opts?: {
-        grpcUrl?: string;
-    });
-    /**
-     * Async factory: fetches the deployment config for `network` and returns
-     * a ready-to-use client. Pass `opts.cache=true` to memoize the JSON.
-     */
-    static create(network: Network, opts?: CreateClientOptions): Promise<WaterXClient>;
-    static mainnet(opts?: CreateClientOptions): Promise<WaterXClient>;
-    static testnet(opts?: CreateClientOptions): Promise<WaterXClient>;
-    getObject(objectId: string): Promise<import("@mysten/sui/client").SuiClientTypes.GetObjectResponse<{}>>;
-    getObjects(objectIds: string[]): Promise<import("@mysten/sui/client").SuiClientTypes.GetObjectsResponse<{}>>;
-    listOwnedObjects(owner: string): Promise<import("@mysten/sui/client").SuiClientTypes.ListOwnedObjectsResponse<{}>>;
-    listCoins(params: {
-        owner: string;
-        coinType?: string;
-    }): Promise<import("@mysten/sui/client").SuiClientTypes.ListCoinsResponse>;
-    getBalance(params: {
-        owner: string;
-        coinType?: string;
-    }): Promise<import("@mysten/sui/client").SuiClientTypes.GetBalanceResponse>;
-    listDynamicFields(parentId: string): ReturnType<SuiGrpcClient["listDynamicFields"]>;
-    getDynamicField(parentId: string, name: {
-        type: string;
-        bcs: Uint8Array;
-    }): Promise<import("@mysten/sui/client").SuiClientTypes.GetDynamicFieldResponse>;
-    waitForTransaction(digest: string): Promise<import("@mysten/sui/client").SuiClientTypes.TransactionResult<{}>>;
-    simulate(tx: Transaction): Promise<import("@mysten/sui/client").SuiClientTypes.SimulateTransactionResult<{
-        commandResults: true;
-    }>>;
-    signAndExecuteTransaction(params: {
-        signer: {
-            toSuiAddress: () => string;
-        } & import("@mysten/sui/cryptography").Signer;
-        transaction: Transaction;
-    }): Promise<import("@mysten/sui/client").SuiClientTypes.TransactionResult<{}>>;
-    /** All package IDs (`published_at`) keyed by package name. */
-    packageIds(): Record<string, string>;
+import type { NativeCustodyAsset, WaterXConfig, WormholeInfraConfig } from "./config.ts";
+export declare class PerpConfigView {
+    private readonly getConfig;
+    private readonly getWormhole;
+    constructor(getConfig: () => WaterXConfig, getWormhole: () => WormholeInfraConfig);
+    private get config();
+    private get wormhole();
     /** `waterx_perp.markets[ticker]`, throws if unknown. */
     getMarket(ticker: string): import("./config.ts").WaterxPerpMarketEntry;
     /** `waterx_oracle.aggregators[ticker]`, throws if unknown. */
@@ -137,7 +92,7 @@ export declare class WaterXClient {
     getBridge(): import("./config.ts").WormholeBridgePackage;
     /**
      * Sui Wormhole `State` object id — prefers the per-deployment
-     * `wormhole_bridge.wormhole_state`, falls back to `client.wormhole`.
+     * `wormhole_bridge.wormhole_state`, falls back to the line's `wormhole` infra.
      */
     wormholeStateId(): string;
     /** All native-custody backing-asset rows (throws if no custody vault). */