@evaafi/sdk 0.9.0 → 0.9.2-a

package/dist/contracts/PythMaster.d.ts

@@ -2,26 +2,29 @@
 import { HexString } from '@pythnetwork/hermes-client';
 import { Address, Cell, ContractProvider, Dictionary, Sender } from '@ton/core';
 import { PythOracleInfo } from '../api/parsers/PythOracleParser';
+import { PoolAssetConfig } from '../types/Master';
 import { AbstractEvaaMaster, BaseMasterConfig, BaseMasterData, EvaaParameters, LiquidationInnerParameters, LiquidationOperationBuilderParameters, LiquidationParameters, SupplyWithdrawParameters, WithdrawParameters } from './AbstractMaster';
 /**
  * pyth specific parameters
  */
-export type PythBaseData = {
-    priceData: Buffer | Cell;
-    targetFeeds: HexString[];
-    requestedRefTokens: bigint[];
-};
-export type ProxySpecificPythParams = {
-    pythAddress: Address;
-    minPublishTime: number | bigint;
-    maxPublishTime: number | bigint;
-};
-export type OnchainSpecificPythParams = {
-    publishGap: number | bigint;
-    maxStaleness: number | bigint;
-};
-export type JettonPythParams = PythBaseData & OnchainSpecificPythParams;
-export type TonPythParams = PythBaseData & ProxySpecificPythParams;
+export interface PythBaseData {
+    readonly priceData: Buffer | Cell;
+    readonly targetFeeds: HexString[];
+    readonly refAssets: PoolAssetConfig[];
+}
+export interface ProxySpecificPythParams {
+    readonly pythAddress: Address;
+    readonly minPublishTime: number | bigint;
+    readonly maxPublishTime: number | bigint;
+}
+export interface OnchainSpecificPythParams {
+    readonly publishGap: number | bigint;
+    readonly maxStaleness: number | bigint;
+}
+export interface JettonPythParams extends PythBaseData, OnchainSpecificPythParams {
+}
+export interface TonPythParams extends PythBaseData, ProxySpecificPythParams {
+}
 export type PythProxyParams = {
     pyth: PythBaseData & (ProxySpecificPythParams | OnchainSpecificPythParams) & {
         pythAddress: Address;
@@ -29,16 +32,16 @@ export type PythProxyParams = {
 };
 export type PythSupplyWithdrawParameters = SupplyWithdrawParameters & Partial<PythProxyParams>;
 export type PythWithdrawParameters = WithdrawParameters & {
-    pyth: TonPythParams;
+    pyth?: TonPythParams;
 };
 export type PythLiquidationOperationParameters = LiquidationOperationBuilderParameters & LiquidationInnerParameters & PythProxyParams;
 export type PythLiquidationParameters = LiquidationParameters & PythLiquidationOperationParameters;
-export type PythMasterConfig = BaseMasterConfig & {
-    oraclesInfo: PythOracleInfo;
-};
-export type PythMasterData = BaseMasterData & {
-    masterConfig: PythMasterConfig;
-};
+export interface PythMasterConfig extends BaseMasterConfig {
+    readonly oraclesInfo: PythOracleInfo;
+}
+export interface PythMasterData extends BaseMasterData {
+    readonly masterConfig: PythMasterConfig;
+}
 export declare class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
     constructor(parameters: EvaaParameters);
     protected buildPythMasterMessage(args: {
@@ -50,8 +53,21 @@ export declare class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
         maxStaleness: number | bigint;
     }, operationPayload: Cell): Cell;
     protected buildPythProxyMessage(targetAddress: Address, priceUpdateData: Cell, targetPythFeeds: Cell, minPublishTime: number | bigint, maxPublishTime: number | bigint, operationPayload: Cell): Cell;
+    /**
+     * Creates a wrapped operation payload for TON assets
+     */
+    private createWrappedOperationPayload;
+    /**
+     * Creates a jetton transfer message with pyth data
+     */
+    private createJettonPythMessage;
+    /**
+     * Creates a TON pyth proxy message
+     */
+    private createTonPythMessage;
+    protected createSupplyWithdrawMessageNoPrices(parameters: SupplyWithdrawParameters, operationPayload: Cell): Cell;
     createSupplyWithdrawMessage(parameters: PythSupplyWithdrawParameters): Cell;
-    buildRefTokensDict(requestedRefTokens: bigint[]): Dictionary<bigint, Buffer>;
+    buildRefTokensDict(refAssets: PoolAssetConfig[]): Dictionary<bigint, Buffer>;
     buildGeneralDataPayload(parameters: PythSupplyWithdrawParameters): Cell;
     sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, parameters: PythWithdrawParameters): Promise<void>;
     protected buildLiquidationOperationPayload(parameters: PythLiquidationOperationParameters): Cell;

package/dist/contracts/PythMaster.js

@@ -36,73 +36,74 @@ class EvaaMasterPyth extends AbstractMaster_1.AbstractEvaaMaster {
             .storeRef(operationPayload)
             .endCell();
     }
-    // TODO: support without OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES
-    createSupplyWithdrawMessage(parameters) {
-        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+    /**
+     * Creates a wrapped operation payload for TON assets
+     */
+    createWrappedOperationPayload(opCode, queryID, operationPayload) {
+        return (0, core_1.beginCell)().storeUint(opCode, 32).storeUint(queryID, 64).storeRef(operationPayload).endCell();
+    }
+    /**
+     * Creates a jetton transfer message with pyth data
+     */
+    createJettonPythMessage(parameters, operationPayload, pythParams, opCode) {
+        const { priceData, targetFeeds, publishGap, maxStaleness } = pythParams;
+        const masterMessage = this.buildPythMasterMessage({
+            queryId: parameters.queryID,
+            opCode,
+            updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
+            targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
+            publishGap,
+            maxStaleness,
+        }, operationPayload);
+        return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW, masterMessage);
+    }
+    /**
+     * Creates a TON pyth proxy message
+     */
+    createTonPythMessage(parameters, operationPayload, pythParams, opCode) {
+        const { priceData, targetFeeds, minPublishTime, maxPublishTime } = pythParams;
+        const wrappedOperationPayload = this.createWrappedOperationPayload(opCode, parameters.queryID, operationPayload);
+        return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.composeFeedsCell)(targetFeeds), minPublishTime, maxPublishTime, wrappedOperationPayload);
+    }
+    createSupplyWithdrawMessageNoPrices(parameters, operationPayload) {
+        const messageBody = (0, core_1.beginCell)()
+            .storeUint(general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES, 32)
+            .storeSlice(operationPayload.beginParse())
+            .endCell();
         if (!(0, utils_1.isTonAsset)(parameters.supplyAsset)) {
-            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth;
-            const masterMessage = this.buildPythMasterMessage({
-                queryId: parameters.queryID,
-                opCode: general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON,
-                updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
-                targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
-                publishGap,
-                maxStaleness,
-            }, operationPayload);
-            return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW, masterMessage);
+            return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW + general_1.FEES.JETTON_FWD, messageBody);
         }
         else {
-            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth;
-            const wrappedOperationPayload = (0, core_1.beginCell)()
-                .storeUint(general_1.OPCODES.SUPPLY_WITHDRAW_MASTER, 32)
+            return (0, core_1.beginCell)()
+                .storeUint(general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES, 32)
                 .storeUint(parameters.queryID, 64)
-                .storeRef(operationPayload)
+                .storeSlice(operationPayload.beginParse())
                 .endCell();
-            return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.composeFeedsCell)(targetFeeds), minPublishTime, maxPublishTime, wrappedOperationPayload);
         }
     }
