lynx-client 0.0.39 → 0.1.0

package/dist/esm/lib/priceFeeds/pyth/hermes/hermesFeedFunctions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHermesPriceKeyForPair = getHermesPriceKeyForPair;
+exports.getHermesFeedIdForPair = getHermesFeedIdForPair;
+exports.getPairIdForHermesFeedId = getPairIdForHermesFeedId;
+const hermesFeedConstants_1 = require("./hermesFeedConstants");
+/**
+ * Get the Pyth Hermes symbol (e.g. "Crypto.BTC/USD") for a pair
+ */
+function getHermesPriceKeyForPair(pairId) {
+    return hermesFeedConstants_1.PYTH_HERMES_PRICE_KEYS[pairId];
+}
+/**
+ * Get the Pyth Hermes feed id (32-byte hex hash) for a pair
+ */
+function getHermesFeedIdForPair(pairId) {
+    return hermesFeedConstants_1.PYTH_HERMES_FEED_IDS[pairId];
+}
+/**
+ * Get the pair id for a Pyth Hermes feed id (reverse lookup)
+ */
+function getPairIdForHermesFeedId(feedId) {
+    return hermesFeedConstants_1.PYTH_HERMES_FEED_ID_TO_PAIR[feedId];
+}

package/dist/esm/lib/priceFeeds/pyth/hermes/hermesPriceData.d.ts

@@ -0,0 +1,11 @@
+import { CombinedPriceData } from "../../interfaces";
+/**
+ * Fetches historical price data from Pyth Hermes for a specific timestamp or later
+ * Only searches forward in time (timestamp >= startTimestamp), never backwards
+ * @param priceFeedId - The Pyth Hermes price feed ID (32-byte hex hash)
+ * @param startTimestamp - The minimum timestamp to search from
+ * @param maxTimeGap - Maximum seconds to search forward from startTimestamp
+ * @param pairId - Optional pair identifier included in error messages for context
+ */
+export declare function getHermesPriceForTimestamp(priceFeedId: string, startTimestamp: number, maxTimeGap: number, pairId?: number): Promise<CombinedPriceData>;
+//# sourceMappingURL=hermesPriceData.d.ts.map

package/dist/esm/lib/priceFeeds/pyth/hermes/hermesPriceData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hermesPriceData.d.ts","sourceRoot":"","sources":["../../../../../../lib/priceFeeds/pyth/hermes/hermesPriceData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAgCrD;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAC9C,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,CAAC,CAkB5B"}

