@evaafi/sdk 0.9.0 → 0.9.2

package/dist/oracles/collectors/PythCollector.js

@@ -0,0 +1,252 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PythCollector_instances, _PythCollector_parsedFeedsMap, _PythCollector_pythConfig, _PythCollector_poolAssetsConfig, _PythCollector_allowedRefTokens, _PythCollector_assetToFeeds, _PythCollector_getPythFeedsUpdates, _PythCollector_fetchPythUpdatesWithRetry, _PythCollector_filterEmptyPrincipalsAndAssets;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythCollector = void 0;
+const hermes_client_1 = require("@pythnetwork/hermes-client");
+const core_1 = require("@ton/core");
+const math_1 = require("../../api/math");
+const prices_1 = require("../../api/prices");
+const general_1 = require("../../constants/general");
+const utils_1 = require("../../utils/utils");
+const constants_1 = require("../constants");
+const PythPrices_1 = require("../prices/PythPrices");
+const AbstractCollector_1 = require("./AbstractCollector");
+class PythCollector extends AbstractCollector_1.AbstractCollector {
+    constructor(config) {
+        super();
+        _PythCollector_instances.add(this);
+        _PythCollector_parsedFeedsMap.set(this, new Map());
+        _PythCollector_pythConfig.set(this, void 0);
+        _PythCollector_poolAssetsConfig.set(this, void 0);
+        _PythCollector_allowedRefTokens.set(this, void 0);
+        _PythCollector_assetToFeeds.set(this, new Map());
+        __classPrivateFieldSet(this, _PythCollector_pythConfig, config.pythConfig, "f");
+        __classPrivateFieldSet(this, _PythCollector_poolAssetsConfig, config.poolAssetsConfig, "f");
+        __classPrivateFieldSet(this, _PythCollector_allowedRefTokens, config.pythOracle.allowedRefTokens, "f");
+        for (const [feedId, feedMap] of config.pythOracle.feedsMap) {
+            __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").set(feedId, feedMap);
+        }
+        for (const [feedId, connectedFeed] of __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f")) {
+            __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").set(connectedFeed.assetId, [feedId, connectedFeed.feedId]);
+        }
+    }
+    async getPricesForLiquidate(realPrincipals, fetchConfig) {
+        const assets = __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        return await this.getPrices(assets.map((x) => x), fetchConfig);
+    }
+    async getPricesForSupplyWithdraw(realPrincipals, supplyAsset, withdrawAsset, collateralToDebt, fetchConfig) {
+        let assets = __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        if (!assets.find((a) => a?.assetId === supplyAsset.assetId)) {
+            assets.push(supplyAsset);
+        }
+        if (!assets.find((a) => a?.assetId === withdrawAsset.assetId)) {
+            assets.push(withdrawAsset);
+        }
+        if (collateralToDebt && assets.length == 1) {
+            throw new Error('Cannot debt only one supplied asset');
+        }
+        return this.getPrices(assets.map((x) => x), fetchConfig);
+    }
+    async getPrices(assets = __classPrivateFieldGet(this, _PythCollector_poolAssetsConfig, "f"), fetchConfig) {
+        // Declare variables at the beginning
+        let minPublishTime;
+        let maxPublishTime;
+        if (assets.length === 0) {
+            return PythPrices_1.PythPrices.createEmptyPrices();
+        }
+        const requestedFeeds = new Set();
+        const requestedRefAssets = new Set();
+        for (const asset of assets) {
+            if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                if (__classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").has(refTokenId)) {
+                    const [feedId, refFeedId] = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(refTokenId);
+                    requestedFeeds.add(feedId);
+                    if (refFeedId !== '0x0') {
+                        requestedFeeds.add(refFeedId);
+                    }
+                }
+                requestedRefAssets.add(asset);
+            }
+            if (__classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").has(asset.assetId)) {
+                const [feedId, refFeedId] = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(asset.assetId);
+                requestedFeeds.add(feedId);
+                if (refFeedId !== '0x0') {
+                    requestedFeeds.add(refFeedId);
+                }
+            }
+        }
+        const targetFeeds = Array.from(requestedFeeds);
+        const refAssets = Array.from(requestedRefAssets);
+        const pythUpdates = await __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_fetchPythUpdatesWithRetry).call(this, targetFeeds, fetchConfig);
+        // Calculate min and max publish times for validation
+        if (pythUpdates.parsed && pythUpdates.parsed.length > 0) {
+            let tmin = pythUpdates.parsed[0].price.publish_time;
+            let tmax = tmin;
+            for (let i = 1; i < pythUpdates.parsed.length; i++) {
+                const publishTime = pythUpdates.parsed[i].price.publish_time;
+                if (publishTime < tmin)
+                    tmin = publishTime;
+                if (publishTime > tmax)
+                    tmax = publishTime;
+            }
+            if (tmax - tmin > constants_1.TTL_ORACLE_DATA_SEC) {
+                throw new Error(`Price feeds don't fit in a single 3-minute window. Time span: ${tmax - tmin} seconds (max allowed: ${constants_1.TTL_ORACLE_DATA_SEC})`);
+            }
+            minPublishTime = tmin;
+            maxPublishTime = tmin + constants_1.TTL_ORACLE_DATA_SEC;
+        }
+        const pricesDict = core_1.Dictionary.empty();
+        const pythPriceUpdates = pythUpdates.parsed;
+        if (pythPriceUpdates) {
+            // Only set prices for requested assets, not all possible mapped assets
+            const requestedAssetIds = new Set(assets.map((a) => a.assetId));
+            for (const u of pythPriceUpdates) {
+                const feedId = `0x${u.id}`;
+                const price = (BigInt(u.price.price) * BigInt(10 ** 9)) / BigInt(10 ** (u.price.expo * -1));
+                // Find the feed mapping for this feedId and always set the price for the mapped asset
+                const feedMapItem = __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").get(feedId);
+                if (feedMapItem) {
+                    pricesDict.set(feedMapItem.assetId, price);
+                }
+                // Handle reference tokens - check if any asset uses this feed as a reference
+                for (const asset of assets) {
+                    if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                        const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                        const refFeeds = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(refTokenId);
+                        if (refFeeds && (refFeeds[0] === feedId || refFeeds[1] === feedId)) {
+                            if (requestedAssetIds.has(asset.assetId)) {
+                                // For allowedRefTokens, both asset and reference token should have the same price
+                                // Set the same price for both the asset and its reference token
+                                pricesDict.set(asset.assetId, price);
+                                pricesDict.set(refTokenId, price);
+                            }
+                        }
+                    }
+                }
+            }
+            // Apply dynamic scaling for liquid staking tokens based on feedsMap configuration
+            // For each asset that has a feedId (not '0x0'), apply scaling: asset_price = asset_rate * base_price / ASSET_PRICE_SCALE
+            for (const [feedId, feedMapItem] of __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f")) {
+                if (feedMapItem.feedId !== '0x0') {
+                    const assetPrice = pricesDict.get(feedMapItem.assetId);
+                    const baseFeedMapItem = __classPrivateFieldGet(this, _PythCollector_parsedFeedsMap, "f").get(feedMapItem.feedId);
+                    const basePrice = baseFeedMapItem ? pricesDict.get(baseFeedMapItem.assetId) : undefined;
+                    if (assetPrice && basePrice) {
+                        const scaledPrice = (assetPrice * basePrice) / general_1.ASSET_PRICE_SCALE;
+                        pricesDict.set(feedMapItem.assetId, scaledPrice);
+                    }
+                }
+            }
+            // Apply scaling for reference tokens (allowedRefTokens)
+            // For assets that reference other tokens, they should have the SAME price as their reference token
+            // This is different from feedsMap scaling where we multiply rates
+            for (const asset of assets) {
+                if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                    const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                    const refTokenPrice = pricesDict.get(refTokenId);
+                    if (refTokenPrice && requestedAssetIds.has(asset.assetId)) {
+                        // For allowedRefTokens, the asset price should equal the reference token price
+                        pricesDict.set(asset.assetId, refTokenPrice);
+                    }
+                }
+            }
+            // Check that all requested assets have prices
+            const missing = assets.map((a) => a.assetId).filter((id) => pricesDict.get(id) === undefined);
+            if (missing.length) {
+                throw new Error(`Missing prices for ${missing.length} asset(s): ${missing.map((x) => x.toString()).join(', ')}`);
+            }
+            const dataCell = (0, prices_1.packPythUpdatesData)(pythUpdates.binary);
+            return new PythPrices_1.PythPrices({
+                dict: pricesDict,
+                dataCell,
+                minPublishTime,
+                maxPublishTime,
+                refAssets,
+                targetFeeds,
+                binaryUpdate: pythUpdates.binary,
+            });
+        }
+        return PythPrices_1.PythPrices.createEmptyPrices();
+    }
+    async getPricesForWithdraw(realPrincipals, withdrawAsset, collateralToDebt = false, fetchConfig) {
+        let assets = __classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_filterEmptyPrincipalsAndAssets).call(this, realPrincipals);
+        if ((0, math_1.checkNotInDebtAtAll)(realPrincipals) &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt) {
+            return PythPrices_1.PythPrices.createEmptyPrices();
+        }
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        if (!assets.includes(withdrawAsset)) {
+            assets.push(withdrawAsset);
+        }
+        if (collateralToDebt && assets.length == 1) {
+            throw new Error('Cannot debt only one supplied asset');
+        }
+        return await this.getPrices(assets.map((x) => x), fetchConfig);
+    }
+    /**
+     * Creates a list of required feed IDs for the given assets
+     * @param assets - Array of pool asset configurations
+     * @returns Array of unique feed IDs required for the assets
+     */
+    createRequiredFeedsList(assets) {
+        const requestedFeeds = new Set();
+        for (const asset of assets) {
+            const addFeedsForAsset = (assetId) => {
+                if (__classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").has(assetId)) {
+                    const [feedId, refFeedId] = __classPrivateFieldGet(this, _PythCollector_assetToFeeds, "f").get(assetId);
+                    requestedFeeds.add(feedId);
+                    if (refFeedId !== '0x0') {
+                        requestedFeeds.add(refFeedId);
+                    }
+                }
+            };
+            if (__classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").has(asset.assetId)) {
+                const refTokenId = __classPrivateFieldGet(this, _PythCollector_allowedRefTokens, "f").get(asset.assetId);
+                addFeedsForAsset(refTokenId);
+            }
+            addFeedsForAsset(asset.assetId);
+        }
+        return Array.from(requestedFeeds);
+    }
+}
+exports.PythCollector = PythCollector;
+_PythCollector_parsedFeedsMap = new WeakMap(), _PythCollector_pythConfig = new WeakMap(), _PythCollector_poolAssetsConfig = new WeakMap(), _PythCollector_allowedRefTokens = new WeakMap(), _PythCollector_assetToFeeds = new WeakMap(), _PythCollector_instances = new WeakSet(), _PythCollector_getPythFeedsUpdates = 
+/**
+ * Updates feeds data from specified endpoint
+ * @param feedIds list of pyth feed ids to fetch
+ * @returns binary - buffer of feeds update, parsed - json feeds data
+ */
+async function _PythCollector_getPythFeedsUpdates(feedIds) {
+    const latestPriceUpdates = await Promise.any(__classPrivateFieldGet(this, _PythCollector_pythConfig, "f").pythEndpoints.map((x) => new hermes_client_1.HermesClient(x).getLatestPriceUpdates(feedIds, { encoding: 'hex' })));
+    const parsed = latestPriceUpdates['parsed'];
+    const binary = Buffer.from(latestPriceUpdates.binary.data[0], 'hex');
+    return { binary, parsed };
+}, _PythCollector_fetchPythUpdatesWithRetry = async function _PythCollector_fetchPythUpdatesWithRetry(requiredFeeds, fetchConfig) {
+    return (0, utils_1.proxyFetchRetries)(__classPrivateFieldGet(this, _PythCollector_instances, "m", _PythCollector_getPythFeedsUpdates).call(this, requiredFeeds), fetchConfig);
+}, _PythCollector_filterEmptyPrincipalsAndAssets = function _PythCollector_filterEmptyPrincipalsAndAssets(principals) {
+    return principals
+        .keys()
+        .filter((x) => principals.get(x) != 0n)
+        .map((x) => __classPrivateFieldGet(this, _PythCollector_poolAssetsConfig, "f").find((asset) => asset.assetId == x));
+};

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

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

