@typus/typus-sdk 1.9.4 → 1.10.1

package/dist/src/utils/api/price.d.ts

@@ -1,10 +1,15 @@
 export declare function getPairPrices(pair: string, startTs: string, endTs: string): Promise<any>;
 export declare function getLatestPrice(pair: string): Promise<string>;
-export declare function getPythLatestPrice(): Promise<Map<string, number> | undefined>;
+/**
+ * Fetch latest display prices for every mapped token.
+ * @param accessToken Optional Lazer JWT / API key; falls back to PYTH_LAZER_TOKEN env.
+ */
+export declare function getPythLatestPrice(accessToken?: string): Promise<Map<string, number>>;
 /**
  * Fetch latest Pyth prices for the specified symbols.
  * @param symbols Array of token symbols (e.g., ["BTC", "ETH"]) to fetch prices for.
+ * @param accessToken Optional Lazer JWT / API key; falls back to PYTH_LAZER_TOKEN env.
  * @returns Map where keys are token symbols and values are their latest prices.
  */
-export declare function getPythLatestPriceBySymbols(symbols: string[]): Promise<Map<string, number>>;
+export declare function getPythLatestPriceBySymbols(symbols: string[], accessToken?: string): Promise<Map<string, number>>;
 export declare function getLatestPriceUSD(): Promise<Map<string, number>>;

package/dist/src/utils/api/price.js

@@ -51,6 +51,15 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPairPrices = getPairPrices;
 exports.getLatestPrice = getLatestPrice;
@@ -113,85 +122,112 @@ function getLatestPrice(pair) {
         });
     });
 }
-function getPythLatestPrice() {
+// Pyth Lazer (Pro) numeric feed ids for the display-price helpers below.
+// hermes.pyth.network requires an API key from 2026-08-18 and no key form is
+// browser-safe there, so these helpers fetch from the Lazer `/price` endpoint
+// instead — it accepts the short-lived JWTs a browser can hold.
+// - XAU is priced off XAUT/USD (feed 172): the metal-spot feed 346 is not
+//   entitled on our key, and one unentitled id 403s the whole batch.
+// - USOIL / XAG / USDJPY are unentitled with no crypto proxy — dropped.
+// - Several Sui-ecosystem feeds are inactive upstream as of 2026-07-20
+//   (TURBOS, SCA, AFSUI, NAVX, BUCK, VSUI, HASUI) and return no row until
+//   Pyth reactivates them.
+var lazerDisplayIds = {
+    SUI: 11,
+    CETUS: 401,
+    USDC: 7,
+    BTC: 1,
+    ETH: 2,
+    SOL: 6,
+    TURBOS: 599,
+    APT: 28,
+    USDT: 8,
+    DOGE: 13,
+    INJ: 46,
+    SEI: 51,
+    JUP: 92,
+    SCA: 545,
+    AFSUI: 353,
+    NAVX: 509,
+    USDY: 276,
+    BUCK: 390,
+    VSUI: 622,
+    HASUI: 443,
+    AUSD: 367,
+    DEEP: 173,
+    BLUE: 381,
+    XAU: 172,
+    WAL: 624,
+    HYPE: 110,
+    XRP: 14,
+    HAEDAL: 648,
+};
+var LAZER_PRICE_URL = "https://pyth.dourolabs.app/v1/fixed_rate@1000ms/price";
+function fetchLazerDisplayPrices(names, accessToken) {
     return __awaiter(this, void 0, void 0, function () {
-        var keys, apiUrlWithParams, response, map, data;
+        var entries, ids, timestamp, query, token, map, response, rows, priceById;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    keys = Object.keys(pythId)
-                        .map(function (key) { return "ids[]=".concat(key); })
-                        .join("&");
-                    apiUrlWithParams = "https://hermes.pyth.network/api/latest_price_feeds?".concat(keys);
-                    return [4 /*yield*/, fetch(apiUrlWithParams, {
+                    entries = names.map(function (name) { return [name, lazerDisplayIds[name]]; }).filter(function (_a) {
+                        var _b = __read(_a, 2), id = _b[1];
+                        return id != null;
+                    });
+                    ids = __spreadArray([], __read(new Set(entries.map(function (_a) {
+                        var _b = __read(_a, 2), id = _b[1];
+                        return id;
+                    }))), false);
+                    timestamp = Math.floor((Date.now() - 2000) / 1000) * 1000000;
+                    query = ids.map(function (id) { return "ids=".concat(id); }).join("&");
+                    token = accessToken !== null && accessToken !== void 0 ? accessToken : process.env.PYTH_LAZER_TOKEN;
+                    map = new Map();
+                    return [4 /*yield*/, fetch("".concat(LAZER_PRICE_URL, "?").concat(query, "&timestamp=").concat(timestamp), {
                             method: "GET",
-                            headers: { "Content-Type": "application/json" },
+                            headers: token ? { Authorization: "Bearer ".concat(token) } : {},
                         })];
                 case 1:
                     response = _a.sent();
-                    map = new Map();
-                    if (!response.ok) return [3 /*break*/, 3];
+                    if (!response.ok) {
+                        console.error("Failed to fetch Pyth prices: ".concat(response.status));
+                        return [2 /*return*/, map];
+                    }
                     return [4 /*yield*/, response.json()];
                 case 2:
-                    data = _a.sent();
-                    data.forEach(function (p) {
-                        var token = pythId[p.id];
-                        var price = p.price.price / Math.pow(10, -p.price.expo);
-                        map.set(token, price);
+                    rows = _a.sent();
+                    priceById = new Map(rows.map(function (r) { return [r.price_feed_id, r.price * Math.pow(10, r.exponent)]; }));
+                    entries.forEach(function (_a) {
+                        var _b = __read(_a, 2), name = _b[0], id = _b[1];
+                        var price = priceById.get(id);
+                        if (price != null) {
+                            map.set(name, price);
+                        }
                     });
                     return [2 /*return*/, map];
-                case 3: return [2 /*return*/];
             }
         });
     });
 }
+/**
+ * Fetch latest display prices for every mapped token.
+ * @param accessToken Optional Lazer JWT / API key; falls back to PYTH_LAZER_TOKEN env.
+ */
+function getPythLatestPrice(accessToken) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, fetchLazerDisplayPrices(Object.keys(lazerDisplayIds), accessToken)];
+        });
+    });
+}
 /**
  * Fetch latest Pyth prices for the specified symbols.
  * @param symbols Array of token symbols (e.g., ["BTC", "ETH"]) to fetch prices for.
+ * @param accessToken Optional Lazer JWT / API key; falls back to PYTH_LAZER_TOKEN env.
  * @returns Map where keys are token symbols and values are their latest prices.
  */
