@typus/typus-sdk 1.9.3 → 1.10.0

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.3",
+    "version": "1.10.0",
     "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"
-}
+}