package/dist/{cjs/lib/priceFeeds/pyth/pythPriceData.js → esm/lib/priceFeeds/pyth/hermes/hermesPriceData.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPricesForTimestamp = getPricesForTimestamp;
-const scales_1 = require("../../constants/scales");
-const lynxScalesUtils_1 = require("../../lynxSystem/lynxScalesUtils");
-const bignumbers_1 = require("../../utils/bignumbers");
+exports.getHermesPriceForTimestamp = getHermesPriceForTimestamp;
+const scales_1 = require("../../../constants/scales");
+const lynxScalesUtils_1 = require("../../../lynxSystem/lynxScalesUtils");
+const bignumbers_1 = require("../../../utils/bignumbers");
 /**
- * Helper function to parse Pyth API response data into CombinedPriceData
+ * Helper function to parse Pyth Hermes API response data into CombinedPriceData
  */
 function parseResponse(data) {
     const encodedPrice = data.binary?.data ? `0x${data.binary.data}` : "";
@@ -30,13 +30,14 @@ function parseResponse(data) {
     };
 }
 /**
- * Fetches historical price data from Pyth for a specific timestamp or later
+ * Fetches historical price data from Pyth Hermes for a specific timestamp or later
  * Only searches forward in time (timestamp >= startTimestamp), never backwards
- * @param priceFeedId - The Pyth price feed ID
+ * @param priceFeedId - The Pyth Hermes price feed ID (32-byte hex hash)
  * @param startTimestamp - The minimum timestamp to search from
  * @param maxTimeGap - Maximum seconds to search forward from startTimestamp
+ * @param pairId - Optional pair identifier included in error messages for context
  */
-async function getPricesForTimestamp(priceFeedId, startTimestamp, maxTimeGap) {
+async function getHermesPriceForTimestamp(priceFeedId, startTimestamp, maxTimeGap, pairId) {
     const hermesUrl = "https://hermes.pyth.network";
     const buildUrl = (timestamp) => `${hermesUrl}/v2/updates/price/${timestamp}?ids[]=${priceFeedId}&encoding=hex`;
     // Try timestamps from startTimestamp onwards, incrementing by 1 second
@@ -47,5 +48,6 @@ async function getPricesForTimestamp(priceFeedId, startTimestamp, maxTimeGap) {
             return parseResponse(await response.json());
         }
     }
-    throw new Error(`No price found for asset ${priceFeedId} at or within ${maxTimeGap}s after timestamp ${startTimestamp}`);
+    const pairContext = pairId !== undefined ? ` (pair ${pairId})` : "";
+    throw new Error(`No price found for Pyth Hermes feed ${priceFeedId}${pairContext} at or within ${maxTimeGap}s after timestamp ${startTimestamp}`);
 }

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerFeedConstants.d.ts

@@ -0,0 +1,54 @@
+import { TPairIds } from "../../../constants/pairIds";
+/**
+ * Pyth Lazer feed identifiers are u32 integers (not 32-byte hex hashes like Hermes).
+ * Branding this as a distinct nominal type prevents accidentally passing a Hermes
+ * hash where a Lazer numeric id is expected, and vice versa.
+ */
+export type PythLazerFeedId = number & {
+    readonly __brand: "PythLazerFeedId";
+};
+/**
+ * Pyth Lazer symbol per pair. Mirrors PYTH_HERMES_PRICE_KEYS but uses Lazer's
+ * symbol convention (e.g. "FX." uppercase prefix instead of Hermes' "Fx.").
+ */
+export declare const PYTH_LAZER_PRICE_KEYS: Record<TPairIds, string>;
+/**
+ * Pyth Lazer u32 feed identifiers per pair. Source of truth is
+ * https://pyth.dourolabs.app/v1/symbols (pyth_lazer_id field).
+ *
+ * CAT pairs intentionally share the same feed id as their non-CAT counterpart
+ * (the underlying market data is identical). This is a behavior change vs the
+ * Hermes map, which uses empty-string sentinels for CAT pairs — Lazer callers
+ * always get a usable id back.
+ *
+ * Feed availability on Lazer at the time these were captured (verify with
+ * scripts/verifyLazerMapping.ts before relying on any of this).
+ *
+ * IMPORTANT — MIGRATION CONTEXT: Hermes is scheduled for deprecation
+ * (~2026-07). Lazer is the long-term path. The two entries below are
+ * migration blockers that need to be resolved (Pyth state change OR feed
+ * replacement) before Hermes shutoff, otherwise we lose pricing entirely:
+ *
+ *  - Crypto.FLR/USD (id 191) — Lazer state `coming_soon`. Querying returns
+ *    HTTP 400 "Price feed id 191 is not ready". Today FLR pricing works via
+ *    Hermes and Flare; post-Hermes-shutoff only Flare remains if Pyth has
+ *    not yet promoted 191 to `stable`. Re-run scripts/verifyLazerMapping.ts
+ *    to check current state.
+ *
+ *  - Commodities.USOILSPOT (id 657) — Lazer state `inactive`. Querying
+ *    returns HTTP 400 "Price feed id 657 is not ready". Today USOIL pricing
+ *    works via Hermes only (the Flare oracle does NOT publish USOIL). This
+ *    is the more urgent migration blocker: if Pyth does not reactivate 657
+ *    before Hermes shutoff, we need an alternative provider for USOIL or
+ *    we lose the pair.
+ *
+ *  All other ids are `stable`.
+ */
+export declare const PYTH_LAZER_FEED_IDS: Record<TPairIds, PythLazerFeedId>;
+/**
+ * Reverse lookup: Lazer feed id → pair id. CAT pairs share an id with their
+ * non-CAT base, so only the base pair is present — the reverse map returns the
+ * "canonical" non-CAT pair for any given Lazer feed id.
+ */
+export declare const PYTH_LAZER_FEED_ID_TO_PAIR: Record<number, TPairIds>;
+//# sourceMappingURL=lazerFeedConstants.d.ts.map

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerFeedConstants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazerFeedConstants.d.ts","sourceRoot":"","sources":["../../../../../../lib/priceFeeds/pyth/lazer/lazerFeedConstants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAiCxE;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAI/E;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAsD1D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,QAAQ,EAAE,eAAe,CAsDjE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAiB5D,CAAC"}

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerFeedConstants.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PYTH_LAZER_FEED_ID_TO_PAIR = exports.PYTH_LAZER_FEED_IDS = exports.PYTH_LAZER_PRICE_KEYS = void 0;
+const pairIds_1 = require("../../../constants/pairIds");
+const lazerId = (n) => n;
+/**
+ * Pyth Lazer symbol per pair. Mirrors PYTH_HERMES_PRICE_KEYS but uses Lazer's
+ * symbol convention (e.g. "FX." uppercase prefix instead of Hermes' "Fx.").
+ */
+exports.PYTH_LAZER_PRICE_KEYS = {
+    // Crypto
+    [pairIds_1.PAIR_CONFIGS_IDS.BTC_USD]: "Crypto.BTC/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.ETH_USD]: "Crypto.ETH/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.BNB_USD]: "Crypto.BNB/USD",
+    // Crypto.FTM/USD is deprecated; reuses Crypto.S/USD (same convention as Hermes map)
+    [pairIds_1.PAIR_CONFIGS_IDS.FTM_USD]: "Crypto.S/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.SOL_USD]: "Crypto.SOL/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.XRP_USD]: "Crypto.XRP/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.FLR_USD]: "Crypto.FLR/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.SEI_USD]: "Crypto.SEI/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.S_USD]: "Crypto.S/USD",
+    // Forex (Lazer uses uppercase "FX." prefix)
+    [pairIds_1.PAIR_CONFIGS_IDS.EUR_USD]: "FX.EUR/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.GBP_USD]: "FX.GBP/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.AUD_USD]: "FX.AUD/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.NZD_USD]: "FX.NZD/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_JPY]: "FX.USD/JPY",
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_CHF]: "FX.USD/CHF",
+    // Stocks
+    [pairIds_1.PAIR_CONFIGS_IDS.TSLA_USD]: "Equity.US.TSLA/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.AAPL_USD]: "Equity.US.AAPL/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.NVDA_USD]: "Equity.US.NVDA/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.AMZN_USD]: "Equity.US.AMZN/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.GOOGL_USD]: "Equity.US.GOOGL/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.MSFT_USD]: "Equity.US.MSFT/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.META_USD]: "Equity.US.META/USD",
+    // Commodities
+    [pairIds_1.PAIR_CONFIGS_IDS.GOLD_USD]: "Metal.XAU/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.SILVER_USD]: "Metal.XAG/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.USOIL_USD]: "Commodities.USOILSPOT",
+    // CAT mode — share the symbol of the corresponding non-CAT pair
+    [pairIds_1.PAIR_CONFIGS_IDS.BTC_USD_CAT]: "Crypto.BTC/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.ETH_USD_CAT]: "Crypto.ETH/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.EUR_USD_CAT]: "FX.EUR/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.GBP_USD_CAT]: "FX.GBP/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.AUD_USD_CAT]: "FX.AUD/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.NZD_USD_CAT]: "FX.NZD/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_JPY_CAT]: "FX.USD/JPY",
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_CHF_CAT]: "FX.USD/CHF",
+    [pairIds_1.PAIR_CONFIGS_IDS.TSLA_USD_CAT]: "Equity.US.TSLA/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.AAPL_USD_CAT]: "Equity.US.AAPL/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.NVDA_USD_CAT]: "Equity.US.NVDA/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.AMZN_USD_CAT]: "Equity.US.AMZN/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.GOOGL_USD_CAT]: "Equity.US.GOOGL/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.MSFT_USD_CAT]: "Equity.US.MSFT/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.META_USD_CAT]: "Equity.US.META/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.GOLD_USD_CAT]: "Metal.XAU/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.SILVER_USD_CAT]: "Metal.XAG/USD",
+    [pairIds_1.PAIR_CONFIGS_IDS.USOIL_USD_CAT]: "Commodities.USOILSPOT",
+};
+/**
+ * Pyth Lazer u32 feed identifiers per pair. Source of truth is
+ * https://pyth.dourolabs.app/v1/symbols (pyth_lazer_id field).
+ *
+ * CAT pairs intentionally share the same feed id as their non-CAT counterpart
+ * (the underlying market data is identical). This is a behavior change vs the
+ * Hermes map, which uses empty-string sentinels for CAT pairs — Lazer callers
+ * always get a usable id back.
+ *
+ * Feed availability on Lazer at the time these were captured (verify with
+ * scripts/verifyLazerMapping.ts before relying on any of this).
+ *
+ * IMPORTANT — MIGRATION CONTEXT: Hermes is scheduled for deprecation
+ * (~2026-07). Lazer is the long-term path. The two entries below are
+ * migration blockers that need to be resolved (Pyth state change OR feed
+ * replacement) before Hermes shutoff, otherwise we lose pricing entirely:
+ *
+ *  - Crypto.FLR/USD (id 191) — Lazer state `coming_soon`. Querying returns
+ *    HTTP 400 "Price feed id 191 is not ready". Today FLR pricing works via
+ *    Hermes and Flare; post-Hermes-shutoff only Flare remains if Pyth has
+ *    not yet promoted 191 to `stable`. Re-run scripts/verifyLazerMapping.ts
+ *    to check current state.
+ *
+ *  - Commodities.USOILSPOT (id 657) — Lazer state `inactive`. Querying
+ *    returns HTTP 400 "Price feed id 657 is not ready". Today USOIL pricing
+ *    works via Hermes only (the Flare oracle does NOT publish USOIL). This
+ *    is the more urgent migration blocker: if Pyth does not reactivate 657
+ *    before Hermes shutoff, we need an alternative provider for USOIL or
+ *    we lose the pair.
+ *
+ *  All other ids are `stable`.
+ */
+exports.PYTH_LAZER_FEED_IDS = {
+    // Crypto
+    [pairIds_1.PAIR_CONFIGS_IDS.BTC_USD]: lazerId(1),
+    [pairIds_1.PAIR_CONFIGS_IDS.ETH_USD]: lazerId(2),
+    [pairIds_1.PAIR_CONFIGS_IDS.BNB_USD]: lazerId(15),
+    // FTM is deprecated; route to S/USD's Lazer id, matching the Hermes map convention.
+    [pairIds_1.PAIR_CONFIGS_IDS.FTM_USD]: lazerId(190),
+    [pairIds_1.PAIR_CONFIGS_IDS.SOL_USD]: lazerId(6),
+    [pairIds_1.PAIR_CONFIGS_IDS.XRP_USD]: lazerId(14),
+    [pairIds_1.PAIR_CONFIGS_IDS.FLR_USD]: lazerId(191), // state=coming_soon at time of writing
+    [pairIds_1.PAIR_CONFIGS_IDS.SEI_USD]: lazerId(51),
+    [pairIds_1.PAIR_CONFIGS_IDS.S_USD]: lazerId(190),
+    // Forex
+    [pairIds_1.PAIR_CONFIGS_IDS.EUR_USD]: lazerId(327),
+    [pairIds_1.PAIR_CONFIGS_IDS.GBP_USD]: lazerId(333),
+    [pairIds_1.PAIR_CONFIGS_IDS.AUD_USD]: lazerId(315),
+    [pairIds_1.PAIR_CONFIGS_IDS.NZD_USD]: lazerId(337),
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_JPY]: lazerId(340),
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_CHF]: lazerId(339),
+    // Stocks
+    [pairIds_1.PAIR_CONFIGS_IDS.TSLA_USD]: lazerId(1435),
+    [pairIds_1.PAIR_CONFIGS_IDS.AAPL_USD]: lazerId(922),
+    [pairIds_1.PAIR_CONFIGS_IDS.NVDA_USD]: lazerId(1314),
+    [pairIds_1.PAIR_CONFIGS_IDS.AMZN_USD]: lazerId(954),
+    [pairIds_1.PAIR_CONFIGS_IDS.GOOGL_USD]: lazerId(1163),
+    [pairIds_1.PAIR_CONFIGS_IDS.MSFT_USD]: lazerId(1292),
+    [pairIds_1.PAIR_CONFIGS_IDS.META_USD]: lazerId(1272),
+    // Commodities
+    [pairIds_1.PAIR_CONFIGS_IDS.GOLD_USD]: lazerId(346),
+    [pairIds_1.PAIR_CONFIGS_IDS.SILVER_USD]: lazerId(345),
+    [pairIds_1.PAIR_CONFIGS_IDS.USOIL_USD]: lazerId(657), // state=inactive at time of writing
+    // CAT mode — share the feed id of the corresponding non-CAT pair
+    [pairIds_1.PAIR_CONFIGS_IDS.BTC_USD_CAT]: lazerId(1),
+    [pairIds_1.PAIR_CONFIGS_IDS.ETH_USD_CAT]: lazerId(2),
+    [pairIds_1.PAIR_CONFIGS_IDS.EUR_USD_CAT]: lazerId(327),
+    [pairIds_1.PAIR_CONFIGS_IDS.GBP_USD_CAT]: lazerId(333),
+    [pairIds_1.PAIR_CONFIGS_IDS.AUD_USD_CAT]: lazerId(315),
+    [pairIds_1.PAIR_CONFIGS_IDS.NZD_USD_CAT]: lazerId(337),
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_JPY_CAT]: lazerId(340),
+    [pairIds_1.PAIR_CONFIGS_IDS.USD_CHF_CAT]: lazerId(339),
+    [pairIds_1.PAIR_CONFIGS_IDS.TSLA_USD_CAT]: lazerId(1435),
+    [pairIds_1.PAIR_CONFIGS_IDS.AAPL_USD_CAT]: lazerId(922),
+    [pairIds_1.PAIR_CONFIGS_IDS.NVDA_USD_CAT]: lazerId(1314),
+    [pairIds_1.PAIR_CONFIGS_IDS.AMZN_USD_CAT]: lazerId(954),
+    [pairIds_1.PAIR_CONFIGS_IDS.GOOGL_USD_CAT]: lazerId(1163),
+    [pairIds_1.PAIR_CONFIGS_IDS.MSFT_USD_CAT]: lazerId(1292),
+    [pairIds_1.PAIR_CONFIGS_IDS.META_USD_CAT]: lazerId(1272),
+    [pairIds_1.PAIR_CONFIGS_IDS.GOLD_USD_CAT]: lazerId(346),
+    [pairIds_1.PAIR_CONFIGS_IDS.SILVER_USD_CAT]: lazerId(345),
+    [pairIds_1.PAIR_CONFIGS_IDS.USOIL_USD_CAT]: lazerId(657),
+};
+/**
+ * Reverse lookup: Lazer feed id → pair id. CAT pairs share an id with their
+ * non-CAT base, so only the base pair is present — the reverse map returns the
+ * "canonical" non-CAT pair for any given Lazer feed id.
+ */
+exports.PYTH_LAZER_FEED_ID_TO_PAIR = (() => {
+    const acc = {};
+    // Iterate non-CAT pairs first so CAT entries don't overwrite them
+    const catSuffix = "_CAT";
+    const orderedPairNames = Object.keys(pairIds_1.PAIR_CONFIGS_IDS).sort((a, b) => {
+        const aCat = a.endsWith(catSuffix);
+        const bCat = b.endsWith(catSuffix);
+        return Number(aCat) - Number(bCat);
+    });
+    for (const name of orderedPairNames) {
+        const pairId = pairIds_1.PAIR_CONFIGS_IDS[name];
+        const feedId = exports.PYTH_LAZER_FEED_IDS[pairId];
+        if (feedId !== undefined && !(feedId in acc)) {
+            acc[feedId] = pairId;
+        }
+    }
+    return acc;
+})();

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerFeedFunctions.d.ts

