@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/oracle-service/src/constants/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pyth"), exports);
+__exportStar(require("./splStake"), exports);
+__exportStar(require("./switchboard"), exports);

package/dist/shared/oracle-service/src/constants/pyth.d.ts

@@ -0,0 +1,7 @@
+import { Address } from "@solana/kit";
+import { MintIdentifier } from "common";
+export interface PythFeed {
+    account: Address;
+    feedId: string;
+}
+export declare const PYTH_FEEDS: Record<MintIdentifier, PythFeed>;

package/dist/shared/oracle-service/src/constants/pyth.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PYTH_FEEDS = void 0;
+const kit_1 = require("@solana/kit");
+// https://docs.pyth.network/price-feeds/core/push-feeds/solana
+exports.PYTH_FEEDS = {
+    // Standard assets
+    SOL: {
+        account: (0, kit_1.address)("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE"),
+        feedId: "ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d",
+    },
+    WETH: {
+        account: (0, kit_1.address)("42amVS4KgzR9rA28tkVYqVXjq9Qa8dcZQMbH5EYFX6XC"),
+        feedId: "ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace",
+    },
+    WBTC: {
+        account: (0, kit_1.address)("9gNX5vguzarZZPjTnE1hWze3s6UsZ7dsU3UnAmKPnMHG"),
+        feedId: "c9d8b075a5c69303365ae23633d4e085199bf5c520a3b90fed1322a0342ffc33",
+    },
+    CBBTC: {
+        account: (0, kit_1.address)("4cSM2e6rvbGQUFiJbqytoVMi5GgghSMr8LwVrT9VPSPo"),
+        feedId: "e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43",
+    },
+    JLP: {
+        account: (0, kit_1.address)("2TTGSRSezqFzeLUH8JwRUbtN66XLLaymfYsWRTMjfiMw"),
+        feedId: "c811abc82b4bad1f9bd711a2773ccaa935b03ecef974236942cec5e0eb845a3a",
+    },
+    SPYx: {
+        account: (0, kit_1.address)("9owhtgrdLiUMAH9JKxYFt5pUY4Luy4EzzLhdcWPVuDyy"),
+        feedId: "19e09bb805456ada3979a7d1cbb4b6d63babc3a0f8e8a9509f68afa5c4c11cd5",
+    },
+    QQQx: {
+        account: (0, kit_1.address)("EwssJrQ7UVz6itHEaQQsKWikhZ3iHddyxRhmR7pTvwt5"),
+        feedId: "9695e2b96ea7b3859da9ed25b7a46a920a776e2fdae19a7bcfdf2b219230452d",
+    },
+    // LSTs
+    JupSOL: {
+        account: (0, kit_1.address)("D7UqeBmCEmhGXGYfi2y9RfoCa7t1Xw5iZLBeYZ3sxFSe"),
+        feedId: "f8d8d6b6c866c8b2624fb5b679ae846738725e5fc887fa8e927c8d8645018a2b",
+    },
+    // Stablecoins
+    USDC: {
+        account: (0, kit_1.address)("Dpw1EAVrSB1ibxiDQyTAW6Zip3J4Btk2x4SgApQCeFbX"),
+        feedId: "eaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
+    },
+    USDT: {
+        account: (0, kit_1.address)("HT2PLQBcG5EiCcNSaMHAjSgd9F98ecpATbk4Sk5oYuM"),
+        feedId: "2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b",
+    },
+    CASH: {
+        account: (0, kit_1.address)("F23Xi7VQw1pdre26VmuKnjRcDcrhpqGtHkGdKdSdbM8w"),
+        feedId: "df3320ef0f4617337b8dbb924f2aaa4f9db08f522a5435b44f9066c1ac4c7f95",
+    },
+    PYUSD: {
+        account: (0, kit_1.address)("9zXQxpYH3kYhtoybmZfUNNCRVuud7fY9jswTg1hLyT8k"),
+        feedId: "0xc1da1b73d7f01e7ddd54b3766cf7fcd644395ad14f70aa706ec5384c59e76692",
+    },
+    USDG: {
+        account: (0, kit_1.address)("6JkZmXGgWnzsyTQaqRARzP64iFYnpMNT4siiuUDUaB8s"),
+        feedId: "0xdaa58c6a3ce7d4b9c46c32a6e646012c17c4a2b24c08dd8c5e476118b855a7da",
+    },
+    USDS: {
+        account: (0, kit_1.address)("DyYBBWEi9xZvgNAeMDCiFnmC1U9gqgVsJDXkL5WETpoX"),
+        feedId: "0x77f0971af11cc8bac224917275c1bf55f2319ed5c654a1ca955c82fa2d297ea1",
+    },
+    // Yield bearing assets
+    PST: {
+        account: (0, kit_1.address)("CBGwQddTeYn3KdvxGWtU95fqCcavzHK9XPFBLENDF5JR"),
+        feedId: "675e36f84a6be779ed793c71eb5c03151e1866c125767f46933626e0610af84d",
+    },
+};

