@evaafi/sdk 0.9.0-a → 0.9.1

package/dist/oracles/collectors/ClassicCollector.js

@@ -0,0 +1,192 @@
+"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 _ClassicCollector_instances, _ClassicCollector_prices, _ClassicCollector_poolAssetsConfig, _ClassicCollector_sourcesConfig, _ClassicCollector_priceSources, _ClassicCollector_minimalOracles, _ClassicCollector_getPricesByAssetList, _ClassicCollector_collectPrices, _ClassicCollector_collectPricesWithValidation, _ClassicCollector_filterPrices, _ClassicCollector_filterEmptyPrincipalsAndAssets, _ClassicCollector_convertToTwapAssets, _ClassicCollector_convertToSpotAssets, _ClassicCollector_getPricesWithMode;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassicCollector = void 0;
+const core_1 = require("@ton/core");
+const math_1 = require("../../api/math");
+const utils_1 = require("../../utils/utils");
+const ClassicPrices_1 = require("../prices/ClassicPrices");
+const Types_1 = require("../Types");
+const utils_2 = require("../utils");
+const AbstractCollector_1 = require("./AbstractCollector");
+class ClassicCollector extends AbstractCollector_1.AbstractCollector {
+    constructor(config) {
+        super();
+        _ClassicCollector_instances.add(this);
+        _ClassicCollector_prices.set(this, void 0);
+        _ClassicCollector_poolAssetsConfig.set(this, void 0);
+        _ClassicCollector_sourcesConfig.set(this, void 0);
+        _ClassicCollector_priceSources.set(this, void 0);
+        _ClassicCollector_minimalOracles.set(this, void 0);
+        __classPrivateFieldSet(this, _ClassicCollector_poolAssetsConfig, config.poolAssetsConfig, "f");
+        __classPrivateFieldSet(this, _ClassicCollector_sourcesConfig, config.sourcesConfig ?? Types_1.DefaultPriceSourcesConfig, "f");
+        __classPrivateFieldSet(this, _ClassicCollector_priceSources, (0, utils_2.generatePriceSources)(__classPrivateFieldGet(this, _ClassicCollector_sourcesConfig, "f"), config.evaaOracles), "f");
+        __classPrivateFieldSet(this, _ClassicCollector_minimalOracles, config.minimalOracles, "f");
+        if (config.additionalPriceSources) {
+            __classPrivateFieldGet(this, _ClassicCollector_priceSources, "f").push(...config.additionalPriceSources);
+        }
+        __classPrivateFieldSet(this, _ClassicCollector_prices, [], "f");
+    }
+    async getPricesForLiquidate(realPrincipals, fetchConfig) {
+        const assets = __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        const validAssets = assets.map((x) => x);
+        const spotAssets = __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_convertToSpotAssets).call(this, validAssets);
+        return await __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_getPricesWithMode).call(this, spotAssets, ClassicPrices_1.ClassicPricesMode.SPOT, fetchConfig);
+    }
+    async getPricesForWithdraw(realPrincipals, withdrawAsset, collateralToDebt = false, fetchConfig) {
+        let assets = __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if ((0, math_1.checkNotInDebtAtAll)(realPrincipals) &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt) {
+            return ClassicPrices_1.ClassicPrices.createEmptyTwapPrices();
+        }
+        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);
+    }
+    async getPricesForSupplyWithdraw(realPrincipals, supplyAsset, withdrawAsset, collateralToDebt, fetchConfig) {
+        let assets = __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if ((0, math_1.checkNotInDebtAtAll)(realPrincipals) &&
+            withdrawAsset &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt) {
+            return ClassicPrices_1.ClassicPrices.createEmptyTwapPrices();
+        }
+        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');
+        }
+        const validAssets = assets.map((x) => x);
+        const twapAssets = __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_convertToTwapAssets).call(this, validAssets);
+        return await __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_getPricesWithMode).call(this, twapAssets, ClassicPrices_1.ClassicPricesMode.TWAP, fetchConfig);
+    }
+    async getPrices(assets = __classPrivateFieldGet(this, _ClassicCollector_poolAssetsConfig, "f"), fetchConfig) {
+        if (assets.length == 0) {
+            return ClassicPrices_1.ClassicPrices.createEmptyPrices();
+        }
+        await __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_collectPricesWithValidation).call(this, fetchConfig);
+        if (__classPrivateFieldGet(this, _ClassicCollector_prices, "f").length < __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")) {
+            throw new Error(`Error per updating prices, valid ${__classPrivateFieldGet(this, _ClassicCollector_prices, "f").length} of ${__classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")}`);
+        }
+        const prices = __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_getPricesByAssetList).call(this, assets);
+        return new ClassicPrices_1.ClassicPrices({
+            dict: prices.dict,
+            dataCell: prices.dataCell,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+}
+exports.ClassicCollector = ClassicCollector;
+_ClassicCollector_prices = new WeakMap(), _ClassicCollector_poolAssetsConfig = new WeakMap(), _ClassicCollector_sourcesConfig = new WeakMap(), _ClassicCollector_priceSources = new WeakMap(), _ClassicCollector_minimalOracles = new WeakMap(), _ClassicCollector_instances = new WeakSet(), _ClassicCollector_getPricesByAssetList = function _ClassicCollector_getPricesByAssetList(assets) {
+    let pricesFiltered = __classPrivateFieldGet(this, _ClassicCollector_prices, "f");
+    if (pricesFiltered.length < __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")) {
+        throw new Error('Not enough price data');
+    }
+    if (pricesFiltered.length > __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")) {
+        const sortedByTimestamp = pricesFiltered.slice().sort((a, b) => b.timestamp - a.timestamp);
+        const newerPrices = sortedByTimestamp.slice(0, __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f"));
+        pricesFiltered = newerPrices.sort((a, b) => a.oracleId - b.oracleId);
+    }
+    const medianData = assets.map((asset) => ({
+        assetId: asset.assetId,
+        medianPrice: (0, utils_2.getMedianPrice)(pricesFiltered, asset.assetId),
+    }));
+    const nonEmptymedianData = medianData.filter((x) => x.medianPrice != null);
+    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_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_2.packPrices)(packedMedianData, packedOracleData),
+    };
+}, _ClassicCollector_collectPrices = async function _ClassicCollector_collectPrices(fetchConfig) {
+    for (const priceSource of __classPrivateFieldGet(this, _ClassicCollector_priceSources, "f")) {
+        try {
+            __classPrivateFieldSet(this, _ClassicCollector_prices, await (0, utils_1.proxyFetchRetries)((0, utils_2.collectAndFilterPrices)(priceSource, __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f"), fetchConfig), fetchConfig), "f");
+            return true;
+        }
+        catch (error) {
+            // Try next source
+            continue;
+        }
+    }
+    return false;
+}, _ClassicCollector_collectPricesWithValidation = async function _ClassicCollector_collectPricesWithValidation(fetchConfig) {
+    if (!__classPrivateFieldGet(this, _ClassicCollector_prices, "f") || __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_filterPrices).call(this) < __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")) {
+        const success = await __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_collectPrices).call(this, fetchConfig);
+        if (!success || __classPrivateFieldGet(this, _ClassicCollector_prices, "f").length < __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")) {
+            throw new Error(`Failed to collect sufficient prices: ${__classPrivateFieldGet(this, _ClassicCollector_prices, "f")?.length || 0} of ${__classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")}`);
+        }
+    }
+}, _ClassicCollector_filterPrices = function _ClassicCollector_filterPrices() {
+    __classPrivateFieldSet(this, _ClassicCollector_prices, __classPrivateFieldGet(this, _ClassicCollector_prices, "f").filter((0, utils_2.verifyPricesTimestamp)()), "f");
+    return __classPrivateFieldGet(this, _ClassicCollector_prices, "f").length;
+}, _ClassicCollector_filterEmptyPrincipalsAndAssets = function _ClassicCollector_filterEmptyPrincipalsAndAssets(principals) {
+    return principals
+        .keys()
+        .filter((x) => principals.get(x) != 0n)
+        .map((x) => __classPrivateFieldGet(this, _ClassicCollector_poolAssetsConfig, "f").find((asset) => asset.assetId == x));
+}, _ClassicCollector_convertToTwapAssets = function _ClassicCollector_convertToTwapAssets(assets) {
+    return assets.map((asset) => ({
+        ...asset,
+        assetId: asset.assetId - ClassicPrices_1.ClassicPricesOffset[ClassicPrices_1.ClassicPricesMode.TWAP],
+    }));
+}, _ClassicCollector_convertToSpotAssets = function _ClassicCollector_convertToSpotAssets(assets) {
+    return assets.map((asset) => ({
+        ...asset,
+        assetId: asset.assetId - ClassicPrices_1.ClassicPricesOffset[ClassicPrices_1.ClassicPricesMode.SPOT],
+    }));
+}, _ClassicCollector_getPricesWithMode = async function _ClassicCollector_getPricesWithMode(assets, mode, fetchConfig) {
+    if (assets.length == 0) {
+        return ClassicPrices_1.ClassicPricesMode.TWAP
+            ? ClassicPrices_1.ClassicPrices.createEmptyTwapPrices()
+            : ClassicPrices_1.ClassicPrices.createEmptySpotPrices();
+    }
+    await __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_collectPricesWithValidation).call(this, fetchConfig);
+    if (__classPrivateFieldGet(this, _ClassicCollector_prices, "f").length < __classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")) {
+        throw new Error(`Error per updating prices, valid ${__classPrivateFieldGet(this, _ClassicCollector_prices, "f").length} of ${__classPrivateFieldGet(this, _ClassicCollector_minimalOracles, "f")}`);
+    }
+    const prices = __classPrivateFieldGet(this, _ClassicCollector_instances, "m", _ClassicCollector_getPricesByAssetList).call(this, assets);
+    return new ClassicPrices_1.ClassicPrices({
+        mode,
+        dict: prices.dict,
+        dataCell: prices.dataCell,
+        minPublishTime: undefined,
+        maxPublishTime: undefined,
+    });
+};