-function getPythLatestPriceBySymbols(symbols) {
+function getPythLatestPriceBySymbols(symbols, accessToken) {
     return __awaiter(this, void 0, void 0, function () {
-        var idsParam, apiUrlWithParams, response, map, data;
         return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    idsParam = Object.entries(pythId)
-                        .filter(function (_a) {
-                        var _b = __read(_a, 2), id = _b[0], token = _b[1];
-                        return symbols.includes(token);
-                    })
-                        .map(function (_a) {
-                        var _b = __read(_a, 1), id = _b[0];
-                        return "ids[]=".concat(id);
-                    })
-                        .join("&");
-                    apiUrlWithParams = "https://hermes.pyth.network/api/latest_price_feeds?".concat(idsParam);
-                    return [4 /*yield*/, fetch(apiUrlWithParams, {
-                            method: "GET",
-                            headers: { "Content-Type": "application/json" },
-                        })];
-                case 1:
-                    response = _a.sent();
-                    map = new Map();
-                    if (!response.ok) return [3 /*break*/, 3];
-                    return [4 /*yield*/, response.json()];
-                case 2:
-                    data = _a.sent();
-                    data.forEach(function (p) {
-                        var token = pythId[p.id];
-                        // Convert price using exponent provided
-                        var price = p.price.price / Math.pow(10, -p.price.expo);
-                        if (symbols.includes(token)) {
-                            map.set(token, price);
-                        }
-                    });
-                    return [3 /*break*/, 4];
-                case 3:
-                    console.error("Failed to fetch Pyth prices: ".concat(response.status));
-                    _a.label = 4;
-                case 4: return [2 /*return*/, map];
-            }
+            return [2 /*return*/, fetchLazerDisplayPrices(symbols, accessToken)];
         });
     });
 }

package/dist/src/utils/pyth/constant.d.ts

@@ -1,29 +1,8 @@
 import { TOKEN } from "../../../src/constants";