-    // 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) {
+    createSupplyWithdrawMessage(parameters) {
+        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+        // Handle case without pyth data
+        if (!parameters.pyth) {
+            return this.createSupplyWithdrawMessageNoPrices(parameters, operationPayload);
+        }
+        if (!(0, utils_1.isTonAsset)(parameters.supplyAsset)) {
+            return this.createJettonPythMessage(parameters, // as JettonParams & { queryID: number | bigint },
+            operationPayload, parameters.pyth, general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON);
+        }
+        else {
+            return this.createTonPythMessage(parameters, operationPayload, parameters.pyth, general_1.OPCODES.SUPPLY_WITHDRAW_MASTER);
+        }
+    }
+    buildRefTokensDict(refAssets) {
         const refsDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), core_1.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) {
-        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.requestedRefTokens ?? []);
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.refAssets ?? []);
         return (0, core_1.beginCell)()
             .storeInt(parameters.includeUserCode ? -1 : 0, 2)
             .storeDict(refTokensDict, core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Buffer(0))
@@ -132,7 +133,7 @@ class EvaaMasterPyth extends AbstractMaster_1.AbstractEvaaMaster {
         });
         await via.send({
             value,
-            to: parameters.pyth.pythAddress,
+            to: parameters.pyth?.pythAddress ?? this.address,
             sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
             body: message,
         });