package/dist/oracles/collectors/PythCollector.d.ts

@@ -0,0 +1,27 @@
+import { HexString } from '@pythnetwork/hermes-client';
+import { Dictionary } from '@ton/core';
+import { OracleConfig } from '../../api/parsers/PythOracleParser';
+import { PoolAssetConfig } from '../../types/Master';
+import { FetchConfig } from '../../utils/utils';
+import { PythPrices } from '../prices/PythPrices';
+import { PythPriceSourcesConfig } from '../Types';
+import { AbstractCollector } from './AbstractCollector';
+export type PythCollectorConfig = {
+    poolAssetsConfig: PoolAssetConfig[];
+    pythOracle: OracleConfig;
+    pythConfig: PythPriceSourcesConfig;
+};
+export declare class PythCollector extends AbstractCollector {
+    #private;
+    constructor(config: PythCollectorConfig);
+    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<PythPrices>;
+    getPricesForSupplyWithdraw(realPrincipals: Dictionary<bigint, bigint>, supplyAsset: PoolAssetConfig, withdrawAsset: PoolAssetConfig, collateralToDebt: boolean, fetchConfig?: FetchConfig): Promise<PythPrices>;
+    getPrices(assets?: PoolAssetConfig[], fetchConfig?: FetchConfig): Promise<PythPrices>;
+    getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt?: boolean, fetchConfig?: FetchConfig): Promise<PythPrices>;
+    /**
+     * Creates a list of required feed IDs for the given assets
+     * @param assets - Array of pool asset configurations
+     * @returns Array of unique feed IDs required for the assets
+     */
+    createRequiredFeedsList(assets: PoolAssetConfig[]): HexString[];
+}

