@evaafi/sdk 0.7.0 → 0.9.0

package/dist/prices/PricesCollector.d.ts

@@ -1,12 +1,22 @@
 import { Dictionary } from "@ton/core";
-import { PoolAssetConfig, PoolAssetsConfig, PoolConfig } from "../types/Master";
+import { ExtendedEvaaOracle, PoolAssetConfig, PoolAssetsConfig } from "../types/Master";
+import { FetchConfig } from '../utils/utils';
+import { Oracle } from "./Oracle.interface";
+import { Prices } from "./Prices";
 import { PriceSource } from "./sources";
 import { PriceSourcesConfig } from "./Types";
-import { Prices } from "./Prices";
-export declare class PricesCollector {
+export type PricesCollectorConfig = {
+    poolAssetsConfig: PoolAssetsConfig;
+    minimalOracles: number;
+    evaaOracles: ExtendedEvaaOracle[];
+    sourcesConfig?: PriceSourcesConfig;
+    additionalPriceSources?: PriceSource[];
+};
+export declare class PricesCollector implements Oracle {
     #private;
-    constructor(poolConfig?: PoolConfig, sourcesConfig?: PriceSourcesConfig, additionalPriceSources?: PriceSource[]);
-    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, retries?: number, timeout?: number): Promise<Prices>;
-    getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt?: boolean, retries?: number, timeout?: number): Promise<Prices>;
-    getPrices(assets?: PoolAssetsConfig, retries?: number, timeout?: number): Promise<Prices>;
+    constructor(config: PricesCollectorConfig);
+    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<Prices>;
+    getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt?: boolean, fetchConfig?: FetchConfig): Promise<Prices>;
+    getPricesForSupplyWithdraw(realPrincipals: Dictionary<bigint, bigint>, supplyAsset: PoolAssetConfig | undefined, withdrawAsset: PoolAssetConfig | undefined, collateralToDebt: boolean, fetchConfig?: FetchConfig): Promise<Prices>;
+    getPrices(assets?: PoolAssetsConfig, fetchConfig?: FetchConfig): Promise<Prices>;
 }

package/dist/prices/PricesCollector.js

@@ -10,40 +10,40 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _PricesCollector_instances, _PricesCollector_prices, _PricesCollector_poolConfig, _PricesCollector_sourcesConfig, _PricesCollector_priceSources, _PricesCollector_getPricesByAssetList, _PricesCollector_collectPrices, _PricesCollector_filterPrices, _PricesCollector_filterEmptyPrincipalsAndAssets;
+var _PricesCollector_instances, _PricesCollector_prices, _PricesCollector_poolAssetsConfig, _PricesCollector_sourcesConfig, _PricesCollector_priceSources, _PricesCollector_minimalOracles, _PricesCollector_getPricesByAssetList, _PricesCollector_collectPrices, _PricesCollector_collectPricesWithValidation, _PricesCollector_filterPrices, _PricesCollector_filterEmptyPrincipalsAndAssets;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PricesCollector = void 0;
 const core_1 = require("@ton/core");
-const pools_1 = require("../constants/pools");
-const Types_1 = require("./Types");
-const utils_1 = require("./utils");
-const utils_2 = require("../utils/utils");
-const Prices_1 = require("./Prices");
 const math_1 = require("../api/math");