package/dist/shared/oracle-service/src/constants/splStake.d.ts

@@ -0,0 +1,2 @@
+/** SPL stake pool account for dfdvSOL (DeFi Development Corp LST). */
+export declare const DFDVSOL_STAKE_POOL: import("@solana/kit").Address<"pyZMBjpWsVjKANAYK5mpNbKiws2krjRPZ2N2UYCSnbP">;

package/dist/shared/oracle-service/src/constants/splStake.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DFDVSOL_STAKE_POOL = void 0;
+const kit_1 = require("@solana/kit");
+/** SPL stake pool account for dfdvSOL (DeFi Development Corp LST). */
+exports.DFDVSOL_STAKE_POOL = (0, kit_1.address)("pyZMBjpWsVjKANAYK5mpNbKiws2krjRPZ2N2UYCSnbP");

package/dist/shared/oracle-service/src/constants/switchboard.d.ts

@@ -0,0 +1,7 @@
+import { MintIdentifier } from "common";
+interface SwitchboardFeed {
+    feedId: string;
+    feedHash: string;
+}
+export declare const SWITCHBOARD_PRICE_FEED_IDS: Record<MintIdentifier, SwitchboardFeed>;
+export {};

package/dist/shared/oracle-service/src/constants/switchboard.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWITCHBOARD_PRICE_FEED_IDS = void 0;
+// https://beta.ondemand.switchboard.xyz/solana/mainnet
+exports.SWITCHBOARD_PRICE_FEED_IDS = {
+    SOL: {
+        feedId: "4Hmd6PdjVA9auCoScE12iaBogfwS4ZXQ6VZoBeqanwWW",
+        feedHash: "0x1f42dfb21efb24828b99fbe70e6d139cd665aafcbb1706bccd8f2a9b12562db6",
+    },
+};

package/dist/shared/oracle-service/src/feeds/custom.d.ts

@@ -0,0 +1,30 @@
+import { Address } from "@solana/kit";
+import { MintIdentifier, OracleType } from "common";
+import { PriceBase, type PriceFetchContext } from "./priceBase";
+import { PriceResult } from "../types";
+export interface CustomOracle {
+    /** Receives the RPC URL for the active environment on each fetch. */
+    priceFetcher: (rpcUrl: string) => Promise<number>;
+    oracle: Address;
+    oracleType: OracleType;
+    /** Optional secondary oracle account for composite oracle types (e.g. the
+     * SPL stake pool account for `PythSplStake`). */
+    secondaryOracle?: Address;
+}
+export declare class CustomPrices extends PriceBase {
+    private customOracles;
+    private getLookupKeys;
+    /**
+     * Register a custom price fetcher for a given mint.
+     *
+     * @param mint - The mint identifier
+     * @param fetcher - An async function that returns the current price
+     */
+    registerCustomOracle(mint: MintIdentifier, oracle: CustomOracle): void;
+    /**
+     * Check if a custom price fetcher is registered for a given mint.
+     */
+    hasCustomOracle(mint: MintIdentifier): boolean;
+    protected internalFetchPrices(mints: MintIdentifier[], context?: PriceFetchContext): Promise<Record<MintIdentifier, PriceResult>>;
+    getCustomOracle(mint: MintIdentifier): CustomOracle | undefined;
+}

