@evaafi/sdk 0.9.0 → 0.9.2-a

package/src/contracts/PythMaster.ts

@@ -4,12 +4,14 @@ import { PythOracleInfo, PythOracleParser } from '../api/parsers/PythOracleParse
 import { composeFeedsCell, packPythUpdatesData } from '../api/prices';
 import { TON_MAINNET } from '../constants';
 import { FEES, OPCODES } from '../constants/general';
+import { PoolAssetConfig } from '../types/Master';
 import { isTonAsset } from '../utils/utils';
 import {
     AbstractEvaaMaster,
     BaseMasterConfig,
     BaseMasterData,
     EvaaParameters,
+    JettonParams,
     LiquidationInnerParameters,
     LiquidationOperationBuilderParameters,
     LiquidationParameters,
@@ -20,26 +22,26 @@ import {
 /**
  * pyth specific parameters
  */
-export type PythBaseData = {
-    priceData: Buffer | Cell;
-    targetFeeds: HexString[];
-    requestedRefTokens: bigint[];
-};
+export interface PythBaseData {
+    readonly priceData: Buffer | Cell;
+    readonly targetFeeds: HexString[];
+    readonly refAssets: PoolAssetConfig[];
+}
 
-export type ProxySpecificPythParams = {
-    pythAddress: Address;
-    minPublishTime: number | bigint;
-    maxPublishTime: number | bigint;
-};
+export interface ProxySpecificPythParams {
+    readonly pythAddress: Address;
+    readonly minPublishTime: number | bigint;
+    readonly maxPublishTime: number | bigint;
+}
 
-export type OnchainSpecificPythParams = {
-    publishGap: number | bigint;
-    maxStaleness: number | bigint;
-};
+export interface OnchainSpecificPythParams {
+    readonly publishGap: number | bigint;
+    readonly maxStaleness: number | bigint;
+}
 
-export type JettonPythParams = PythBaseData & OnchainSpecificPythParams;
+export interface JettonPythParams extends PythBaseData, OnchainSpecificPythParams {}
 
-export type TonPythParams = PythBaseData & ProxySpecificPythParams;
+export interface TonPythParams extends PythBaseData, ProxySpecificPythParams {}
 
 export type PythProxyParams = {
     pyth: PythBaseData & (ProxySpecificPythParams | OnchainSpecificPythParams) & { pythAddress: Address };
@@ -48,7 +50,7 @@ export type PythProxyParams = {
 export type PythSupplyWithdrawParameters = SupplyWithdrawParameters & Partial<PythProxyParams>;
 
 export type PythWithdrawParameters = WithdrawParameters & {
-    pyth: TonPythParams;
+    pyth?: TonPythParams;
 };
 
 export type PythLiquidationOperationParameters = LiquidationOperationBuilderParameters &
@@ -58,14 +60,14 @@ export type PythLiquidationOperationParameters = LiquidationOperationBuilderPara
 export type PythLiquidationParameters = LiquidationParameters & PythLiquidationOperationParameters;
 
 // Specific master configurations
-export type PythMasterConfig = BaseMasterConfig & {
-    oraclesInfo: PythOracleInfo;
-};
+export interface PythMasterConfig extends BaseMasterConfig {
+    readonly oraclesInfo: PythOracleInfo;
+}
 
 // Specific master data types
-export type PythMasterData = BaseMasterData & {
-    masterConfig: PythMasterConfig;
-};
+export interface PythMasterData extends BaseMasterData {
+    readonly masterConfig: PythMasterConfig;
+}
 
 export class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
     constructor(parameters: EvaaParameters) {
@@ -117,94 +119,120 @@ export class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
             .endCell();
     }
 
-    // TODO: support without OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES
+    /**
+     * Creates a wrapped operation payload for TON assets
+     */
+    private createWrappedOperationPayload(opCode: number, queryID: number | bigint, operationPayload: Cell): Cell {
+        return beginCell().storeUint(opCode, 32).storeUint(queryID, 64).storeRef(operationPayload).endCell();
+    }
+
+    /**
+     * Creates a jetton transfer message with pyth data
+     */
+    private createJettonPythMessage(
+        parameters: JettonParams & { queryID: number | bigint },
+        operationPayload: Cell,
+        pythParams: JettonPythParams,
+        opCode: number,
+    ): Cell {
+        const { priceData, targetFeeds, publishGap, maxStaleness } = pythParams;
+        const masterMessage = this.buildPythMasterMessage(
+            {
+                queryId: parameters.queryID,
+                opCode,
+                updateDataCell: packPythUpdatesData(priceData),
+                targetFeedsCell: composeFeedsCell(targetFeeds),
+                publishGap,
+                maxStaleness,
+            },
+            operationPayload,
+        );
+
+        return this.createJettonTransferMessage(parameters, FEES.SUPPLY_WITHDRAW, masterMessage);
+    }
+
+    /**
+     * Creates a TON pyth proxy message
+     */
+    private createTonPythMessage(
+        parameters: { queryID: number | bigint },
+        operationPayload: Cell,
+        pythParams: TonPythParams,
+        opCode: number,
+    ): Cell {
+        const { priceData, targetFeeds, minPublishTime, maxPublishTime } = pythParams;
+        const wrappedOperationPayload = this.createWrappedOperationPayload(
+            opCode,
+            parameters.queryID,
+            operationPayload,
+        );
+
+        return this.buildPythProxyMessage(
+            this.address,
+            packPythUpdatesData(priceData),
+            composeFeedsCell(targetFeeds),
+            minPublishTime,
+            maxPublishTime,
+            wrappedOperationPayload,
+        );
+    }
+
+    protected createSupplyWithdrawMessageNoPrices(parameters: SupplyWithdrawParameters, operationPayload: Cell): Cell {
+        const messageBody = beginCell()
+            .storeUint(OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES, 32)
+            .storeSlice(operationPayload.beginParse())
+            .endCell();
+
+        if (!isTonAsset(parameters.supplyAsset)) {
+            return this.createJettonTransferMessage(parameters, FEES.SUPPLY_WITHDRAW + FEES.JETTON_FWD, messageBody);
+        } else {
+            return beginCell()
+                .storeUint(OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeSlice(operationPayload.beginParse())
+                .endCell();
+        }
+    }
+
     createSupplyWithdrawMessage(parameters: PythSupplyWithdrawParameters): Cell {
         const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
 
+        // Handle case without pyth data
+        if (!parameters.pyth) {
+            return this.createSupplyWithdrawMessageNoPrices(parameters, operationPayload);
+        }
+
         if (!isTonAsset(parameters.supplyAsset)) {
-            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth as JettonPythParams;
-            const masterMessage = this.buildPythMasterMessage(
-                {
-                    queryId: parameters.queryID,
-                    opCode: OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON,
-                    updateDataCell: packPythUpdatesData(priceData),
-                    targetFeedsCell: composeFeedsCell(targetFeeds),
-                    publishGap,
-                    maxStaleness,
-                },
+            return this.createJettonPythMessage(
+                parameters, // as JettonParams & { queryID: number | bigint },
                 operationPayload,
+                parameters.pyth as JettonPythParams,
+                OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON,
             );
-
-            return this.createJettonTransferMessage(parameters, FEES.SUPPLY_WITHDRAW, masterMessage);
         } else {
-            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth as TonPythParams;
-            const wrappedOperationPayload = beginCell()
-                .storeUint(OPCODES.SUPPLY_WITHDRAW_MASTER, 32)
-                .storeUint(parameters.queryID, 64)
-                .storeRef(operationPayload)
-                .endCell();
-            return this.buildPythProxyMessage(
-                this.address,
-                packPythUpdatesData(priceData),
-                composeFeedsCell(targetFeeds),
-                minPublishTime,
-                maxPublishTime,
-                wrappedOperationPayload,
+            return this.createTonPythMessage(
+                parameters,
+                operationPayload,
+                parameters.pyth as TonPythParams,
+                OPCODES.SUPPLY_WITHDRAW_MASTER,
             );
         }
     }
 
-    // private createPythWithdrawMessage(parameters: PythWithdrawParameters): Cell {
-    //     const extraTail =
-    //         (parameters.subaccountId ?? 0) == 0
-    //             ? beginCell().endCell()
-    //             : beginCell()
-    //                   .storeInt(parameters.subaccountId ?? 0, 16)
-    //                   .storeUint(0, 2)
-    //                   .endCell();
-
-    //     const wrappedOperationPayload = beginCell()
-    //         .storeUint(OPCODES.SUPPLY_WITHDRAW_MASTER, 32) // op_code: 0x4
-    //         .storeUint(parameters.queryID, 64)
-    //         .storeRef(
-    //             beginCell()
-    //                 .storeUint(parameters.asset.assetId, 256)
-    //                 .storeUint(parameters.amount, 64)
-    //                 .storeAddress(parameters.userAddress)
-    //                 .storeInt(parameters.includeUserCode ? -1 : 0, 2)
-    //                 .storeUint(parameters.amountToTransfer, 64)
-    //                 .storeRef(parameters.payload)
-    //                 .storeSlice(extraTail.beginParse())
-    //                 .endCell(),
-    //         )
-    //         .endCell();
-
-    //     const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth as TonPythParams;
-
-    //     return makePythProxyMessage(
-    //         this.address,
-    //         packPythUpdatesData(priceData),
-    //         composeFeedsCell(targetFeeds),
-    //         minPublishTime,
-    //         maxPublishTime,
-    //         wrappedOperationPayload,
-    //     );
-    // }
-
-    buildRefTokensDict(requestedRefTokens: bigint[]): Dictionary<bigint, Buffer> {
+    buildRefTokensDict(refAssets: PoolAssetConfig[]): Dictionary<bigint, Buffer> {
         const refsDict: Dictionary<bigint, Buffer> = Dictionary.empty(
             Dictionary.Keys.BigUint(256),
             Dictionary.Values.Buffer(0),
         );
-        for (const refToken of requestedRefTokens) {
-            refsDict.set(refToken, Buffer.alloc(0));
+        for (const refAsset of refAssets) {
+            refsDict.set(refAsset.assetId, Buffer.alloc(0));
         }
 
         return refsDict;
     }
 
     buildGeneralDataPayload(parameters: PythSupplyWithdrawParameters): Cell {
-        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.requestedRefTokens ?? []);
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.refAssets ?? []);
         return beginCell()
             .storeInt(parameters.includeUserCode ? -1 : 0, 2)
             .storeDict(refTokensDict, Dictionary.Keys.BigUint(256), Dictionary.Values.Buffer(0))
@@ -240,7 +268,7 @@ export class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
         });
         await via.send({
             value,
-            to: parameters.pyth.pythAddress,
+            to: parameters.pyth?.pythAddress ?? this.address,
             sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
             body: message,
         });
@@ -250,48 +278,27 @@ export class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
         const operationPayloadBuilder = this.buildLiquidationOperationPayloadBuilder(parameters);
         const innerBuilder = this.buildLiquidationInnerBuilder(parameters);
 
-        const refTokensDict = this.buildRefTokensDict(parameters.pyth.requestedRefTokens);
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth.refAssets);
 
         return operationPayloadBuilder.storeDict(refTokensDict).storeRef(innerBuilder).endCell();
     }
 
     createLiquidationMessage(parameters: PythLiquidationParameters): Cell {
-        const isTon = isTonAsset(parameters.asset);
-
         const operationPayload = this.buildLiquidationOperationPayload(parameters);
 
-        if (!isTon) {
-            const { priceData, targetFeeds, publishGap, maxStaleness } =
-                parameters.pyth as OnchainSpecificPythParams & { priceData: Buffer | Cell; targetFeeds: HexString[] };
-            const masterMessage = this.buildPythMasterMessage(
-                {
-                    queryId: parameters.queryID,
-                    opCode: OPCODES.LIQUIDATE_MASTER,
-                    updateDataCell: packPythUpdatesData(priceData as Buffer | Cell),
-                    targetFeedsCell: composeFeedsCell(targetFeeds),
-                    publishGap,
-                    maxStaleness,
-                },
+        if (!isTonAsset(parameters.asset)) {
+            return this.createJettonPythMessage(
+                parameters,
                 operationPayload,
+                parameters.pyth as JettonPythParams,
+                OPCODES.LIQUIDATE_MASTER,
             );
-            return this.createJettonTransferMessage(parameters, FEES.LIQUIDATION_JETTON_FWD, masterMessage);
         } else {
-            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth as TonPythParams & {
-                priceData: Buffer | Cell;
-                targetFeeds: HexString[];
-            };
-            const wrappedOperationPayload = beginCell()
-                .storeUint(OPCODES.LIQUIDATE_MASTER, 32)
-                .storeUint(parameters.queryID, 64)
-                .storeRef(operationPayload)
-                .endCell();
-            return this.buildPythProxyMessage(
-                this.address,
-                packPythUpdatesData(priceData as Buffer | Cell),
-                composeFeedsCell(targetFeeds),
-                minPublishTime,
-                maxPublishTime,
-                wrappedOperationPayload,
+            return this.createTonPythMessage(
+                parameters,
+                operationPayload,
+                parameters.pyth as TonPythParams,
+                OPCODES.LIQUIDATE_MASTER,
             );
         }
     }

package/src/contracts/PythOracle.ts

@@ -0,0 +1,20 @@
+import { calculateUpdatePriceFeedsFee, createCellChain } from '@pythnetwork/pyth-ton-js';
+import { Address, Cell, Contract, ContractProvider } from '@ton/core';
+
+export class PythOracle implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: { code: Cell; data: Cell },
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new this(address);
+    }
+
+    async getUpdateFee(provider: ContractProvider, vm: Buffer) {
+        const result = await provider.get('get_update_fee', [{ type: 'slice', cell: createCellChain(vm) }]);
+        const numUpdates = result.stack.readNumber();
+
+        return calculateUpdatePriceFeedsFee(BigInt(numUpdates)) + BigInt(numUpdates);
+    }
+}

package/src/contracts/index.ts

@@ -5,3 +5,5 @@ export * from './PythMaster';
 export * from './UserContract';
 
 export * from './JettonWallet';
+
+export * from './PythOracle';

package/src/index.ts

@@ -37,7 +37,7 @@ export * from './constants/general';
 export * from './constants/pools';
 
 export * from './constants/assets';
-export * from './prices';
+export * from './oracles';
 export * from './utils/utils';
 
 // Utils

package/src/{prices → oracles}/Types.ts

@@ -51,11 +51,6 @@ export type PythFeedUpdateType = {
     binary: Buffer;
 };
 
-export type PriceData = {
-    dict: Dictionary<bigint, bigint>;
-    dataCell: Cell;
-};
-
 export type OraclePricesData = {
     timestamp: number;
     prices: Dictionary<bigint, bigint>;

package/src/oracles/collectors/AbstractCollector.ts

@@ -0,0 +1,22 @@
+import { Dictionary } from '@ton/core';
+import { PoolAssetConfig } from '../../types/Master';
+import { FetchConfig } from '../../utils/utils';
+import { ClassicPrices } from '../prices/ClassicPrices';
+import { PythPrices } from '../prices/PythPrices';
+
+export abstract class AbstractCollector {
+    abstract getPricesForLiquidate(
+        realPrincipals: Dictionary<bigint, bigint>,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices | PythPrices>;
+
+    abstract getPricesForSupplyWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        supplyAsset: PoolAssetConfig | undefined,
+        withdrawAsset: PoolAssetConfig | undefined,
+        collateralToDebt: boolean,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices | PythPrices>;
+
+    abstract getPrices(assets: PoolAssetConfig[], fetchConfig?: FetchConfig): Promise<ClassicPrices | PythPrices>;
+}

package/src/oracles/collectors/ClassicCollector.ts

@@ -0,0 +1,263 @@
+import { Dictionary } from '@ton/core';
+import { checkNotInDebtAtAll } from '../../api/math';
+import { ExtendedEvaaOracle, PoolAssetConfig } from '../../types/Master';
+import { FetchConfig, proxyFetchRetries } from '../../utils/utils';
+import { ClassicPrices, ClassicPricesMode, ClassicPricesOffset } from '../prices/ClassicPrices';
+import { PriceSource } from '../sources';
+import { DefaultPriceSourcesConfig, PriceSourcesConfig, RawPriceData } from '../Types';
+import {
+    collectAndFilterPrices,
+    generatePriceSources,
+    getMedianPrice,
+    packAssetsData,
+    packOraclesData,
+    packPrices,
+    verifyPricesTimestamp,
+} from '../utils';
+import { AbstractCollector } from './AbstractCollector';
+
+export type ClassicCollectorConfig = {
+    poolAssetsConfig: PoolAssetConfig[];
+    minimalOracles: number;
+    evaaOracles: ExtendedEvaaOracle[];
+    sourcesConfig?: PriceSourcesConfig;
+    additionalPriceSources?: PriceSource[];
+};
+
+export class ClassicCollector extends AbstractCollector {
+    #prices: RawPriceData[];
+    #poolAssetsConfig: PoolAssetConfig[];
+    #sourcesConfig: PriceSourcesConfig;
+    #priceSources: PriceSource[];
+    #minimalOracles: number;
+
+    constructor(config: ClassicCollectorConfig) {
+        super();
+
+        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 = [];
+    }
+
+    async getPricesForLiquidate(
+        realPrincipals: Dictionary<bigint, bigint>,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        const assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+
+        const validAssets = assets.map((x) => x!);
+        const spotAssets = this.#convertToSpotAssets(validAssets);
+
+        return await this.#getPricesWithMode(spotAssets, ClassicPricesMode.SPOT, fetchConfig);
+    }
+
+    async getPricesForWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        withdrawAsset: PoolAssetConfig,
+        collateralToDebt = false,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (
+            checkNotInDebtAtAll(realPrincipals) &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt
+        ) {
+            return 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: Dictionary<bigint, bigint>,
+        supplyAsset: PoolAssetConfig | undefined,
+        withdrawAsset: PoolAssetConfig | undefined,
+        collateralToDebt: boolean,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (
+            checkNotInDebtAtAll(realPrincipals) &&
+            withdrawAsset &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt
+        ) {
+            return 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 = this.#convertToTwapAssets(validAssets);
+
+        return await this.#getPricesWithMode(twapAssets, ClassicPricesMode.TWAP, fetchConfig);
+    }
+
+    async getPrices(
+        assets: PoolAssetConfig[] = this.#poolAssetsConfig,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        if (assets.length == 0) {
+            return ClassicPrices.createEmptyPrices();
+        }
+
+        await this.#collectPricesWithValidation(fetchConfig);
+
+        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 ClassicPrices({
+            dict: prices.dict,
+            dataCell: prices.dataCell,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+
+    #getPricesByAssetList(assets: PoolAssetConfig[]) {
+        let pricesFiltered = this.#prices;
+        if (pricesFiltered.length < this.#minimalOracles) {
+            throw new Error('Not enough price data');
+        }
+        if (pricesFiltered.length > this.#minimalOracles) {
+            const sortedByTimestamp = pricesFiltered.slice().sort((a, b) => b.timestamp - a.timestamp);
+            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(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;
+            }
+        }
+
+        return false;
+    }
+
+    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.#poolAssetsConfig.find((asset) => asset.assetId == x));
+    }
+
+    #convertToTwapAssets(assets: PoolAssetConfig[]): PoolAssetConfig[] {
+        return assets.map((asset) => ({
+            ...asset,
+            assetId: asset.assetId - ClassicPricesOffset[ClassicPricesMode.TWAP],
+        }));
+    }
+
+    #convertToSpotAssets(assets: PoolAssetConfig[]): PoolAssetConfig[] {
+        return assets.map((asset) => ({
+            ...asset,
+            assetId: asset.assetId - ClassicPricesOffset[ClassicPricesMode.SPOT],
+        }));
+    }
+
+    async #getPricesWithMode(
+        assets: PoolAssetConfig[],
+        mode: ClassicPricesMode,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        if (assets.length == 0) {
+            return ClassicPricesMode.TWAP
+                ? ClassicPrices.createEmptyTwapPrices()
+                : ClassicPrices.createEmptySpotPrices();
+        }
+
+        await this.#collectPricesWithValidation(fetchConfig);
+
+        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 ClassicPrices({
+            mode,
+            dict: prices.dict,
+            dataCell: prices.dataCell,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+}