@@ -140,32 +141,16 @@ class EvaaMasterPyth extends AbstractMaster_1.AbstractEvaaMaster {
     buildLiquidationOperationPayload(parameters) {
         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) {
-        const isTon = (0, utils_1.isTonAsset)(parameters.asset);
         const operationPayload = this.buildLiquidationOperationPayload(parameters);
-        if (!isTon) {
-            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth;
-            const masterMessage = this.buildPythMasterMessage({
-                queryId: parameters.queryID,
-                opCode: general_1.OPCODES.LIQUIDATE_MASTER,
-                updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
-                targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
-                publishGap,
-                maxStaleness,
-            }, operationPayload);
-            return this.createJettonTransferMessage(parameters, general_1.FEES.LIQUIDATION_JETTON_FWD, masterMessage);
+        if (!(0, utils_1.isTonAsset)(parameters.asset)) {
+            return this.createJettonPythMessage(parameters, operationPayload, parameters.pyth, general_1.OPCODES.LIQUIDATE_MASTER);
         }
         else {
-            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth;
-            const wrappedOperationPayload = (0, core_1.beginCell)()
-                .storeUint(general_1.OPCODES.LIQUIDATE_MASTER, 32)
-                .storeUint(parameters.queryID, 64)
-                .storeRef(operationPayload)
-                .endCell();
-            return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.composeFeedsCell)(targetFeeds), minPublishTime, maxPublishTime, wrappedOperationPayload);
+            return this.createTonPythMessage(parameters, operationPayload, parameters.pyth, general_1.OPCODES.LIQUIDATE_MASTER);
         }
     }
     async sendLiquidation(provider, via, value, parameters) {

package/dist/contracts/PythOracle.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Address, Cell, Contract, ContractProvider } from '@ton/core';
+export declare class PythOracle implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): PythOracle;
+    getUpdateFee(provider: ContractProvider, vm: Buffer): Promise<bigint>;
+}

package/dist/contracts/PythOracle.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythOracle = void 0;
+const pyth_ton_js_1 = require("@pythnetwork/pyth-ton-js");
+class PythOracle {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new this(address);
+    }
+    async getUpdateFee(provider, vm) {
+        const result = await provider.get('get_update_fee', [{ type: 'slice', cell: (0, pyth_ton_js_1.createCellChain)(vm) }]);
+        const numUpdates = result.stack.readNumber();
+        return (0, pyth_ton_js_1.calculateUpdatePriceFeedsFee)(BigInt(numUpdates)) + BigInt(numUpdates);
+    }
+}
+exports.PythOracle = PythOracle;

package/dist/contracts/index.d.ts

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

package/dist/contracts/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./ClassicMaster"), exports);
 __exportStar(require("./PythMaster"), exports);
 __exportStar(require("./UserContract"), exports);
 __exportStar(require("./JettonWallet"), exports);
+__exportStar(require("./PythOracle"), exports);

package/dist/index.d.ts

@@ -17,7 +17,7 @@ export * from './types/User';
 export * from './constants/general';
 export * from './constants/pools';
 export * from './constants/assets';
-export * from './prices';
+export * from './oracles';
 export * from './utils/utils';
 export { getLastSentBoc, getTonConnectSender } from './utils/tonConnectSender';
 export { getUserJettonWallet } from './utils/userJettonWallet';

package/dist/index.js

@@ -46,7 +46,7 @@ __exportStar(require("./types/User"), exports);
 __exportStar(require("./constants/general"), exports);
 __exportStar(require("./constants/pools"), exports);
 __exportStar(require("./constants/assets"), exports);
-__exportStar(require("./prices"), exports);
+__exportStar(require("./oracles"), exports);
 __exportStar(require("./utils/utils"), exports);
 // Utils
 var tonConnectSender_1 = require("./utils/tonConnectSender");

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

@@ -37,10 +37,6 @@ export type PythFeedUpdateType = {
     parsed: PriceUpdate['parsed'];
     binary: Buffer;
 };
-export type PriceData = {
-    dict: Dictionary<bigint, bigint>;
-    dataCell: Cell;
-};
 export type OraclePricesData = {
     timestamp: number;
     prices: Dictionary<bigint, bigint>;

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

@@ -0,0 +1,10 @@
+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 declare 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/dist/oracles/collectors/AbstractCollector.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractCollector = void 0;
+class AbstractCollector {
+}
+exports.AbstractCollector = AbstractCollector;

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

@@ -0,0 +1,22 @@
+import { Dictionary } from '@ton/core';
+import { ExtendedEvaaOracle, PoolAssetConfig } from '../../types/Master';
+import { FetchConfig } from '../../utils/utils';
+import { ClassicPrices } from '../prices/ClassicPrices';
+import { PriceSource } from '../sources';
+import { PriceSourcesConfig } from '../Types';
+import { AbstractCollector } from './AbstractCollector';
+export type ClassicCollectorConfig = {
+    poolAssetsConfig: PoolAssetConfig[];
+    minimalOracles: number;
+    evaaOracles: ExtendedEvaaOracle[];
+    sourcesConfig?: PriceSourcesConfig;
+    additionalPriceSources?: PriceSource[];
+};
+export declare class ClassicCollector extends AbstractCollector {
+    #private;
+    constructor(config: ClassicCollectorConfig);
+    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+    getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt?: boolean, fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+    getPricesForSupplyWithdraw(realPrincipals: Dictionary<bigint, bigint>, supplyAsset: PoolAssetConfig | undefined, withdrawAsset: PoolAssetConfig | undefined, collateralToDebt: boolean, fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+    getPrices(assets?: PoolAssetConfig[], fetchConfig?: FetchConfig): Promise<ClassicPrices>;
+}

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[];
+}