@evaafi/sdk 0.6.4 → 0.9.0

package/dist/prices/PythCollector.js

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

package/dist/prices/Types.d.ts

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

package/dist/prices/Types.js

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

package/dist/prices/index.d.ts

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

package/dist/prices/index.js

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

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

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

package/dist/prices/sources/Backend.js

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

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

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

package/dist/prices/sources/Icp.js

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

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

@@ -1,14 +1,15 @@
 import { RawPriceData } from "..";
-import { OracleNFT } from "../../types/Master";
+import { ExtendedEvaaOracle } from "../../types/Master";
+import { FetchConfig } from "../../utils/utils";
 export declare abstract class PriceSource {
     protected priceSourceName: string;
     protected _endpoint: string;
-    protected _nfts: OracleNFT[];
-    constructor(endpoint: string, nfts: OracleNFT[]);
+    protected _nfts: ExtendedEvaaOracle[];
+    constructor(endpoint: string, nfts: ExtendedEvaaOracle[]);
     get sourceName(): string;
     get endpoint(): string;
-    get nfts(): OracleNFT[];
+    get nfts(): ExtendedEvaaOracle[];
     set endpoint(endpoint: string);
-    set nfts(nfts: OracleNFT[]);
-    abstract getPrices(): Promise<RawPriceData[]>;
+    set nfts(nfts: ExtendedEvaaOracle[]);
+    abstract getPrices(fetchConfig?: FetchConfig): Promise<RawPriceData[]>;
 }

package/dist/prices/utils.d.ts

@@ -1,24 +1,25 @@
 /// <reference types="node" />
-/// <reference types="node" />
-import { Cell, Dictionary, Slice } from "@ton/core";
-import { OraclePricesData, PriceData, PriceSource, PriceSourcesConfig, RawPriceData } from "..";
-import { Oracle, OracleNFT, PoolConfig } from "../types/Master";
+import { Cell, Dictionary, Slice } from '@ton/core';
+import { EvaaOracle, ExtendedEvaaOracle } from '../types/Master';
+import { FetchConfig } from '../utils/utils';
+import { PriceSource } from './sources/PriceSource';
+import { OraclePricesData, PriceData, PriceSourcesConfig, RawPriceData } from './Types';
 export declare function verifyPricesTimestamp(): (priceData: RawPriceData) => boolean;
-export declare function verifyPricesSign(nfts: OracleNFT[]): (priceData: RawPriceData) => boolean;
 export declare function getMedianPrice(pricesData: PriceData[], asset: bigint): bigint | null;
 export declare function packAssetsData(assetsData: {
     assetId: bigint;
     medianPrice: bigint;
 }[]): Cell;
 export declare function packPrices(assetsDataCell: Cell, oraclesDataCell: Cell): Cell;
-export declare function createOracleDataProof(oracle: Oracle, data: OraclePricesData, signature: Buffer, assets: Array<bigint>): Slice;
+export declare function createOracleDataProof(oracle: EvaaOracle, data: OraclePricesData, signature: Buffer, assets: Array<bigint>): Slice;
 export declare function packOraclesData(oraclesData: {
-    oracle: Oracle;
+    oracle: EvaaOracle;
     data: OraclePricesData;
     signature: Buffer;
 }[], assets: Array<bigint>): Cell;
 export declare function sumDicts(result: Dictionary<bigint, bigint>, addendum: Dictionary<bigint, bigint>): void;
-export declare function generatePriceSources(config?: PriceSourcesConfig, nfts?: OracleNFT[]): PriceSource[];
-export declare function collectAndFilterPrices(priceSource: PriceSource, poolConfig: PoolConfig): Promise<RawPriceData[]>;
+export declare function generatePriceSources(config: PriceSourcesConfig, nfts: ExtendedEvaaOracle[]): PriceSource[];
+export declare function collectAndFilterPrices(priceSource: PriceSource, minimalOracles: number, fetchConfig?: FetchConfig): Promise<RawPriceData[]>;
 export declare function unpackMedianPrices(pricesCell: Cell): Dictionary<bigint, bigint> | undefined;