package/dist/oracles/collectors/index.js

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

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

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

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

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

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

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

package/dist/oracles/prices/AbstractPrices.js

@@ -0,0 +1,40 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AbstractPrices_instances, _AbstractPrices_extractAssetId;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractPrices = void 0;
+const core_1 = require("@ton/core");
+class AbstractPrices {
+    constructor(parameters) {
+        _AbstractPrices_instances.add(this);
+        this.parameters = parameters;
+    }
+    get dict() {
+        const dict = core_1.Dictionary.empty();
+        for (const [key, value] of this.parameters.dict) {
+            dict.set(key, value);
+        }
+        return dict;
+    }
+    get dataCell() {
+        return new core_1.Cell(this.parameters.dataCell);
+    }
+    getAssetPrice(asset) {
+        const assetId = __classPrivateFieldGet(this, _AbstractPrices_instances, "m", _AbstractPrices_extractAssetId).call(this, asset);
+        return this.parameters.dict.get(assetId);
+    }
+    get minPublishTime() {
+        return this.parameters.minPublishTime;
+    }
+    get maxPublishTime() {
+        return this.parameters.maxPublishTime;
+    }
+}
+exports.AbstractPrices = AbstractPrices;
+_AbstractPrices_instances = new WeakSet(), _AbstractPrices_extractAssetId = function _AbstractPrices_extractAssetId(asset) {
+    return typeof asset === 'bigint' ? asset : asset.assetId;
+};

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

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

