@waterx/sdk 2.4.1 → 3.0.0

package/dist/src/unified-client.js

@@ -1,34 +1,54 @@
 /**
- * Unified WaterX SDK client.
+ * Umbrella WaterX SDK client — the main entry point.
  *
- * Wraps the two product-line clients (`WaterXClient` for perp, `PredictClient`
- * for prediction) behind a single object with namespaced modules, so the
- * colliding builder names (`placeOrder`, `createAccount`, `deposit`, …) can be
- * called unambiguously:
+ * Exposes three namespaces over the two product-line sub-clients:
  *
- *   const client = await Client.create({ network: "TESTNET" });
- *   client.perp.openPosition(tx, params);     // -> perp builder
- *   client.predict.placeOrder(tx, params);    // -> prediction builder
+ *   const client = await WaterXClient.create({ network: "TESTNET" });
+ *   client.account.createAccount(tx, { alias });   // -> shared waterx_account + funding
+ *   client.perp.placeOrderRequest(tx, params);     // -> perp builder
+ *   client.predict.placeOrder(tx, params);         // -> prediction builder
  *
- * The modules are thin: each method forwards to the existing free-function
- * builder with the line's client pre-bound as the first argument. Builders are
- * build-only (they return / mutate a `Transaction`); signing & execution stay
- * with the caller (`client.perpClient` / `client.predictClient`, or a wallet),
- * so frontend wallet flows and multi-step Pyth injection keep working.
+ * `client.perp` **is** the `PerpClient` instance with the perp builder/view
+ * methods grafted on, and `client.predict` **is** the `PredictClient` instance
+ * likewise — so signing & execution live on the same object
+ * (`client.perp.signAndExecuteTransaction(...)`) right next to the builders.
+ * There are no separate `.perpClient` / `.predictClient` accessors.
+ *
+ * `client.account` is a thin namespace (no own client) bound to the perp
+ * sub-client: the perp config carries the shared `waterx_account` registry plus
+ * the bridge / native_custody / withdrawal_queue / credit_registry that the
+ * credit & custody builders read. `waterx_account` is one shared on-chain object,
+ * so an account created here serves both lines — except when the two lines target
+ * different networks (`opts.perp.network !== opts.predict.network`), where
+ * `client.account` follows the perp line; split-network callers should reach the
+ * predict line's generic account builders via the `prediction` namespace directly.
+ *
+ * Each namespace method forwards to the existing free-function builder with the
+ * line's client pre-bound as the first argument; builders are build-only (they
+ * return / mutate a `Transaction`), so frontend wallet flows and multi-step Pyth
+ * injection keep working.
  */
-import { WaterXClient } from "./client.js";
+// Unified account namespace: generic waterx_account framework + funding (credit + custody).
+import * as accountOps from "./account/index.js";
+import * as perpReferral from "./account/referral.js";
+import { PerpClient } from "./perp/client.js";
 // Perp builder/view modules (every export takes the client as its first arg).
-import * as perpFetch from "./fetch.js";
-// Prediction builder/view modules (every export takes the client as its first arg).
-import * as predAccount from "./prediction/account.js";
+import * as perpFetch from "./perp/fetch.js";
+import * as perpTx from "./perp/tx-builders.js";
+// Perp-only user builders — account/credit/custody are excluded here; they live
+// under `client.account`. trading / order / wlp / staking / referral only.
+import * as perpOrder from "./perp/user/order.js";
+import * as perpStaking from "./perp/user/staking.js";
+import * as perpTrading from "./perp/user/trading.js";
+import * as perpWlp from "./perp/user/wlp.js";
+// Prediction-specific account ops (need the prediction package; NOT generic account).
+import { allowPredictionProtocolAsset, disallowPredictionProtocolAsset, setDelegatePredictionPermission, whitelistPredictionProtocol, } from "./prediction/account.js";
 import * as predAdmin from "./prediction/admin.js";
 import { PredictClient, } from "./prediction/client.js";
 import * as predFetch from "./prediction/fetch.js";
 import * as predGift from "./prediction/gift.js";
 import * as predOps from "./prediction/prediction.js";
 import { buildBatchClaimTx as buildPredictBatchClaimTx, buildPlaceOrderTx as buildPredictPlaceOrderTx, } from "./prediction/tx-builders.js";