package/dist/shared/oracle-service/src/feeds/custom.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomPrices = void 0;
+const common_1 = require("common");
+const priceBase_1 = require("./priceBase");
+class CustomPrices extends priceBase_1.PriceBase {
+    constructor() {
+        super(...arguments);
+        this.customOracles = new Map();
+    }
+    getLookupKeys(mint) {
+        const symbol = common_1.mints.get(mint)?.symbol;
+        const address = common_1.mints.get(mint)?.address;
+        return [mint, symbol, address].filter((key) => key !== undefined);
+    }
+    /**
+     * Register a custom price fetcher for a given mint.
+     *
+     * @param mint - The mint identifier
+     * @param fetcher - An async function that returns the current price
+     */
+    registerCustomOracle(mint, oracle) {
+        this.customOracles.set(mint, oracle);
+    }
+    /**
+     * Check if a custom price fetcher is registered for a given mint.
+     */
+    hasCustomOracle(mint) {
+        return this.getLookupKeys(mint).some((key) => this.customOracles.has(key));
+    }
+    async internalFetchPrices(mints, context) {
+        const rpcUrl = context?.rpcUrl;
+        if (!rpcUrl) {
+            throw new Error("Custom oracle price fetch requires an RPC URL");
+        }
+        const entries = await Promise.all(mints.map(async (mint) => {
+            const oracle = this.getCustomOracle(mint);
+            if (!oracle) {
+                return [mint, { realtimePrice: 0 }];
+            }
+            const price = await oracle.priceFetcher(rpcUrl);
+            return [mint, { realtimePrice: price }];
+        }));
+        return Object.fromEntries(entries);
+    }
+    getCustomOracle(mint) {
+        for (const key of this.getLookupKeys(mint)) {
+            const oracle = this.customOracles.get(key);
+            if (oracle) {
+                return oracle;
+            }
+        }
+        return undefined;
+    }
+}
+exports.CustomPrices = CustomPrices;

package/dist/shared/oracle-service/src/feeds/jupiter.d.ts

@@ -0,0 +1,7 @@
+import { Address } from "@solana/kit";
+import { PriceBase, type PriceFetchContext } from "./priceBase";
+import { PriceResult } from "../types";
+export declare class JupiterPrices extends PriceBase {
+    private getJupPriceData;
+    internalFetchPrices(mints: Address[], _context?: PriceFetchContext): Promise<Record<Address, PriceResult>>;
+}

package/dist/shared/oracle-service/src/feeds/jupiter.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JupiterPrices = void 0;
+const common_1 = require("common");
+const ts_retry_1 = require("ts-retry");
+const priceBase_1 = require("./priceBase");
+class JupiterPrices extends priceBase_1.PriceBase {
+    async getJupPriceData(mints) {
+        const batches = (0, common_1.getBatches)(mints, 50);
+        const results = await Promise.all(batches.map((batch) => (0, ts_retry_1.retry)(async () => {
+            const res = await (await fetch("https://lite-api.jup.ag/price/v3?ids=" + batch.map((x) => x.toString()).join(","))).json();
+            if (!res || typeof res !== "object") {
+                throw new Error("Failed to get mint prices using Jupiter");
+            }
+            return res;
+        }, { maxTry: 6, delay: 250 })));
+        return Object.assign({}, ...results);
+    }
+    async internalFetchPrices(mints, _context) {
+        if (mints.length == 0) {
+            return {};
+        }
+        const priceData = await this.getJupPriceData(mints);
+        const sortedPrices = {};
+        for (const mint of mints) {
+            const key = mint.toString();
+            if (priceData.hasOwnProperty(key)) {
+                sortedPrices[key] = priceData[key];
+            }
+        }
+        const prices = Object.fromEntries(mints.map((mint) => [
+            mint,
+            sortedPrices !== null &&
+                typeof sortedPrices === "object" &&
+                typeof sortedPrices[mint.toString()] === "object" &&
+                "usdPrice" in sortedPrices[mint.toString()]
+                ? { realtimePrice: parseFloat(sortedPrices[mint.toString()].usdPrice) }
+                : { realtimePrice: 0 },
+        ]));
+        return prices;
+    }
+}
+exports.JupiterPrices = JupiterPrices;

