@waterx/sdk 4.3.3 → 5.0.0

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

@@ -1,97 +0,0 @@
-/**
- * `PythCoreRule` — `PriceUpdateRule` wrapper around the existing Pyth Core
- * (Hermes VAA) source in `../pyth.ts`. Delegates to `fetchPriceFeedsUpdateData`
- * / `buildPythPriceUpdateCalls` verbatim; this file only adapts them to the
- * `PriceUpdateRule` port shape (fetch → build) so a future router can select
- * across rules by `kind`. Mechanical wrap only — no on-chain/off-chain logic
- * changes vs `../pyth.ts` / `./pyth-rule.ts`.
- */
-import { ownEntry } from "../../utils/record.js";
-import { assertRuleUpdateData, } from "../price-update-rule.js";
-import { buildPythPriceUpdateCalls, endpointSupportedFeedIds, fetchPriceFeedsUpdateData, pythCoreHermesEndpoint, } from "../pyth.js";
-/**
- * Shape check ONLY — the `kind` discriminant is checked separately by the
- * caller before this runs, since a same-shaped payload from a different rule
- * (e.g. a hypothetical Lazer payload also carrying `updates`/`feedIds`) must
- * not silently pass as a Pyth Core VAA block.
- */
-function isPythCoreUpdatePayloadShape(payload) {
-    return (typeof payload === "object" &&
-        payload !== null &&
-        Array.isArray(payload.updates) &&
-        Array.isArray(payload.feedIds));
-}
-export const PythCoreRule = {
-    kind: "pyth_rule",
-    // Charges a per-feed `base_update_fee` via `pyth::update_single_price_feed` —
-    // see `PriceUpdateRule.requiresFeeSource`.
-    requiresFeeSource: true,
-    /** Tickers with a `pyth_rule.feeds` entry (mirrors `refreshOraclePrices`'s filter). */
-    supportedTickers(host) {
-        return Object.keys(host.config.packages.pyth_rule?.feeds ?? {});
-    },
-    /** Resolves feed ids for `tickers`, then fetches their Hermes accumulator update. */
-    async fetchUpdateData(host, tickers) {
-        if (tickers.length === 0)
-            return null;
-        // Endpoint is this source's own per-network infra (`PYTH_CORE_INFRA`);
-        // credential + retry/timeout policy are the caller-supplied `client.pyth`
-        // access slice.
-        const endpoint = pythCoreHermesEndpoint(host.network);
-        const feedIds = tickers.map((ticker) => host.getPythFeed(ticker).feed_id);
-        const updates = await fetchPriceFeedsUpdateData(endpoint, feedIds, {
-            apiKey: host.pyth.api_key,
-            fetch: host.pyth.fetch,
-        });
-        // `updates` covers only the feeds this endpoint actually served — the fetch
-        // drops (and memoizes) any it lacks, e.g. Core feeds absent from Pyth Pro
-        // (WTIUSD/BRENTUSD). Align `feedIds` with them: buildPythPriceUpdateCalls
-        // emits one moveCall per feedId and must not reference a feed the
-        // accumulator blob doesn't cover.
-        return {
-            kind: "pyth_rule",
-            payload: {
-                updates,
-                feedIds: endpointSupportedFeedIds(endpoint, feedIds, host.pyth.api_key),
-            },
-        };
-    },
-    /**
-     * Subsets a (typically whole-universe) payload from {@link fetchUpdateData}
-     * down to exactly `tickers`. Pyth Core charges a per-feed update fee (one
-     * `update_single_price_feed` moveCall per `feedIds` entry — see
-     * `buildPythPriceUpdateCalls`), so serving a full all-registry payload for a
-     * 2-ticker build would multiply both the fee and the PTB size ~N× — a
-     * per-feed subset is valid input by construction. Narrows `feedIds` only:
-     * the single combined Hermes accumulator blob in `updates` already covers
-     * every packed feed and needs no re-slicing. A ticker with no
-     * `pyth_rule.feeds` entry, or whose feed id is not packed in THIS payload's
-     * `feedIds`, is a coverage gap → `null` (miss), never a silent partial.
-     */
-    narrowUpdateData(host, data, tickers) {
-        const payload = assertRuleUpdateData(data, "pyth_rule", isPythCoreUpdatePayloadShape, "{ updates: Uint8Array[]; feedIds: string[] }");
-        if (!payload || tickers.length === 0)
-            return null;
-        const packedFeedIds = new Set(payload.feedIds);
-        const feedIds = [];
-        for (const ticker of tickers) {
-            // Same lookup as `host.getPythFeed(ticker)` minus its throw — an
-            // unlisted ticker is a miss here, not an error.
-            const feedId = ownEntry(host.config.packages.pyth_rule?.feeds, ticker)?.feed_id;
-            if (feedId === undefined || !packedFeedIds.has(feedId))
-                return null;
-            feedIds.push(feedId);
-        }
-        return { kind: "pyth_rule", payload: { updates: payload.updates, feedIds } };
-    },
-    /** Appends the wormhole/pyth update PTB block for the payload from {@link fetchUpdateData}. */
-    async buildUpdateCalls(tx, host, data, opts) {
-        const payload = assertRuleUpdateData(data, "pyth_rule", isPythCoreUpdatePayloadShape, "{ updates: Uint8Array[]; feedIds: string[] }");
-        if (!payload)
-            return;
-        await buildPythPriceUpdateCalls(tx, host, payload.updates, payload.feedIds, {
-            cache: opts?.cache,
-            feeSource: opts?.feeSource,
-        });
-    },
-};

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

@@ -1,11 +0,0 @@
-/**
- * `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

@@ -1,26 +0,0 @@
-/**
- * `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";
-import { PYTH_CORE_INFRA } from "../pyth.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),
-            // The deployed pyth_rule package is compiled against the Core pyth
-            // dependency, so its `&PythState` parameter is the Core-package-qualified
-            // type and the Core source's own per-network state (`PYTH_CORE_INFRA`)
-            // is always the right state to pass. The config's price_info_object
-            // entries are Core objects to match.
-            pythState: tx.object(PYTH_CORE_INFRA[host.network].state_id),
-            pythPriceInfo: tx.object(priceInfoObjectId),
-        },
-    })(tx);
-}

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

@@ -1,32 +0,0 @@
-/**
- * `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; the caller wraps
- * the returned `{ fund, packageId }` into an `OracleFeeSource` (`{ kind:
- * 'sponsor', fund, packageId }`) and passes that to the Pyth update path (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. Wrap the
- * returned `{ fund, packageId }` into an `OracleFeeSource`
- * (`{ kind: 'sponsor', fund, packageId }`) and pass that to
- * `refreshOraclePrices` as `feeSource`, 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

@@ -1,52 +0,0 @@
-/**
- * `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; the caller wraps
- * the returned `{ fund, packageId }` into an `OracleFeeSource` (`{ kind:
- * 'sponsor', fund, packageId }`) and passes that to the Pyth update path (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. Wrap the
- * returned `{ fund, packageId }` into an `OracleFeeSource`
- * (`{ kind: 'sponsor', fund, packageId }`) and pass that to
- * `refreshOraclePrices` as `feeSource`, 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);
-}