-import * as perpTx from "./tx-builders.js";
-import * as perpUser from "./user/index.js";
 /**
  * Exports from the spread builder/view modules that are NOT client-first — their
  * first argument is not the line client, so they must not become bound facade
@@ -62,40 +82,68 @@ function bindClient(client, ns) {
     }
     return out;
 }
+// Prediction-specific account ops kept on `client.predict` (generic account ops
+// moved to `client.account`).
+const predAccountSpecific = {
+    setDelegatePredictionPermission,
+    whitelistPredictionProtocol,
+    allowPredictionProtocolAsset,
+    disallowPredictionProtocolAsset,
+};
 // Frozen, reused for both the runtime binding and the public module types.
-const perpOps = { ...perpUser, ...perpTx, ...perpFetch };
-const predictOps = { ...predAccount, ...predAdmin, ...predOps, ...predFetch, ...predGift };
-export class Client {
-    /** Underlying perp client — use for signing/executing perp transactions. */
-    perpClient;
-    /** Underlying prediction client — use for signing/executing prediction transactions. */
-    predictClient;
-    /** Perp builders & views (`client.perp.openPosition(tx, params)`). */
+const perpOps = {
+    ...perpTrading,
+    ...perpOrder,
+    ...perpWlp,
+    ...perpStaking,
+    ...perpReferral,
+    ...perpTx,
+    ...perpFetch,
+};
+const predictOps = { ...predAccountSpecific, ...predAdmin, ...predOps, ...predFetch, ...predGift };
+export class WaterXClient {
+    /** Shared account namespace (`client.account.createAccount(tx, params)`) — perp-backed. */
+    account;
+    /**
+     * Perp sub-client **with** the perp builders/views grafted on
+     * (`client.perp.placeOrderRequest(...)`, `client.perp.signAndExecuteTransaction(...)`).
+     */
     perp;
-    /** Prediction builders & views (`client.predict.placeOrder(tx, params)`). */
+    /**
+     * Prediction sub-client **with** the prediction builders/views grafted on
+     * (`client.predict.placeOrder(...)`, `client.predict.signAndExecuteTransaction(...)`).
+     */
     predict;
     /**
      * Async prediction builder: optional consolidate + `placeOrder`.
-     * Uses `perpClient` for the sweep and `predictClient` for the bet leg.
+     * Uses the perp client for the sweep and the predict client for the bet leg.
      */
     buildPredictPlaceOrderTx(params) {
-        return buildPredictPlaceOrderTx(this.perpClient, this.predictClient, params);
+        return buildPredictPlaceOrderTx(this.perp, this.predict, params);
     }
     /**
      * Async prediction builder: optional consolidate + `batchClaim`.
      */
     buildPredictBatchClaimTx(params) {
-        return buildPredictBatchClaimTx(this.perpClient, this.predictClient, params);
+        return buildPredictBatchClaimTx(this.perp, this.predict, params);
     }
     constructor(perpClient, predictClient) {
-        this.perpClient = perpClient;
-        this.predictClient = predictClient;
-        this.perp = bindClient(perpClient, perpOps);
-        this.predict = bindClient(predictClient, predictOps);
+        // Graft the bound builders onto the sub-client instances. No builder name
+        // collides with the client's own (transport/config) methods — enforced by the
+        // "graft guard" unit test (disjoint from the prototype chain), not just a
+        // comment. The instances stay `instanceof PerpClient` / `PredictClient`, so
+        // signing/config methods work.
+        this.perp = Object.assign(perpClient, bindClient(perpClient, perpOps));
+        this.predict = Object.assign(predictClient, bindClient(predictClient, predictOps));
+        this.account = bindClient(perpClient, accountOps);
     }
-    /** Combine two pre-built line clients (advanced — full control over each). */
+    /**
+     * Combine two pre-built line clients (advanced — full control over each).
+     * Note: this grafts the bound builder methods onto the provided client
+     * instances in place.
+     */
     static fromClients(perpClient, predictClient) {
-        return new Client(perpClient, predictClient);
+        return new WaterXClient(perpClient, predictClient);
     }
     /**
      * Async factory — loads each line's deployment config (from the canonical
@@ -106,18 +154,28 @@ export class Client {
         const baseNetwork = opts.network ?? "TESTNET";
         const { network: perpNetwork, ...perpRest } = opts.perp ?? {};
         const { network: predictNetwork, ...predictRest } = opts.predict ?? {};
-        const perpClient = await WaterXClient.create(perpNetwork ?? baseNetwork, {
+        const resolvedPerpNetwork = perpNetwork ?? baseNetwork;
+        const resolvedPredictNetwork = predictNetwork ?? baseNetwork;
+        if (resolvedPerpNetwork !== resolvedPredictNetwork) {
+            // `client.account` always follows the perp line (see the class header).
+            // On a split-network setup a caller reaching for `client.account.*` would
+            // silently build against the perp deployment — warn so it isn't a surprise.
+            console.warn(`[WaterXClient] split-network: perp=${resolvedPerpNetwork} predict=${resolvedPredictNetwork}. ` +
+                `client.account follows the perp line (${resolvedPerpNetwork}); reach the predict line's ` +
+                `generic account builders via the prediction namespace directly.`);
+        }
+        const perpClient = await PerpClient.create(resolvedPerpNetwork, {
             grpcUrl: opts.grpcUrl,
             configUrl: opts.configUrl,
             cache: opts.cache,
             ...perpRest,
         });
-        const predictClient = await PredictClient.create(predictNetwork ?? baseNetwork, {
+        const predictClient = await PredictClient.create(resolvedPredictNetwork, {
             grpcUrl: opts.grpcUrl,
             configUrl: opts.configUrl,
             cache: opts.cache,
             ...predictRest,
         });
-        return new Client(perpClient, predictClient);
+        return new WaterXClient(perpClient, predictClient);
     }
 }

package/dist/src/utils/config.d.ts

@@ -1,4 +1,4 @@
-import type { WaterXConfig } from "../config.ts";
+import type { WaterXConfig } from "../perp/config.ts";
 /** Returns all registered market tickers (e.g. "BTCUSD") from waterx-config. */
 export declare function getMarketTickers(config: WaterXConfig): string[];
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waterx/sdk",
-  "version": "2.4.1",
+  "version": "3.0.0",
   "description": "WaterX SDK — perpetuals and prediction markets on Sui",
   "license": "MIT",
   "author": "WaterX",
@@ -16,13 +16,29 @@
       "types": "./dist/src/sdk.d.ts",
       "import": "./dist/src/sdk.js"
     },
