@waterx/sdk 4.3.2 → 5.0.0

package/dist/src/generated/waterx_pyth_rule/pyth_rule.js

@@ -1,170 +0,0 @@
-/**************************************************************
- * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
- **************************************************************/
-import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
-import { bcs } from '@mysten/sui/bcs';
-import * as vec_map from "./deps/sui/vec_map.js";
-const $moduleName = '@waterx/pyth-rule::pyth_rule';
-export const PythRule = new MoveStruct({ name: `${$moduleName}::PythRule`, fields: {
-        dummy_field: bcs.bool()
-    } });
-export const Config = new MoveStruct({ name: `${$moduleName}::Config`, fields: {
-        id: bcs.Address,
-        /** Ticker (e.g. `b"BTC_USD".to_string()`) → Pyth feed identifier bytes. */
-        identifier_map: vec_map.VecMap(bcs.string(), bcs.vector(bcs.u8())),
-        /** Per-ticker timestamp tolerance in seconds. Falls back to DEFAULT_TOLERANCE_SEC. */
-        tolerance_sec_map: vec_map.VecMap(bcs.string(), bcs.u64())
-    } });
-export const MaxConfBpsKey = new MoveStruct({ name: `${$moduleName}::MaxConfBpsKey`, fields: {
-        dummy_field: bcs.bool()
-    } });
-export const MaxConfBpsConfig = new MoveStruct({ name: `${$moduleName}::MaxConfBpsConfig`, fields: {
-        /** Default max confidence band (bps of price) for symbols without an override. */
-        default_bps: bcs.u64(),
-        /** Per-symbol overrides. */
-        by_symbol: vec_map.VecMap(bcs.string(), bcs.u64())
-    } });
-/**
- * Reads a Pyth price for `collector.symbol()` and feeds it. Drops the value
- * (records `none`) if the on-chain timestamp diverges from the Pyth feed timestamp
- * by more than the configured tolerance.
- */
-export function feed(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null,
-        null,
-        '0x2::clock::Clock',
-        null,
-        null
-    ];
-    const parameterNames = ["collector", "config", "pythState", "pythPriceInfo"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'feed',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-export function setIdentifier(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null,
-        null,
-        '0x1::string::String',
-        'vector<u8>'
-    ];
-    const parameterNames = ["config", "Cap", "symbol", "identifier"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'set_identifier',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-export function setToleranceSec(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null,
-        null,
-        '0x1::string::String',
-        'u64'
-    ];
-    const parameterNames = ["config", "Cap", "symbol", "toleranceSec"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'set_tolerance_sec',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-/**
- * Sets the default confidence gate (bps of price) applied to symbols without an
- * explicit override. `10_000` = 100%. Lazily creates the confidence-gate DF.
- */
-export function setDefaultMaxConfidenceBps(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null,
-        null,
-        'u64'
-    ];
-    const parameterNames = ["config", "Cap", "defaultBps"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'set_default_max_confidence_bps',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-/** Sets a per-symbol confidence gate (bps of price), overriding the default. */
-export function setSymbolMaxConfidenceBps(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null,
-        null,
-        '0x1::string::String',
-        'u64'
-    ];
-    const parameterNames = ["config", "Cap", "symbol", "bps"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'set_symbol_max_confidence_bps',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-/**
- * Removes a per-symbol confidence override (no-op if absent); the symbol then
- * falls back to the default.
- */
-export function unsetSymbolMaxConfidenceBps(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null,
-        null,
-        '0x1::string::String'
-    ];
-    const parameterNames = ["config", "Cap", "symbol"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'unset_symbol_max_confidence_bps',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-/**
- * The effective confidence gate (bps of price) `feed` applies for `symbol`:
- * per-symbol override → default → `DEFAULT_MAX_CONFIDENCE_BPS`.
- */
-export function maxConfidenceBps(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null,
-        '0x1::string::String'
-    ];
-    const parameterNames = ["config", "symbol"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'max_confidence_bps',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}
-/**
- * The configured default confidence gate, or `DEFAULT_MAX_CONFIDENCE_BPS` if
- * unset.
- */
-export function defaultMaxConfidenceBps(options) {
-    const packageAddress = options.package ?? '@waterx/pyth-rule';
-    const argumentsTypes = [
-        null
-    ];
-    const parameterNames = ["config"];
-    return (tx) => tx.moveCall({
-        package: packageAddress,
-        module: 'pyth_rule',
-        function: 'default_max_confidence_bps',
-        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    });
-}

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

@@ -1,227 +0,0 @@
-/**
- * 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 type { Transaction, TransactionArgument } from "@mysten/sui/transactions";
-import type { Network } from "../constants.ts";
-import type { PythFetchPolicy } from "./config.ts";
-import type { OracleHost } from "./host.ts";
-/**
- * Everything the Core source needs that is not in the canonical
- * `waterx-config` JSON lives HERE, in the source that consumes it —
- * `client.pyth` carries only the caller's credential/fetch policy
- * (see `PythAccessConfig`). No other oracle source reads this table:
- * selecting `pyth_lazer_rule` (or any future source) must never touch a Core
- * endpoint or Core state object, so nothing Core-shaped stays on the shared
- * client to leak across sources.
- *
- * - `state_id` / `wormhole_state_id` — the Core Pyth + Wormhole state objects
- *   the on-chain update PTB reads (below).
- * - `hermes_endpoint` — the Core Hermes REST base for
- *   `fetchPriceFeedsUpdateData`. Keyless today; auth-first after the Pyth Pro
- *   migration (post-2026-08-18) via `client.pyth.api_key`.
- */
-export interface PythCoreInfra {
-    state_id: string;
-    wormhole_state_id: string;
-    hermes_endpoint: string;
-}
-export declare const PYTH_CORE_INFRA: Record<Network, PythCoreInfra>;
-/**
- * The Core source's Hermes REST base for `network` — for consumers (BE/FE
- * read planes) whose `ORACLE_SOURCE` fed set includes `'pyth_rule'`. A fed
- * set WITHOUT `pyth_rule` reads the keyed Pyth Pro base instead — resolve
- * through `resolveHermesReadEndpoint` (`oracle/read-plane.ts`) rather than
- * branching by hand.
- */
-export declare function pythCoreHermesEndpoint(network: Network): string;
-/**
- * The Pyth Pro Hermes-compatible REST base — the documented drop-in
- * replacement for the Core endpoint (`https://pyth.dourolabs.app/hermes/…`),
- * IDENTICAL for every subscriber: only the `Authorization: Bearer` key
- * (`client.pyth.api_key` / the `pythApiKey` create option) is
- * account-specific, so the URL is SDK infra, not deployment config. One base
- * for both networks — Pro has no testnet variant (Pyth feed ids are
- * chain-agnostic; `hermes-beta` is a Core-testnet concern). Consumers with a
- * proxy/self-hosted mirror override it per deployment via
- * `resolveHermesReadEndpoint`'s `override` param.
- */
-export declare const PYTH_PRO_HERMES_ENDPOINT = "https://pyth.dourolabs.app/hermes";
-/** Accessor mirror of {@link pythCoreHermesEndpoint} for the Pro base. */
-export declare function pythProHermesEndpoint(): string;
-type PriceTableInfo = {
-    id: string;
-    fieldType: string;
-};
-type PythStateInfo = {
-    packageId: string;
-    baseUpdateFee: bigint;
-};
-export declare class PythCache {
-    pythStateInfo?: PythStateInfo;
-    wormholePackageId?: string;
-    priceTableInfo?: PriceTableInfo;
-    priceFeedObjectIdCache: Map<string, string | undefined>;
-}
-type FetchOpts = {
-    apiKey?: string;
-    fetch?: PythFetchPolicy;
-};
-/**
- * How long a "this endpoint lacks feed X" verdict stays memoized. The verdict
- * is a claim about *someone else's* deployment — a feed can be added to the
- * catalog, an entitlement can be granted, a Pro plan can be upgraded — so it
- * must expire rather than bind the whole process lifetime. Long enough that a
- * genuinely-absent feed costs one discovery per window instead of one per
- * build; short enough that a recovered endpoint self-heals without a restart.
- */
-export declare const MISSING_FEED_MEMO_TTL_MS: number;
-/**
- * Thrown when discovery concludes that an endpoint rejects EVERY requested
- * feed id without a catalog vouching for that verdict. `instanceof`-able
- * (mirrors `FetchPolicyError` / {@link OracleFeeSourceUnavailableError}).
- *
- * "All of them are missing" is the signature of an endpoint/credential fault —
- * a wrong base path (the Pyth Pro `/hermes` prefix dropped), a changed route,
- * a revoked or downgraded entitlement — not of N individually-absent feeds.
- * Memoizing it would convert a loud, fixable misconfiguration into a silent
- * permanent one: every id marked missing ⇒ `fetchPriceFeedsUpdateData` returns
- * `[]` ⇒ `buildPythPriceUpdateCalls` throws "Hermes returned empty results",
- * blaming Hermes for having no data, for the rest of the process's life. So
- * this case writes NOTHING to the memo and throws instead; the next call
- * re-probes and recovers on its own once the endpoint does.
- *
- * The message keeps the `Hermes price fetch failed: <status>` prefix on its
- * first line — the documented contract downstream consumers string-match (see
- * {@link fetchPriceFeedsUpdateData} and the e2e transient detector).
- */
-export declare class HermesEndpointRejectedAllFeedsError extends Error {
-    readonly endpoint: string;
-    readonly requestedCount: number;
-    constructor(endpoint: string, requestedCount: number, catalogState: "unreadable" | "empty");
-}
-/**
- * The subset of `feedIds` this `endpoint` is known to serve — i.e. minus any
- * discovered to be absent within the last {@link MISSING_FEED_MEMO_TTL_MS}
- * (see {@link fetchPriceFeedsUpdateData}). Callers building a
- * `{ updates, feedIds }` payload use this to keep `feedIds` aligned with the
- * feeds the fetch actually returned data for, so `buildPythPriceUpdateCalls`
- * (one moveCall per feed id) never references a feed the accumulator blob
- * doesn't cover.
- *
- * Expired entries are pruned here rather than on a timer: the memo is only
- * ever consulted through this function, so a lazy sweep is both sufficient and
- * free of a dangling interval in a library.
- */
-export declare function endpointSupportedFeedIds(endpoint: string, feedIds: string[], apiKey?: string): string[];
-/** Test-only: forget everything learned about which feeds an endpoint lacks. */
-export declare function __resetMissingFeedCacheForTest(): void;
-/**
- * Discovery-only entry for consumers that fetch Hermes THEMSELVES (e.g. a
- * parsed latest-price reader) and just observed a whole-batch 404: resolves
- * which ids the endpoint lacks, memoizes them (see {@link
- * endpointSupportedFeedIds}), fetches NO survivor data. Without this, such a
- * consumer's only way to populate the memo was calling {@link
- * fetchPriceFeedsUpdateData} and discarding its accumulator blob — two full
- * redundant transfers per cold discovery.
- *
- * @throws HermesEndpointRejectedAllFeedsError when the rejection looks
- * endpoint-wide rather than per-feed — the caller's own 404 is then a
- * misconfiguration to surface, not a set of feeds to quietly drop.
- */
-export declare function probeMissingFeeds(endpoint: string, ids: string[], opts?: FetchOpts): Promise<void>;
-export declare function fetchPriceFeedsUpdateData(endpoint: string, priceIds: string[], opts?: FetchOpts): Promise<Uint8Array[]>;
-/**
- * Resolved source for the Pyth Core on-chain update fee. Deliberately a
- * closed two-variant union, not a `{ sponsorFund?, allowGasFee? }` pair — a
- * caller can no longer construct the "both supplied" or "neither supplied
- * but some other truthy flag" shapes that used to require a priority rule to
- * disambiguate.
- *
- * Resolved exactly ONCE, at the edges (`wrapRequestAndExecute` and the WLP
- * builders' equivalent in `perp/tx-builders/`) from config presence
- * (`pyth_sponsor_rule` deployed → open a fund → `'sponsor'`) and the
- * caller's ergonomic `allowGasFee` opt-in (→ `'gas'`), then threaded
- * verbatim through `refreshOraclePrices` → `BuildUpdateOpts` →
- * `PythCoreRule` → {@link buildPythPriceUpdateCalls}. The sponsor-beats-gas
- * priority from the old two-flag design is now structural — whichever edge
- * resolves this value decides once; no downstream layer re-derives or
- * re-documents a priority because none of them ever see more than one
- * candidate source.
- */
-export type OracleFeeSource = {
-    readonly kind: "sponsor";
-    readonly fund: TransactionArgument;
-    readonly packageId: string;
-} | {
-    readonly kind: "gas";
-};
-/**
- * Thrown when no {@link OracleFeeSource} is available for the Pyth update fee
- * — from `buildPythPriceUpdateCalls`'s own per-call guard, or `aggregate.ts`'s
- * hoisted `refreshOraclePrices` pre-check (see its docblock). `instanceof`-able
- * (mirrors `FetchPolicyError` in `update-fetch.ts`) so a consumer — e.g. a BE
- * integration wiring its own `allowGasFee` decision — can branch on the error
- * type directly instead of string-matching `error.message`.
- */
-export declare class OracleFeeSourceUnavailableError extends Error {
-    constructor();
-}
-/**
- * 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`).
- *
- * `opts.feeSource` is resolved BEFORE any PTB mutation and is never silently
- * defaulted — this function trusts whatever single {@link OracleFeeSource}
- * it's handed, it does not choose between competing candidates:
- *   - `{ kind: 'sponsor' }` → the per-feed update fee is drawn from the
- *     sponsor pool (`pyth_sponsor_rule::split`) instead of `tx.gas`. Opening
- *     and reimbursing that fund is the caller's job (`rules/sponsor.ts` /
- *     `wrapRequestAndExecute`, which opens it whenever the client's config
- *     has `pyth_sponsor_rule` deployed) — this function only draws a fee
- *     coin from the already-open `fund` hot potato.
- *   - `{ kind: 'gas' }` → the fee is drawn from `tx.gas` via `tx.splitCoins`.
- *     Only safe in a non-sponsored context — Enoki-sponsored transactions
- *     reject any `tx.gas` draw.
- *   - `undefined` → throws `OracleFeeSourceUnavailable` instead of silently
- *     drawing from `tx.gas` (the old default), which broke under Enoki and,
- *     worse, could fail ON-CHAIN when the market's `request_checklist`
- *     requires the `PythSponsorRule` witness that only a real sponsor fund
- *     attaches.
- *
- * This function's own check runs AFTER `updates`/`feedIds` are already in
- * hand, so for `updatePythPrices` (which fetches from Hermes, then calls
- * straight into this function) the off-chain fetch has already completed by
- * the time this throws — a wasted network call, never a stray PTB command.
- * `refreshOraclePrices` avoids that waste entirely: it hoists an EQUIVALENT
- * check ABOVE its off-chain fetch AND its per-group build loop (see its
- * docblock in `aggregate.ts`), keyed on `PriceUpdateRule.requiresFeeSource`
- * rather than waiting for a specific rule's fetch to complete — so for that
- * route neither the network call NOR any PTB command happens before the
- * throw. This function's own (later, per-call) guard alone could not
- * provide that "before any group builds" guarantee in a mixed shape (e.g. a
- * fee-free Lazer group ordered ahead of a Pyth Core fallback group in the
- * same PTB) — `refreshOraclePrices`'s pre-check is what closes it.
- */
-export declare function buildPythPriceUpdateCalls(tx: Transaction, host: OracleHost, updates: Uint8Array[], feedIds: string[], opts?: {
-    cache?: PythCache;
-    feeSource?: OracleFeeSource;
-}): Promise<string[]>;
-/** All-in-one: fetch from Hermes, append update calls. Returns PriceInfoObject IDs. */
-export declare function updatePythPrices(tx: Transaction, host: OracleHost, feedIds: string[], opts?: {
-    cache?: PythCache;
-    feeSource?: OracleFeeSource;
-}): Promise<string[]>;
-export {};