@evaafi/sdk 0.9.0-a → 0.9.1

package/src/oracles/collectors/PythCollector.ts

@@ -0,0 +1,358 @@
+import { HermesClient, HexString, PriceUpdate } from '@pythnetwork/hermes-client';
+import { Dictionary } from '@ton/core';
+import { checkNotInDebtAtAll } from '../../api/math';
+import { OracleConfig } from '../../api/parsers/PythOracleParser';
+import { packPythUpdatesData } from '../../api/prices';
+import { ASSET_PRICE_SCALE } from '../../constants/general';
+import { FeedMapItem, PoolAssetConfig } from '../../types/Master';
+import { FetchConfig, proxyFetchRetries } from '../../utils/utils';
+import { TTL_ORACLE_DATA_SEC } from '../constants';
+import { PythPrices } from '../prices/PythPrices';
+import { PythFeedUpdateType, PythPriceSourcesConfig } from '../Types';
+import { AbstractCollector } from './AbstractCollector';
+
+export type PythCollectorConfig = {
+    poolAssetsConfig: PoolAssetConfig[];
+    pythOracle: OracleConfig;
+    pythConfig: PythPriceSourcesConfig;
+};
+
+export class PythCollector extends AbstractCollector {
+    #parsedFeedsMap = new Map<HexString, FeedMapItem>();
+    #pythConfig: PythPriceSourcesConfig;
+    #poolAssetsConfig: PoolAssetConfig[];
+    #allowedRefTokens: Dictionary<bigint, bigint>;
+
+    #assetToFeeds = new Map<bigint, HexString[]>();
+
+    constructor(config: PythCollectorConfig) {
+        super();
+        this.#pythConfig = config.pythConfig;
+        this.#poolAssetsConfig = config.poolAssetsConfig;
+
+        this.#allowedRefTokens = config.pythOracle.allowedRefTokens;
+
+        for (const [feedId, feedMap] of config.pythOracle.feedsMap) {
+            this.#parsedFeedsMap.set(feedId, feedMap);
+        }
+
+        for (const [feedId, connectedFeed] of this.#parsedFeedsMap) {
+            this.#assetToFeeds.set(connectedFeed.assetId, [feedId, connectedFeed.feedId]);
+        }
+    }
+
+    async getPricesForLiquidate(
+        realPrincipals: Dictionary<bigint, bigint>,
+        fetchConfig?: FetchConfig,
+    ): Promise<PythPrices> {
+        const assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error('User from another pool');
+        }
+        return await this.getPrices(
+            assets.map((x) => x!),
+            fetchConfig,
+        );
+    }
+
+    async getPricesForSupplyWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        supplyAsset: PoolAssetConfig,
+        withdrawAsset: PoolAssetConfig,
+        collateralToDebt: boolean,
+        fetchConfig?: FetchConfig,
+    ): Promise<PythPrices> {
+        let assets = this.#filterEmptyPrincipalsAndAssets(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: PoolAssetConfig[] = this.#poolAssetsConfig,
+        fetchConfig?: FetchConfig,
+    ): Promise<PythPrices> {
+        // Declare variables at the beginning
+        let minPublishTime: number | undefined;
+        let maxPublishTime: number | undefined;
+
+        if (assets.length === 0) {
+            return PythPrices.createEmptyPrices();
+        }
+        const requestedFeeds = new Set<HexString>();
+        const requestedRefAssets = new Set<PoolAssetConfig>();
+
+        for (const asset of assets) {
+            if (this.#allowedRefTokens.has(asset.assetId)) {
+                const refTokenId = this.#allowedRefTokens.get(asset.assetId)!;
+
+                if (this.#assetToFeeds.has(refTokenId)) {
+                    const [feedId, refFeedId] = this.#assetToFeeds.get(refTokenId)!;
+                    requestedFeeds.add(feedId);
+
+                    if (refFeedId !== '0x0') {
+                        requestedFeeds.add(refFeedId);
+                    }
+                }
+
+                requestedRefAssets.add(asset);
+            }
+
+            if (this.#assetToFeeds.has(asset.assetId)) {
+                const [feedId, refFeedId] = this.#assetToFeeds.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 this.#fetchPythUpdatesWithRetry(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 > 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: ${TTL_ORACLE_DATA_SEC})`,
+                );
+            }
+
+            minPublishTime = tmin;
+            maxPublishTime = tmin + TTL_ORACLE_DATA_SEC;
+        }
+
+        const pricesDict = Dictionary.empty<bigint, bigint>();
+        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 = this.#parsedFeedsMap.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 (this.#allowedRefTokens.has(asset.assetId)) {
+                        const refTokenId = this.#allowedRefTokens.get(asset.assetId)!;
+                        const refFeeds = this.#assetToFeeds.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 this.#parsedFeedsMap) {
+                if (feedMapItem.feedId !== '0x0') {
+                    const assetPrice = pricesDict.get(feedMapItem.assetId);
+                    const baseFeedMapItem = this.#parsedFeedsMap.get(feedMapItem.feedId);
+                    const basePrice = baseFeedMapItem ? pricesDict.get(baseFeedMapItem.assetId) : undefined;
+
+                    if (assetPrice && basePrice) {
+                        const scaledPrice = (assetPrice * basePrice) / 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 (this.#allowedRefTokens.has(asset.assetId)) {
+                    const refTokenId = this.#allowedRefTokens.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 = packPythUpdatesData(pythUpdates.binary);
+
+            return new PythPrices({
+                dict: pricesDict,
+                dataCell,
+                minPublishTime,
+                maxPublishTime,
+                refAssets,
+                targetFeeds,
+                binaryUpdate: pythUpdates.binary,
+            });
+        }
+        return PythPrices.createEmptyPrices();
+    }
+
+    async getPricesForWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        withdrawAsset: PoolAssetConfig,
+        collateralToDebt = false,
+        fetchConfig?: FetchConfig,
+    ): Promise<PythPrices> {
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (
+            checkNotInDebtAtAll(realPrincipals) &&
+            (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n &&
+            !collateralToDebt
+        ) {
+            return 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,
+        );
+    }
+
+    /**
+     * 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 #getPythFeedsUpdates(feedIds: HexString[]): Promise<PythFeedUpdateType> {
+        const latestPriceUpdates: PriceUpdate = await Promise.any(
+            this.#pythConfig.pythEndpoints.map((x) =>
+                new HermesClient(x).getLatestPriceUpdates(feedIds, { encoding: 'hex' }),
+            ),
+        );
+
+        const parsed = latestPriceUpdates['parsed'];
+        const binary = Buffer.from(latestPriceUpdates.binary.data[0], 'hex');
+
+        return { binary, parsed };
+    }
+
+    async #fetchPythUpdatesWithRetry(
+        requiredFeeds: HexString[],
+        fetchConfig?: FetchConfig,
+    ): Promise<PythFeedUpdateType> {
+        return proxyFetchRetries(this.#getPythFeedsUpdates(requiredFeeds), 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: PoolAssetConfig[]): HexString[] {
+        const requestedFeeds = new Set<HexString>();
+
+        for (const asset of assets) {
+            const addFeedsForAsset = (assetId: bigint) => {
+                if (this.#assetToFeeds.has(assetId)) {
+                    const [feedId, refFeedId] = this.#assetToFeeds.get(assetId)!;
+                    requestedFeeds.add(feedId);
+
+                    if (refFeedId !== '0x0') {
+                        requestedFeeds.add(refFeedId);
+                    }
+                }
+            };
+
+            if (this.#allowedRefTokens.has(asset.assetId)) {
+                const refTokenId = this.#allowedRefTokens.get(asset.assetId)!;
+                addFeedsForAsset(refTokenId);
+            }
+
+            addFeedsForAsset(asset.assetId);
+        }
+
+        return Array.from(requestedFeeds);
+    }
+
+    // public createRequiredFeedsList(assets: PoolAssetConfig[]): HexString[] {
+    //     const requiredFeeds = new Set<bigint>();
+
+    //     for (const asset of assets) {
+    //         let pythId = this.#evaaToPythDirect.get(asset.assetId);
+
+    //         // If assetId no have native feed — try by allowedRefTokens (evAA->baseEvAA->pyth)
+    //         if (!pythId) {
+    //             const baseEvaa = this.#allowedRefEvaa.get(asset.assetId);
+    //             if (baseEvaa) pythId = this.#evaaToPythDirect.get(baseEvaa) ?? null!;
+    //         }
+
+    //         if (pythId) {
+    //             requiredFeeds.add(pythId);
+    //             const feedInfo = this.#parsedFeedsMap.get(pythId);
+    //             if (feedInfo?.feedId && feedInfo.feedId !== 0n) {
+    //                 requiredFeeds.add(feedInfo.feedId);
+    //             }
+    //         }
+    //     }
+
+    //     return Array.from(requiredFeeds).map((id) => '0x' + id.toString(16));
+    // }
+
+    #filterEmptyPrincipalsAndAssets(principals: Dictionary<bigint, bigint>) {
+        return principals
+            .keys()
+            .filter((x) => principals.get(x)! != 0n)
+            .map((x) => this.#poolAssetsConfig.find((asset) => asset.assetId == x));
+    }
+}

package/src/oracles/collectors/index.ts

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

package/src/{prices → oracles}/index.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/src/oracles/prices/AbstractPrices.ts

@@ -0,0 +1,59 @@
+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 abstract class AbstractPrices {
+    constructor(protected readonly parameters: PriceParameters) {}
+
+    get dict() {
+        const dict = Dictionary.empty<bigint, bigint>();
+        for (const [key, value] of this.parameters.dict) {
+            dict.set(key, value);
+        }
+        return dict;
+    }
+
+    get dataCell() {
+        return new Cell(this.parameters.dataCell);
+    }
+
+    getAssetPrice<T extends bigint | PoolAssetConfig>(asset: T): bigint | undefined {
+        const assetId = this.#extractAssetId(asset);
+        return this.parameters.dict.get(assetId);
+    }
+
+    #extractAssetId(asset: bigint | PoolAssetConfig): bigint {
+        return typeof asset === 'bigint' ? asset : asset.assetId;
+    }
+
+    get minPublishTime() {
+        return this.parameters.minPublishTime;
+    }
+
+    get maxPublishTime() {
+        return this.parameters.maxPublishTime;
+    }
+}

package/src/oracles/prices/ClassicPrices.ts

@@ -0,0 +1,52 @@
+import { Cell, Dictionary } from '@ton/core';
+import { AbstractPrices, PriceParameters } from './AbstractPrices';
+
+export enum ClassicPricesMode {
+    SPOT = 'spot',
+    TWAP = 'twap',
+}
+
+export const ClassicPricesOffset = {
+    [ClassicPricesMode.SPOT]: 1n,
+    [ClassicPricesMode.TWAP]: 0n,
+};
+
+export interface ClassicPricesParams extends PriceParameters {
+    readonly mode?: ClassicPricesMode;
+}
+
+export class ClassicPrices extends AbstractPrices {
+    constructor(private readonly params: ClassicPricesParams) {
+        super(params);
+    }
+
+    static createEmptyTwapPrices(): ClassicPrices {
+        return new ClassicPrices({
+            mode: ClassicPricesMode.TWAP,
+            dict: Dictionary.empty<bigint, bigint>(),
+            dataCell: Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+
+    static createEmptySpotPrices(): ClassicPrices {
+        return new ClassicPrices({
+            mode: ClassicPricesMode.SPOT,
+            dict: Dictionary.empty<bigint, bigint>(),
+            dataCell: Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+
+    static createEmptyPrices(): ClassicPrices {
+        return new ClassicPrices({
+            mode: undefined,
+            dict: Dictionary.empty<bigint, bigint>(),
+            dataCell: Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+}

package/src/oracles/prices/PythPrices.ts

@@ -0,0 +1,40 @@
+import { HexString } from '@pythnetwork/hermes-client';
+import { Cell, Dictionary } from '@ton/core';
+import { PoolAssetConfig } from '../../types/Master';
+import { AbstractPrices, PriceParameters } from './AbstractPrices';
+
+export interface PythPricesParams extends PriceParameters {
+    targetFeeds: HexString[];
+    refAssets: PoolAssetConfig[];
+    binaryUpdate: Buffer;
+}
+
+export class PythPrices extends AbstractPrices {
+    constructor(private readonly params: PythPricesParams) {
+        super(params);
+    }
+
+    static createEmptyPrices(): PythPrices {
+        return new PythPrices({
+            dict: Dictionary.empty<bigint, bigint>(),
+            dataCell: Cell.EMPTY,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+            targetFeeds: [],
+            refAssets: [],
+            binaryUpdate: Buffer.alloc(0),
+        });
+    }
+
+    refAssets(): PoolAssetConfig[] {
+        return this.params.refAssets;
+    }
+
+    targetFeeds(): HexString[] {
+        return this.params.targetFeeds;
+    }
+
+    binaryUpdate(): Buffer {
+        return this.params.binaryUpdate;
+    }
+}

package/src/oracles/prices/index.ts

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

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

@@ -4,10 +4,21 @@ import { EvaaOracle, ExtendedEvaaOracle } from '../types/Master';
 import { convertToMerkleProof, generateMerkleProofDirect } from '../utils/merkleProof';
 import { FetchConfig } from '../utils/utils';
 import { TTL_ORACLE_DATA_SEC } from './constants';
+import { PriceData } from './prices';
 import { BackendPriceSource } from './sources/Backend';
 import { IcpPriceSource } from './sources/Icp';
 import { PriceSource } from './sources/PriceSource';
-import { OraclePricesData, PriceData, PriceSourcesConfig, RawPriceData } from './Types';
+import { OraclePricesData, PriceSourcesConfig, RawPriceData } from './Types';
+
+export const UPDATE_PRICE_FEEDS_BASE_GAS = 300000n;
+export const UPDATE_PRICE_FEEDS_PER_UPDATE_GAS = 90000n;
+// Current settings in basechain are as follows: 1 unit of gas costs 400 nanotons
+export const GAS_PRICE_FACTOR = 400n;
+
+// TODO: use PythContract for dynamic fee calc
+export function calcPythUpdateFee(numUpdates: number) {
+    return (UPDATE_PRICE_FEEDS_BASE_GAS + UPDATE_PRICE_FEEDS_PER_UPDATE_GAS * BigInt(numUpdates)) * GAS_PRICE_FACTOR;
+}
 
 export function verifyPricesTimestamp() {
     return function (priceData: RawPriceData): boolean {

package/src/types/Master.ts

@@ -1,5 +1,5 @@
 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 = {
@@ -16,8 +16,6 @@ export type MasterConstants = {
     COLLATERAL_WORTH_THRESHOLD: bigint;
 };
 
-export type PoolAssetsConfig = PoolAssetConfig[];
-
 export type PoolAssetConfig = {
     name: string;
     assetId: bigint;
@@ -29,9 +27,9 @@ export type PoolConfig = {
     masterAddress: Address;
     masterVersion: number;
     masterConstants: MasterConstants;
-    poolAssetsConfig: PoolAssetsConfig;
+    poolAssetsConfig: PoolAssetConfig[];
     lendingCode: Cell;
-    oracles: Oracle;
+    collector: AbstractCollector;
 };
 
 export type UpgradeConfig = {
@@ -77,7 +75,7 @@ export type AssetData = {
     bRate: bigint;
     totalSupply: bigint;
     totalBorrow: bigint;
-    lastAccural: bigint;
+    lastAccrual: bigint;
     balance: bigint;
     trackingSupplyIndex: bigint;
     trackingBorrowIndex: bigint;

package/dist/prices/Oracle.interface.d.ts

@@ -1,9 +0,0 @@
-import { Dictionary } from '@ton/core';
-import { Prices } from '.';
-import { PoolAssetConfig, PoolAssetsConfig } from '../types/Master';
-import { FetchConfig } from '../utils/utils';
-export interface Oracle {
-    getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, fetchConfig?: FetchConfig): Promise<Prices>;
-    getPricesForSupplyWithdraw(realPrincipals: Dictionary<bigint, bigint>, supplyAsset: PoolAssetConfig | undefined, withdrawAsset: PoolAssetConfig | undefined, collateralToDebt: boolean, fetchConfig?: FetchConfig): Promise<Prices>;
-    getPrices(assets: PoolAssetsConfig, fetchConfig?: FetchConfig): Promise<Prices>;
-}

package/dist/prices/Oracle.interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/prices/Prices.d.ts

@@ -1,11 +0,0 @@
-import { Cell, Dictionary } from '@ton/core';
-import { PoolAssetConfig } from '../types/Master';
-export declare class Prices {
-    #private;
-    constructor(dict: Dictionary<bigint, bigint>, dataCell: Cell, minPublishTime?: bigint, maxPublishTime?: bigint);
-    get dict(): Dictionary<bigint, bigint>;
-    get dataCell(): Cell;
-    get minPublishTime(): bigint | undefined;
-    get maxPublishTime(): bigint | undefined;
-    getAssetPrice<T extends bigint | PoolAssetConfig>(asset: T): bigint | undefined;
-}

package/dist/prices/Prices.js

@@ -1,53 +0,0 @@
-"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 _Prices_instances, _Prices_dict, _Prices_dataCell, _Prices_minPublishTime, _Prices_maxPublishTime, _Prices_extractAssetId;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Prices = void 0;
-const core_1 = require("@ton/core");
-class Prices {
-    constructor(dict, dataCell, minPublishTime, maxPublishTime) {
-        _Prices_instances.add(this);
-        _Prices_dict.set(this, void 0);
-        _Prices_dataCell.set(this, void 0);
-        _Prices_minPublishTime.set(this, void 0);
-        _Prices_maxPublishTime.set(this, void 0);
-        __classPrivateFieldSet(this, _Prices_dict, dict, "f");
-        __classPrivateFieldSet(this, _Prices_dataCell, dataCell, "f");
-        __classPrivateFieldSet(this, _Prices_minPublishTime, minPublishTime, "f");
-        __classPrivateFieldSet(this, _Prices_maxPublishTime, maxPublishTime, "f");
-    }
-    get dict() {
-        const dict = core_1.Dictionary.empty();
-        for (const [key, value] of __classPrivateFieldGet(this, _Prices_dict, "f")) {
-            dict.set(key, value);
-        }
-        return dict;
-    }
-    get dataCell() {
-        return new core_1.Cell(__classPrivateFieldGet(this, _Prices_dataCell, "f"));
-    }
-    get minPublishTime() {
-        return __classPrivateFieldGet(this, _Prices_minPublishTime, "f");
-    }
-    get maxPublishTime() {
-        return __classPrivateFieldGet(this, _Prices_maxPublishTime, "f");
-    }
-    getAssetPrice(asset) {
-        const assetId = __classPrivateFieldGet(this, _Prices_instances, "m", _Prices_extractAssetId).call(this, asset);
-        return __classPrivateFieldGet(this, _Prices_dict, "f").get(assetId);
-    }
-}
-exports.Prices = Prices;
-_Prices_dict = new WeakMap(), _Prices_dataCell = new WeakMap(), _Prices_minPublishTime = new WeakMap(), _Prices_maxPublishTime = new WeakMap(), _Prices_instances = new WeakSet(), _Prices_extractAssetId = function _Prices_extractAssetId(asset) {
-    return typeof asset === 'bigint' ? asset : asset.assetId;
-};