+    "./account": {
+      "types": "./dist/src/account/index.d.ts",
+      "import": "./dist/src/account/index.js"
+    },
+    "./account/*": {
+      "types": "./dist/src/account/*.d.ts",
+      "import": "./dist/src/account/*.js"
+    },
+    "./oracle": {
+      "types": "./dist/src/oracle/index.d.ts",
+      "import": "./dist/src/oracle/index.js"
+    },
+    "./oracle/*": {
+      "types": "./dist/src/oracle/*.d.ts",
+      "import": "./dist/src/oracle/*.js"
+    },
     "./perp": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
+      "types": "./dist/src/perp/index.d.ts",
+      "import": "./dist/src/perp/index.js"
     },
     "./perp/*": {
-      "types": "./dist/src/*.d.ts",
-      "import": "./dist/src/*.js"
+      "types": "./dist/src/perp/*.d.ts",
+      "import": "./dist/src/perp/*.js"
     },
     "./prediction": {
       "types": "./dist/src/prediction/index.d.ts",
@@ -102,6 +118,7 @@
     "smoke:chain": "tsx scripts/run-smoke-chain.ts",
     "smoke:chain:dry": "tsx scripts/run-smoke-chain.ts --dry-run",
     "seed:testnet": "tsx test/prediction/scripts/seed-testnet.ts",
+    "seed:testnet:perp": "tsx test/perp/scripts/seed-testnet.ts",
     "predict:list-accounts": "tsx test/prediction/scripts/list-accounts.ts",
     "predict:bootstrap-stress-accounts": "tsx test/prediction/scripts/bootstrap-stress-accounts.ts",
     "predict:bootstrap-stress-deposits": "tsx test/prediction/scripts/bootstrap-stress-deposits.ts",

package/dist/src/config.d.ts

@@ -1,292 +0,0 @@
-/**
- * WaterX deployment config — fetched at client init from the canonical
- * `waterx-config` repo (default: GitHub raw).
- *
- * The schema mirrors the canonical JSON layout one-to-one (each package
- * groups its own object IDs + per-ticker maps). External chain infra
- * (Pyth state, Wormhole state/core, Hermes & Wormholescan endpoints) is
- * **not** in the JSON — it lives in `PYTH_DEFAULTS` / `WORMHOLE_DEFAULTS`
- * below, keyed by network.
- */
-import type { Network } from "./constants.ts";
-export interface BasePackageEntry {
-    published_at: string;
-    original_id: string;
-    version: number;
-    upgrade_capability?: string;
-}
-export interface PythRulePackage extends BasePackageEntry {
-    config: string;
-    feeds: Record<string, {
-        feed_id: string;
-        price_info_object: string;
-    }>;
-}
-export interface PythSponsorRulePackage extends BasePackageEntry {
-    pyth_sponsor: string;
-}
-/** Per-ticker `constant_rule` feed entry (mirrors the `pyth_rule.feeds` shape). */
-export interface ConstantFeedEntry {
-    /**
-     * Constant 1e9-scaled price (decimal string), mirroring the on-chain
-     * `Config.prices` value (e.g. `"1000000000"` for $1). Informational off-chain —
-     * the on-chain `constant_rule::feed` reads the price from `Config`; the SDK only
-     * keys routing off the presence of the entry.
-     */
-    price: string;
-}
-export interface WaterxConstantRulePackage extends BasePackageEntry {
-    /** Shared `constant_rule::Config` holding the per-ticker constant prices. */
-    config: string;
-    /**
-     * Oracle ticker → constant feed entry, mirroring `pyth_rule.feeds`. A ticker
-     * present here is fed via `constant_rule::feed` instead of (steady state) or
-     * alongside (dual-feed) `pyth_rule::feed` (e.g. `USDCUSD → { price: "1000000000" }`).
-     */
-    feeds?: Record<string, ConstantFeedEntry>;
-}
-/** Per-ticker `supra_rule` feed entry (mirrors the `pyth_rule.feeds` shape). */
-export interface SupraFeedEntry {
-    /** Supra pair id (mirrors the on-chain `Config`; informational off-chain). */
-    pair_id: number;
-    /** Optional per-ticker freshness tolerance override (ms). */
-    tolerance_ms?: number;
-}
-export interface SupraRulePackage extends BasePackageEntry {
-    /** Shared `supra_rule::Config` (per-symbol Supra pair_id + freshness tolerance). */
-    config: string;
-    /** Supra `OracleHolder` shared object id (network-specific). Required to feed. */
-    oracle_holder?: string;
-    /** Oracle ticker → Supra feed entry (mirrors the on-chain `Config`; informational). */
-    feeds?: Record<string, SupraFeedEntry>;
-    /**
-     * When true AND `config` + `oracle_holder` are set, `refreshOraclePrices`
-     * feeds `supra_rule` on the same `PriceCollector` as Pyth before `aggregate`
-     * (a second weighted rule). Defaults to **false** so a Pyth-only deployment
-     * is unaffected — flip on only after `weight_threshold`/feeders are ready.
-     */
-    enabled?: boolean;
-}
-export interface WxaAccountPackage extends BasePackageEntry {
-    admin_cap: string;
-    account_registry: string;
-}
-export interface WaterxOraclePackage extends BasePackageEntry {
-    listing_cap: string;
-    oracle: string;
-    aggregators: Record<string, string>;
-}
-export interface WaterxPerpMarketEntry {
-    market: string;
-    config: string;
-}
-export interface WaterxPerpPackage extends BasePackageEntry {
-    admin_cap: string;
-    global_config: string;
-    market_registry_wlp: string;
-    markets: Record<string, WaterxPerpMarketEntry>;
-}
-export interface RewarderEntry {
-    /** `Rewarder<STAKE, R>` shared object ID. */
-    rewarder_id: string;
-    /** Fully-qualified reward coin Move type (e.g. `0x2::sui::SUI`). */
-    coin_type: string;
-    /** Reward coin display decimals. */
-    decimals: number;
-}
-export interface WaterxStakingPackage extends BasePackageEntry {
-    admin_cap?: string;
-    /** Map of stake-type alias (e.g. `"WLP"`) → `StakingPool<STAKE>` shared object ID. */
-    pools?: Record<string, string>;
-    /**
-     * Map of stake-type alias → reward-token alias → rewarder metadata.
-     * Reward-token alias is display-only (e.g. `"SUI"`, `"MOCK_SUI"`); the
-     * fully-qualified coin Move type lives on the {@link RewarderEntry}.
-     */
-    rewarders?: Record<string, Record<string, RewarderEntry>>;
-}
-export interface WlpPackage extends BasePackageEntry {
-    metadata_cap?: string;
-    currency?: string;
-    wlp_pool: string;
-    /** Optional `WlpAum<LP>` shared object; required by `mint_wlp` / `settle_redeem`. */
-    wlp_aum?: string;
-    /** Map of oracle ticker → fully-qualified Move type registered via `lp_pool::add_token`. */
-    pool_tokens: Record<string, string>;
-}
-export interface WaterxReferralPackage extends BasePackageEntry {
-    /** Shared `ReferralTable`. */
-    referral_table: string;
-}
-export interface MockCoinPackage extends BasePackageEntry {
-    currency?: string;
-    treasury_cap?: string;
-    metadata_cap?: 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;
-}
-export interface TestnetFaucetPackage {
-    published_at: string;
-    whitelist?: string[];
-    faucet?: string;
-}
-export interface WaterXPackages {
-    bucket_framework: BasePackageEntry;
-    waterx_referral?: WaterxReferralPackage;
-    pyth_rule: PythRulePackage;
-    pyth_sponsor_rule?: PythSponsorRulePackage;
-    constant_rule?: WaterxConstantRulePackage;
-    supra_rule?: SupraRulePackage;
-    waterx_account: WxaAccountPackage;
-    waterx_oracle: WaterxOraclePackage;
-    waterx_perp: WaterxPerpPackage;
-    waterx_perp_view: BasePackageEntry;
-    waterx_staking?: WaterxStakingPackage;
-    wlp: WlpPackage;
-    waterx_credit?: WaterxCreditPackage;
-    wormhole_bridge?: WormholeBridgePackage;
-    withdrawal_queue?: WithdrawalQueuePackage;
-    native_custody?: NativeCustodyPackage;
-    testnet_faucet?: TestnetFaucetPackage;
-    mock_usdc?: MockCoinPackage;
-    mock_usdsui?: MockCoinPackage;
-    mock_sui?: MockCoinPackage;
-    waterx_rule?: BasePackageEntry;
-    waterx_rule_nautilus_enclave?: BasePackageEntry;
-}
-export interface PythInfraConfig {
-    state_id: string;
-    wormhole_state_id: string;
-    hermes_endpoint: string;
-}
-export declare const PYTH_DEFAULTS: Record<Network, PythInfraConfig>;
-/**
- * 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;
-}
-export declare const WORMHOLE_DEFAULTS: Record<Network, WormholeInfraConfig>;
-export interface WaterXConfig {
-    /** Absent on credit-only deployment files. */
-    network?: "mainnet" | "testnet";
-    chain_id?: string | number | null;
-    /** Sui gRPC base URL (default: public Mysten fullnode for the network). */
-    grpcUrl?: string;
-    packages: WaterXPackages;
-    /** Pyth infra override (defaults from `PYTH_DEFAULTS[network]`). */
-    pyth?: PythInfraConfig;
-    /** Wormhole infra override (defaults from `WORMHOLE_DEFAULTS[network]`). */
-    wormhole?: WormholeInfraConfig;
-    /** Sui `CoinRegistry` shared object (credit deployments). */
-    coin_registry?: string;
-    /** Per-module credit supply caps (credit deployments). */
-    credit_caps?: Record<string, string>;
-    /** Deploy-script phase completion flags (credit deployments). */
-    done?: Record<string, boolean>;
-}
-export interface LoadConfigOptions {
-    /**
-     * Override the default config URL. Use this to point at a staging branch
-     * (`?ref=staging`) or a local mirror during development. Takes precedence
-     * over {@link configRef}.
-     */
-    configUrl?: string;
-    /**
-     * Pin the canonical config to a specific git ref — a commit SHA, branch,
-     * or tag — instead of the default `main` branch. Resolves to
-     * `https://raw.githubusercontent.com/WaterXProtocol/waterx-config/<ref>/<network>.json`.
-     * Ignored when {@link configUrl} is set.
-     */
-    configRef?: string;
-    /**
-     * Reuse a previously-fetched config from the in-memory cache (keyed by
-     * the effective URL). Default: false (always fetch fresh).
-     */
-    cache?: boolean;
-    /** Optional fetch implementation (for tests or environments without global `fetch`). */
-    fetchImpl?: typeof fetch;
-    /** Optional request timeout in ms. Default 10_000. */
-    timeoutMs?: number;
-}
-/**
- * Build the canonical config URL for `network`, optionally pinned to a
- * specific git `ref` (commit SHA, branch, or tag). Defaults to `main`.
- */
-export declare function defaultConfigUrl(network: Network, ref?: string): string;
-export declare function clearConfigCache(): void;
-export declare function loadConfig(network: Network, opts?: LoadConfigOptions): Promise<WaterXConfig>;