+export declare function verifyPricesSign(nfts: ExtendedEvaaOracle[]): (priceData: RawPriceData) => boolean;
 export declare function verifyRawPriceDataSign(priceData: RawPriceData): boolean;

package/dist/prices/utils.js

@@ -1,43 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyRawPriceDataSign = exports.unpackMedianPrices = exports.collectAndFilterPrices = exports.generatePriceSources = exports.sumDicts = exports.packOraclesData = exports.createOracleDataProof = exports.packPrices = exports.packAssetsData = exports.getMedianPrice = exports.verifyPricesSign = exports.verifyPricesTimestamp = void 0;
+exports.verifyRawPriceDataSign = exports.verifyPricesSign = exports.unpackMedianPrices = exports.collectAndFilterPrices = exports.generatePriceSources = exports.sumDicts = exports.packOraclesData = exports.createOracleDataProof = exports.packPrices = exports.packAssetsData = exports.getMedianPrice = exports.verifyPricesTimestamp = void 0;
 const core_1 = require("@ton/core");
 const crypto_1 = require("@ton/crypto");
-const __1 = require("..");
 const merkleProof_1 = require("../utils/merkleProof");
+const constants_1 = require("./constants");
+const Backend_1 = require("./sources/Backend");
+const Icp_1 = require("./sources/Icp");
 function verifyPricesTimestamp() {
     return function (priceData) {
         const timestamp = Date.now() / 1000;
         const pricesTime = priceData.timestamp;
-        //console.debug('timestamp - pricesTime, pricesTime', timestamp - pricesTime, pricesTime);
-        return timestamp - pricesTime < __1.TTL_ORACLE_DATA_SEC;
+        return timestamp - pricesTime < constants_1.TTL_ORACLE_DATA_SEC;
     };
 }
 exports.verifyPricesTimestamp = verifyPricesTimestamp;
