@waterx/sdk 4.3.3 → 5.0.0

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

@@ -1,6 +1,6 @@
 /**
  * Oracle-layer config schema — the package entries + config slice the shared
- * oracle layer (Pyth source + oracle rules + aggregate) reads. This is shared
+ * oracle layer (oracle rules + aggregate) reads. This is shared
  * infra, **not** the perp line: `perp/config.ts` imports these and
  * `WaterXPackages extends OraclePackages`; nothing here imports `perp/` or
  * `prediction/`. Snake_case mirrors the canonical `waterx-config` JSON 1:1.
@@ -12,35 +12,26 @@
 import type { BasePackageEntry } from "../account/config.ts";
 import type { BaseLineConfig } from "../base-client.ts";
 import type { FetchPolicy } from "./update-fetch.ts";
-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;
-}
 /**
  * `pyth_lazer_rule` deployment entry — present in the deployed testnet
  * `waterx-config` JSON. Read by `PythLazerRule` (`rules/pyth-lazer-rule.ts`):
  * `feeds` for ticker support + integer feed-id resolution, `state` for the
  * verify call, `published_at`/`config` for the per-ticker feed call.
  *
- * `enabled` mirrors the JSON field verbatim but MUST NOT be read for routing —
- * which rule prices a ticker is decided solely by the client's `oracleSource`
- * create option (see `OracleHost.oracleSources`), never by this flag or any
- * other config value.
+ * `enabled` switches the source off for this deployment: `deriveOracleSources`
+ * skips a block explicitly set to `false`. Absent means ON — every live config
+ * omits it, and a published block with feeds is a wired source. Which rule
+ * prices a given TICKER is still decided by the feeds maps alone, never by a
+ * per-ticker flag.
  */
 export interface PythLazerRulePackage extends BasePackageEntry {
     config: string;
     state: string;
     enabled?: boolean;
-    /** Oracle ticker → integer Pyth Lazer feed id (distinct id scheme from `pyth_rule`'s hex `feed_id`). */
+    /** Oracle ticker → integer Pyth Lazer feed id (distinct from the legacy Hermes hex id scheme). */
     feeds: Record<string, number>;
 }
-/** Per-ticker `constant_rule` feed entry (mirrors the `pyth_rule.feeds` shape). */
+/** Per-ticker `constant_rule` feed entry (per-ticker map keyed by oracle ticker). */
 export interface ConstantFeedEntry {
     /**
      * Constant 1e9-scaled price (decimal string), mirroring the on-chain
@@ -54,13 +45,13 @@ 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" }`).
+     * Oracle ticker → constant feed entry. A ticker present here is fed via
+     * `constant_rule::feed`, alone (constant-only) or alongside the live
+     * sources (e.g. `USDCUSD → { price: "1000000000" }`).
      */
     feeds?: Record<string, ConstantFeedEntry>;
 }
