@evaafi/sdk 0.7.0 → 0.9.0

package/src/prices/PricesCollector.ts

@@ -1,146 +1,169 @@
-import { Cell, Dictionary } from "@ton/core";
-import { MAINNET_POOL_CONFIG } from "../constants/pools";
-import { PoolAssetConfig, PoolAssetsConfig, PoolConfig } from "../types/Master";
-import { PriceSource } from "./sources";
-import { DefaultPriceSourcesConfig, PriceSourcesConfig, RawPriceData } from "./Types";
-import { collectAndFilterPrices, generatePriceSources, getMedianPrice, packAssetsData, packOraclesData, packPrices, verifyPricesSign, verifyPricesTimestamp } from "./utils";
-import { delay } from "../utils/utils";
-import { Prices } from "./Prices";
-import { checkNotInDebtAtAll } from "../api/math";
-
-
-export class PricesCollector {
+import { Cell, Dictionary } from "@ton/core"
+import { checkNotInDebtAtAll } from "../api/math"
+import { ExtendedEvaaOracle, PoolAssetConfig, PoolAssetsConfig } from "../types/Master"
+import { FetchConfig, proxyFetchRetries } from '../utils/utils'
+import { Oracle } from "./Oracle.interface"
+import { Prices } from "./Prices"
+import { PriceSource } from "./sources"
+import { DefaultPriceSourcesConfig, PriceSourcesConfig, RawPriceData } from "./Types"
+import { collectAndFilterPrices, generatePriceSources, getMedianPrice, packAssetsData, packOraclesData, packPrices, verifyPricesTimestamp } from "./utils"
+
+
+export type PricesCollectorConfig = {
+    poolAssetsConfig: PoolAssetsConfig;
+    minimalOracles: number;
+    evaaOracles: ExtendedEvaaOracle[];
+    sourcesConfig?: PriceSourcesConfig;
+    additionalPriceSources?: PriceSource[];
+};
+
+export class PricesCollector implements Oracle {
     #prices: RawPriceData[];
-    #poolConfig: PoolConfig;
+    #poolAssetsConfig: PoolAssetsConfig;
     #sourcesConfig: PriceSourcesConfig;
     #priceSources: PriceSource[];
-
-    constructor(poolConfig: PoolConfig = MAINNET_POOL_CONFIG, sourcesConfig: PriceSourcesConfig = DefaultPriceSourcesConfig, additionalPriceSources?: PriceSource[]) {
-        this.#poolConfig = poolConfig;
-        this.#sourcesConfig = sourcesConfig;
-        this.#priceSources = generatePriceSources(this.#sourcesConfig, this.#poolConfig.oracles);
-
-        if (additionalPriceSources) {
-            this.#priceSources.push(...additionalPriceSources);
+    #minimalOracles: number;
+
+    constructor(config: PricesCollectorConfig) {
+        this.#poolAssetsConfig = config.poolAssetsConfig;
+        this.#sourcesConfig = config.sourcesConfig ?? DefaultPriceSourcesConfig;
+        this.#priceSources = generatePriceSources(this.#sourcesConfig, config.evaaOracles);
+        this.#minimalOracles = config.minimalOracles;
+        if (config.additionalPriceSources) {
+            this.#priceSources.push(...config.additionalPriceSources);
         }
-
         this.#prices = [];
     }
 
-    // TODO Make UserData class and incapsulate raw bigintegers
-
-    async getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
+    async getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<Prices>  {
         const assets = this.#filterEmptyPrincipalsAndAssets(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: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt = false, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
+    async getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt = false, fetchConfig?: FetchConfig): Promise<Prices>  {
         let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
         if (checkNotInDebtAtAll(realPrincipals) && (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n && !collateralToDebt) {
             return new Prices(Dictionary.empty<bigint, bigint>(), 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!), retries, timeout);
+        return await this.getPrices(assets.map(x => x!), fetchConfig);
     }
 
-    async getPrices(assets: PoolAssetsConfig = this.#poolConfig.poolAssetsConfig, retries: number = 1, timeout: number = 3000): Promise<Prices> {
-        console.debug('[getPrices] Assets length', assets.length);
+    async getPricesForSupplyWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        supplyAsset: PoolAssetConfig | undefined,
+        withdrawAsset: PoolAssetConfig | undefined,
+        collateralToDebt: boolean,
+        fetchConfig?: FetchConfig,
+    ): Promise<Prices> {
+        // Используем ту же логику, что и getPricesForWithdraw, но supplyAsset не используется
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (checkNotInDebtAtAll(realPrincipals) && withdrawAsset && (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n && !collateralToDebt) {
+            return new Prices(Dictionary.empty<bigint, bigint>(), Cell.EMPTY);
+        }
+        if (assets.includes(undefined)) {
+            throw new Error("User from another pool");
+        }
+        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: PoolAssetsConfig = this.#poolAssetsConfig, fetchConfig?: FetchConfig): Promise<Prices> {
         if (assets.length == 0) {
             return new Prices(Dictionary.empty<bigint, bigint>(), Cell.EMPTY);
         }
 
-        for (let i = 0; i <= retries; i++) {  // attemts = retries + 1
-            if (!this.#prices || this.#filterPrices() < this.#poolConfig.minimalOracles) {
-                //console.debug('[getPrices] Load prices attemp', i + 1)
-                if (i > 0) {
-                    await delay(timeout);
-                }
-                await this.#collectPrices();
-            } else {
-                break;
-            }
-        }
+        await this.#collectPricesWithValidation(fetchConfig);
 
-        if (this.#prices.length < this.#poolConfig.minimalOracles) {
-            throw new Error(`Error per updating prices, valid ${this.#prices.length} of ${this.#poolConfig.minimalOracles}`);  // if still not enough data after retries
+        if (this.#prices.length < this.#minimalOracles) {
+            throw new Error(`Error per updating prices, valid ${this.#prices.length} of ${this.#minimalOracles}`);
         }
         const prices = this.#getPricesByAssetList(assets);
         return new Prices(prices.dict, prices.dataCell);
     }
 
     #getPricesByAssetList(assets: PoolAssetsConfig) {
-        //console.debug('[getPricesByAssetList] start')
-        let pricesFiltered = this.#prices;  // for strict check this.#prices.filter(x => assets.every(asset => x.dict.has(asset.assetId)));
-
-        if (pricesFiltered.length < this.#poolConfig.minimalOracles) {
+        let pricesFiltered = this.#prices;
+        if (pricesFiltered.length < this.#minimalOracles) {
             throw new Error("Not enough price data");
         }
-
-        if (pricesFiltered.length > this.#poolConfig.minimalOracles) {
+        if (pricesFiltered.length > this.#minimalOracles) {
             const sortedByTimestamp = pricesFiltered.slice().sort((a, b) => b.timestamp - a.timestamp);
-            const newerPrices = sortedByTimestamp.slice(0, this.#poolConfig.minimalOracles);
+            const newerPrices = sortedByTimestamp.slice(0, this.#minimalOracles);
             pricesFiltered = newerPrices.sort((a, b) => a.oracleId - b.oracleId);
         }
-
         const medianData = assets.map((asset) => ({
             assetId: asset.assetId,
             medianPrice: getMedianPrice(pricesFiltered, asset.assetId),
         }));
-        
         const nonEmptymedianData = medianData.filter(x => x.medianPrice != null) as { assetId: bigint, medianPrice: bigint }[];
-
         const packedMedianData = 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 = packOraclesData(oraclesData, nonEmptymedianData.map(x => x.assetId));
-
         const dict = Dictionary.empty<bigint, bigint>();
         for (const medianDataAsset of nonEmptymedianData) {
             dict.set(medianDataAsset.assetId, medianDataAsset.medianPrice);
         }
-
         return {
             dict: dict,
             dataCell: packPrices(packedMedianData, packedOracleData)
         }
     }
 
-    async #collectPrices(): Promise<boolean> {
-        try {
-            this.#prices = await Promise.any(this.#priceSources.map(x => collectAndFilterPrices(x, this.#poolConfig)));
-            return true;
+    async #collectPrices(fetchConfig?: FetchConfig): Promise<boolean> {
+        for (const priceSource of this.#priceSources) {
+            try {
+                this.#prices = await proxyFetchRetries(
+                    collectAndFilterPrices(priceSource, this.#minimalOracles, fetchConfig),
+                    fetchConfig,
+                );
+                return true;
+            } catch (error) {
+                // Try next source
+                continue;
+            }
         }
-        catch { }
+
         return false;
     }
 
-    #filterPrices(): number {  // filter again for expire check
+    async #collectPricesWithValidation(fetchConfig?: FetchConfig): Promise<void> {
+        if (!this.#prices || this.#filterPrices() < this.#minimalOracles) {
+            const success = await this.#collectPrices(fetchConfig);
+            if (!success || this.#prices.length < this.#minimalOracles) {
+                throw new Error(
+                    `Failed to collect sufficient prices: ${this.#prices?.length || 0} of ${this.#minimalOracles}`,
+                );
+            }
+        }
+    }
+
+    #filterPrices(): number {
         this.#prices = this.#prices.filter(verifyPricesTimestamp());
         return this.#prices.length;
     }
 
     #filterEmptyPrincipalsAndAssets(principals: Dictionary<bigint, bigint>) {
-        return principals.keys().filter(x => principals.get(x)! != 0n).map(x => this.#poolConfig.poolAssetsConfig.find(asset => asset.assetId == x));
+        return principals.keys().filter(x => principals.get(x)! != 0n).map(x => this.#poolAssetsConfig.find(asset => asset.assetId == x));
     }
 }

package/src/prices/PythCollector.ts

@@ -0,0 +1,294 @@
+import { HermesClient, HexString, PriceUpdate } from '@pythnetwork/hermes-client';
+import { Cell, Dictionary } from '@ton/core';
+import { checkNotInDebtAtAll } from '../api/math';
+import { OracleConfig } from '../api/parsers/PythOracleParser';
+import { packPythUpdatesData } from '../api/prices';
+import { STTON_MAINNET, TON_MAINNET, TSTON_MAINNET, TSUSDE_MAINNET, USDE_MAINNET } from '../constants';
+import { FeedMapItem, parseFeedsMapDict, PoolAssetConfig, PoolAssetsConfig } from '../types/Master';
+import { FetchConfig, proxyFetchRetries } from '../utils/utils';
+import { Oracle } from './Oracle.interface';
+import { Prices } from './Prices';
+import { PythFeedUpdateType, PythPriceSourcesConfig } from './Types';
+import { TTL_ORACLE_DATA_SEC } from './constants';
+
+export type PythCollectorConfig = {
+    poolAssetsConfig: PoolAssetsConfig;
+    pythOracle: OracleConfig;
+    pythConfig: PythPriceSourcesConfig;
+};
+
+export class PythCollector implements Oracle {
+    #oracleInfo: OracleConfig;
+    #parsedFeedsMap: Map<bigint, FeedMapItem>;
+    #pythConfig: PythPriceSourcesConfig;
+    #poolAssetsConfig: PoolAssetsConfig;
+
+    #pythToEvaaDirect = new Map<bigint, bigint>(); // pythId -> evaaId (native)
+    #pythToEvaaReferred = new Map<bigint, Set<bigint>>(); // pythId -> Set<evaaId>,
+    #evaaToPythDirect = new Map<bigint, bigint>(); // evaaId -> pythId (native)
+    #allowedRefEvaa = new Map<bigint, bigint>(); // evaaId -> baseEvaaId (allowedRefTokens)
+
+    constructor(config: PythCollectorConfig) {
+        this.#oracleInfo = config.pythOracle;
+        this.#pythConfig = config.pythConfig;
+        this.#poolAssetsConfig = config.poolAssetsConfig;
+        this.#parsedFeedsMap = parseFeedsMapDict(this.#oracleInfo.feedsMap);
+
+        // 1) pythId -> evaaId, evaaId -> pythId
+        for (const [pythId, feedInfo] of this.#parsedFeedsMap.entries()) {
+            this.#pythToEvaaDirect.set(pythId, feedInfo.evaaId);
+            this.#evaaToPythDirect.set(feedInfo.evaaId, pythId);
+        }
+
+        // 2) pythId (native) -> Set<evaaId>
+        for (const [pythId, feedInfo] of this.#parsedFeedsMap.entries()) {
+            const ref = feedInfo.referredPythFeed;
+            if (ref && ref !== 0n) {
+                if (!this.#pythToEvaaReferred.has(ref)) this.#pythToEvaaReferred.set(ref, new Set());
+                this.#pythToEvaaReferred.get(ref)!.add(feedInfo.evaaId);
+            }
+        }
+
+        // 3)  evaaId -> baseEvaaId (allowedRefTokens)
+        for (const evaaId of this.#oracleInfo.allowedRefTokens.keys()) {
+            const base = this.#oracleInfo.allowedRefTokens.get(evaaId)!;
+            this.#allowedRefEvaa.set(evaaId, base);
+
+            // If baseEvaaId have pythId. evaaId -> pyth(base)
+            const basePyth = this.#evaaToPythDirect.get(base);
+            if (basePyth) {
+                if (!this.#pythToEvaaReferred.has(basePyth)) this.#pythToEvaaReferred.set(basePyth, new Set());
+                this.#pythToEvaaReferred.get(basePyth)!.add(evaaId);
+            }
+        }
+    }
+
+    async getPricesForLiquidate(
+        realPrincipals: Dictionary<bigint, bigint>,
+        fetchConfig?: FetchConfig,
+    ): Promise<Prices> {
+        const assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        return await this.getPrices(
+            assets.map((x) => x!),
+            fetchConfig,
+        );
+    }
+
+    async getPricesForSupplyWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        supplyAsset: PoolAssetConfig | undefined,
+        withdrawAsset: PoolAssetConfig | undefined,
+        collateralToDebt: boolean,
+        fetchConfig?: FetchConfig,
+    ): Promise<Prices> {
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (
+            checkNotInDebtAtAll(realPrincipals) &&
+            withdrawAsset &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt
+        ) {
+            return new Prices(Dictionary.empty<bigint, bigint>(), 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: PoolAssetsConfig = this.#poolAssetsConfig, fetchConfig?: FetchConfig): Promise<Prices> {
+        // Declare variables at the beginning
+        let minPublishTime: bigint | undefined;
+        let maxPublishTime: bigint | undefined;
+
+        if (assets.length === 0) {
+            return new Prices(Dictionary.empty<bigint, bigint>(), Cell.EMPTY, undefined, undefined);
+        }
+
+        const requiredFeeds = this.createRequiredFeedsList(assets.map((a) => a.assetId));
+        const pythUpdates = await this.#fetchPythUpdatesWithRetry(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 > 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: ${TTL_ORACLE_DATA_SEC})`,
+                );
+            }
+
+            // Set boundaries using "from oldest" approach: minPublishTime = tmin, maxPublishTime = tmin + 180
+            minPublishTime = tmin;
+            maxPublishTime = tmin + BigInt(TTL_ORACLE_DATA_SEC);
+        }
+
+        const pricesDict = Dictionary.empty<bigint, bigint>();
+        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 = this.#pythToEvaaDirect.get(pythId);
+                if (directEvaa && requestedAssetIds.has(directEvaa)) {
+                    pricesDict.set(directEvaa, price);
+                }
+
+                // Set price for referred assets only if they are requested
+                const referredSet = this.#pythToEvaaReferred.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(TSTON_MAINNET.assetId) && pricesDict.get(TON_MAINNET.assetId)) {
+                pricesDict.set(
+                    TSTON_MAINNET.assetId,
+                    (pricesDict.get(TSTON_MAINNET.assetId)! * pricesDict.get(TON_MAINNET.assetId)!) / BigInt(10 ** 9),
+                );
+            }
+
+            // TODO: fix it
+            if (pricesDict.get(STTON_MAINNET.assetId) && pricesDict.get(TON_MAINNET.assetId)) {
+                pricesDict.set(
+                    STTON_MAINNET.assetId,
+                    (pricesDict.get(STTON_MAINNET.assetId)! * pricesDict.get(TON_MAINNET.assetId)!) / BigInt(10 ** 9),
+                );
+            }
+
+            // TODO: fix it
+            if (pricesDict.get(TSUSDE_MAINNET.assetId) && pricesDict.get(USDE_MAINNET.assetId)) {
+                pricesDict.set(
+                    TSUSDE_MAINNET.assetId,
+                    (pricesDict.get(TSUSDE_MAINNET.assetId)! * pricesDict.get(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 = packPythUpdatesData(pythUpdates.binary);
+            return new Prices(pricesDict, dataCell, minPublishTime, maxPublishTime);
+        }
+        return new Prices(Dictionary.empty<bigint, bigint>(), Cell.EMPTY, minPublishTime, maxPublishTime);
+    }
+
+    async getPricesForWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        withdrawAsset: PoolAssetConfig,
+        collateralToDebt = false,
+        fetchConfig?: FetchConfig,
+    ): Promise<Prices> {
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (
+            checkNotInDebtAtAll(realPrincipals) &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt
+        ) {
+            return new Prices(Dictionary.empty<bigint, bigint>(), 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,
+        );
+    }
+
+    /**
+     * 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 #getPythFeedsUpdates(feedIds: HexString[]): Promise<PythFeedUpdateType> {
+        const latestPriceUpdates: PriceUpdate = await Promise.any(
+            this.#pythConfig.pythEndpoints.map((x) =>
+                new HermesClient(x).getLatestPriceUpdates(feedIds, { encoding: 'hex' }),
+            ),
+        );
+
+        const parsed = latestPriceUpdates['parsed'];
+        const binary = Buffer.from(latestPriceUpdates.binary.data[0], 'hex');
+
+        return { binary, parsed };
+    }
+
+    async #fetchPythUpdatesWithRetry(
+        requiredFeeds: HexString[],
+        fetchConfig?: FetchConfig,
+    ): Promise<PythFeedUpdateType> {
+        return proxyFetchRetries(this.#getPythFeedsUpdates(requiredFeeds), fetchConfig);
+    }
+
+    public createRequiredFeedsList(evaaIds: bigint[]): HexString[] {
+        const requiredFeeds = new Set<bigint>();
+
+        for (const evaaId of evaaIds) {
+            let pythId = this.#evaaToPythDirect.get(evaaId);
+
+            // If evaaId no have native feed — try by allowedRefTokens (evAA->baseEvAA->pyth)
+            if (!pythId) {
+                const baseEvaa = this.#allowedRefEvaa.get(evaaId);
+                if (baseEvaa) pythId = this.#evaaToPythDirect.get(baseEvaa) ?? null!;
+            }
+
+            if (pythId) {
+                requiredFeeds.add(pythId);
+                const feedInfo = this.#parsedFeedsMap.get(pythId);
+                if (feedInfo?.referredPythFeed && feedInfo.referredPythFeed !== 0n) {
+                    requiredFeeds.add(feedInfo.referredPythFeed);
+                }
+            }
+        }
+
+        return Array.from(requiredFeeds).map((id) => '0x' + id.toString(16));
+    }
+
+    #filterEmptyPrincipalsAndAssets(principals: Dictionary<bigint, bigint>) {
+        return principals
+            .keys()
+            .filter((x) => principals.get(x)! != 0n)
+            .map((x) => this.#poolAssetsConfig.find((asset) => asset.assetId == x));
+    }
+}

package/src/prices/Types.ts

@@ -1,4 +1,5 @@
-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.
@@ -6,18 +7,35 @@ import { Cell, Dictionary } from '@ton/core';
 export type PriceSourcesConfig = {
     /** Endpoints for backend price data */
     backendEndpoints: string[];
-    
+
     /** 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 const DefaultPriceSourcesConfig: PriceSourcesConfig = {
     backendEndpoints: ['api.evaa.space', 'evaa.space'],
     icpEndpoints: ['6khmc-aiaaa-aaaap-ansfq-cai.raw.icp0.io'],
-}
+};
+
+/**
+ * Configuration for pyth price sources.
+ */
+export const DefaultPythPriceSourcesConfig: PythPriceSourcesConfig = {
+    // FYI: 3RPS limit per IP, TODO: support Pythnet RPC
+    pythEndpoints: ['https://hermes.pyth.network'],
+};
 
 export type RawPriceData = {
     dict: Dictionary<bigint, bigint>;
@@ -28,6 +46,10 @@ export type RawPriceData = {
     timestamp: number;
 };
 
+export type PythFeedUpdateType = {
+    parsed: PriceUpdate['parsed'];
+    binary: Buffer;
+};
 
 export type PriceData = {
     dict: Dictionary<bigint, bigint>;
@@ -35,6 +57,6 @@ export type PriceData = {
 };
 
 export type OraclePricesData = {
-    timestamp: number, 
-    prices: Dictionary<bigint, bigint>
-}
+    timestamp: number;
+    prices: Dictionary<bigint, bigint>;
+};

package/src/prices/index.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/src/prices/sources/Backend.ts

@@ -1,32 +1,34 @@
-import { beginCell, Cell, Dictionary } from "@ton/core";
-import { RawPriceData } from "..";
-import { PriceSource } from "./PriceSource";
+import { beginCell, Cell, Dictionary } from '@ton/core';
+import { RawPriceData } from '..';
+import { DefaultFetchConfig, FetchConfig, proxyFetchRetries } from '../../utils/utils';
+import { PriceSource } from './PriceSource';
 
 export class BackendPriceSource extends PriceSource {
     protected priceSourceName: string = 'BackendPriceSource';
 
-    async getPrices(): Promise<RawPriceData[]> {
-        const data = await this.loadOracleData();
-        return data.map(outputData => this.parsePrices(outputData));
+    async getPrices(fetchConfig?: FetchConfig): Promise<RawPriceData[]> {
+        const data = await this.loadOracleData(fetchConfig);
+        return data.map((outputData) => this.parsePrices(outputData));
     }
 
-    async loadOracleData(): Promise<OutputData[]> {
-        let response = await fetch(`https://${this._endpoint}/api/prices`, {
+    async loadOracleData(fetchConfig: FetchConfig = DefaultFetchConfig): Promise<OutputData[]> {
+        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 as Record<string, string>;
+            let outputData: OutputData[] = [];
 
-        const resp = (await response.json());
-        const data = resp as Record<string, string>;
-        let outputData: OutputData[] = [];
+            for (const nft of this._nfts) {
+                outputData.push({ oracleId: nft.id, data: data[nft.address] });
+            }
 
-        for (const nft of this._nfts) {
-            outputData.push({ oracleId: nft.id, data: data[nft.address] })
-        }
-    
-        return outputData;
-    }
+            return outputData;
+        });
 
+        return await proxyFetchRetries(fetchPromise, fetchConfig);
+    }
 
     parsePrices(outputData: OutputData): RawPriceData {
         try {