package/dist/shared/oracle-service/src/feeds/priceBase.d.ts

@@ -0,0 +1,13 @@
+import { DataCache, MintIdentifier } from "common";
+import { PriceResult } from "../types";
+/** Optional per-fetch context passed through {@link PriceBase.fetchPrices}. */
+export interface PriceFetchContext {
+    /** RPC URL for feeds that need on-chain reads (e.g. custom SPL-stake oracles). */
+    rpcUrl?: string;
+}
+export declare abstract class PriceBase {
+    dataCache: DataCache;
+    constructor();
+    protected abstract internalFetchPrices(mints: MintIdentifier[], context?: PriceFetchContext): Promise<Record<MintIdentifier, PriceResult>>;
+    fetchPrices(mints: MintIdentifier[], bypassCache?: boolean, context?: PriceFetchContext): Promise<Record<MintIdentifier, PriceResult>>;
+}

package/dist/shared/oracle-service/src/feeds/priceBase.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceBase = void 0;
+const common_1 = require("common");
+class PriceBase {
+    constructor() {
+        this.dataCache = new common_1.DataCache({
+            defaultTtlMs: common_1.PRICE_STALENESS_SECONDS * 1000,
+        });
+    }
+    async fetchPrices(mints, bypassCache, context) {
+        if (!mints.length) {
+            return {};
+        }
+        if (bypassCache) {
+            return await this.internalFetchPrices(mints, context);
+        }
+        const { data } = await this.dataCache.getDataBatch(async () => {
+            const prices = await this.internalFetchPrices(mints, context);
+            return mints.map((mint) => prices[mint] ?? null);
+        }, "prices", mints);
+        return Object.fromEntries(mints.map((mint, i) => [mint, data[i] ?? 0]));
+    }
+}
+exports.PriceBase = PriceBase;

package/dist/shared/oracle-service/src/feeds/pyth.d.ts

@@ -0,0 +1,8 @@
+import { Address } from "@solana/kit";
+import { PriceBase, type PriceFetchContext } from "./priceBase";
+import { PriceResult } from "../types";
+export declare class PythPrices extends PriceBase {
+    private deriveValue;
+    private findFeed;
+    protected internalFetchPrices(mints: Address[], _context?: PriceFetchContext): Promise<Record<Address, PriceResult>>;
+}