package/dist/oracles/collectors/PythCollector.js

@@ -0,0 +1,252 @@
+"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_parsedFeedsMap, _PythCollector_pythConfig, _PythCollector_poolAssetsConfig, _PythCollector_allowedRefTokens, _PythCollector_assetToFeeds, _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 general_1 = require("../../constants/general");
+const utils_1 = require("../../utils/utils");
+const constants_1 = require("../constants");
+const PythPrices_1 = require("../prices/PythPrices");
+const AbstractCollector_1 = require("./AbstractCollector");
+class PythCollector extends AbstractCollector_1.AbstractCollector {
+    constructor(config) {
+        super();
+        _PythCollector_instances.add(this);
+        _PythCollector_parsedFeedsMap.set(this, new Map());
+        _PythCollector_pythConfig.set(this, void 0);
+        _PythCollector_poolAssetsConfig.set(this, void 0);
+        _PythCollector_allowedRefTokens.set(this, void 0);
+        _PythCollector_assetToFeeds.set(this, new Map());
+        __classPrivateFieldSet(this, _PythCollector_pythConfig, config.pythConfig, "f");
+        __classPrivateFieldSet(this, _PythCollector_poolAssetsConfig, config.poolAssetsConfig, "f");
+        __classPrivateFieldSet(this, _PythCollector_allowedRefTokens, config.pythOracle.allowedRefTokens, "f");
+        for (const [feedId, feedMap] of config.pythOracle.feedsMap) {
+            __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").set(feedId, feedMap);
+        }
+        for (const [feedId, connectedFeed] of __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f")) {
+            __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").set(connectedFeed.assetId, [feedId, connectedFeed.feedId]);
+        }
+    }
+    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 (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        if (!assets.find((a) => a?.assetId === supplyAsset.assetId)) {
+            assets.push(supplyAsset);
+        }
+        if (!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 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 PythPrices_1.PythPrices.createEmptyPrices();
+        }
+        const requestedFeeds = new Set();
+        const requestedRefAssets = new Set();
+        for (const asset of assets) {
+            if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                if (__classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").has(refTokenId)) {
+                    const [feedId, refFeedId] = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(refTokenId);
+                    requestedFeeds.add(feedId);
+                    if (refFeedId !== '0x0') {
+                        requestedFeeds.add(refFeedId);
+                    }
+                }
+                requestedRefAssets.add(asset);
+            }
+            if (__classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").has(asset.assetId)) {
+                const [feedId, refFeedId] = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(asset.assetId);
+                requestedFeeds.add(feedId);
+                if (refFeedId !== '0x0') {
+                    requestedFeeds.add(refFeedId);
+                }
+            }
+        }
+        const targetFeeds = Array.from(requestedFeeds);
+        const refAssets = Array.from(requestedRefAssets);
+        const pythUpdates = await __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_fetchPythUpdatesWithRetry).call(this, targetFeeds, fetchConfig);
+        // Calculate min and max publish times for validation
+        if (pythUpdates.parsed && pythUpdates.parsed.length > 0) {
+            let tmin = pythUpdates.parsed[0].price.publish_time;
+            let tmax = tmin;
+            for (let i = 1; i < pythUpdates.parsed.length; i++) {
+                const publishTime = pythUpdates.parsed[i].price.publish_time;
+                if (publishTime < tmin)
+                    tmin = publishTime;
+                if (publishTime > tmax)
+                    tmax = publishTime;
+            }
+            if (tmax - tmin > constants_1.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_1.TTL_ORACLE_DATA_SEC})`);
+            }
+            minPublishTime = tmin;
+            maxPublishTime = tmin + constants_1.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 feedId = `0x${u.id}`;
+                const price = (BigInt(u.price.price) * BigInt(10 ** 9)) / BigInt(10 ** (u.price.expo * -1));
+                // Find the feed mapping for this feedId and always set the price for the mapped asset
+                const feedMapItem = __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").get(feedId);
+                if (feedMapItem) {
+                    pricesDict.set(feedMapItem.assetId, price);
+                }
+                // Handle reference tokens - check if any asset uses this feed as a reference
+                for (const asset of assets) {
+                    if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                        const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                        const refFeeds = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(refTokenId);
+                        if (refFeeds && (refFeeds[0] === feedId || refFeeds[1] === feedId)) {
+                            if (requestedAssetIds.has(asset.assetId)) {
+                                // For allowedRefTokens, both asset and reference token should have the same price
+                                // Set the same price for both the asset and its reference token
+                                pricesDict.set(asset.assetId, price);
+                                pricesDict.set(refTokenId, price);
+                            }
+                        }
+                    }
+                }
+            }
+            // Apply dynamic scaling for liquid staking tokens based on feedsMap configuration
+            // For each asset that has a feedId (not '0x0'), apply scaling: asset_price = asset_rate * base_price / ASSET_PRICE_SCALE
+            for (const [feedId, feedMapItem] of __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f")) {
+                if (feedMapItem.feedId !== '0x0') {
+                    const assetPrice = pricesDict.get(feedMapItem.assetId);
+                    const baseFeedMapItem = __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").get(feedMapItem.feedId);
+                    const basePrice = baseFeedMapItem ? pricesDict.get(baseFeedMapItem.assetId) : undefined;
+                    if (assetPrice && basePrice) {
+                        const scaledPrice = (assetPrice * basePrice) / general_1.ASSET_PRICE_SCALE;
+                        pricesDict.set(feedMapItem.assetId, scaledPrice);
+                    }
+                }
+            }
+            // Apply scaling for reference tokens (allowedRefTokens)
+            // For assets that reference other tokens, they should have the SAME price as their reference token
+            // This is different from feedsMap scaling where we multiply rates
+            for (const asset of assets) {
+                if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                    const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                    const refTokenPrice = pricesDict.get(refTokenId);
+                    if (refTokenPrice && requestedAssetIds.has(asset.assetId)) {
+                        // For allowedRefTokens, the asset price should equal the reference token price
+                        pricesDict.set(asset.assetId, refTokenPrice);
+                    }
+                }
+            }
+            // 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 PythPrices_1.PythPrices({
+                dict: pricesDict,
+                dataCell,
+                minPublishTime,
+                maxPublishTime,
+                refAssets,
+                targetFeeds,
+                binaryUpdate: pythUpdates.binary,
+            });
+        }
+        return PythPrices_1.PythPrices.createEmptyPrices();
+    }
+    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 PythPrices_1.PythPrices.createEmptyPrices();
+        }
+        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);
+    }
+    /**
+     * Creates a list of required feed IDs for the given assets
+     * @param assets - Array of pool asset configurations
+     * @returns Array of unique feed IDs required for the assets
+     */
+    createRequiredFeedsList(assets) {
+        const requestedFeeds = new Set();
+        for (const asset of assets) {
+            const addFeedsForAsset = (assetId) => {
+                if (__classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").has(assetId)) {
+                    const [feedId, refFeedId] = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(assetId);
+                    requestedFeeds.add(feedId);
+                    if (refFeedId !== '0x0') {
+                        requestedFeeds.add(refFeedId);
+                    }
+                }
+            };
+            if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                addFeedsForAsset(refTokenId);
+            }
+            addFeedsForAsset(asset.assetId);
+        }
+        return Array.from(requestedFeeds);
+    }
+}
+exports.PythCollector = PythCollector;
+_PythCollector_parsedFeedsMap = new WeakMap(), _PythCollector_pythConfig = new WeakMap(), _PythCollector_poolAssetsConfig = new WeakMap(), _PythCollector_allowedRefTokens = new WeakMap(), _PythCollector_assetToFeeds = 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/oracles/collectors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AbstractCollector';
+export * from './ClassicCollector';
+export * from './PythCollector';

package/dist/oracles/collectors/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./AbstractCollector"), exports);
+__exportStar(require("./ClassicCollector"), exports);
+__exportStar(require("./PythCollector"), exports);

package/dist/{prices → oracles}/index.d.ts

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

package/dist/{prices → oracles}/index.js

@@ -14,10 +14,9 @@ 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("./collectors"), exports);
 __exportStar(require("./constants"), exports);
-__exportStar(require("./Prices"), exports);
-__exportStar(require("./PricesCollector"), exports);
-__exportStar(require("./PythCollector"), exports);
+__exportStar(require("./prices"), exports);
 __exportStar(require("./sources"), exports);
 __exportStar(require("./Types"), exports);
 __exportStar(require("./utils"), exports);

package/dist/oracles/prices/AbstractPrices.d.ts

@@ -0,0 +1,33 @@
+import { Cell, Dictionary } from '@ton/core';
+import { PoolAssetConfig } from '../../types/Master';
+/**
+ * Basic price data structure
+ * Simplified version of RawPriceData for internal processing
+ */
+export interface PriceData {
+    /** Dictionary mapping asset IDs to their prices */
+    readonly dict: Dictionary<bigint, bigint>;
+    /** Serialized data cell containing price information uses for smartcontract */
+    readonly dataCell: Cell;
+}
+/**
+ * Configuration interface for timestamp boundaries
+ * Used to filter price data based on publish time
+ */
+export interface TimestampBoundaries {
+    /** Maximum valid time for price data in seconds */
+    readonly minPublishTime?: number;
+    /** Minimum valid time for price data in seconds */
+    readonly maxPublishTime?: number;
+}
+export type PriceParameters = PriceData & TimestampBoundaries;
+export declare abstract class AbstractPrices {
+    #private;
+    protected readonly parameters: PriceParameters;
+    constructor(parameters: PriceParameters);
+    get dict(): Dictionary<bigint, bigint>;
+    get dataCell(): Cell;
+    getAssetPrice<T extends bigint | PoolAssetConfig>(asset: T): bigint | undefined;
+    get minPublishTime(): number | undefined;
+    get maxPublishTime(): number | undefined;
+}

package/dist/oracles/prices/AbstractPrices.js

@@ -0,0 +1,40 @@
+"use strict";
+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 _AbstractPrices_instances, _AbstractPrices_extractAssetId;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractPrices = void 0;
+const core_1 = require("@ton/core");
+class AbstractPrices {
+    constructor(parameters) {
+        _AbstractPrices_instances.add(this);
+        this.parameters = parameters;
+    }
+    get dict() {
+        const dict = core_1.Dictionary.empty();
+        for (const [key, value] of this.parameters.dict) {
+            dict.set(key, value);
+        }
+        return dict;
+    }
+    get dataCell() {
+        return new core_1.Cell(this.parameters.dataCell);
+    }
+    getAssetPrice(asset) {
+        const assetId = __classPrivateFieldGet(this, _AbstractPrices_instances, "m", _AbstractPrices_extractAssetId).call(this, asset);
+        return this.parameters.dict.get(assetId);
+    }
+    get minPublishTime() {
+        return this.parameters.minPublishTime;
+    }
+    get maxPublishTime() {
+        return this.parameters.maxPublishTime;
+    }
+}
+exports.AbstractPrices = AbstractPrices;
+_AbstractPrices_instances = new WeakSet(), _AbstractPrices_extractAssetId = function _AbstractPrices_extractAssetId(asset) {
+    return typeof asset === 'bigint' ? asset : asset.assetId;
+};

package/dist/oracles/prices/ClassicPrices.d.ts

@@ -0,0 +1,19 @@
+import { AbstractPrices, PriceParameters } from './AbstractPrices';
+export declare enum ClassicPricesMode {
+    SPOT = "spot",
+    TWAP = "twap"
+}
+export declare const ClassicPricesOffset: {
+    spot: bigint;
+    twap: bigint;
+};
+export interface ClassicPricesParams extends PriceParameters {
+    readonly mode?: ClassicPricesMode;
+}
+export declare class ClassicPrices extends AbstractPrices {
+    private readonly params;
+    constructor(params: ClassicPricesParams);
+    static createEmptyTwapPrices(): ClassicPrices;
+    static createEmptySpotPrices(): ClassicPrices;
+    static createEmptyPrices(): ClassicPrices;
+}