-function verifyPricesSign(nfts) {
-    return function (priceData) {
-        if (nfts.findIndex(x => x.pubkey.equals(priceData.pubkey)) == -1) {
-            //console.debug('[verifyPricesSign] nft not found');
-            return false;
-        }
-        return verifyRawPriceDataSign(priceData);
-    };
-}
-exports.verifyPricesSign = verifyPricesSign;
-/* export function verifyPricesAssets(assets: PoolAssetsConfig) {
-    return function(priceData: RawPriceData): boolean {
-        for (const asset of assets) {
-            if(!priceData.dict.has(asset.assetId)) {
-                return false;
-            }
-        }
-        return true;
-    }
-} */
 function getMedianPrice(pricesData, asset) {
     try {
-        const usingPrices = pricesData.filter(x => x.dict.has(asset));
-        const sorted = usingPrices.map(x => x.dict.get(asset)).sort((a, b) => Number(a) - Number(b));
+        const usingPrices = pricesData.filter((x) => x.dict.has(asset));
+        const sorted = usingPrices.map((x) => x.dict.get(asset)).sort((a, b) => Number(a) - Number(b));
         if (sorted.length == 0) {
             return null;
         }
@@ -56,20 +37,13 @@ function getMedianPrice(pricesData, asset) {
 exports.getMedianPrice = getMedianPrice;
 function packAssetsData(assetsData) {
     if (assetsData.length == 0) {
-        throw new Error("No assets data to pack");
+        throw new Error('No assets data to pack');
     }
-    return assetsData.reduceRight((acc, { assetId, medianPrice }) => (0, core_1.beginCell)()
-        .storeUint(assetId, 256)
-        .storeCoins(medianPrice)
-        .storeMaybeRef(acc)
-        .endCell(), null);
+    return assetsData.reduceRight((acc, { assetId, medianPrice }) => (0, core_1.beginCell)().storeUint(assetId, 256).storeCoins(medianPrice).storeMaybeRef(acc).endCell(), null);
 }
 exports.packAssetsData = packAssetsData;
 function packPrices(assetsDataCell, oraclesDataCell) {
-    let pricesCell = (0, core_1.beginCell)()
-        .storeRef(assetsDataCell)
-        .storeRef(oraclesDataCell)
-        .endCell();
+    let pricesCell = (0, core_1.beginCell)().storeRef(assetsDataCell).storeRef(oraclesDataCell).endCell();
     return pricesCell;
 }
 exports.packPrices = packPrices;
@@ -83,9 +57,11 @@ function createOracleDataProof(oracle, data, signature, assets) {
 exports.createOracleDataProof = createOracleDataProof;
 function packOraclesData(oraclesData, assets) {
     if (oraclesData.length == 0) {
-        throw new Error("no oracles data to pack");
+        throw new Error('no oracles data to pack');
     }
-    let proofs = oraclesData.sort((d1, d2) => d1.oracle.id - d2.oracle.id).map(({ oracle, data, signature }) => createOracleDataProof(oracle, data, signature, assets));
+    let proofs = oraclesData
+        .sort((d1, d2) => d1.oracle.id - d2.oracle.id)
+        .map(({ oracle, data, signature }) => createOracleDataProof(oracle, data, signature, assets));
     return proofs.reduceRight((acc, val) => (0, core_1.beginCell)().storeSlice(val).storeMaybeRef(acc).endCell(), null);
 }
 exports.packOraclesData = packOraclesData;
@@ -101,20 +77,20 @@ function sumDicts(result, addendum) {
     }
 }
 exports.sumDicts = sumDicts;
-function generatePriceSources(config = __1.DefaultPriceSourcesConfig, nfts = __1.MAINNET_POOL_CONFIG.oracles) {
-    let result = config.backendEndpoints.map(x => new __1.BackendPriceSource(x, nfts));
-    result.push(...config.icpEndpoints.map(x => new __1.IcpPriceSource(x, nfts)));
+function generatePriceSources(config, nfts) {
+    let result = config.backendEndpoints.map((x) => new Backend_1.BackendPriceSource(x, nfts));
+    result.push(...config.icpEndpoints.map((x) => new Icp_1.IcpPriceSource(x, nfts)));
     return result;
 }
 exports.generatePriceSources = generatePriceSources;
-async function collectAndFilterPrices(priceSource, poolConfig) {
-    const prices = await priceSource.getPrices();
+async function collectAndFilterPrices(priceSource, minimalOracles, fetchConfig) {
+    const prices = await priceSource.getPrices(fetchConfig);
     //console.debug('[FILTERING] before filtering prices len ', priceSource.sourceName, prices.length);
     return (async () => {
-        const acceptedPrices = prices.filter(price => verifyPricesTimestamp()(price) && verifyPricesSign(poolConfig.oracles)(price));
+        const acceptedPrices = prices.filter((price) => verifyPricesTimestamp()(price) && verifyPricesSign(priceSource.nfts)(price));
         //console.debug('[FILTERING] after filtering prices len ', priceSource.sourceName, acceptedPrices.length);
-        if (acceptedPrices.length < poolConfig.minimalOracles) {
-            throw new Error("Prices are outdated");
+        if (acceptedPrices.length < minimalOracles) {
+            throw new Error('Prices are outdated');
         }
         return acceptedPrices;
     })();
@@ -136,6 +112,16 @@ function unpackMedianPrices(pricesCell) {
     return res;
 }
 exports.unpackMedianPrices = unpackMedianPrices;
+function verifyPricesSign(nfts) {
+    return function (priceData) {
+        if (nfts.findIndex((x) => x.pubkey.equals(priceData.pubkey)) == -1) {
+            //console.debug('[verifyPricesSign] nft not found');
+            return false;
+        }
+        return verifyRawPriceDataSign(priceData);
+    };
+}
+exports.verifyPricesSign = verifyPricesSign;
 function verifyRawPriceDataSign(priceData) {
     const message = priceData.dataCell.refs[0].hash();
     const signature = priceData.signature;

package/dist/rewards/RewardMaster.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { Address, Cell, Contract, ContractProvider, Sender, StateInit } from '@ton/ton';
 import { Maybe } from '@ton/ton/dist/utils/maybe';
 import { EvaaRewardsConfig } from '../types/MasterRewards';

package/dist/rewards/RewardUser.d.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="node" />
 import { Address, Cell, Contract, ContractProvider, Sender, StateInit } from '@ton/ton';
 import { Maybe } from '@ton/ton/dist/utils/maybe';
 import { EvaaUserRewardsConfig } from '../types/UserRewards';