package/dist/shared/oracle-service/src/feeds/pyth.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythPrices = void 0;
+const priceBase_1 = require("./priceBase");
+const constants_1 = require("../constants");
+const common_1 = require("common");
+const ts_retry_1 = require("ts-retry");
+const utils_1 = require("../utils");
+class PythPrices extends priceBase_1.PriceBase {
+    constructor() {
+        super(...arguments);
+        this.deriveValue = (price, exponent) => {
+            if (exponent > 0) {
+                return Number((0, common_1.fromUiAmount)(Number(price), exponent));
+            }
+            else if (exponent < 0) {
+                return (0, common_1.toUiAmount)(BigInt(price), Math.abs(exponent));
+            }
+            else {
+                return Number(price);
+            }
+        };
+    }
+    findFeed(symbol) {
+        const key = (0, common_1.findKeyIgnoreCase)(constants_1.PYTH_FEEDS, symbol);
+        return key ? constants_1.PYTH_FEEDS[key] : undefined;
+    }
+    async internalFetchPrices(mints, _context) {
+        const feedIds = mints.map((mint) => {
+            const symbol = common_1.mints.get(mint)?.symbol;
+            const feed = symbol ? this.findFeed(symbol) : undefined;
+            if (!feed) {
+                throw new Error(`No Pyth feed configured for mint ${mint.toString()}`);
+            }
+            return feed.feedId;
+        });
+        const prices = await (0, ts_retry_1.retry)(async () => {
+            const resp = await (0, utils_1.pythRequest)(feedIds);
+            const status = resp.status;
+            if (status !== 200) {
+                const body = await resp.text().catch(() => "<failed to read response body>");
+                throw new Error(`Pyth price request failed status=${status} statusText=${resp.statusText} feedIds=${feedIds.join(",")} body=${body}`);
+            }
+            const json = await resp.json();
+            const prices = json.parsed.map((x) => {
+                return {
+                    realtimePrice: this.deriveValue(x.price.price, x.price.expo),
+                    emaPrice: this.deriveValue(x.ema_price.price, x.ema_price.expo),
+                };
+            });
+            return prices;
+        }, {
+            maxTry: 5,
+            delay: 250,
+        });
+        return (0, common_1.createRecord)(mints.map((x) => x.toString()), prices);
+    }
+}
+exports.PythPrices = PythPrices;

package/dist/shared/oracle-service/src/feeds/splStake.d.ts

@@ -0,0 +1,26 @@
+import { Address } from "@solana/kit";
+import { MintIdentifier } from "common";
+import { PythFeed } from "../constants/pyth";
+/**
+ * Upper bound on the LST/SOL exchange rate, expressed as a multiple of SOL/USD.
+ * Mirrors Kamino/Scope's SPL-stake LST pricing (and the on-chain Rust
+ * `SPL_STAKE_PRICE_CAP_MULTIPLIER`): the price is capped at `1.1 × SOL/USD` so a
+ * corrupted or manipulated stake pool exchange rate can never value the LST
+ * above 1.1 SOL.
+ */
+export declare const SPL_STAKE_PRICE_CAP_MULTIPLIER = 1.1;
+export interface SplStakeLstConfig {
+    /** The LST mint (the stake pool's pool token). */
+    mint: MintIdentifier;
+    /** The SPL stake pool account. */
+    stakePool: Address;
+    /** The Pyth SOL/USD feed used to convert the SOL-denominated rate to USD. */
+    pythSolFeed: PythFeed;
+}
+/**
+ * Price an SPL-stake LST in USD, matching Kamino/Scope and the on-chain Rust
+ * `PythSplStake` oracle:
+ *
+ *   price = min(stake_rate × SOL/USD, 1.1 × SOL/USD)
+ */
+export declare function getSplStakeLstUiPrice(rpcUrl: string, config: SplStakeLstConfig): Promise<number>;