@@ -0,0 +1,16 @@
+import { PythLazerFeedId } from "./lazerFeedConstants";
+import { TPairIds } from "../../../constants/pairIds";
+/**
+ * Get the Pyth Lazer symbol (e.g. "Crypto.BTC/USD") for a pair
+ */
+export declare function getLazerPriceKeyForPair(pairId: TPairIds): string;
+/**
+ * Get the Pyth Lazer u32 feed id for a pair
+ */
+export declare function getLazerFeedIdForPair(pairId: TPairIds): PythLazerFeedId;
+/**
+ * Get the canonical (non-CAT) pair id for a Pyth Lazer feed id, or undefined
+ * if no pair is registered for that feed id.
+ */
+export declare function getPairIdForLazerFeedId(feedId: PythLazerFeedId): TPairIds | undefined;
+//# sourceMappingURL=lazerFeedFunctions.d.ts.map

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerFeedFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazerFeedFunctions.d.ts","sourceRoot":"","sources":["../../../../../../lib/priceFeeds/pyth/lazer/lazerFeedFunctions.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,eAAe,EAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtD;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,CAEhE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,QAAQ,GAAG,eAAe,CAEvE;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,GACtB,QAAQ,GAAG,SAAS,CAEtB"}

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerFeedFunctions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLazerPriceKeyForPair = getLazerPriceKeyForPair;
+exports.getLazerFeedIdForPair = getLazerFeedIdForPair;
+exports.getPairIdForLazerFeedId = getPairIdForLazerFeedId;
+const lazerFeedConstants_1 = require("./lazerFeedConstants");
+/**
+ * Get the Pyth Lazer symbol (e.g. "Crypto.BTC/USD") for a pair
+ */
+function getLazerPriceKeyForPair(pairId) {
+    return lazerFeedConstants_1.PYTH_LAZER_PRICE_KEYS[pairId];
+}
+/**
+ * Get the Pyth Lazer u32 feed id for a pair
+ */
+function getLazerFeedIdForPair(pairId) {
+    return lazerFeedConstants_1.PYTH_LAZER_FEED_IDS[pairId];
+}
+/**
+ * Get the canonical (non-CAT) pair id for a Pyth Lazer feed id, or undefined
+ * if no pair is registered for that feed id.
+ */
+function getPairIdForLazerFeedId(feedId) {
+    return lazerFeedConstants_1.PYTH_LAZER_FEED_ID_TO_PAIR[feedId];
+}

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerPayloadTypes.d.ts