-/** Per-ticker `supra_rule` feed entry (mirrors the `pyth_rule.feeds` shape). */
+/** Per-ticker `supra_rule` feed entry (per-ticker map keyed by oracle ticker). */
 export interface SupraFeedEntry {
     /** Supra pair id (mirrors the on-chain `Config`; informational off-chain). */
     pair_id: number;
@@ -84,8 +75,8 @@ export interface SupraRulePackage extends BasePackageEntry {
 }
 /**
  * Per-ticker `waterx_rule` feed entry. Keyed in `feeds` by the oracle **ticker**
- * (e.g. `"SUIUSD"`, the same key `pyth_rule.feeds` uses), so
- * `Object.keys(feeds)` is the SDK's supported-ticker set. The fields are
+ * (e.g. `"SUIUSD"`), so `Object.keys(feeds)` is the SDK's supported-ticker
+ * set. The fields are
  * informational off-chain — the SDK keys routing/support off the entry's
  * presence and pushes the enclave-signed price verbatim, never re-deriving it.
  */
@@ -103,8 +94,8 @@ export interface WaterxRuleFeedEntry {
  * `rules/waterx-rule.ts`), not this JSON.
  *
  * `enabled` mirrors the JSON field verbatim but MUST NOT be read for routing —
- * which rule prices a ticker is decided solely by the client's `oracleSource`
- * create option (see `OracleHost.oracleSources`), mirroring `pyth_lazer_rule`.
+ * which rule prices a ticker is decided solely by the client's derived fed set
+ * (see `OracleHost.oracleSources`), mirroring `pyth_lazer_rule`.
  */
 export interface WaterxRulePackage extends BasePackageEntry {
     /** Shared `waterx_rule::Config` (per-symbol on-chain feed_config). */
@@ -128,23 +119,21 @@ export interface WaterxOraclePackage extends BasePackageEntry {
  * structurally an oracle config.
  */
 export interface OraclePackages {
-    pyth_rule: PythRulePackage;
-    pyth_sponsor_rule?: PythSponsorRulePackage;
     /** See {@link PythLazerRulePackage} — typed only, not read for routing. */
     pyth_lazer_rule?: PythLazerRulePackage;
     constant_rule?: WaterxConstantRulePackage;
     supra_rule?: SupraRulePackage;
-    /** See {@link WaterxRulePackage} — read by `WaterxRule` when `oracleSource` selects it. */
+    /** See {@link WaterxRulePackage} — read by `WaterxRule` when the config wires it. */
     waterx_rule?: WaterxRulePackage;
     waterx_oracle: WaterxOraclePackage;
 }
 /**
  * The caller-tunable subset of `fetchWithPolicy`'s policy exposed on the
  * `pythFetch` create option and `client.pyth.fetch` — the retry/timeout budget
- * for the off-chain Hermes (`fetchPriceFeedsUpdateData`) and Lazer
- * (`PythLazerRule`) update fetches. Deliberately narrower than the internal
- * `FetchPolicy` (no `retryDelayMs` / `apiKey` / `fetchImpl`). Both fetches fall
- * back to `fetchWithPolicy`'s defaults (15s timeout, 2 retries) when unset.
+ * for the off-chain Lazer (`PythLazerRule`) update fetch and the Lazer read
+ * executor (`readLazerPrices`). Deliberately narrower than the internal
+ * `FetchPolicy` (no `retryDelayMs` / `apiKey` / `fetchImpl`). Falls back to
+ * `fetchWithPolicy`'s defaults (15s timeout, 2 retries) when unset.
  */
 export type PythFetchPolicy = {
     timeoutMs?: number;
@@ -152,10 +141,9 @@ export type PythFetchPolicy = {
 };
 /**
  * `client.pyth` — ONLY the caller-supplied Pyth credential + fetch policy,
- * shared by the Pyth-family rules (`pyth_rule`, `pyth_lazer_rule`). It carries
- * NO endpoints and NO on-chain object ids: every oracle source owns its own
- * infra, co-located with its rule (`PYTH_CORE_INFRA` in `oracle/pyth.ts`;
- * the Lazer constants inside `rules/pyth-lazer-rule.ts`). A non-Pyth source
+ * read by `PythLazerRule`. It carries NO endpoints and NO on-chain object
+ * ids: every oracle source owns its own infra, co-located with its rule (the
+ * Lazer constants inside `rules/pyth-lazer-rule.ts`). A non-Pyth source
  * never reads this slice.
  * Nothing here is sourced from the canonical `waterx-config` JSON — a Bearer
  * secret has no place in a public CDN document.
@@ -164,22 +152,20 @@ export interface PythAccessConfig {
     /**
      * Pyth access token (`Authorization: Bearer …`). Required by
      * `PythLazerRule`'s signed-update fetch — Lazer is auth-first, so there is
-     * no keyless default; absent when a lazer-routed fetch runs →
-     * `LazerApiKeyMissing` is thrown at fetch time. Supplied via the
-     * `pythApiKey` create option (the SDK never reads `process.env` or the
-     * config JSON). As of the Pyth Pro migration (post-2026-08-18, per
-     * https://docs.pyth.network/price-feeds/core/upgrade) this is ALSO required
-     * for `pyth_rule`'s Hermes fetch (`fetchPriceFeedsUpdateData`) — see
-     * `fetch` below.
+     * no keyless default; absent when a lazer-routed build runs →
+     * `LazerApiKeyMissing` is thrown by `refreshOraclePrices`'s credential
+     * pre-check (before any fetch) or by the rule's own fetch. Supplied via
+     * the `pythApiKey` create option (the SDK never reads `process.env` or the
+     * config JSON). The same key authenticates the Pyth Pro read/history
+     * surfaces (`readLazerPrices`, `fetchPythProHistory`).
      */
     api_key?: string;
     /**
-     * Retry/timeout policy for the Hermes (`fetchPriceFeedsUpdateData`) and
-     * Lazer (`PythLazerRule`) off-chain update fetches — see `fetchWithPolicy`
-     * (`./update-fetch.ts`) for the full policy (backoff, which statuses retry,
-     * Bearer attachment). Supplied via the `pythFetch` create option. Optional:
-     * both fetches default to `fetchWithPolicy`'s built-in defaults (15s
-     * timeout, 2 retries) when unset.
+     * Retry/timeout policy for the Lazer (`PythLazerRule`) off-chain update
+     * fetch — see `fetchWithPolicy` (`./update-fetch.ts`) for the full policy
+     * (backoff, which statuses retry, Bearer attachment). Supplied via the
+     * `pythFetch` create option. Optional: defaults to `fetchWithPolicy`'s
+     * built-in defaults (15s timeout, 2 retries) when unset.
      */
     fetch?: PythFetchPolicy;
 }

package/dist/src/oracle/config.js

@@ -1,6 +1,6 @@
 /**
  * Oracle-layer config schema — the package entries + config slice the shared
- * oracle layer (Pyth source + oracle rules + aggregate) reads. This is shared
+ * oracle layer (oracle rules + aggregate) reads. This is shared
  * infra, **not** the perp line: `perp/config.ts` imports these and
  * `WaterXPackages extends OraclePackages`; nothing here imports `perp/` or
  * `prediction/`. Snake_case mirrors the canonical `waterx-config` JSON 1:1.

package/dist/src/oracle/host.d.ts

@@ -3,16 +3,16 @@
  *
  * The oracle/refresh code used to take a concrete `PerpClient`, which fused the
  * shared oracle layer to the perp line. It only ever needs config-schema
- * lookups, the Pyth infra block, and a gRPC client — so it depends on this
- * structural interface instead. `PerpClient` satisfies it without any `implements`
- * clause, and a future `PredictClient` (or a test double) can too.
+ * lookups, the caller-supplied access slices, and a gRPC client — so it depends
+ * on this structural interface instead. `PerpClient` satisfies it without any
+ * `implements` clause, and a future `PredictClient` (or a test double) can too.
  */
 import type { SuiGrpcClient } from "@mysten/sui/grpc";
 import type { Network } from "../constants.ts";
 import type { OracleConfig, PythAccessConfig, WaterxAccessConfig } from "./config.ts";
 import type { OracleSource } from "./price-update-rule.ts";
 export interface OracleHost {
-    /** Sui network this client targets — each rule keys its OWN infra table by it (`PYTH_CORE_INFRA`, `LAZER_INFRA`). */
+    /** Sui network this client targets — each rule keys its OWN infra table by it (`LAZER_INFRA`, `WATERX_INFRA`). */
     readonly network: Network;
     /** Oracle slice of the canonical `waterx-config` JSON (rule packages + per-ticker feeds). */
     readonly config: OracleConfig;
@@ -29,19 +29,19 @@ export interface OracleHost {
      * by the quote-center's CORS allowlist.
      */
     readonly waterx?: WaterxAccessConfig;
-    /** gRPC client for the on-chain reads the Pyth update path needs. */
+    /** gRPC client for any on-chain reads an update path needs. */
     readonly grpcClient: SuiGrpcClient;
     /**
-     * The FED SET for `refreshOraclePrices`'s update legs — the REQUIRED
-     * `oracleSource` create option normalized to a non-empty, deduped list.
-     * Every listed source's data is fetched and fed in one build; the chain's
+     * The FED SET for `refreshOraclePrices`'s update legs, derived from the
+     * deployment config (`deriveOracleSources`) — never a create option and
+     * never an env var.
+     *
+     * Every derived source's data is fetched and fed in one build; the chain's
      * per-ticker weight tables decide which contributions count (feeding an
-     * unweighted rule is dropped on-chain; starving a weighted one aborts), so
-     * during weight migrations the list stays a SUPERSET of every ticker's
-     * weighted set. Routing is driven by this value ALONE: never by a config
-     * JSON `enabled` flag and never by `process.env` — the SDK never reads it;
-     * consumers (BE/FE) wire this option from their own env var
-     * (`ORACLE_SOURCE`, comma-separated).
+     * unweighted rule is dropped on-chain; starving a weighted one aborts).
+     * Deriving the maximal wired set is therefore the fail-safe direction, and
+     * it keeps the fed set a SUPERSET of every ticker's weighted set through a
+     * weight migration for free.
      */
     readonly oracleSources: readonly OracleSource[];
     /** True when `ticker` is priced by `constant_rule`. */
@@ -52,9 +52,4 @@ export interface OracleHost {
         config: string;
         oracle_holder: string;
     } | undefined;
-    /** The `pyth_rule.feeds` entry for `ticker` (`{ feed_id, price_info_object }`); throws if absent. */
-    getPythFeed(ticker: string): {
-        feed_id: string;
-        price_info_object: string;
-    };
 }

package/dist/src/oracle/host.js

@@ -3,8 +3,8 @@
  *
  * The oracle/refresh code used to take a concrete `PerpClient`, which fused the
  * shared oracle layer to the perp line. It only ever needs config-schema
- * lookups, the Pyth infra block, and a gRPC client — so it depends on this
- * structural interface instead. `PerpClient` satisfies it without any `implements`
- * clause, and a future `PredictClient` (or a test double) can too.
+ * lookups, the caller-supplied access slices, and a gRPC client — so it depends
+ * on this structural interface instead. `PerpClient` satisfies it without any
+ * `implements` clause, and a future `PredictClient` (or a test double) can too.
  */
 export {};

package/dist/src/oracle/index.d.ts

@@ -5,32 +5,41 @@
  *   - `host.ts`             — `OracleHost`, the narrow client slice this module reads.
  *   - `update-fetch.ts`     — `fetchWithPolicy`, the shared retry/timeout/Bearer resilience
  *                             wrapper every off-chain oracle (and config) fetch goes through.
- *   - `pyth.ts`             — Pyth as a price source: Hermes REST + on-chain update PTB.
  *   - `price-update-rule.ts`— `PriceUpdateRule`, the fetch/build strategy port a rule
  *                             implements; `rule-registry.ts` + `aggregate.ts` wire
  *                             routing across rules.
- *   - `rules/*`             — one file per oracle rule (pyth / supra / constant / sponsor).
+ *   - `rules/*`             — one file per oracle rule (lazer / waterx / supra / constant).
  *   - `aggregate.ts`        — the orchestrator that feeds rules into a collector + aggregates.
- *
- * `pyth.ts` deliberately imports NO rule package — Pyth-the-source and the
- * rules that consume it are separate concerns.
+ *   - `read-plane.ts` / `read-prices.ts` — per-source READ plans + their executors.
+ *   - `validate.ts`         — consumers' boot-time coverage/credential asserts.
+ *   - `schedule.ts` / `symbol-catalog.ts` / `pyth-pro-history.ts` — market hours
+ *                             (parser + status walker), the Pyth Pro symbol catalog,
+ *                             and Pro chart history.
  */
 export type { OracleHost } from "./host.ts";
 export { FetchPolicyError, fetchWithPolicy, joinEndpointPath } from "./update-fetch.ts";
 export type { FetchPolicy } from "./update-fetch.ts";
-export { PythCache, fetchPriceFeedsUpdateData, endpointSupportedFeedIds, probeMissingFeeds, buildPythPriceUpdateCalls, pythCoreHermesEndpoint, pythProHermesEndpoint, PYTH_PRO_HERMES_ENDPOINT, updatePythPrices, HermesEndpointRejectedAllFeedsError, MISSING_FEED_MEMO_TTL_MS, OracleFeeSourceUnavailableError, } from "./pyth.ts";
-export type { OracleFeeSource } from "./pyth.ts";
-export type { PriceUpdateRule, PriceUpdateRuleKind, RuleUpdateData, RuleUpdateHandle, BuildUpdateOpts, OracleSource, UpdateDataProvider, } from "./price-update-rule.ts";
+export type { PriceUpdateRule, PriceUpdateRuleKind, RuleUpdateData, RuleUpdateHandle, OracleCredentialRequirement, OracleCredentials, OracleSource, UpdateDataProvider, } from "./price-update-rule.ts";
+export { oracleCredentialsFromHost } from "./price-update-rule.ts";
 export { ORACLE_SOURCES } from "./price-update-rule.ts";
-export { isOracleSource, parseOracleSourceList } from "./source-list.ts";
-export { resolveOracleReadPlan, resolveHermesReadEndpoint } from "./read-plane.ts";
+export { deriveOracleSources } from "./source-list.ts";
+export { resolveOracleReadPlan, readPlanTickers } from "./read-plane.ts";
 export type { OracleReadPlan } from "./read-plane.ts";
-export { PythCoreRule } from "./rules/pyth-core-rule.ts";
-export type { PythCoreUpdatePayload } from "./rules/pyth-core-rule.ts";
+export { LazerNotEntitledError, readLazerPrices, readQuoteCenterPrices } from "./read-prices.ts";
+export type { OraclePriceEntry } from "./read-prices.ts";
+export { OracleTickerUnservedError, assertOracleWriteCoverage, missingOracleCredentials, partitionServableTickers, servableTickers, } from "./validate.ts";
+export type { OracleCredentialKind } from "./validate.ts";
+export { assertOracleWeightCoverage, readOracleWeightCoverage, OracleWeightCoverageError, OracleWeightUnreadableError, } from "./weight-coverage.ts";
+export type { TickerWeightCoverage } from "./weight-coverage.ts";
 export { PythLazerRule, LazerApiKeyMissingError } from "./rules/pyth-lazer-rule.ts";
 export type { PythLazerUpdatePayload } from "./rules/pyth-lazer-rule.ts";
-export { WaterxRule, parseSignedEnvelope, parseSignedLeaves, BATCH_PRICE_INTENT, MERKLE_ROOT_INTENT, WATERX_INFRA, waterxQuoteCenterEndpoint, waterxLeavesOf, waterxEnvelopeOf, } from "./rules/waterx-rule.ts";
-export type { WaterxUpdatePayload, WaterxLeafPayload, WaterxEnvelopePayload, WaterxSignedEnvelope, WaterxSignedLeaf, WaterxBatchItem, } from "./rules/waterx-rule.ts";
+export { WaterxRule, parseSignedEnvelope, parseSignedLeaves, BATCH_PRICE_INTENT, MERKLE_ROOT_INTENT, WATERX_INFRA, waterxQuoteCenterEndpoint, fetchWaterxSignedUpdate, fetchWaterxSignedLeaves, fetchWaterxUpdateData, pullWaterxQuotes, WATERX_MAX_PRICE_AGE_MS, isFreshWaterxEntry, waterxLeavesOf, waterxEnvelopeOf, } from "./rules/waterx-rule.ts";
+export type { WaterxUpdatePayload, WaterxLeafPayload, WaterxEnvelopePayload, WaterxSignedEnvelope, WaterxSignedLeaf, WaterxBatchItem, LeafPull, } from "./rules/waterx-rule.ts";
 export { OracleSourceNotImplementedError, resolveOracleRule } from "./rule-registry.ts";
-export { aggregateTicker, aggregateTickerWithPyth, aggregateTickerWithConstant, refreshOraclePrices, } from "./aggregate.ts";
-export { openPythSponsorFund, reimbursePythSponsor } from "./rules/sponsor.ts";
+export { aggregateTicker, aggregateTickerWithConstant, refreshOraclePrices } from "./aggregate.ts";
+export type { OracleRefreshSummary } from "./aggregate.ts";
+export { PythScheduleParseError, parsePythSchedule, getMarketStatus } from "./schedule.ts";
+export type { HolidayDate, MarketStatusResult, ParsedPythSchedule, TradingHours, TradingSession, } from "./schedule.ts";
+export { fetchPythSymbolCatalog } from "./symbol-catalog.ts";
+export type { PythSymbolRecord } from "./symbol-catalog.ts";
+export { fetchPythProHistory } from "./pyth-pro-history.ts";

package/dist/src/oracle/index.js

@@ -5,77 +5,82 @@
  *   - `host.ts`             — `OracleHost`, the narrow client slice this module reads.
  *   - `update-fetch.ts`     — `fetchWithPolicy`, the shared retry/timeout/Bearer resilience
  *                             wrapper every off-chain oracle (and config) fetch goes through.
- *   - `pyth.ts`             — Pyth as a price source: Hermes REST + on-chain update PTB.
  *   - `price-update-rule.ts`— `PriceUpdateRule`, the fetch/build strategy port a rule
  *                             implements; `rule-registry.ts` + `aggregate.ts` wire
  *                             routing across rules.
- *   - `rules/*`             — one file per oracle rule (pyth / supra / constant / sponsor).
+ *   - `rules/*`             — one file per oracle rule (lazer / waterx / supra / constant).
  *   - `aggregate.ts`        — the orchestrator that feeds rules into a collector + aggregates.
- *
- * `pyth.ts` deliberately imports NO rule package — Pyth-the-source and the
- * rules that consume it are separate concerns.
+ *   - `read-plane.ts` / `read-prices.ts` — per-source READ plans + their executors.
+ *   - `validate.ts`         — consumers' boot-time coverage/credential asserts.
+ *   - `schedule.ts` / `symbol-catalog.ts` / `pyth-pro-history.ts` — market hours
+ *                             (parser + status walker), the Pyth Pro symbol catalog,
+ *                             and Pro chart history.
  */
 // Shared fetch resilience wrapper — `FetchPolicyError` is re-exported (not
 // just the type) so a consumer (e.g. a BE prefetch cache) can `instanceof`
-// it off the failure `fetchPriceFeedsUpdateData` / `PythLazerRule` /
-// `loadConfig` surface, without a deep import of `./update-fetch.ts`.
-// `fetchWithPolicy` + `joinEndpointPath` are exported for consumers that hit
-// Hermes-compatible endpoints THEMSELVES (e.g. the BE's parsed latest-price
-// bootstrap and Pyth schedule readers): one shared Bearer/timeout/retry
-// policy and one base-path-safe URL join, instead of each caller re-rolling
-// them (the hand-rolled copies were how the Pro `/hermes` base path got
-// dropped and the Bearer went missing on sibling fetches).
+// it off a failed rule fetch / `loadConfig` surface, without a deep import
+// of `./update-fetch.ts`. `fetchWithPolicy` + `joinEndpointPath` are exported
+// for consumers that hit oracle-adjacent endpoints THEMSELVES: one shared
+// Bearer/timeout/retry policy and one base-path-safe URL join, instead of
+// each caller re-rolling them (the hand-rolled copies were how base paths
+// got dropped and Bearers went missing on sibling fetches).
 export { FetchPolicyError, fetchWithPolicy, joinEndpointPath } from "./update-fetch.js";
-// Pyth source — `OracleFeeSourceUnavailableError` and
-// `HermesEndpointRejectedAllFeedsError` are re-exported (not just the types)
-// for the same `instanceof` reason as `FetchPolicyError` above: a consumer of
-// `buildPythPriceUpdateCalls` / `updatePythPrices` / `refreshOraclePrices` can
-// branch on the fee-source failure directly, and a consumer of
-// `fetchPriceFeedsUpdateData` / `probeMissingFeeds` can tell a misconfigured
-// or unentitled endpoint apart from feeds that endpoint genuinely lacks.
-export { PythCache, fetchPriceFeedsUpdateData, endpointSupportedFeedIds, probeMissingFeeds, buildPythPriceUpdateCalls, 
-// The pyth read-plane endpoint accessors — Core (keyless, per network) and
-// Pro (the documented fixed base; auth via the caller's Bearer key). There
-// is no client-level endpoint field: consumers pick via
-// `resolveHermesReadEndpoint` (pyth_rule listed → Core, else override ??
-// Pro) — never a hand-rolled branch, never a cross-source fallback.
-pythCoreHermesEndpoint, pythProHermesEndpoint, PYTH_PRO_HERMES_ENDPOINT, updatePythPrices, HermesEndpointRejectedAllFeedsError, MISSING_FEED_MEMO_TTL_MS, OracleFeeSourceUnavailableError, } from "./pyth.js";
-// Canonical OracleSource value list + THE env-string parser consumers fold
-// onto — semantics and rationale in `source-list.ts`'s header.
+export { oracleCredentialsFromHost } from "./price-update-rule.js";
+// Canonical OracleSource value list + THE fed-set derivation (config in,
+// sources out) — semantics and rationale in `source-list.ts`'s header. There
+// is no `oracleSource` option and no `ORACLE_SOURCE` env var to parse.
 export { ORACLE_SOURCES } from "./price-update-rule.js";
-export { isOracleSource, parseOracleSourceList } from "./source-list.js";
+export { deriveOracleSources } from "./source-list.js";
 // Per-source READ-plane resolution — which tickers a source can price
-// off-chain and with which ids (`resolveOracleReadPlan`), and which
-// Hermes-compatible base the hermes plans execute against
-// (`resolveHermesReadEndpoint`: pyth_rule listed → Core, else override ??
-// the documented Pyth Pro base). The one place the "lazer reads through
-// `pyth_rule.feeds` hex ids" invariant lives; consumers resolve through
-// this instead of hardcoding namespace sharing or endpoint branching.
-export { resolveOracleReadPlan, resolveHermesReadEndpoint } from "./read-plane.js";
-// Pyth Core rule (PriceUpdateRule wrapper over the Pyth source above)
-export { PythCoreRule } from "./rules/pyth-core-rule.js";
+// off-chain and with which ids (`resolveOracleReadPlan`; every source reads
+// its OWN feeds namespace, so write set == read set), plus the executors that
+// run a plan (`readLazerPrices` / `readQuoteCenterPrices`) and decode each
+// source's wire scaling in ONE place. `LazerNotEntitledError` is re-exported
+// (not just the type) for the same `instanceof` reason as `FetchPolicyError`
+// above: a consumer drops unentitled feeds and retries.
+export { resolveOracleReadPlan, readPlanTickers } from "./read-plane.js";
+export { LazerNotEntitledError, readLazerPrices, readQuoteCenterPrices } from "./read-prices.js";
+// Boot-time deployment asserts consumers fold onto (`OracleTickerUnservedError`
+// is `instanceof`-able, same rationale as above — and is the SAME type the
+// per-build composers raise). Deliberately NOT called at client creation —
+// see `validate.ts`'s header.
+export { OracleTickerUnservedError, assertOracleWriteCoverage, missingOracleCredentials, partitionServableTickers, servableTickers, } from "./validate.js";
+// The ON-CHAIN half of the same question. `validate.ts` reasons from config
+// alone (necessary, not sufficient); this reads the aggregator weights, which
+// is the only way to catch a ticker that is servable by config yet weighted to
+// a rule the fed set cannot supply — the shape that aborts a WHOLE PTB.
+export { assertOracleWeightCoverage, readOracleWeightCoverage, OracleWeightCoverageError, OracleWeightUnreadableError, } from "./weight-coverage.js";
 // Pyth Lazer rule (signed-update generation; `feedLazerRule` stays internal to `aggregate.ts`)
 // `LazerApiKeyMissingError` is re-exported (not just the type) for the same
-// `instanceof` reason as `OracleFeeSourceUnavailableError` above.
+// `instanceof` reason as `FetchPolicyError` above.
 export { PythLazerRule, LazerApiKeyMissingError } from "./rules/pyth-lazer-rule.js";
 // `WATERX_INFRA` / `waterxQuoteCenterEndpoint` are the source's own infra table +
-// read-plane accessor (mirrors `pythCoreHermesEndpoint`).
+// read-plane accessor.
 // WaterX quote-center rule (first-party ed25519 signed prices; the `feedWaterxRule*`
 // legs stay internal to `aggregate.ts`). Both wire shapes are exported because a
 // BE prefetch cache holds whichever one its quote-center serves: per-symbol
-// Merkle leaves (default) or one indivisible batch envelope (fallback).
-export { WaterxRule, parseSignedEnvelope, parseSignedLeaves, BATCH_PRICE_INTENT, MERKLE_ROOT_INTENT, WATERX_INFRA, waterxQuoteCenterEndpoint, 
+// Merkle leaves (default) or one indivisible batch envelope (fallback). The
+// WL-2345 seams: the raw fetchers (`fetchWaterxSignedUpdate` /
+// `fetchWaterxSignedLeaves`), the coverage-policy fetch
+// (`fetchWaterxUpdateData`), and the freshness contract
+// (`WATERX_MAX_PRICE_AGE_MS` / `isFreshWaterxEntry`).
+export { WaterxRule, parseSignedEnvelope, parseSignedLeaves, BATCH_PRICE_INTENT, MERKLE_ROOT_INTENT, WATERX_INFRA, waterxQuoteCenterEndpoint, fetchWaterxSignedUpdate, fetchWaterxSignedLeaves, fetchWaterxUpdateData, pullWaterxQuotes, WATERX_MAX_PRICE_AGE_MS, isFreshWaterxEntry, 
 // Rule-owned payload accessors (kind-check + unwrap in one place) — never
 // hand-cast the payload shape, and never assume which variant it is.
 waterxLeavesOf, waterxEnvelopeOf, } from "./rules/waterx-rule.js";
 // `resolveOracleRule` is the ONE source→rule registry — exported so external
 // consumers (e.g. a BE prefetch cache that keys per source and needs each
-// source's `supportedTickers`/`fetchUpdateData`) resolve through it instead of
-// hand-mirroring the map and drifting. `OracleSourceNotImplementedError` is
-// its `instanceof`-able failure (same reason as `OracleFeeSourceUnavailableError`
-// above).
+// source's `supportedTickers`/`fetchUpdateData`/`updateIdentityBySymbol`)
+// resolve through it instead of hand-mirroring the map and drifting.
+// `OracleSourceNotImplementedError` is its `instanceof`-able failure (same
+// reason as `FetchPolicyError` above).
 export { OracleSourceNotImplementedError, resolveOracleRule } from "./rule-registry.js";
 // Aggregation orchestrator
-export { aggregateTicker, aggregateTickerWithPyth, aggregateTickerWithConstant, refreshOraclePrices, } from "./aggregate.js";
-// Sponsor rule (fund open / reimburse + witness attach)
-export { openPythSponsorFund, reimbursePythSponsor } from "./rules/sponsor.js";
+export { aggregateTicker, aggregateTickerWithConstant, refreshOraclePrices } from "./aggregate.js";
+// Market hours: the Pyth schedule-grammar parser + the pure market-status
+// walker (the one cross-repo implementation — see `schedule.ts`'s header).
+export { PythScheduleParseError, parsePythSchedule, getMarketStatus } from "./schedule.js";
+// Pyth Pro symbol catalog (keyless; schedule strings + hex↔integer id map)
+// and Bearer-keyed chart history.
+export { fetchPythSymbolCatalog } from "./symbol-catalog.js";
+export { fetchPythProHistory } from "./pyth-pro-history.js";