-export declare const priceIDs: {
-    MAINNET: {
-        [key in TOKEN]?: string;
-    };
-    TESTNET: {
-        [key in TOKEN]?: string;
-    };
+export declare const feedIds: {
+    [key in TOKEN]: number;
 };
-export declare const priceInfoObjectIds: {
-    MAINNET: {
-        [key in TOKEN]?: string;
-    };
-    TESTNET: {
-        [key in TOKEN]?: string;
-    };
-};
-export declare const wormholeStateId: {
-    MAINNET: string;
-    TESTNET: string;
-};
-export declare const pythStateId: {
-    MAINNET: string;
-    TESTNET: string;
-};
-export declare const endpoint: {
+export declare const lazerStateId: {
     MAINNET: string;
     TESTNET: string;
 };

package/dist/src/utils/pyth/constant.js

@@ -1,195 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.endpoint = exports.pythStateId = exports.wormholeStateId = exports.priceInfoObjectIds = exports.priceIDs = void 0;
-// You can find the IDs of prices at https://pyth.network/developers/price-feed-ids
-exports.priceIDs = {
-    MAINNET: {
-        // Pyth EVM Stable
-        SUI: "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
-        CETUS: "0xe5b274b2611143df055d6e7cd8d93fe1961716bcd4dca1cad87a83bc1e78c1ef",
-        USDC: "0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a",
-        WBTC: "0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43",
-        wETH: "0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace",
-        sbETH: "0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace",
-        wSOL: "0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d",
-        TURBOS: "0xf9c2e890443dd995d0baafc08eea3358be1ffb874f93f99c30b3816c460bbac3",
-        wAPT: "0x03ae4db29ed4ae33d323568895aa00337e658e348b37509f5372ae51f0af00d5",
-        wUSDT: "0x2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b",
-        DOGE: "0xdcef50dd0a4cd2dcc17e45df1676dcb336a11a61c69df7a0299b0150c672d25c",
-        INJ: "0x7a5bc1d2b56ad029048cd63964b3ad2776eadf812edc1a43a31406cb54bff592",
-        SEI: "0x53614f1cb0c031d4af66c04cb9c756234adad0e1cee85303795091499a4084eb",
-        JUP: "0x0a0408d619e9380abad35060f9192039ed5042fa6f82301d0e48bb52be830996",
-        SCA: "0x7e17f0ac105abe9214deb9944c30264f5986bf292869c6bd8e8da3ccd92d79bc",
-        AFSUI: "0x17cd845b16e874485b2684f8b8d1517d744105dbb904eec30222717f4bc9ee0d",
-        NAVX: "0x88250f854c019ef4f88a5c073d52a18bb1c6ac437033f5932cd017d24917ab46",
-        USDY: "0xe393449f6aff8a4b6d3e1165a7c9ebec103685f3b41e60db4277b5b6d10e7326",
-        BUCK: "0xfdf28a46570252b25fd31cb257973f865afc5ca2f320439e45d95e0394bc7382",
-        VSUI: "0x57ff7100a282e4af0c91154679c5dae2e5dcacb93fd467ea9cb7e58afdcfde27",
-        HASUI: "0x6120ffcf96395c70aa77e72dcb900bf9d40dccab228efca59a17b90ce423d5e8",
-        AUSD: "0xd9912df360b5b7f21a122f15bdd5e27f62ce5e72bd316c291f7c86620e07fb2a",
-        // These are not available on Pyth
-        // FUD: "0x6a4090703da959247727f2b490eb21aea95c8684ecfac675f432008830890c75",
-        DEEP: "0x29bdd5248234e33bd93d3b81100b5fa32eaa5997843847e2c2cb16d7c6d9f7ff",
-        BLUE: "0x04cfeb7b143eb9c48e9b074125c1a3447b85f59c31164dc20c1beaa6f21f2b6b",
-        // These are not available on Pyth
-        // BLUB: "0x5fc11ffe4975b624be495be038da30e30bee2004d8ae6282b5364577ef4ca92c",
-        HIPPO: "0xf2c5249856da2fbe0221e163b3fed678dd6f76515ab933292dfb4f15a1de8f8c",
-        STSUI: "0x0449948a9a210481464ea7030734fa79f59b751c2f411cfb1ba56b5f69e4a62a",
-        NS: "0xbb5ff26e47a3a6cc7ec2fce1db996c2a145300edc5acaabe43bf9ff7c5dd5d32",
-        WAL: "0xeba0732395fae9dec4bae12e52760b35fc1c5671e2da8b449c9af4efe5d54341",
-        LBTC: "0x8f257aab6e7698bb92b15511915e593d6f8eae914452f781874754b03d0c612b",
-        JPY: "0xef2c98c804ba503c6a707e38be4dfbb16683775f195b091252bf24693042fd52",
-        XAU: "0x765d2ba906dbc32ca17cc11f5310a89e9ee1f6420508c63861f2f8ba4ee34bb2",
-        XAG: "0xf2fb02c32b055c805e7238d628e5e9dadef274376114eb1f012337cabe93871e",
-        USOIL: "0x925ca92ff005ae943c158e3563f59698ce7e75c5a8c8dd43303a0a154887b3e6",
-        HAEDAL: "0xe67d98cc1fbd94f569d5ba6c3c3c759eb3ffc5d2b28e64538a53ae13efad8fd1",
-        HYPE: "0x4279e31cc369bbcc2faf022b382b080e32a8e689ff20fbc530d2a603eb6cd98b",
-        XRP: "0xec5d399846a9209f3fe5881d70aae9268c94339ff9817e8d18ff19fa05eea1c8",
-        xBTC: "0xae8f269ed9c4bed616c99a98cf6dfe562bd3202e7f91821a471ff854713851b4",
-        TBTC: "0x56a3121958b01f99fdc4e1fd01e81050602c7ace3a571918bb55c6a96657cca9",
-        BNB: "0x2f95862b045670cd22bee3114c39763a4a08beeb663b145d283c31d7d1101c4f",
-        QQQX: "0x178a6f73a5aede9d0d682e86b0047c9f333ed0efe5c6537ca937565219c4054d",
-        SPYX: "0x2817b78438c769357182c04346fddaad1178c82f4048828fe0997c3c64624e14",
-        NVDAX: "0x4244d07890e4610f46bbde67de8f43a4bf8b569eebe904f136b469f148503b7f",
-        TSLAX: "0x47a156470288850a440df3a6ce85a55917b813a19bb5b31128a33a986566a362",
-        AAPLX: "0x978e6cc68a119ce066aa830017318563a9ed04ec3a0a6439010fc11296a58675",
-        GOOGLX: "0xb911b0329028cd0283e4259c33809d62942bd2716a58084e5f31d64c00b5424e",
-        METAX: "0xbf3e5871be3f80ab7a4d1f1fd039145179fb58569e159aee1ccd472868ea5900",
-        COINX: "0x641435d5dffb5311140b480517c79986d8488d5cf08a11eec53b83ad02cab33f",
-        CRCLX: "0xc13184461c0c80d98ffcd89be627c2220b94a96c7c67f0c4b16bc12fd3b17758",
-        HOODX: "0xdd49a9ac6df5cbfa9d8fc6371f7ae927a74d5c6763c1c01b4220d70314c647f9",
-        MSTRX: "0x53f95ba4e23ed15ea56083e2ee9a5eec48055d6f59033d4bb95f1ca2a2349c28",
-    },
-    TESTNET: {
-        // Pyth EVM Beta
-        SUI: "0x50c67b3fd225db8912a424dd4baed60ffdde625ed2feaaf283724f9608fea266",
-        CETUS: "0xcb324dafd531712dd31c39969ae0246ee4c6ae167257bcf8ac27e28ca35e6a0c",
-        USDC: "0x41f3625971ca2ed2263e78573fe5ce23e13d2558ed3f2e47ab0f84fb9e7ae722",
-        wUSDC: "0x41f3625971ca2ed2263e78573fe5ce23e13d2558ed3f2e47ab0f84fb9e7ae722", // USDC/USD price ID
-        WBTC: "0xf9c0172ba10dfa4d19088d94f5bf61d3b54d5bd7483a322a982e1373ee8ea31b",
-        wETH: "0xca80ba6dc32e08d06f1aa886011eed1d77c77be9eb761cc10d72b7d0a2fd57a6",
-        sbETH: "0xca80ba6dc32e08d06f1aa886011eed1d77c77be9eb761cc10d72b7d0a2fd57a6",
-        wSOL: "0xfe650f0367d4a7ef9815a593ea15d36593f0643aaaf0149bb04be67ab851decd",
-        TURBOS: "0x3f545e3f4ec9fd8eb3b9d9d6071a1da361f6729fa1b93d1d1baca3379551d99e",
-        wAPT: "0x44a93dddd8effa54ea51076c4e851b6cbbfd938e82eb90197de38fe8876bb66e",
-        wUSDT: "0x1fc18861232290221461220bd4e2acd1dcdfbc89c84092c93c18bdc7756c1588",
-        // DOGE: "0x31775e1d6897129e8a84eeba975778fb50015b88039e9bc140bbd839694ac0ae",
-        INJ: "0x2d9315a88f3019f8efa88dfe9c0f0843712da0bac814461e27733f6b83eb51b3",
-        SEI: "0x95f1aef92c74670d40f1f37ee6fb158ffd6a0f8913b07b9e61087f9b7273b11c",
-        JUP: "0xe92860f24d56f9ba9894658202633062744556e98fb3e924b4a2694d82f05737",
-        SCA: "0xeacabc6304d11fc10a757f63286ef44415d8e91b7a1a525ae94a7ec9398b73f3",
-        AFSUI: "0xd213e2929116af56c3ce71a1acee874f1dd03f42567b552085fa9d8ce8ce7134",
-        NAVX: "0x946292ad3f481f36f5e558726cf4974e2a7a34598bf15d2abe3619e7b6a8db91",
-        USDY: "0xc222a1d2b89218c034b515e738b19ee268c105d8ede44d95b279f1c8bfbb68af",
-        BUCK: "0xed0899e3a021f1e59031ad365bb3014d78f9ba5556e263692d3508b9272daabf",
-        VSUI: "0xabb2661c87ecac9f93eade3dd089dbb6e9eb4083eba3b35371ee6f8fa1133752",
-        HASUI: "0xb675212df51f05b159e31e3047895778df9df1c870587102a06fc96100853361",
-        AUSD: "0xf1882d28af56a63960f0c313e6c76eab8f802f15e801ebfca223412b55375fe3",
-        FUD: "0x15f63843dcccf30510f48ff6e363f9ead3b0b05d7f7dde6e3890a7e9e4d83e4a",
-        DEEP: "0xe18bf5fa857d5ca8af1f6a458b26e853ecdc78fc2f3dc17f4821374ad94d8327",
-        BLUE: "0x64559fcff99ed360543d7f4778f4712d2dc5c303ec1ac98f084c88c647ff7689",
-        BLUB: "0xc171055a63e9b4c09e29cc018129379e0a8581512f6726f5bfe5429985773312",
-        HIPPO: "0x082736b80698caf1379f0ad10a637668ccd531a96133d1f5053df97bffd2933b",
-        STSUI: "0xda703fbee4d7ee09aba630ef809efd79d162202bdf976ae8258875207ebd5557",
-        NS: "0x65aca56071505735c09091deb8733fdeba265bd9723dd4fb326b5ffd6843b3a3",
-        WAL: "0xa6ba0195b5364be116059e401fb71484ed3400d4d9bfbdf46bd11eab4f9b7cea",
-        LBTC: "0x29448db25efe8c72afe3a3c0c0631337408bd3cbc5f09d3dab0754460a965dae",
-        JPY: "0x20a938f54b68f1f2ef18ea0328f6dd0747f8ea11486d22b021e83a900be89776",
-        XAU: "0x30a19158f5a54c0adf8fb7560627343f22a1bc852b89d56be1accdc5dbf96d0e",
-        XAG: "0x321ba4d608fa75ba76d6d73daa715abcbdeb9dba02257f05a1b59178b49f599b",
-        USOIL: "0x24d84a7ab973231e4394015ece17a2155174123be2f8e38c751e17fbd2fcedad",
-        TBTC: "0xed1b51d4fb17e8c8b54a0c5bdbd59b38a0304d032287eb38d907374f16b5f535",
-        BNB: "0xecf553770d9b10965f8fb64771e93f5690a182edc32be4a3236e0caaa6e0581a",
-        xBTC: "0xfd5464ac394d347958864c8a93dc71f2be56a5943fefc459a0074dc314b415d8",
-    },
+exports.lazerStateId = exports.feedIds = void 0;
+// Pyth Lazer numeric feed IDs (u32). Source: https://docs.pyth.network/lazer/price-feed-ids
+// Same-asset wrappers (wETH, sbETH, wSOL, wAPT, wUSDT, wUSDC, sbBTC) map to their
+// underlying base/USD feed; LSTs and BTC derivatives (AFSUI, VSUI, HASUI, STSUI,
+// LBTC, xBTC, TBTC, WBTC) use their own dedicated feeds, matching typus-rust.
+// XAU is priced off Crypto.XAUT/USD 172 (24/7; spot 346 is market-hours gated).
+exports.feedIds = {
+    // placeholder feed ID for Typus Index; not live on Pyth Lazer
+    TYPUS: 0,
+    FUD: 0,
+    BLUB: 0,
+    LIQ: 0,
+    MFUD: 0,
+    MBLUB: 0,
+    MLIQ: 0,
+    SPSUI: 0,
+    sSCA: 0,
+    TEXP: 0,
+    USD: 0,
+    sbBTC: 1,
+    WBTC: 103,
+    xBTC: 1598,
+    TBTC: 588,
+    LBTC: 468,
+    wETH: 2,
+    sbETH: 2,
+    wSOL: 6,
+    USDC: 7,
+    wUSDC: 7,
+    sbUSDT: 8,
+    wUSDT: 8,
+    SUI: 11,
+    AFSUI: 353,
+    VSUI: 622,
+    HASUI: 443,
+    STSUI: 736,
+    DOGE: 13,
+    XRP: 14,
+    BNB: 15,
+    wAPT: 28,
+    INJ: 46,
+    SEI: 51,
+    JUP: 92,
+    HYPE: 110,
+    DEEP: 173,
+    USDY: 276,
+    JPY: 340,
+    USOIL: 657,
+    XAG: 345,
+    XAU: 172,
+    AUSD: 367,
+    BLUE: 381,
+    BUCK: 390,
+    CETUS: 401,
+    HIPPO: 448,
+    NAVX: 509,
+    NS: 514,
+    SCA: 545,
+    TURBOS: 599,
+    WAL: 624,
+    HAEDAL: 648,
+    AAPLX: 1792,
+    COINX: 1796,
+    CRCLX: 1798,
+    GOOGLX: 1808,
+    HOODX: 1815,
+    METAX: 1824,
+    MSTRX: 1827,
+    NVDAX: 1833,
+    QQQX: 1837,
+    SPYX: 1843,
+    TSLAX: 1847,
 };
-exports.priceInfoObjectIds = {
-    MAINNET: {
-        SUI: "0x801dbc2f0053d34734814b2d6df491ce7807a725fe9a01ad74a07e9c51396c37",
-        USDC: "0x5dec622733a204ca27f5a90d8c2fad453cc6665186fd5dff13a83d0b6c9027ab",
-        wUSDT: "0x985e3db9f93f76ee8bace7c3dd5cc676a096accd5d9e09e9ae0fb6e492b14572",
-        WBTC: "0x9a62b4863bdeaabdc9500fce769cf7e72d5585eeb28a6d26e4cafadc13f76ab2",
-        wETH: "0x9193fd47f9a0ab99b6e365a464c8a9ae30e6150fc37ed2a89c1586631f6fc4ab",
-        sbETH: "0x9193fd47f9a0ab99b6e365a464c8a9ae30e6150fc37ed2a89c1586631f6fc4ab",
-        wSOL: "0x9d0d275efbd37d8a8855f6f2c761fa5983293dd8ce202ee5196626de8fcd4469",
-        wAPT: "0x7c5b7837c44a69b469325463ac0673ac1aa8435ff44ddb4191c9ae380463647f",
-        CETUS: "0x24c0247fb22457a719efac7f670cdc79be321b521460bd6bd2ccfa9f80713b14",
-        TURBOS: "0x442e52f04392b0dcb48c6aaf7940568acd510281021be9f9b3a449c559c79613",
-        SCA: "0xf6de1d3279a269a597d813cbaca59aa906543ab9a8c64e84a4722f1a20863985",
-        SEI: "0xde2dd2684b3ff808cebdfb23afbf8b6ac3822832029dae744f81d9eb44b5c9b8",
-        INJ: "0x353a36a5b3d6809b4cc349dca627e2775e1d19b6b9c86f0eabe138fd3d772023",
-        AFSUI: "0xd779885c5246357e24cbde7348f2d81f756d9650975c02d81346b15d8b557ebf",
-        NAVX: "0x5b117a6a2de70796bffe36495bad576b788a34c33ca0648bd57852ead3f41e32",
-        HASUI: "0x4c1d831576b60fec657e0c310943eff8c1f28197c552e57d1fefdc55edddb263",
-        VSUI: "0xf3bc79117acc3636d57778d9d0f83a871df1b7a53eb61fe893ff108d9664ec8b",
-        DEEP: "0x8c7f3a322b94cc69db2a2ac575cbd94bf5766113324c3a3eceac91e3e88a51ed",
-        BLUE: "0x5515a34fc610bba6b601575ed1d2535b2f9df1f339fd0d435fef487c1ee3df9c",
-        NS: "0xc6352e1ea55d7b5acc3ed690cc3cdf8007978071d7bfd6a189445018cfb366e0",
-        JUP: "0xb804ada6f77feb30a73fbed7fc53dc66ff25133dee0815109d4267e43b2e6bdd",
-        WAL: "0xeb7e669f74d976c0b99b6ef9801e3a77716a95f1a15754e0f1399ce3fb60973d",
-        LBTC: "0xeba15840ddf425dacb5ff0990334fc03d034487f4ad416280859b96bf2af89f8",
-        XAU: "0x5b36eb3c0935908082926c0c767a55b87a2a4eb3a45908785b41f9d5a11e4f7b",
-        XAG: "0xd5c5afce92e988bf0a0940d618443c36c31dd7f239a545982db3166e963c9aa4",
-        USOIL: "0x71e40a6e2af5a194e149a761ae11d43e987b9ecbee1834d65d61103721c72e02",
-        DOGE: "0xd59a5f5173424ba725a7d033d86f2eadf2745f87a908bd27e1d27339eff598ce",
-        HYPE: "0x1c047be615eaa5a87afa0e111b20a512dd6c0f4a1f0f691693cf852c1768f35d",
-        XRP: "0x93bfda25cb6b1653a9c769e8216014bd2c06997f3edb479566761fbf2abf6ac2",
-        xBTC: "0xa4b9db1866ee6e2a156e8c36fc66be0f68f232388ebb578c949c2c6beb50128b",
-        JPY: "0xde0e6088e7292f50738ecbdebd4502415d4f8de4cfe001918e29b3f4faf15baa",
-        BNB: "0x9c6e77f0ecfc46aac395e21c52ccb96518f85acacae743c5b47f4ca5e29826c3",
-        SPYX: "0x6a2d53a802faee96b26f5fa86d9ccf05d58008e4f32c95985d12edb60f5e23ea",
-        QQQX: "0xcce836357b028bd85e866320f194980125b58e6117a2e86a24ed5c154df1e799",
-        NVDAX: "0x1ccc57727035cc40a122cecd95f15240de4fb3f2acd5542c8f2109ebc47871a1",
-        TSLAX: "0x678fee0f8d449160f7df3a14db41d7318e917c3afae98eed434a87073cb80c6b",
-        AAPLX: "0x80c9fa9060e2682528a9b02e0facfd6c4816e1bb363bdc3c9a6e94224618e03d",
-        GOOGLX: "0xff0bda4e0c212f409b89c6c5714c1957f6a867eced1bcfde863bd074d2a0d54c",
-        METAX: "0x0cd398ea0262b504a946b3d4acde457a21bee9d41a27083ebf6ec19f99272155",
-        COINX: "0xf19da6da74181c159f3619cc50fdd4dcc62d15538c707175464968a14cbb0464",
-        CRCLX: "0x299b647faef2456b93155b5609ac5edc9ba18bb4f5f6a27383920a528b2ff052",
-        HOODX: "0x1f0a01610d47dfe0506bb4cfd903335bf2d148adc86459c06385b97309e51d2a",
-        MSTRX: "0xab35f27f1118959cbf82e5ab907808df40b25c16c5745c21a1af721a2e0a926e",
-    },
-    TESTNET: {
-        SUI: "0x1ebb295c789cc42b3b2a1606482cd1c7124076a0f5676718501fda8c7fd075a0",
-        CETUS: "0xb0ba78106259b7ceefd288edc5f65b65f8b7bca0816e61dae5136616aac7d3da",
-        USDC: "0x9c4dd4008297ffa5e480684b8100ec21cc934405ed9a25d4e4d7b6259aad9c81",
-        wUSDC: "0x9c4dd4008297ffa5e480684b8100ec21cc934405ed9a25d4e4d7b6259aad9c81",
-        WBTC: "0x72431a238277695d3f31e4425225a4462674ee6cceeea9d66447b210755fffba",
-        wETH: "0x4fde30cb8a5dc3cfee1c1c358fc66dc308408827efb217247c7ba54d76ccbee9",
-        sbETH: "0x4fde30cb8a5dc3cfee1c1c358fc66dc308408827efb217247c7ba54d76ccbee9",
-        wSOL: "0x33fbce1cad5ca155f2f5051430b23a694bc6e5de6df43e0f8aefe29f4a84336d",
-        TURBOS: "0xfe38289883c3afed692e5856f4896b3e094d4793e2ccf0a2715b890a718fa5c0",
-        wAPT: "0x9eeb8cb349d8e89fa9e6c94a97d6d30096f5b3c16bd50d9de96608f67a278c18",
-        wUSDT: "0x956fdcbf83a26c962319f7742f5728a0a7ce59c7f0cbe13c112b259e7ee953cd",
-        // DOGE: "0x17b358d730663caa888c8b621b9994a60af422cd83f32237c6b2a8b3230d71b9",
-        INJ: "0x459e2e0dd757715449fc1d36925f384446bf192c9f86a4ca02d587c82de51802",
-        SEI: "0xb3e7f40e8268fb2539a03b29c1b38366e061c3c8222f7ad4c8db998eb0a02f8d",
-        JUP: "0x23817c9edbbfbdef6add3800cd52751eff5bb0f7abd32e54a8f2225d6a6523d3",
-        SCA: "0xf96e3c4b7d74efbde9df5b669188421196e6164adf6fbaaa92903c42569807c8",
-        AFSUI: "0x6785a8c69da40c9435d41a2585cf92643d2ed2c5cd12938ecff28eaf54efadcd",
-        NAVX: "0x94905bdcaa656b0908aa8a3a42cf72b0e8e2e849f7d0a7e0e39bb9e1dc3c9cf6",
-        USDY: "0x1fec4ed70f870911948d93eb2abe6fa4a3a4b1e4633cf36c7e91adfb4af1733f",
-        BLUE: "0xcc9016bcfaf1839f1dd63b0929a0d62dfb93e84442fd5b4598552605e365b3ec",
-        BLUB: "0xdcd4cc5f06fac1ca72e8551ab1a2e847298afa6f19e370ad9891199a59d2c22e",
-        JPY: "0xd14cadaf54a926f701db021eceaa89b3d09363e1bce51bfcb2291a32a693f928",
-        XAU: "0x742d48ff1d7a45c91aee4ad4f0059396c28988f99074d4a191951ac086b90a5a",
-        XAG: "",
-        USOIL: "",
-        xBTC: "0xb6c3b17fdda1eaa847e62c8d36a8dada35b010bb340fdb5a16d556f0fa37e59b",
-    },
-};
-// Get the state IDs of the Pyth and Wormhole contracts from
-// https://docs.pyth.network/price-feeds/contract-addresses/sui
-exports.wormholeStateId = {
-    MAINNET: "0xaeab97f96cf9877fee2883315d459552b2b921edc16d7ceac6eab944dd88919c",
-    TESTNET: "0x31358d198147da50db32eda2562951d53973a0c0ad5ed738e9b17d88b213d790",
-};
-exports.pythStateId = {
-    MAINNET: "0x1f9310238ee9298fb703c3419030b35b22bb1cc37113e3bb5007c99aec79e5b8",
-    TESTNET: "0x243759059f4c3111179da5878c12f68d612c21a8d54d85edc86164bb18be1c7c",
-};
-// Get the Stable Hermes service URL from https://docs.pyth.network/price-feeds/api-instances-and-providers/hermes
-exports.endpoint = {
-    MAINNET: "https://hermes.pyth.network",
-    TESTNET: "https://hermes-beta.pyth.network",
+// Pyth Lazer State object IDs on Sui.
+// Source: https://docs.pyth.network/price-feeds/pro/contract-addresses
+exports.lazerStateId = {
+    MAINNET: "0xd0db9c1e9212a98120384bf78d8b8c985d87b9ee6921dffcf9d1394062911573",
+    TESTNET: "0x7b570126bfdcc7f7b2b4028445d4ac1d35c41da498606a2b097c3973425698d3",
 };

package/dist/src/utils/pyth/pythClient.d.ts

@@ -1,22 +1,80 @@
-import { HexString, SuiPriceServiceConnection, SuiPythClient } from "@pythnetwork/pyth-sui-js";
-import { Argument, Transaction } from "@mysten/sui/transactions";
+import type { PythLazerClient, Channel } from "@pythnetwork/pyth-lazer-sdk";
+import { SuiJsonRpcClient } from "@mysten/sui/jsonRpc";
+import { Transaction, type TransactionResult } from "@mysten/sui/transactions";
 import { TOKEN } from "../../../src/constants";
-import { ObjectId } from "@pythnetwork/pyth-sui-js/lib/client";
-export declare class PythClient {
+export type MoveApiVersion = "v1" | "v2";
+export interface PythLazerSuiClientOpts {
+    /**
+     * Long-lived-key source (WebSocket). Node-side crankers and scripts pass
+     * this. Do NOT use it in a browser — the key would ship in the bundle.
+     */
+    lazer?: PythLazerClient;
+    /**
+     * Client-safe alternative: returns a short-lived Pyth JWT per call, and
+     * price fetches go over REST instead of the WS. The JWT is accepted on
+     * `POST /v1/latest_price` and `/v1/price` (verified against mainnet), and
+     * that host sends `access-control-allow-origin: *`, so the browser can call
+     * it directly. Takes precedence over `lazer` when both are supplied.
+     */
+    getAccessToken?: () => string | Promise<string>;
+    restEndpoint?: string;
+    channel?: Channel;
+    /** Which Lazer Move API to call. See DEFAULT_MOVE_API. */
+    moveApiVersion?: MoveApiVersion;
+    sui: SuiJsonRpcClient;
     network: "MAINNET" | "TESTNET";
-    client: SuiPythClient;
-    connection: SuiPriceServiceConnection;
+    lazerPackage: string;
+    oraclePackage: string;
+    oracleV2Id: string;
+    stateObjectId?: string;
+}
+export declare class PythLazerSuiClient {
+    readonly lazer?: PythLazerClient;
+    readonly getAccessToken?: () => string | Promise<string>;
+    readonly restEndpoint: string;
+    readonly channel: Channel;
+    readonly moveApiVersion: MoveApiVersion;
+    readonly sui: SuiJsonRpcClient;
+    readonly network: "MAINNET" | "TESTNET";
+    readonly stateObjectId: string;
+    readonly lazerPackage: string;
+    readonly oraclePackage: string;
+    readonly oracleV2Id: string;
+    constructor(opts: PythLazerSuiClientOpts);
+    /** `_v2` suffix on the Lazer/oracle entries when on the v2 Move API. */
+    private get v();
+    /**
+     * Fetches a signed `leEcdsa` update over REST using a short-lived token.
+     * Mirrors typus-rust `lazer_ingestion::rest_client`.
+     */
+    private fetchUpdateOverRest;
+    private resolveFeedIds;
+    private resolveTypeArgument;
+    /**
+     * Fetches a Pyth Lazer `leEcdsa` update covering every requested token, adds
+     * `pyth_lazer::parse_and_verify_le_ecdsa_update` to the PTB, and returns the
+     * verified `Update` argument for use in subsequent move calls.
+     */
+    updatePythLazer(tx: Transaction, tokens: TOKEN[], timestamp?: number): Promise<TransactionResult>;
+    /**
+     * Calls `oracle_v2::update_latest_price(oracle_v2, update, clock)`. A single
+     * call updates every feed in the verified update.
+     */
+    updateOracleV2WithPythLazer(tx: Transaction, tokens: TOKEN[]): Promise<void>;
+    /**
+     * Calls `oracle_v2::update_settle_price(oracle_v2, update, timestamp, clock)`.
+     * Authority-gated on-chain. `timestamp` is in seconds.
+     */
+    updateOracleV2SettlePriceWithPythLazer(tx: Transaction, tokens: TOKEN[], timestamp: number): Promise<void>;
+    /**
+     * Calls `oracle_v2::add_latest_price_new_token<TOKEN>(oracle_v2, feed_id, update, clock)`.
+     * One-shot initializer for a brand-new token in the oracle's `feed_id_map`.
+     */
+    addLatestPriceNewToken(tx: Transaction, token: TOKEN, tokenTypeArgument?: string): Promise<void>;
+    /**
+     * Calls `oracle_v2::add_settle_price_new_token<TOKEN>(oracle_v2, feed_id, update, timestamp, clock)`.
+     * `timestamp` (seconds) is forwarded to the Lazer fetch when supplied and
+     * passed on-chain; defaults to now, matching the freshness window.
+     */
+    addSettlePriceNewToken(tx: Transaction, token: TOKEN, timestamp?: number, tokenTypeArgument?: string): Promise<void>;
 }
-export declare function createPythClient(provider: any, network: "MAINNET" | "TESTNET"): PythClient;
-/**
- * @returns priceInfoObjectIds
- */
-export declare function updatePyth(pythClient: PythClient, tx: Transaction, tokens: TOKEN[], suiCoin?: Argument): Promise<ObjectId[]>;
-export declare function updateOracleWithPythUsd(pythClient: PythClient, tx: Transaction, oraclePackage: string, baseToken: TOKEN): void;
-/**
- * Adds the necessary commands for updating the pyth price feeds to the transaction block.
- * @param tx transaction block to add commands to
- * @param updates array of price feed updates received from the price service
- * @param feedIds array of feed ids to update (in hex format)
- */
-export declare function updatePriceFeeds(pythClient: PythClient, tx: Transaction, updates: Buffer[], feedIds: HexString[], suiCoin?: Argument): Promise<ObjectId[]>;

package/dist/src/utils/pyth/pythClient.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -36,81 +47,259 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPythClient = createPythClient;
-exports.updatePyth = updatePyth;
-exports.updateOracleWithPythUsd = updateOracleWithPythUsd;
-exports.updatePriceFeeds = updatePriceFeeds;
-var pyth_sui_js_1 = require("@pythnetwork/pyth-sui-js");
-var constant_1 = require("./constant");
+exports.PythLazerSuiClient = void 0;
 var constants_1 = require("../../../src/constants");
-function createPythClient(provider, network) {
-    var client = new pyth_sui_js_1.SuiPythClient(provider, constant_1.pythStateId[network], constant_1.wormholeStateId[network]);
-    var connection = network == "MAINNET"
-        ? new pyth_sui_js_1.SuiPriceServiceConnection("https://hermes.pyth.network")
-        : new pyth_sui_js_1.SuiPriceServiceConnection("https://hermes-beta.pyth.network");
-    var pythClient = { network: network, client: client, connection: connection };
-    return pythClient;
-}
-/**
- * @returns priceInfoObjectIds
- */
-function updatePyth(pythClient, tx, tokens, suiCoin) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _priceIDs, priceFeedUpdateData, priceInfoObjectIds;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _priceIDs = tokens.map(function (token) { return constant_1.priceIDs[pythClient.network][token]; });
-                    return [4 /*yield*/, pythClient.connection.getPriceFeedsUpdateData(_priceIDs)];
-                case 1:
-                    priceFeedUpdateData = _a.sent();
-                    return [4 /*yield*/, updatePriceFeeds(pythClient, tx, priceFeedUpdateData, _priceIDs, suiCoin)];
-                case 2:
-                    priceInfoObjectIds = _a.sent();
-                    return [2 /*return*/, priceInfoObjectIds];
-            }
-        });
-    });
-}
-function updateOracleWithPythUsd(pythClient, tx, oraclePackage, baseToken) {
-    tx.moveCall({
-        target: "".concat(oraclePackage, "::oracle::update_with_pyth_usd"),
-        typeArguments: [],
-        arguments: [
-            tx.object(constants_1.oracle[pythClient.network][baseToken]),
-            tx.object(constant_1.pythStateId[pythClient.network]),
-            tx.object(constant_1.priceInfoObjectIds[pythClient.network][baseToken]),
-            tx.object("0x6"),
-        ],
+var constant_1 = require("./constant");
+var DEFAULT_PROPERTIES = ["price", "emaPrice", "exponent", "feedUpdateTimestamp"];
+// The mainnet oracle reads `fixed_rate@1000ms`, and that channel is only served
+// by the Lazer *v2* Move API (`..._v2` entries) — the v1 entries are pinned to
+// the 200ms channel. Changing one without the other aborts on-chain.
+var DEFAULT_CHANNEL = "fixed_rate@1000ms";
+var DEFAULT_MOVE_API = "v2";
+// Signed (`leEcdsa`) payloads come from the legacy Lazer host, not the Pro `/v1`
+// API — the Pro OpenAPI exposes no signed-payload route at all.
+var DEFAULT_REST_ENDPOINT = "https://pyth-lazer-0.dourolabs.app";
+/** Browser-safe: hex -> bytes without Node's Buffer. */
+var hexToBytes = function (hex) {
+    var clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (clean.length % 2 !== 0) {
+        throw new Error("Pyth Lazer leEcdsa payload is not valid hex (odd length)");
+    }
+    var out = new Uint8Array(clean.length / 2);
+    for (var i = 0; i < out.length; i++) {
+        out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+};
+var PythLazerSuiClient = /** @class */ (function () {
+    function PythLazerSuiClient(opts) {
+        var _a, _b, _c, _d;
+        this.lazer = opts.lazer;
+        this.getAccessToken = opts.getAccessToken;
+        // A missing price source is only fatal when a price is actually fetched
+        // — plenty of callers construct a client purely for read-only views.
+        this.restEndpoint = ((_a = opts.restEndpoint) !== null && _a !== void 0 ? _a : DEFAULT_REST_ENDPOINT).replace(/\/+$/, "");
+        this.channel = (_b = opts.channel) !== null && _b !== void 0 ? _b : DEFAULT_CHANNEL;
+        this.moveApiVersion = (_c = opts.moveApiVersion) !== null && _c !== void 0 ? _c : DEFAULT_MOVE_API;
+        this.sui = opts.sui;
+        this.network = opts.network;
+        this.lazerPackage = opts.lazerPackage;
+        this.oraclePackage = opts.oraclePackage;
+        this.oracleV2Id = opts.oracleV2Id;
+        this.stateObjectId = (_d = opts.stateObjectId) !== null && _d !== void 0 ? _d : constant_1.lazerStateId[opts.network];
+        if (!this.stateObjectId) {
+            throw new Error("No Pyth Lazer state object id mapped for ".concat(opts.network));
+        }
+    }
+    Object.defineProperty(PythLazerSuiClient.prototype, "v", {
+        /** `_v2` suffix on the Lazer/oracle entries when on the v2 Move API. */
+        get: function () {
+            return this.moveApiVersion === "v2" ? "_v2" : "";
+        },
+        enumerable: false,
+        configurable: true
     });
-}
-/**
- * Adds the necessary commands for updating the pyth price feeds to the transaction block.
- * @param tx transaction block to add commands to
- * @param updates array of price feed updates received from the price service
- * @param feedIds array of feed ids to update (in hex format)
- */
-function updatePriceFeeds(pythClient, tx, updates, feedIds, suiCoin) {
-    return __awaiter(this, void 0, void 0, function () {
-        var packageId, priceUpdatesHotPotato, baseUpdateFee, coins;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, pythClient.client.getPythPackageId()];
-                case 1:
-                    packageId = _a.sent();
-                    return [4 /*yield*/, pythClient.client.verifyVaasAndGetHotPotato(tx, updates, packageId)];
-                case 2:
-                    priceUpdatesHotPotato = _a.sent();
-                    return [4 /*yield*/, pythClient.client.getBaseUpdateFee()];
-                case 3:
-                    baseUpdateFee = _a.sent();
-                    coins = tx.splitCoins(suiCoin !== null && suiCoin !== void 0 ? suiCoin : tx.gas, feedIds.map(function () { return tx.pure.u64(baseUpdateFee); }));
-                    if (suiCoin) {
-                        tx.moveCall({ target: "0x2::coin::destroy_zero", arguments: [suiCoin], typeArguments: [constants_1.tokenType.MAINNET.SUI] });
-                    }
-                    return [4 /*yield*/, pythClient.client.executePriceFeedUpdates(tx, packageId, feedIds, priceUpdatesHotPotato, coins)];
-                case 4: return [2 /*return*/, _a.sent()];
+    /**
+     * Fetches a signed `leEcdsa` update over REST using a short-lived token.
+     * Mirrors typus-rust `lazer_ingestion::rest_client`.
+     */
+    PythLazerSuiClient.prototype.fetchUpdateOverRest = function (priceFeedIds, timestamp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var token, path, res, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.getAccessToken()];
+                    case 1:
+                        token = _d.sent();
+                        path = timestamp ? "v1/price" : "v1/latest_price";
+                        return [4 /*yield*/, fetch("".concat(this.restEndpoint, "/").concat(path), {
+                                method: "POST",
+                                headers: { Authorization: "Bearer ".concat(token), "Content-Type": "application/json" },
+                                body: JSON.stringify(__assign({ priceFeedIds: priceFeedIds, properties: DEFAULT_PROPERTIES, formats: ["leEcdsa"], jsonBinaryEncoding: "hex", channel: this.channel }, (timestamp ? { timestamp: timestamp * 1000000 } : {}))),
+                            })];
+                    case 2:
+                        res = _d.sent();
+                        if (!!res.ok) return [3 /*break*/, 4];
+                        _a = Error.bind;
+                        _c = (_b = "Pyth Lazer ".concat(path, " ").concat(res.status, ": ")).concat;
+                        return [4 /*yield*/, res.text()];
+                    case 3: throw new (_a.apply(Error, [void 0, _c.apply(_b, [_d.sent()])]))();
+                    case 4: return [4 /*yield*/, res.json()];
+                    case 5: return [2 /*return*/, (_d.sent())];
+                }
+            });
+        });
+    };
+    PythLazerSuiClient.prototype.resolveFeedIds = function (tokens) {
+        return tokens.map(function (token) {
+            var id = constant_1.feedIds[token];
+            if (id == null) {
+                throw new Error("No Pyth Lazer feed id mapped for token ".concat(token));
             }
+            return id;
         });
-    });
-}
+    };
+    PythLazerSuiClient.prototype.resolveTypeArgument = function (token, override) {
+        var typeArg = override !== null && override !== void 0 ? override : constants_1.tokenType[this.network][token];
+        if (!typeArg) {
+            throw new Error("No coin type mapped for ".concat(token, " on ").concat(this.network));
+        }
+        return typeArg;
+    };
+    /**
+     * Fetches a Pyth Lazer `leEcdsa` update covering every requested token, adds
+     * `pyth_lazer::parse_and_verify_le_ecdsa_update` to the PTB, and returns the
+     * verified `Update` argument for use in subsequent move calls.
+     */
+    PythLazerSuiClient.prototype.updatePythLazer = function (tx, tokens, timestamp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var priceFeedIds, update, hex, u8array;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        priceFeedIds = this.resolveFeedIds(tokens);
+                        if (!this.lazer && !this.getAccessToken) {
+                            throw new Error("PythLazerSuiClient needs either `lazer` (WS) or `getAccessToken` (REST) to fetch prices");
+                        }
+                        if (!this.getAccessToken) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.fetchUpdateOverRest(priceFeedIds, timestamp)];
+                    case 1:
+                        update = _b.sent();
+                        return [3 /*break*/, 6];
+                    case 2:
+                        if (!timestamp) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.lazer.getPrice({
+                                priceFeedIds: priceFeedIds,
+                                properties: DEFAULT_PROPERTIES,
+                                formats: ["leEcdsa"],
+                                jsonBinaryEncoding: "hex",
+                                channel: this.channel,
+                                timestamp: timestamp * 1000000, // seconds -> nanoseconds
+                            })];
+                    case 3:
+                        update = _b.sent();
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, this.lazer.getLatestPrice({
+                            priceFeedIds: priceFeedIds,
+                            properties: DEFAULT_PROPERTIES,
+                            formats: ["leEcdsa"],
+                            jsonBinaryEncoding: "hex",
+                            channel: this.channel,
+                        })];
+                    case 5:
+                        update = _b.sent();
+                        _b.label = 6;
+                    case 6:
+                        hex = (_a = update.leEcdsa) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!hex) {
+                            throw new Error("Pyth Lazer getLatestPrice returned no leEcdsa payload");
+                        }
+                        u8array = hexToBytes(hex);
+                        return [2 /*return*/, tx.moveCall({
+                                target: "".concat(this.lazerPackage, "::pyth_lazer::parse_and_verify_le_ecdsa_update").concat(this.v),
+                                arguments: [tx.object(this.stateObjectId), tx.object.clock(), tx.pure.vector("u8", u8array)],
+                            })];
+                }
+            });
+        });
+    };
+    /**
+     * Calls `oracle_v2::update_latest_price(oracle_v2, update, clock)`. A single
+     * call updates every feed in the verified update.
+     */
+    PythLazerSuiClient.prototype.updateOracleV2WithPythLazer = function (tx, tokens) {
+        return __awaiter(this, void 0, void 0, function () {
+            var verifiedUpdate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.updatePythLazer(tx, tokens)];
+                    case 1:
+                        verifiedUpdate = _a.sent();
+                        tx.moveCall({
+                            target: "".concat(this.oraclePackage, "::oracle_v2::update_latest_price").concat(this.v),
+                            typeArguments: [],
+                            arguments: [tx.object(this.oracleV2Id), verifiedUpdate, tx.object("0x6")],
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Calls `oracle_v2::update_settle_price(oracle_v2, update, timestamp, clock)`.
+     * Authority-gated on-chain. `timestamp` is in seconds.
+     */
+    PythLazerSuiClient.prototype.updateOracleV2SettlePriceWithPythLazer = function (tx, tokens, timestamp) {
+        return __awaiter(this, void 0, void 0, function () {
+            var verifiedUpdate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.updatePythLazer(tx, tokens, timestamp)];
+                    case 1:
+                        verifiedUpdate = _a.sent();
+                        tx.moveCall({
+                            target: "".concat(this.oraclePackage, "::oracle_v2::update_settle_price").concat(this.v),
+                            typeArguments: [],
+                            arguments: [tx.object(this.oracleV2Id), verifiedUpdate, tx.pure.u64(timestamp), tx.object("0x6")],
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Calls `oracle_v2::add_latest_price_new_token<TOKEN>(oracle_v2, feed_id, update, clock)`.
+     * One-shot initializer for a brand-new token in the oracle's `feed_id_map`.
+     */
+    PythLazerSuiClient.prototype.addLatestPriceNewToken = function (tx, token, tokenTypeArgument) {
+        return __awaiter(this, void 0, void 0, function () {
+            var feedId, typeArg, verifiedUpdate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        feedId = this.resolveFeedIds([token])[0];
+                        typeArg = this.resolveTypeArgument(token, tokenTypeArgument);
+                        return [4 /*yield*/, this.updatePythLazer(tx, [token])];
+                    case 1:
+                        verifiedUpdate = _a.sent();
+                        tx.moveCall({
+                            target: "".concat(this.oraclePackage, "::oracle_v2::add_latest_price_new_token").concat(this.v),
+                            typeArguments: [typeArg],
+                            arguments: [tx.object(this.oracleV2Id), tx.pure.u32(feedId), verifiedUpdate, tx.object("0x6")],
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Calls `oracle_v2::add_settle_price_new_token<TOKEN>(oracle_v2, feed_id, update, timestamp, clock)`.
+     * `timestamp` (seconds) is forwarded to the Lazer fetch when supplied and
+     * passed on-chain; defaults to now, matching the freshness window.
+     */
+    PythLazerSuiClient.prototype.addSettlePriceNewToken = function (tx, token, timestamp, tokenTypeArgument) {
+        return __awaiter(this, void 0, void 0, function () {
+            var feedId, typeArg, ts, verifiedUpdate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        feedId = this.resolveFeedIds([token])[0];
+                        typeArg = this.resolveTypeArgument(token, tokenTypeArgument);
+                        ts = timestamp !== null && timestamp !== void 0 ? timestamp : Math.floor(Date.now() / 1000);
+                        return [4 /*yield*/, this.updatePythLazer(tx, [token], timestamp)];
+                    case 1:
+                        verifiedUpdate = _a.sent();
+                        tx.moveCall({
+                            target: "".concat(this.oraclePackage, "::oracle_v2::add_settle_price_new_token").concat(this.v),
+                            typeArguments: [typeArg],
+                            arguments: [tx.object(this.oracleV2Id), tx.pure.u32(feedId), verifiedUpdate, tx.pure.u64(ts), tx.object("0x6")],
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return PythLazerSuiClient;
+}());
+exports.PythLazerSuiClient = PythLazerSuiClient;

package/package.json

@@ -2,12 +2,13 @@
     "name": "@typus/typus-sdk",
     "author": "Typus",
     "description": "typus sdk",
-    "version": "1.9.4",
+    "version": "1.10.1",
     "dependencies": {
         "@mysten/bcs": "2.0.3",
         "@mysten/kiosk": "1.2.0",
         "@mysten/sui": "2.13.2",
-        "@pythnetwork/pyth-sui-js": "2.3.0",
+        "@pythnetwork/pyth-lazer-sdk": "6.2.2",
+        "@pythnetwork/pyth-lazer-sui-js": "0.3.0",
         "@shinami/clients": "0.10.0",
         "bignumber.js": "^9.1.2",
         "camelcase-keys-deep": "^0.1.0",
@@ -51,4 +52,4 @@
         "url": "https://github.com/Typus-Lab/typus-sdk/issues"
     },
     "homepage": "https://github.com/Typus-Lab/typus-sdk#readme"
-}
+}