package/dist/oracles/prices/ClassicPrices.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassicPrices = exports.ClassicPricesOffset = exports.ClassicPricesMode = void 0;
+const core_1 = require("@ton/core");
+const AbstractPrices_1 = require("./AbstractPrices");
+var ClassicPricesMode;
+(function (ClassicPricesMode) {
+    ClassicPricesMode["SPOT"] = "spot";
+    ClassicPricesMode["TWAP"] = "twap";
+})(ClassicPricesMode || (exports.ClassicPricesMode = ClassicPricesMode = {}));
+exports.ClassicPricesOffset = {
+    [ClassicPricesMode.SPOT]: 1n,
+    [ClassicPricesMode.TWAP]: 0n,
+};
+class ClassicPrices extends AbstractPrices_1.AbstractPrices {
+    constructor(params) {
+        super(params);
+        this.params = params;
+    }
+    static createEmptyTwapPrices() {
+        return new ClassicPrices({
+            mode: ClassicPricesMode.TWAP,
+            dict: core_1.Dictionary.empty(),
+            dataCell: core_1.Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+    static createEmptySpotPrices() {
+        return new ClassicPrices({
+            mode: ClassicPricesMode.SPOT,
+            dict: core_1.Dictionary.empty(),
+            dataCell: core_1.Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+    static createEmptyPrices() {
+        return new ClassicPrices({
+            mode: undefined,
+            dict: core_1.Dictionary.empty(),
+            dataCell: core_1.Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+}
+exports.ClassicPrices = ClassicPrices;

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { HexString } from '@pythnetwork/hermes-client';
+import { PoolAssetConfig } from '../../types/Master';
+import { AbstractPrices, PriceParameters } from './AbstractPrices';
+export interface PythPricesParams extends PriceParameters {
+    targetFeeds: HexString[];
+    refAssets: PoolAssetConfig[];
+    binaryUpdate: Buffer;
+}
+export declare class PythPrices extends AbstractPrices {
+    private readonly params;
+    constructor(params: PythPricesParams);
+    static createEmptyPrices(): PythPrices;
+    refAssets(): PoolAssetConfig[];
+    targetFeeds(): HexString[];
+    binaryUpdate(): Buffer;
+}

package/dist/oracles/prices/PythPrices.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythPrices = void 0;
+const core_1 = require("@ton/core");
+const AbstractPrices_1 = require("./AbstractPrices");
+class PythPrices extends AbstractPrices_1.AbstractPrices {
+    constructor(params) {
+        super(params);
+        this.params = params;
+    }
+    static createEmptyPrices() {
+        return new PythPrices({
+            dict: core_1.Dictionary.empty(),
+            dataCell: core_1.Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+            targetFeeds: [],
+            refAssets: [],
+            binaryUpdate: Buffer.alloc(0),
+        });
+    }
+    refAssets() {
+        return this.params.refAssets;
+    }
+    targetFeeds() {
+        return this.params.targetFeeds;
+    }
+    binaryUpdate() {
+        return this.params.binaryUpdate;
+    }
+}
+exports.PythPrices = PythPrices;

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

@@ -0,0 +1,3 @@
+export * from './AbstractPrices';
+export * from './ClassicPrices';
+export * from './PythPrices';

package/dist/oracles/prices/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AbstractPrices"), exports);
+__exportStar(require("./ClassicPrices"), exports);
+__exportStar(require("./PythPrices"), exports);

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

@@ -1,9 +1,15 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Cell, Dictionary, Slice } from '@ton/core';
 import { EvaaOracle, ExtendedEvaaOracle } from '../types/Master';
 import { FetchConfig } from '../utils/utils';
+import { PriceData } from './prices';
 import { PriceSource } from './sources/PriceSource';
-import { OraclePricesData, PriceData, PriceSourcesConfig, RawPriceData } from './Types';
+import { OraclePricesData, PriceSourcesConfig, RawPriceData } from './Types';
+export declare const UPDATE_PRICE_FEEDS_BASE_GAS = 300000n;
+export declare const UPDATE_PRICE_FEEDS_PER_UPDATE_GAS = 90000n;
+export declare const GAS_PRICE_FACTOR = 400n;
+export declare function calcPythUpdateFee(numUpdates: number): bigint;
 export declare function verifyPricesTimestamp(): (priceData: RawPriceData) => boolean;
 export declare function getMedianPrice(pricesData: PriceData[], asset: bigint): bigint | null;
 export declare function packAssetsData(assetsData: {

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

@@ -1,12 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.verifyRawPriceDataSign = exports.verifyPricesSign = exports.unpackMedianPrices = exports.collectAndFilterPrices = exports.generatePriceSources = exports.sumDicts = exports.packOraclesData = exports.createOracleDataProof = exports.packPrices = exports.packAssetsData = exports.getMedianPrice = exports.verifyPricesTimestamp = exports.calcPythUpdateFee = exports.GAS_PRICE_FACTOR = exports.UPDATE_PRICE_FEEDS_PER_UPDATE_GAS = exports.UPDATE_PRICE_FEEDS_BASE_GAS = void 0;
 const core_1 = require("@ton/core");
 const crypto_1 = require("@ton/crypto");
 const merkleProof_1 = require("../utils/merkleProof");
 const constants_1 = require("./constants");
 const Backend_1 = require("./sources/Backend");
 const Icp_1 = require("./sources/Icp");
+exports.UPDATE_PRICE_FEEDS_BASE_GAS = 300000n;
+exports.UPDATE_PRICE_FEEDS_PER_UPDATE_GAS = 90000n;
+// Current settings in basechain are as follows: 1 unit of gas costs 400 nanotons
+exports.GAS_PRICE_FACTOR = 400n;
+// TODO: use PythContract for dynamic fee calc
+function calcPythUpdateFee(numUpdates) {
+    return (exports.UPDATE_PRICE_FEEDS_BASE_GAS + exports.UPDATE_PRICE_FEEDS_PER_UPDATE_GAS * BigInt(numUpdates)) * exports.GAS_PRICE_FACTOR;
+}
+exports.calcPythUpdateFee = calcPythUpdateFee;
 function verifyPricesTimestamp() {
     return function (priceData) {
         const timestamp = Date.now() / 1000;

package/dist/rewards/RewardMaster.d.ts

@@ -1,4 +1,5 @@
 /// <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,4 +1,5 @@
 /// <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';

package/dist/types/Master.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Address, Cell, Dictionary } from '@ton/core';
-import { Oracle } from '../prices/Oracle.interface';
+import { AbstractCollector } from '../oracles';
 export { FeedMapItem, parseFeedsMapDict } from '../api/feeds';
 export type MasterConstants = {
     FACTOR_SCALE: bigint;
@@ -15,7 +16,6 @@ export type MasterConstants = {
     ASSET_BRATE_SCALE: bigint;
     COLLATERAL_WORTH_THRESHOLD: bigint;
 };
-export type PoolAssetsConfig = PoolAssetConfig[];
 export type PoolAssetConfig = {
     name: string;
     assetId: bigint;
@@ -26,9 +26,9 @@ export type PoolConfig = {
     masterAddress: Address;
     masterVersion: number;
     masterConstants: MasterConstants;
-    poolAssetsConfig: PoolAssetsConfig;
+    poolAssetsConfig: PoolAssetConfig[];
     lendingCode: Cell;
-    oracles: Oracle;
+    collector: AbstractCollector;
 };
 export type UpgradeConfig = {
     masterCodeVersion: number;
@@ -70,7 +70,7 @@ export type AssetData = {
     bRate: bigint;
     totalSupply: bigint;
     totalBorrow: bigint;
-    lastAccural: bigint;
+    lastAccrual: bigint;
     balance: bigint;
     trackingSupplyIndex: bigint;
     trackingBorrowIndex: bigint;

package/dist/types/MasterRewards.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Address, Cell } from '@ton/ton';
 import { PoolAssetConfig } from './Master';
 export type EvaaRewardsConfig = {

package/dist/types/UserRewards.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Address, Cell } from '@ton/ton';
 import { PoolAssetConfig } from './Master';
 export type EvaaUserRewardsConfig = {

package/dist/utils/fivaUtils.d.ts

@@ -0,0 +1,2 @@
+import { Address } from "@ton/core";
+export declare function calculateCloseAddress(address: Address, closeToAddress: Address): Address;