package/dist/shared/oracle-service/src/feeds/splStake.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPL_STAKE_PRICE_CAP_MULTIPLIER = void 0;
+exports.getSplStakeLstUiPrice = getSplStakeLstUiPrice;
+const common_1 = require("common");
+const utils_1 = require("../utils");
+/**
+ * Upper bound on the LST/SOL exchange rate, expressed as a multiple of SOL/USD.
+ * Mirrors Kamino/Scope's SPL-stake LST pricing (and the on-chain Rust
+ * `SPL_STAKE_PRICE_CAP_MULTIPLIER`): the price is capped at `1.1 × SOL/USD` so a
+ * corrupted or manipulated stake pool exchange rate can never value the LST
+ * above 1.1 SOL.
+ */
+exports.SPL_STAKE_PRICE_CAP_MULTIPLIER = 1.1;
+// Byte offsets into an SPL stake pool account (no discriminator; Borsh layout
+// of `spl_stake_pool::state::StakePool`). Verified on-chain: `token_program_id`
+// lands on the SPL Token program at offset 226, so these two u64s are correct.
+//   account_type(1) + manager(32) + staker(32) + stake_deposit_authority(32)
+//   + stake_withdraw_bump_seed(1) + validator_list(32) + reserve_stake(32)
+//   + pool_mint(32) + manager_fee_account(32) + token_program_id(32) = 258
+const STAKE_POOL_TOTAL_LAMPORTS_OFFSET = 258;
+const STAKE_POOL_POOL_TOKEN_SUPPLY_OFFSET = 266;
+function errorWithCause(message, cause) {
+    const err = new Error(message);
+    err.cause = cause;
+    return err;
+}
+/** Convert a raw Pyth price + exponent into a UI number (mirrors `pyth.ts`). */
+function deriveValue(price, exponent) {
+    if (exponent > 0)
+        return Number((0, common_1.fromUiAmount)(Number(price), exponent));
+    if (exponent < 0)
+        return (0, common_1.toUiAmount)(BigInt(price), Math.abs(exponent));
+    return Number(price);
+}
+/**
+ * Read the LST/SOL exchange rate from an SPL stake pool account:
+ * `rate = total_lamports / pool_token_supply` — how much SOL one LST is
+ * redeemable for. The underlying SOL and the LST mint both use 9 decimals, so
+ * the raw ratio is the dimensionless SOL-per-LST rate.
+ */
+async function fetchStakeRate(rpcUrl, stakePool) {
+    const rpc = (0, common_1.createRpcWithRetry)(rpcUrl);
+    const redactedRpcUrl = (0, common_1.redactRpcUrlForLog)(rpcUrl);
+    let response;
+    try {
+        response = await rpc.getAccountInfo(stakePool, { encoding: "base64" }).send();
+    }
+    catch (err) {
+        throw errorWithCause(`SPL stake pool getAccountInfo failed (stakePool=${stakePool}, rpc=${redactedRpcUrl})`, err);
+    }
+    const { value } = response;
+    if (!value) {
+        throw new Error(`SPL stake pool account not found (stakePool=${stakePool}, rpc=${redactedRpcUrl})`);
+    }
+    const data = Buffer.from(value.data[0], "base64");
+    const totalLamports = data.readBigUInt64LE(STAKE_POOL_TOTAL_LAMPORTS_OFFSET);
+    const poolTokenSupply = data.readBigUInt64LE(STAKE_POOL_POOL_TOKEN_SUPPLY_OFFSET);
+    if (poolTokenSupply === BigInt(0)) {
+        throw new Error(`SPL stake pool has zero pool token supply (stakePool=${stakePool}, rpc=${redactedRpcUrl})`);
+    }
+    return Number(totalLamports) / Number(poolTokenSupply);
+}
+/** Fetch the latest SOL/USD realtime price from Pyth Hermes. */
+async function fetchSolUsd(feedId) {
+    let resp;
+    try {
+        resp = await (0, utils_1.pythRequest)([feedId]);
+    }
+    catch (err) {
+        throw errorWithCause(`Pyth SOL/USD request failed before response (feedId=${feedId})`, err);
+    }
+    if (resp.status !== 200) {
+        const body = await resp.text().catch(() => "<failed to read response body>");
+        throw new Error(`Pyth SOL/USD request failed status=${resp.status} feedId=${feedId} body=${body}`);
+    }
+    let json;
+    try {
+        json = (await resp.json());
+    }
+    catch (err) {
+        throw errorWithCause(`Pyth SOL/USD response JSON parse failed (feedId=${feedId})`, err);
+    }
+    const price = json.parsed[0].price;
+    return deriveValue(price.price, price.expo);
+}
+/**
+ * Price an SPL-stake LST in USD, matching Kamino/Scope and the on-chain Rust
+ * `PythSplStake` oracle:
+ *
+ *   price = min(stake_rate × SOL/USD, 1.1 × SOL/USD)
+ */
+async function getSplStakeLstUiPrice(rpcUrl, config) {
+    const [rate, solUsd] = await Promise.all([
+        fetchStakeRate(rpcUrl, config.stakePool),
+        fetchSolUsd(config.pythSolFeed.feedId),
+    ]);
+    return Math.min(rate * solUsd, exports.SPL_STAKE_PRICE_CAP_MULTIPLIER * solUsd);
+}