@@ -0,0 +1,64 @@
+import { PythLazerFeedId } from "./lazerFeedConstants";
+import { LazerVerifiablePayload } from "./lazerSigningFormats";
+/**
+ * Subscription channel — selects update cadence. `real_time` pushes every
+ * publisher update; fixed-rate channels coalesce updates onto a fixed cadence.
+ */
+export type LazerChannel = "real_time" | "fixed_rate@50ms" | "fixed_rate@200ms" | "fixed_rate@1000ms";
+/**
+ * Trading session of an underlying market at the time of the update.
+ * Some markets (FX, equities, commodities) have non-regular sessions; crypto
+ * is always `regular`.
+ */
+export type LazerMarketSession = "regular" | "pre" | "post" | "closed" | (string & {});
+/**
+ * A single price feed update inside a `streamUpdated` message.
+ * Optional fields appear only when requested via the subscription `properties`.
+ *
+ * Numeric fields delivered as strings by the wire format (large `i64` values
+ * exceed JS safe-integer range) are kept as strings here; consumers should
+ * `BigInt(...)` them before arithmetic.
+ */
+export interface LazerPriceFeedUpdate {
+    priceFeedId: PythLazerFeedId;
+    /** i64 mantissa as string. Actual price = `BigInt(price) * 10n ** BigInt(exponent)`. */
+    price: string;
+    /** i16 power-of-ten exponent (typically negative, e.g. -8). */
+    exponent: number;
+    /** i64 confidence interval, same scale as price. */
+    confidence: number;
+    /** Number of publishers contributing to this update. */
+    publisherCount: number;
+    marketSession: LazerMarketSession;
+    /** Microsecond Unix timestamp of when the price was generated. */
+    feedUpdateTimestamp: number;
+    bestBidPrice?: string;
+    bestAskPrice?: string;
+    emaPrice?: string;
+    emaConfidence?: number;
+    fundingRate?: string;
+    fundingTimestamp?: number;
+    fundingRateInterval?: number;
+}
+/**
+ * Wire shape of a Pyth Lazer `streamUpdated` WebSocket message.
+ *
+ * The `evm` / `solana` / `leEcdsa` / `leUnsigned` keys hold the binary signed
+ * payload(s) for whichever signing formats were requested in the subscription.
+ * Use {@link lazerPayloadToBytes} to convert a payload into the bytes that
+ * `PythLazer.verifyUpdate(bytes)` expects on EVM chains.
+ */
+export interface LazerStreamUpdated {
+    type: "streamUpdated";
+    subscriptionId: number;
+    parsed: {
+        /** Microsecond Unix timestamp as a string (does not fit in JS Number for far-future values). */
+        timestampUs: string;
+        priceFeeds: LazerPriceFeedUpdate[];
+    };
+    evm?: LazerVerifiablePayload;
+    solana?: LazerVerifiablePayload;
+    leEcdsa?: LazerVerifiablePayload;
+    leUnsigned?: LazerVerifiablePayload;
+}
+//# sourceMappingURL=lazerPayloadTypes.d.ts.map

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerPayloadTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazerPayloadTypes.d.ts","sourceRoot":"","sources":["../../../../../../lib/priceFeeds/pyth/lazer/lazerPayloadTypes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D;;;GAGG;AACH,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,iBAAiB,GACjB,kBAAkB,GAClB,mBAAmB,CAAC;AAExB;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,KAAK,GACL,MAAM,GACN,QAAQ,GACR,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAElB;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,eAAe,CAAC;IAC7B,wFAAwF;IACxF,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,kBAAkB,CAAC;IAClC,kEAAkE;IAClE,mBAAmB,EAAE,MAAM,CAAC;IAG5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,eAAe,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,gGAAgG;QAChG,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,oBAAoB,EAAE,CAAC;KACpC,CAAC;IACF,GAAG,CAAC,EAAE,sBAAsB,CAAC;IAC7B,MAAM,CAAC,EAAE,sBAAsB,CAAC;IAChC,OAAO,CAAC,EAAE,sBAAsB,CAAC;IACjC,UAAU,CAAC,EAAE,sBAAsB,CAAC;CACrC"}

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerPayloadTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerPriceData.d.ts