+const utils_1 = require("../utils/utils");
+const Prices_1 = require("./Prices");
+const Types_1 = require("./Types");
+const utils_2 = require("./utils");
 class PricesCollector {
-    constructor(poolConfig = pools_1.MAINNET_POOL_CONFIG, sourcesConfig = Types_1.DefaultPriceSourcesConfig, additionalPriceSources) {
+    constructor(config) {
         _PricesCollector_instances.add(this);
         _PricesCollector_prices.set(this, void 0);
-        _PricesCollector_poolConfig.set(this, void 0);
+        _PricesCollector_poolAssetsConfig.set(this, void 0);
         _PricesCollector_sourcesConfig.set(this, void 0);
         _PricesCollector_priceSources.set(this, void 0);
-        __classPrivateFieldSet(this, _PricesCollector_poolConfig, poolConfig, "f");
-        __classPrivateFieldSet(this, _PricesCollector_sourcesConfig, sourcesConfig, "f");
-        __classPrivateFieldSet(this, _PricesCollector_priceSources, (0, utils_1.generatePriceSources)(__classPrivateFieldGet(this, _PricesCollector_sourcesConfig, "f"), __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").oracles), "f");
-        if (additionalPriceSources) {
-            __classPrivateFieldGet(this, _PricesCollector_priceSources, "f").push(...additionalPriceSources);
+        _PricesCollector_minimalOracles.set(this, void 0);
+        __classPrivateFieldSet(this, _PricesCollector_poolAssetsConfig, config.poolAssetsConfig, "f");
+        __classPrivateFieldSet(this, _PricesCollector_sourcesConfig, config.sourcesConfig ?? Types_1.DefaultPriceSourcesConfig, "f");
+        __classPrivateFieldSet(this, _PricesCollector_priceSources, (0, utils_2.generatePriceSources)(__classPrivateFieldGet(this, _PricesCollector_sourcesConfig, "f"), config.evaaOracles), "f");
+        __classPrivateFieldSet(this, _PricesCollector_minimalOracles, config.minimalOracles, "f");
+        if (config.additionalPriceSources) {
+            __classPrivateFieldGet(this, _PricesCollector_priceSources, "f").push(...config.additionalPriceSources);
         }
         __classPrivateFieldSet(this, _PricesCollector_prices, [], "f");
     }
-    // TODO Make UserData class and incapsulate raw bigintegers
-    async getPricesForLiquidate(realPrincipals, retries = 1, timeout = 3000) {
+    async getPricesForLiquidate(realPrincipals, fetchConfig) {
         const assets = __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
         if (assets.includes(undefined)) {
             throw new Error("User from another pool");
         }
-        return await this.getPrices(assets.map(x => x), retries, timeout);
+        return await this.getPrices(assets.map(x => x), fetchConfig);
     }
-    async getPricesForWithdraw(realPrincipals, withdrawAsset, collateralToDebt = false, retries = 1, timeout = 3000) {
+    async getPricesForWithdraw(realPrincipals, withdrawAsset, collateralToDebt = false, fetchConfig) {
         let assets = __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
         if ((0, math_1.checkNotInDebtAtAll)(realPrincipals) && (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n && !collateralToDebt) {
             return new Prices_1.Prices(core_1.Dictionary.empty(), core_1.Cell.EMPTY);
@@ -57,74 +57,90 @@ class PricesCollector {
         if (collateralToDebt && assets.length == 1) {
             throw new Error("Cannot debt only one supplied asset");
         }
-        return await this.getPrices(assets.map(x => x), retries, timeout);
+        return await this.getPrices(assets.map(x => x), fetchConfig);
     }
-    async getPrices(assets = __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").poolAssetsConfig, retries = 1, timeout = 3000) {
-        console.debug('[getPrices] Assets length', assets.length);
-        if (assets.length == 0) {
+    async getPricesForSupplyWithdraw(realPrincipals, supplyAsset, withdrawAsset, collateralToDebt, fetchConfig) {
+        // Используем ту же логику, что и getPricesForWithdraw, но supplyAsset не используется
+        let assets = __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if ((0, math_1.checkNotInDebtAtAll)(realPrincipals) && withdrawAsset && (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n && !collateralToDebt) {
             return new Prices_1.Prices(core_1.Dictionary.empty(), core_1.Cell.EMPTY);
         }
-        for (let i = 0; i <= retries; i++) { // attemts = retries + 1
-            if (!__classPrivateFieldGet(this, _PricesCollector_prices, "f") || __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_filterPrices).call(this) < __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").minimalOracles) {
-                //console.debug('[getPrices] Load prices attemp', i + 1)
-                if (i > 0) {
-                    await (0, utils_2.delay)(timeout);
-                }
-                await __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_collectPrices).call(this);
-            }
-            else {
-                break;
-            }
+        if (assets.includes(undefined)) {
+            throw new Error("User from another pool");
         }
-        if (__classPrivateFieldGet(this, _PricesCollector_prices, "f").length < __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").minimalOracles) {
-            throw new Error(`Error per updating prices, valid ${__classPrivateFieldGet(this, _PricesCollector_prices, "f").length} of ${__classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").minimalOracles}`); // if still not enough data after retries
+        if (withdrawAsset && !assets.includes(withdrawAsset)) {
+            assets.push(withdrawAsset);
+        }
+        if (collateralToDebt && assets.length == 1) {
+            throw new Error("Cannot debt only one supplied asset");
+        }
+        return await this.getPrices(assets.map(x => x), fetchConfig);
+    }
+    async getPrices(assets = __classPrivateFieldGet(this, _PricesCollector_poolAssetsConfig, "f"), fetchConfig) {
+        if (assets.length == 0) {
+            return new Prices_1.Prices(core_1.Dictionary.empty(), core_1.Cell.EMPTY);
+        }
+        await __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_collectPricesWithValidation).call(this, fetchConfig);
+        if (__classPrivateFieldGet(this, _PricesCollector_prices, "f").length < __classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f")) {
+            throw new Error(`Error per updating prices, valid ${__classPrivateFieldGet(this, _PricesCollector_prices, "f").length} of ${__classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f")}`);
         }
         const prices = __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_getPricesByAssetList).call(this, assets);
         return new Prices_1.Prices(prices.dict, prices.dataCell);
     }
 }
 exports.PricesCollector = PricesCollector;
-_PricesCollector_prices = new WeakMap(), _PricesCollector_poolConfig = new WeakMap(), _PricesCollector_sourcesConfig = new WeakMap(), _PricesCollector_priceSources = new WeakMap(), _PricesCollector_instances = new WeakSet(), _PricesCollector_getPricesByAssetList = function _PricesCollector_getPricesByAssetList(assets) {
-    //console.debug('[getPricesByAssetList] start')
-    let pricesFiltered = __classPrivateFieldGet(this, _PricesCollector_prices, "f"); // for strict check this.#prices.filter(x => assets.every(asset => x.dict.has(asset.assetId)));
-    if (pricesFiltered.length < __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").minimalOracles) {
+_PricesCollector_prices = new WeakMap(), _PricesCollector_poolAssetsConfig = new WeakMap(), _PricesCollector_sourcesConfig = new WeakMap(), _PricesCollector_priceSources = new WeakMap(), _PricesCollector_minimalOracles = new WeakMap(), _PricesCollector_instances = new WeakSet(), _PricesCollector_getPricesByAssetList = function _PricesCollector_getPricesByAssetList(assets) {
+    let pricesFiltered = __classPrivateFieldGet(this, _PricesCollector_prices, "f");
+    if (pricesFiltered.length < __classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f")) {
         throw new Error("Not enough price data");
     }
-    if (pricesFiltered.length > __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").minimalOracles) {
+    if (pricesFiltered.length > __classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f")) {
         const sortedByTimestamp = pricesFiltered.slice().sort((a, b) => b.timestamp - a.timestamp);
-        const newerPrices = sortedByTimestamp.slice(0, __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").minimalOracles);
+        const newerPrices = sortedByTimestamp.slice(0, __classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f"));
         pricesFiltered = newerPrices.sort((a, b) => a.oracleId - b.oracleId);
     }
     const medianData = assets.map((asset) => ({
         assetId: asset.assetId,
-        medianPrice: (0, utils_1.getMedianPrice)(pricesFiltered, asset.assetId),
+        medianPrice: (0, utils_2.getMedianPrice)(pricesFiltered, asset.assetId),
     }));
     const nonEmptymedianData = medianData.filter(x => x.medianPrice != null);
-    const packedMedianData = (0, utils_1.packAssetsData)(nonEmptymedianData);
+    const packedMedianData = (0, utils_2.packAssetsData)(nonEmptymedianData);
     const oraclesData = pricesFiltered.map((x) => ({
         oracle: { id: x.oracleId, pubkey: x.pubkey },
         data: { timestamp: x.timestamp, prices: x.dict },
         signature: x.signature,
     }));
-    const packedOracleData = (0, utils_1.packOraclesData)(oraclesData, nonEmptymedianData.map(x => x.assetId));
+    const packedOracleData = (0, utils_2.packOraclesData)(oraclesData, nonEmptymedianData.map(x => x.assetId));
     const dict = core_1.Dictionary.empty();
     for (const medianDataAsset of nonEmptymedianData) {
         dict.set(medianDataAsset.assetId, medianDataAsset.medianPrice);
     }
     return {
         dict: dict,
-        dataCell: (0, utils_1.packPrices)(packedMedianData, packedOracleData)
+        dataCell: (0, utils_2.packPrices)(packedMedianData, packedOracleData)
     };
-}, _PricesCollector_collectPrices = async function _PricesCollector_collectPrices() {
-    try {
-        __classPrivateFieldSet(this, _PricesCollector_prices, await Promise.any(__classPrivateFieldGet(this, _PricesCollector_priceSources, "f").map(x => (0, utils_1.collectAndFilterPrices)(x, __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f")))), "f");
-        return true;
+}, _PricesCollector_collectPrices = async function _PricesCollector_collectPrices(fetchConfig) {
+    for (const priceSource of __classPrivateFieldGet(this, _PricesCollector_priceSources, "f")) {
+        try {
+            __classPrivateFieldSet(this, _PricesCollector_prices, await (0, utils_1.proxyFetchRetries)((0, utils_2.collectAndFilterPrices)(priceSource, __classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f"), fetchConfig), fetchConfig), "f");
+            return true;
+        }
+        catch (error) {
+            // Try next source
+            continue;
+        }
     }
-    catch { }
     return false;
+}, _PricesCollector_collectPricesWithValidation = async function _PricesCollector_collectPricesWithValidation(fetchConfig) {
+    if (!__classPrivateFieldGet(this, _PricesCollector_prices, "f") || __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_filterPrices).call(this) < __classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f")) {
+        const success = await __classPrivateFieldGet(this, _PricesCollector_instances, "m", _PricesCollector_collectPrices).call(this, fetchConfig);
+        if (!success || __classPrivateFieldGet(this, _PricesCollector_prices, "f").length < __classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f")) {
+            throw new Error(`Failed to collect sufficient prices: ${__classPrivateFieldGet(this, _PricesCollector_prices, "f")?.length || 0} of ${__classPrivateFieldGet(this, _PricesCollector_minimalOracles, "f")}`);
+        }
+    }
 }, _PricesCollector_filterPrices = function _PricesCollector_filterPrices() {
-    __classPrivateFieldSet(this, _PricesCollector_prices, __classPrivateFieldGet(this, _PricesCollector_prices, "f").filter((0, utils_1.verifyPricesTimestamp)()), "f");
+    __classPrivateFieldSet(this, _PricesCollector_prices, __classPrivateFieldGet(this, _PricesCollector_prices, "f").filter((0, utils_2.verifyPricesTimestamp)()), "f");
     return __classPrivateFieldGet(this, _PricesCollector_prices, "f").length;
 }, _PricesCollector_filterEmptyPrincipalsAndAssets = function _PricesCollector_filterEmptyPrincipalsAndAssets(principals) {
-    return principals.keys().filter(x => principals.get(x) != 0n).map(x => __classPrivateFieldGet(this, _PricesCollector_poolConfig, "f").poolAssetsConfig.find(asset => asset.assetId == x));
+    return principals.keys().filter(x => principals.get(x) != 0n).map(x => __classPrivateFieldGet(this, _PricesCollector_poolAssetsConfig, "f").find(asset => asset.assetId == x));
 };

package/dist/prices/PythCollector.d.ts

@@ -0,0 +1,22 @@
+import { HexString } from '@pythnetwork/hermes-client';
+import { Dictionary } from '@ton/core';
+import { OracleConfig } from '../api/parsers/PythOracleParser';
+import { PoolAssetConfig, PoolAssetsConfig } from '../types/Master';
+import { FetchConfig } from '../utils/utils';
+import { Oracle } from './Oracle.interface';
+import { Prices } from './Prices';
+import { PythPriceSourcesConfig } from './Types';
+export type PythCollectorConfig = {
+    poolAssetsConfig: PoolAssetsConfig;
+    pythOracle: OracleConfig;
+    pythConfig: PythPriceSourcesConfig;
+};
+export declare class PythCollector implements Oracle {
+    #private;
+    constructor(config: PythCollectorConfig);
+    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<Prices>;
+    getPricesForSupplyWithdraw(realPrincipals: Dictionary<bigint, bigint>, supplyAsset: PoolAssetConfig | undefined, withdrawAsset: PoolAssetConfig | undefined, collateralToDebt: boolean, fetchConfig?: FetchConfig): Promise<Prices>;
+    getPrices(assets?: PoolAssetsConfig, fetchConfig?: FetchConfig): Promise<Prices>;
+    getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt?: boolean, fetchConfig?: FetchConfig): Promise<Prices>;
+    createRequiredFeedsList(evaaIds: bigint[]): HexString[];
+}

package/dist/prices/PythCollector.js

@@ -0,0 +1,217 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PythCollector_instances, _PythCollector_oracleInfo, _PythCollector_parsedFeedsMap, _PythCollector_pythConfig, _PythCollector_poolAssetsConfig, _PythCollector_pythToEvaaDirect, _PythCollector_pythToEvaaReferred, _PythCollector_evaaToPythDirect, _PythCollector_allowedRefEvaa, _PythCollector_getPythFeedsUpdates, _PythCollector_fetchPythUpdatesWithRetry, _PythCollector_filterEmptyPrincipalsAndAssets;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythCollector = void 0;
+const hermes_client_1 = require("@pythnetwork/hermes-client");
+const core_1 = require("@ton/core");
+const math_1 = require("../api/math");
+const prices_1 = require("../api/prices");
+const constants_1 = require("../constants");
+const Master_1 = require("../types/Master");
+const utils_1 = require("../utils/utils");
+const Prices_1 = require("./Prices");
+const constants_2 = require("./constants");
+class PythCollector {
+    constructor(config) {
+        _PythCollector_instances.add(this);
+        _PythCollector_oracleInfo.set(this, void 0);
+        _PythCollector_parsedFeedsMap.set(this, void 0);
+        _PythCollector_pythConfig.set(this, void 0);
+        _PythCollector_poolAssetsConfig.set(this, void 0);
+        _PythCollector_pythToEvaaDirect.set(this, new Map()); // pythId -> evaaId (native)
+        _PythCollector_pythToEvaaReferred.set(this, new Map()); // pythId -> Set<evaaId>,
+        _PythCollector_evaaToPythDirect.set(this, new Map()); // evaaId -> pythId (native)
+        _PythCollector_allowedRefEvaa.set(this, new Map()); // evaaId -> baseEvaaId (allowedRefTokens)
+        __classPrivateFieldSet(this, _PythCollector_oracleInfo, config.pythOracle, "f");
+        __classPrivateFieldSet(this, _PythCollector_pythConfig, config.pythConfig, "f");
+        __classPrivateFieldSet(this, _PythCollector_poolAssetsConfig, config.poolAssetsConfig, "f");
+        __classPrivateFieldSet(this, _PythCollector_parsedFeedsMap, (0, Master_1.parseFeedsMapDict)(__classPrivateFieldGet(this, _PythCollector_oracleInfo, "f").feedsMap), "f");
+        // 1) pythId -> evaaId, evaaId -> pythId
+        for (const [pythId, feedInfo] of __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").entries()) {
+            __classPrivateFieldGet(this, _PythCollector_pythToEvaaDirect, "f").set(pythId, feedInfo.evaaId);
+            __classPrivateFieldGet(this, _PythCollector_evaaToPythDirect, "f").set(feedInfo.evaaId, pythId);
+        }
+        // 2) pythId (native) -> Set<evaaId>
+        for (const [pythId, feedInfo] of __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").entries()) {
+            const ref = feedInfo.referredPythFeed;
+            if (ref && ref !== 0n) {
+                if (!__classPrivateFieldGet(this, _PythCollector_pythToEvaaReferred, "f").has(ref))
+                    __classPrivateFieldGet(this, _PythCollector_pythToEvaaReferred, "f").set(ref, new Set());
+                __classPrivateFieldGet(this, _PythCollector_pythToEvaaReferred, "f").get(ref).add(feedInfo.evaaId);
+            }
+        }
+        // 3)  evaaId -> baseEvaaId (allowedRefTokens)
+        for (const evaaId of __classPrivateFieldGet(this, _PythCollector_oracleInfo, "f").allowedRefTokens.keys()) {
+            const base = __classPrivateFieldGet(this, _PythCollector_oracleInfo, "f").allowedRefTokens.get(evaaId);
+            __classPrivateFieldGet(this, _PythCollector_allowedRefEvaa, "f").set(evaaId, base);
+            // If baseEvaaId have pythId. evaaId -> pyth(base)
+            const basePyth = __classPrivateFieldGet(this, _PythCollector_evaaToPythDirect, "f").get(base);
+            if (basePyth) {
+                if (!__classPrivateFieldGet(this, _PythCollector_pythToEvaaReferred, "f").has(basePyth))
+                    __classPrivateFieldGet(this, _PythCollector_pythToEvaaReferred, "f").set(basePyth, new Set());
+                __classPrivateFieldGet(this, _PythCollector_pythToEvaaReferred, "f").get(basePyth).add(evaaId);
+            }
+        }
+    }
+    async getPricesForLiquidate(realPrincipals, fetchConfig) {
+        const assets = __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        return await this.getPrices(assets.map((x) => x), fetchConfig);
+    }
+    async getPricesForSupplyWithdraw(realPrincipals, supplyAsset, withdrawAsset, collateralToDebt, fetchConfig) {
+        let assets = __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if ((0, math_1.checkNotInDebtAtAll)(realPrincipals) &&
+            withdrawAsset &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt) {
+            return new Prices_1.Prices(core_1.Dictionary.empty(), core_1.Cell.EMPTY, undefined, undefined);
+        }
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        if (withdrawAsset && !assets.find((a) => a?.assetId === withdrawAsset.assetId)) {
+            assets.push(withdrawAsset);
+        }
+        if (collateralToDebt && assets.length == 1) {
+            throw new Error('Cannot debt only one supplied asset');
+        }
+        return await this.getPrices(assets.map((x) => x), fetchConfig);
+    }
+    async getPrices(assets = __classPrivateFieldGet(this, _PythCollector_poolAssetsConfig, "f"), fetchConfig) {
+        // Declare variables at the beginning
+        let minPublishTime;
+        let maxPublishTime;
+        if (assets.length === 0) {
+            return new Prices_1.Prices(core_1.Dictionary.empty(), core_1.Cell.EMPTY, undefined, undefined);
+        }
+        const requiredFeeds = this.createRequiredFeedsList(assets.map((a) => a.assetId));
+        const pythUpdates = await __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_fetchPythUpdatesWithRetry).call(this, requiredFeeds, fetchConfig);
+        // Calculate min and max publish times for validation
+        if (pythUpdates.parsed && pythUpdates.parsed.length > 0) {
+            const publishTimes = pythUpdates.parsed.map((u) => BigInt(u.price.publish_time));
+            const tmin = publishTimes.reduce((a, b) => (a < b ? a : b));
+            const tmax = publishTimes.reduce((a, b) => (a > b ? a : b));
+            if (tmax - tmin > constants_2.TTL_ORACLE_DATA_SEC) {
+                throw new Error(`Price feeds don't fit in a single 3-minute window. Time span: ${tmax - tmin} seconds (max allowed: ${constants_2.TTL_ORACLE_DATA_SEC})`);
+            }
+            // Set boundaries using "from oldest" approach: minPublishTime = tmin, maxPublishTime = tmin + 180
+            minPublishTime = tmin;
+            maxPublishTime = tmin + BigInt(constants_2.TTL_ORACLE_DATA_SEC);
+        }
+        const pricesDict = core_1.Dictionary.empty();
+        const pythPriceUpdates = pythUpdates.parsed;
+        if (pythPriceUpdates) {
+            // Only set prices for requested assets, not all possible mapped assets
+            const requestedAssetIds = new Set(assets.map((a) => a.assetId));
+            for (const u of pythPriceUpdates) {
+                const pythId = BigInt('0x' + u.id);
+                const price = (BigInt(u.price.price) * BigInt(10 ** 9)) / BigInt(10 ** (u.price.expo * -1));
+                // Set price for direct mapping if the evaaId is requested
+                const directEvaa = __classPrivateFieldGet(this, _PythCollector_pythToEvaaDirect, "f").get(pythId);
+                if (directEvaa && requestedAssetIds.has(directEvaa)) {
+                    pricesDict.set(directEvaa, price);
+                }
+                // Set price for referred assets only if they are requested
+                const referredSet = __classPrivateFieldGet(this, _PythCollector_pythToEvaaReferred, "f").get(pythId);
+                if (referredSet && referredSet.size) {
+                    for (const evaaId of referredSet) {
+                        if (requestedAssetIds.has(evaaId)) {
+                            pricesDict.set(evaaId, price);
+                        }
+                    }
+                }
+            }
+            // TODO: fix it
+            if (pricesDict.get(constants_1.TSTON_MAINNET.assetId) && pricesDict.get(constants_1.TON_MAINNET.assetId)) {
+                pricesDict.set(constants_1.TSTON_MAINNET.assetId, (pricesDict.get(constants_1.TSTON_MAINNET.assetId) * pricesDict.get(constants_1.TON_MAINNET.assetId)) / BigInt(10 ** 9));
+            }
+            // TODO: fix it
+            if (pricesDict.get(constants_1.STTON_MAINNET.assetId) && pricesDict.get(constants_1.TON_MAINNET.assetId)) {
+                pricesDict.set(constants_1.STTON_MAINNET.assetId, (pricesDict.get(constants_1.STTON_MAINNET.assetId) * pricesDict.get(constants_1.TON_MAINNET.assetId)) / BigInt(10 ** 9));
+            }
+            // TODO: fix it
+            if (pricesDict.get(constants_1.TSUSDE_MAINNET.assetId) && pricesDict.get(constants_1.USDE_MAINNET.assetId)) {
+                pricesDict.set(constants_1.TSUSDE_MAINNET.assetId, (pricesDict.get(constants_1.TSUSDE_MAINNET.assetId) * pricesDict.get(constants_1.USDE_MAINNET.assetId)) / BigInt(10 ** 9));
+            }
+            // Check that all requested assets have prices
+            const missing = assets.map((a) => a.assetId).filter((id) => pricesDict.get(id) === undefined);
+            if (missing.length) {
+                throw new Error(`Missing prices for ${missing.length} asset(s): ${missing.map((x) => x.toString()).join(', ')}`);
+            }
+            const dataCell = (0, prices_1.packPythUpdatesData)(pythUpdates.binary);
+            return new Prices_1.Prices(pricesDict, dataCell, minPublishTime, maxPublishTime);
+        }
+        return new Prices_1.Prices(core_1.Dictionary.empty(), core_1.Cell.EMPTY, minPublishTime, maxPublishTime);
+    }
+    async getPricesForWithdraw(realPrincipals, withdrawAsset, collateralToDebt = false, fetchConfig) {
+        let assets = __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if ((0, math_1.checkNotInDebtAtAll)(realPrincipals) &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt) {
+            return new Prices_1.Prices(core_1.Dictionary.empty(), core_1.Cell.EMPTY);
+        }
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        if (!assets.includes(withdrawAsset)) {
+            assets.push(withdrawAsset);
+        }
+        if (collateralToDebt && assets.length == 1) {
+            throw new Error('Cannot debt only one supplied asset');
+        }
+        return await this.getPrices(assets.map((x) => x), fetchConfig);
+    }
+    createRequiredFeedsList(evaaIds) {
+        const requiredFeeds = new Set();
+        for (const evaaId of evaaIds) {
+            let pythId = __classPrivateFieldGet(this, _PythCollector_evaaToPythDirect, "f").get(evaaId);
+            // If evaaId no have native feed — try by allowedRefTokens (evAA->baseEvAA->pyth)
+            if (!pythId) {
+                const baseEvaa = __classPrivateFieldGet(this, _PythCollector_allowedRefEvaa, "f").get(evaaId);
+                if (baseEvaa)
+                    pythId = __classPrivateFieldGet(this, _PythCollector_evaaToPythDirect, "f").get(baseEvaa) ?? null;
+            }
+            if (pythId) {
+                requiredFeeds.add(pythId);
+                const feedInfo = __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").get(pythId);
+                if (feedInfo?.referredPythFeed && feedInfo.referredPythFeed !== 0n) {
+                    requiredFeeds.add(feedInfo.referredPythFeed);
+                }
+            }
+        }
+        return Array.from(requiredFeeds).map((id) => '0x' + id.toString(16));
+    }
+}
+exports.PythCollector = PythCollector;
+_PythCollector_oracleInfo = new WeakMap(), _PythCollector_parsedFeedsMap = new WeakMap(), _PythCollector_pythConfig = new WeakMap(), _PythCollector_poolAssetsConfig = new WeakMap(), _PythCollector_pythToEvaaDirect = new WeakMap(), _PythCollector_pythToEvaaReferred = new WeakMap(), _PythCollector_evaaToPythDirect = new WeakMap(), _PythCollector_allowedRefEvaa = new WeakMap(), _PythCollector_instances = new WeakSet(), _PythCollector_getPythFeedsUpdates = 
+/**
+ * Updates feeds data from specified endpoint
+ * @param feedIds list of pyth feed ids to fetch
+ * @returns binary - buffer of feeds update, parsed - json feeds data
+ */
+async function _PythCollector_getPythFeedsUpdates(feedIds) {
+    const latestPriceUpdates = await Promise.any(__classPrivateFieldGet(this, _PythCollector_pythConfig, "f").pythEndpoints.map((x) => new hermes_client_1.HermesClient(x).getLatestPriceUpdates(feedIds, { encoding: 'hex' })));
+    const parsed = latestPriceUpdates['parsed'];
+    const binary = Buffer.from(latestPriceUpdates.binary.data[0], 'hex');
+    return { binary, parsed };
+}, _PythCollector_fetchPythUpdatesWithRetry = async function _PythCollector_fetchPythUpdatesWithRetry(requiredFeeds, fetchConfig) {
+    return (0, utils_1.proxyFetchRetries)(__classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_getPythFeedsUpdates).call(this, requiredFeeds), fetchConfig);
+}, _PythCollector_filterEmptyPrincipalsAndAssets = function _PythCollector_filterEmptyPrincipalsAndAssets(principals) {
+    return principals
+        .keys()
+        .filter((x) => principals.get(x) != 0n)
+        .map((x) => __classPrivateFieldGet(this, _PythCollector_poolAssetsConfig, "f").find((asset) => asset.assetId == x));
+};

package/dist/prices/Types.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
-import { Cell, Dictionary } from '@ton/core';
+import type { PriceUpdate } from '@pythnetwork/hermes-client';
+import type { Cell, Dictionary } from '@ton/core';
 /**
  * Configuration for price source endpoints.
  */
@@ -9,10 +10,21 @@ export type PriceSourcesConfig = {
     /** Endpoints for ICP price data */
     icpEndpoints: string[];
 };
+/**
+ * Configuration for pyth prices.
+ */
+export type PythPriceSourcesConfig = {
+    /** Endpoints for pyth price data */
+    pythEndpoints: string[];
+};
 /**
  * Default configuration for price source endpoints.
  */
 export declare const DefaultPriceSourcesConfig: PriceSourcesConfig;
+/**
+ * Configuration for pyth price sources.
+ */
+export declare const DefaultPythPriceSourcesConfig: PythPriceSourcesConfig;
 export type RawPriceData = {
     dict: Dictionary<bigint, bigint>;
     dataCell: Cell;
@@ -21,6 +33,10 @@ export type RawPriceData = {
     pubkey: Buffer;
     timestamp: number;
 };
+export type PythFeedUpdateType = {
+    parsed: PriceUpdate['parsed'];
+    binary: Buffer;
+};
 export type PriceData = {
     dict: Dictionary<bigint, bigint>;
     dataCell: Cell;

package/dist/prices/Types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultPriceSourcesConfig = void 0;
+exports.DefaultPythPriceSourcesConfig = exports.DefaultPriceSourcesConfig = void 0;
 /**
  * Default configuration for price source endpoints.
  */
@@ -8,3 +8,10 @@ exports.DefaultPriceSourcesConfig = {
     backendEndpoints: ['api.evaa.space', 'evaa.space'],
     icpEndpoints: ['6khmc-aiaaa-aaaap-ansfq-cai.raw.icp0.io'],
 };
+/**
+ * Configuration for pyth price sources.
+ */
+exports.DefaultPythPriceSourcesConfig = {
+    // FYI: 3RPS limit per IP, TODO: support Pythnet RPC
+    pythEndpoints: ['https://hermes.pyth.network'],
+};

package/dist/prices/index.d.ts

@@ -1,6 +1,7 @@
-export * from './sources';
-export * from './Types';
 export * from './constants';
-export * from './utils';
 export * from './Prices';
 export * from './PricesCollector';
+export * from './PythCollector';
+export * from './sources';
+export * from './Types';
+export * from './utils';

package/dist/prices/index.js

@@ -14,9 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./sources"), exports);
-__exportStar(require("./Types"), exports);
 __exportStar(require("./constants"), exports);
-__exportStar(require("./utils"), exports);
 __exportStar(require("./Prices"), exports);
 __exportStar(require("./PricesCollector"), exports);
+__exportStar(require("./PythCollector"), exports);
+__exportStar(require("./sources"), exports);
+__exportStar(require("./Types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/prices/sources/Backend.d.ts

@@ -1,9 +1,10 @@
-import { RawPriceData } from "..";
-import { PriceSource } from "./PriceSource";
+import { RawPriceData } from '..';
+import { FetchConfig } from '../../utils/utils';
+import { PriceSource } from './PriceSource';
 export declare class BackendPriceSource extends PriceSource {
     protected priceSourceName: string;
-    getPrices(): Promise<RawPriceData[]>;
-    loadOracleData(): Promise<OutputData[]>;
+    getPrices(fetchConfig?: FetchConfig): Promise<RawPriceData[]>;
+    loadOracleData(fetchConfig?: FetchConfig): Promise<OutputData[]>;
     parsePrices(outputData: OutputData): RawPriceData;
 }
 type OutputData = {

package/dist/prices/sources/Backend.js

@@ -2,28 +2,31 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendPriceSource = void 0;
 const core_1 = require("@ton/core");
+const utils_1 = require("../../utils/utils");
 const PriceSource_1 = require("./PriceSource");
 class BackendPriceSource extends PriceSource_1.PriceSource {
     constructor() {
         super(...arguments);
         this.priceSourceName = 'BackendPriceSource';
     }
-    async getPrices() {
-        const data = await this.loadOracleData();
-        return data.map(outputData => this.parsePrices(outputData));
+    async getPrices(fetchConfig) {
+        const data = await this.loadOracleData(fetchConfig);
+        return data.map((outputData) => this.parsePrices(outputData));
     }
-    async loadOracleData() {
-        let response = await fetch(`https://${this._endpoint}/api/prices`, {
+    async loadOracleData(fetchConfig = utils_1.DefaultFetchConfig) {
+        const fetchPromise = fetch(`https://${this._endpoint}/api/prices`, {
             headers: { accept: 'application/json' },
-            signal: AbortSignal.timeout(5000)
+            signal: AbortSignal.timeout(fetchConfig.timeout),
+        }).then(async (response) => {
+            const resp = await response.json();
+            const data = resp;
+            let outputData = [];
+            for (const nft of this._nfts) {
+                outputData.push({ oracleId: nft.id, data: data[nft.address] });
+            }
+            return outputData;
         });
-        const resp = (await response.json());
-        const data = resp;
-        let outputData = [];
-        for (const nft of this._nfts) {
-            outputData.push({ oracleId: nft.id, data: data[nft.address] });
-        }
-        return outputData;
+        return await (0, utils_1.proxyFetchRetries)(fetchPromise, fetchConfig);
     }
     parsePrices(outputData) {
         try {

package/dist/prices/sources/Icp.d.ts

@@ -1,7 +1,8 @@
 import { BackendPriceSource } from ".";
+import { FetchConfig } from "../../utils/utils";
 export declare class IcpPriceSource extends BackendPriceSource {
     protected priceSourceName: string;
-    loadOracleData(): Promise<OutputData[]>;
+    loadOracleData(fetchConfig?: FetchConfig): Promise<OutputData[]>;
 }
 type OutputData = {
     oracleId: number;