package/dist/shared/oracle-service/src/feeds/switchboard.d.ts

@@ -0,0 +1,6 @@
+import { Address } from "@solana/kit";
+import { PriceBase, type PriceFetchContext } from "./priceBase";
+import { PriceResult } from "../types";
+export declare class SwitchboardPrices extends PriceBase {
+    protected internalFetchPrices(mints: Address[], _context?: PriceFetchContext): Promise<Record<Address, PriceResult>>;
+}

package/dist/shared/oracle-service/src/feeds/switchboard.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchboardPrices = void 0;
+const priceBase_1 = require("./priceBase");
+class SwitchboardPrices extends priceBase_1.PriceBase {
+    async internalFetchPrices(mints, _context) {
+        // TODO
+        return {};
+    }
+}
+exports.SwitchboardPrices = SwitchboardPrices;

package/dist/shared/oracle-service/src/index.d.ts

@@ -0,0 +1,5 @@
+export { OracleService, oracle } from "./oracle";
+export * from "./constants";
+export { type PriceResult } from "./types";
+export { registerSplStakeLstOracle, registerDfdvSolOracle } from "./utils";
+export { getSplStakeLstUiPrice, type SplStakeLstConfig } from "./feeds/splStake";

package/dist/shared/oracle-service/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSplStakeLstUiPrice = exports.registerDfdvSolOracle = exports.registerSplStakeLstOracle = exports.oracle = exports.OracleService = void 0;
+var oracle_1 = require("./oracle");
+Object.defineProperty(exports, "OracleService", { enumerable: true, get: function () { return oracle_1.OracleService; } });
+Object.defineProperty(exports, "oracle", { enumerable: true, get: function () { return oracle_1.oracle; } });
+__exportStar(require("./constants"), exports);
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "registerSplStakeLstOracle", { enumerable: true, get: function () { return utils_1.registerSplStakeLstOracle; } });
+Object.defineProperty(exports, "registerDfdvSolOracle", { enumerable: true, get: function () { return utils_1.registerDfdvSolOracle; } });
+var splStake_1 = require("./feeds/splStake");
+Object.defineProperty(exports, "getSplStakeLstUiPrice", { enumerable: true, get: function () { return splStake_1.getSplStakeLstUiPrice; } });

package/dist/shared/oracle-service/src/oracle.d.ts

@@ -0,0 +1,22 @@
+import { OracleType, type Environment, type MintIdentifier } from "common";
+import { CustomOracle } from "./feeds/custom";
+export declare class OracleService {
+    private jupiter;
+    private pyth;
+    private switchboard;
+    private custom;
+    constructor();
+    /**
+     * Register a custom oracle for a given mint.
+     * Custom-registered mints take priority over all other oracle sources.
+     */
+    registerCustomOracle(mint: MintIdentifier, oracle: CustomOracle): void;
+    getOracleData(mint: MintIdentifier): {
+        oracle: import("@solana/kit").Address;
+        oracleType: OracleType;
+        secondaryOracle: import("@solana/kit").Address | undefined;
+    };
+    clearCache(): void;
+    fetchPrices(mints: MintIdentifier[], mode?: "realtime" | "ema", bypassCache?: boolean, environment?: Environment): Promise<Record<MintIdentifier, number>>;
+}
+export declare const oracle: OracleService;