@@ -0,0 +1,26 @@
+import { CombinedPriceData } from "../../interfaces";
+import { PythLazerFeedId } from "./lazerFeedConstants";
+import { LazerChannel } from "./lazerPayloadTypes";
+export interface GetLazerPriceOptions {
+    /** Update channel to query. Defaults to `real_time`. */
+    channel?: LazerChannel;
+    /** Pair identifier included in error messages for context. */
+    pairId?: number;
+    /** Override the Lazer history base URL (e.g. for testing). */
+    baseUrl?: string;
+}
+/**
+ * Fetch unsigned historical price data from Pyth Lazer's History REST API
+ * for a single feed id at a specific timestamp.
+ *
+ * Returns the price snapshot the History API resolves at that timestamp.
+ * Throws if the API returns no row for the feed.
+ *
+ * @param feedId            - Pyth Lazer u32 feed identifier
+ * @param timestampSec      - Unix timestamp in seconds
+ * @param options.channel   - `real_time` | `fixed_rate@50ms` | `fixed_rate@200ms` | `fixed_rate@1000ms` (default `real_time`)
+ * @param options.pairId    - Pair id for error message context
+ * @param options.baseUrl   - Override the API base URL
+ */
+export declare function getLazerPriceForTimestamp(feedId: PythLazerFeedId, timestampSec: number, options?: GetLazerPriceOptions): Promise<CombinedPriceData>;
+//# sourceMappingURL=lazerPriceData.d.ts.map

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerPriceData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazerPriceData.d.ts","sourceRoot":"","sources":["../../../../../../lib/priceFeeds/pyth/lazer/lazerPriceData.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAmDnD,MAAM,WAAW,oBAAoB;IACnC,wDAAwD;IACxD,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,eAAe,EACvB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,iBAAiB,CAAC,CA2B5B"}

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerPriceData.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLazerPriceForTimestamp = getLazerPriceForTimestamp;
+const scales_1 = require("../../../constants/scales");
+const lynxScalesUtils_1 = require("../../../lynxSystem/lynxScalesUtils");
+const bignumbers_1 = require("../../../utils/bignumbers");
+const LAZER_HISTORY_BASE_URL = "https://pyth.dourolabs.app";
+function parseHistoryRow(row) {
+    const expo = row.exponent;
+    const price = Number(row.price);
+    const conf = Number(row.confidence);
+    const priceInScale = (0, bignumbers_1.floatToUnitsBn)(price, scales_1.PRICES_SCALE + expo);
+    const confInScale = (0, bignumbers_1.floatToUnitsBn)(conf, scales_1.PRICES_SCALE + expo);
+    return {
+        // History endpoint returns unsigned price data; encodedPrice stays empty.
+        // Verifiable bytes for on-chain submission must come from the WebSocket
+        // stream's `evm` field (see LazerStreamUpdated).
+        encodedPrice: "",
+        priceInUnits: (0, lynxScalesUtils_1.priceBnToFloat)(priceInScale),
+        priceConfidenceInUnits: (0, lynxScalesUtils_1.priceBnToFloat)(confInScale),
+        // publish_time is microseconds on Lazer; CombinedPriceData.priceTimestamp
+        // is seconds, matching the Hermes convention.
+        priceTimestamp: Math.floor(row.publish_time / 1000000),
+        priceInScale,
+        confInScale,
+    };
+}
+/**
+ * Fetch unsigned historical price data from Pyth Lazer's History REST API
+ * for a single feed id at a specific timestamp.
+ *
+ * Returns the price snapshot the History API resolves at that timestamp.
+ * Throws if the API returns no row for the feed.
+ *
+ * @param feedId            - Pyth Lazer u32 feed identifier
+ * @param timestampSec      - Unix timestamp in seconds
+ * @param options.channel   - `real_time` | `fixed_rate@50ms` | `fixed_rate@200ms` | `fixed_rate@1000ms` (default `real_time`)
+ * @param options.pairId    - Pair id for error message context
+ * @param options.baseUrl   - Override the API base URL
+ */
+async function getLazerPriceForTimestamp(feedId, timestampSec, options = {}) {
+    const channel = options.channel ?? "real_time";
+    const baseUrl = options.baseUrl ?? LAZER_HISTORY_BASE_URL;
+    const timestampMicros = timestampSec * 1000000;
+    const url = `${baseUrl}/v1/${channel}/price?ids=${feedId}&timestamp=${timestampMicros}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        const pairContext = options.pairId !== undefined ? ` (pair ${options.pairId})` : "";
+        throw new Error(`Pyth Lazer history request failed for feed ${feedId}${pairContext} at timestamp ${timestampSec}s on channel '${channel}': HTTP ${response.status}`);
+    }
+    const rows = (await response.json());
+    const row = Array.isArray(rows)
+        ? rows.find((r) => r.price_feed_id === feedId)
+        : undefined;
+    if (!row) {
+        const pairContext = options.pairId !== undefined ? ` (pair ${options.pairId})` : "";
+        throw new Error(`No price found for Pyth Lazer feed ${feedId}${pairContext} at timestamp ${timestampSec}s on channel '${channel}'`);
+    }
+    return parseHistoryRow(row);
+}

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerSigningFormats.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pyth Lazer binary payload encoding format, selected per subscription.
+ * The chosen format determines the on-chain verifier that can validate it.
+ *
+ *  - `evm`         — secp256k1 ECDSA, 65-byte signature. For EVM chains
+ *                    (Ethereum, Arbitrum, Optimism, Polygon, BSC, Avalanche).
+ *  - `solana`      — Ed25519 EdDSA, 64-byte signature. For Solana / Fogo /
+ *                    Ed25519-native chains.
+ *  - `leEcdsa`     — secp256k1 ECDSA in little-endian byte order. For custom
+ *                    integrations.
+ *  - `leUnsigned`  — No signature. Off-chain / dev only.
+ */
+export type LazerSigningFormat = "evm" | "solana" | "leEcdsa" | "leUnsigned";
+/**
+ * Verifiable on-chain payload as returned by Pyth Lazer in the WebSocket
+ * `streamUpdated` message under the `evm` (or `solana`, etc.) key.
+ *
+ * The encoding is chosen by the subscriber via `jsonBinaryEncoding` on the
+ * subscribe request, and the server echoes the choice back in `encoding`:
+ *  - `'base64'` (Pyth's default) — `data` is a base64 string. Smaller
+ *    WebSocket frames; needs decoding before on-chain submission.
+ *  - `'hex'` — `data` is a hex string (may or may not be `0x`-prefixed;
+ *    `lazerPayloadToBytes` handles either). Larger frames, but feeds
+ *    straight into ethers/viem `bytes` args without a decode step.
+ */
+export interface LazerVerifiablePayload {
+    encoding: "base64" | "hex";
+    data: string;
+}
+/**
+ * Convert a Lazer verifiable payload into a 0x-prefixed hex string suitable for
+ * submitting as the `bytes priceUpdate` argument to `PythLazer.verifyUpdate`
+ * (or any EVM contract method expecting raw payload bytes).
+ */
+export declare function lazerPayloadToBytes(payload: LazerVerifiablePayload): string;
+//# sourceMappingURL=lazerSigningFormats.d.ts.map

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerSigningFormats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazerSigningFormats.d.ts","sourceRoot":"","sources":["../../../../../../lib/priceFeeds/pyth/lazer/lazerSigningFormats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,YAAY,CAAC;AAE7E;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAW3E"}

package/dist/esm/lib/priceFeeds/pyth/lazer/lazerSigningFormats.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazerPayloadToBytes = lazerPayloadToBytes;
+/**
+ * Convert a Lazer verifiable payload into a 0x-prefixed hex string suitable for
+ * submitting as the `bytes priceUpdate` argument to `PythLazer.verifyUpdate`
+ * (or any EVM contract method expecting raw payload bytes).
+ */
+function lazerPayloadToBytes(payload) {
+    if (payload.encoding === "hex") {
+        return payload.data.startsWith("0x") ? payload.data : `0x${payload.data}`;
+    }
+    // base64 → hex
+    const base64 = payload.data;
+    const binary = typeof Buffer !== "undefined"
+        ? Buffer.from(base64, "base64").toString("hex")
+        : base64ToHexBrowser(base64);
+    return `0x${binary}`;
+}
+function base64ToHexBrowser(base64) {
+    const binaryString = atob(base64);
+    let hex = "";
+    for (let i = 0; i < binaryString.length; i++) {
+        hex += binaryString.charCodeAt(i).toString(16).padStart(2, "0");
+    }
+    return hex;
+}