@evaafi/sdk 0.7.0 → 0.9.0

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,23 +1,25 @@
 /// <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/types/Master.d.ts

@@ -1,5 +1,7 @@
 /// <reference types="node" />
 import { Address, Cell, Dictionary } from '@ton/core';
+import { Oracle } from '../prices/Oracle.interface';
+export { FeedMapItem, parseFeedsMapDict } from '../api/feeds';
 export type MasterConstants = {
     FACTOR_SCALE: bigint;
     ASSET_COEFFICIENT_SCALE: bigint;
@@ -24,10 +26,9 @@ export type PoolConfig = {
     masterAddress: Address;
     masterVersion: number;
     masterConstants: MasterConstants;
-    oracles: OracleNFT[];
-    minimalOracles: number;
     poolAssetsConfig: PoolAssetsConfig;
     lendingCode: Cell;
+    oracles: Oracle;
 };
 export type UpgradeConfig = {
     masterCodeVersion: number;
@@ -40,7 +41,7 @@ export type UpgradeConfig = {
     newUserCode: Cell | null;
 };
 export type AssetConfig = {
-    oracle: bigint;
+    jwAddress: bigint;
     decimals: bigint;
     collateralFactor: bigint;
     liquidationThreshold: bigint;
@@ -59,17 +60,10 @@ export type AssetConfig = {
     minPrincipalForRewards: bigint;
     baseTrackingSupplySpeed: bigint;
     baseTrackingBorrowSpeed: bigint;
-};
-export type MasterConfig = {
-    ifActive: number;
-    admin: Address;
-    oraclesInfo: OraclesInfo;
-    tokenKeys: Cell | null;
-};
-export type OraclesInfo = {
-    numOracles: number;
-    threshold: number;
-    oracles: Cell | null;
+    borrowCap: number | bigint;
+    heCategory: number;
+    heCollateralFactor: number;
+    heLiquidationThreshold: number;
 };
 export type AssetData = {
     sRate: bigint;
@@ -93,28 +87,14 @@ export type AssetApy = {
 export type ExtendedAssetData = AssetData & AssetInterest & AssetApy;
 export type ExtendedAssetsData = Dictionary<bigint, ExtendedAssetData>;
 export type ExtendedAssetsConfig = Dictionary<bigint, AssetConfig>;
-export type MasterData = {
-    meta: string;
-    upgradeConfig: UpgradeConfig;
-    masterConfig: MasterConfig;
-    assetsConfig: ExtendedAssetsConfig;
-    assetsData: ExtendedAssetsData;
-    assetsReserves: Dictionary<bigint, bigint>;
-    apy: {
-        supply: Dictionary<bigint, number>;
-        borrow: Dictionary<bigint, number>;
-    };
-};
 export type AgregatedBalances = {
     totalBorrow: bigint;
     totalSupply: bigint;
 };
-export type OracleNFT = {
-    id: number;
+export type ExtendedEvaaOracle = EvaaOracle & {
     address: string;
-    pubkey: Buffer;
 };
-export type Oracle = {
+export type EvaaOracle = {
     id: number;
     pubkey: Buffer;
 };

package/dist/types/Master.js

@@ -1,2 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFeedsMapDict = void 0;
+var feeds_1 = require("../api/feeds");
+Object.defineProperty(exports, "parseFeedsMapDict", { enumerable: true, get: function () { return feeds_1.parseFeedsMapDict; } });

package/dist/utils/userJettonWallet.js

@@ -5,14 +5,6 @@ const core_1 = require("@ton/core");
 const assets_1 = require("../constants/assets");
 function getUserJettonData(ownerAddress, assetName, jettonWalletCode, jettonMasterAddress) {
     switch (assetName) {
-        case 'uTON':
-            return (0, core_1.beginCell)()
-                .storeCoins(0)
-                .storeUint(0, 64)
-                .storeAddress(ownerAddress)
-                .storeAddress(jettonMasterAddress)
-                .storeRef(jettonWalletCode)
-                .endCell();
         case 'DOGS':
         case 'NOT':
         case 'USDT':

package/dist/utils/utils.d.ts

@@ -1,4 +1,11 @@
-import { PoolAssetConfig } from "../types/Master";
+import { PoolAssetConfig } from '../types/Master';
 export declare function isTonAsset(asset: PoolAssetConfig): boolean;
 export declare function isTonAssetId(assetId: bigint): boolean;
 export declare function delay(ms: number): Promise<unknown>;
+export interface FetchConfig {
+    retries: number;
+    timeout: number;
+}
+export declare const DefaultFetchConfig: FetchConfig;
+export declare function proxyFetchRetries<T>(fetch: Promise<T>, config?: FetchConfig): Promise<T>;
+export declare function isValidSubaccountId(subaccountId: number): boolean;

package/dist/utils/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.delay = exports.isTonAssetId = exports.isTonAsset = void 0;
+exports.isValidSubaccountId = exports.proxyFetchRetries = exports.DefaultFetchConfig = exports.delay = exports.isTonAssetId = exports.isTonAsset = void 0;
 const assets_1 = require("../constants/assets");
 function isTonAsset(asset) {
     return asset.name === 'TON';
@@ -11,6 +11,35 @@ function isTonAssetId(assetId) {
 }
 exports.isTonAssetId = isTonAssetId;
 function delay(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 exports.delay = delay;
+exports.DefaultFetchConfig = {
+    retries: 3,
+    timeout: 1000,
+};
+async function proxyFetchRetries(fetch, config = exports.DefaultFetchConfig) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= config.retries; attempt++) {
+        try {
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('Request timeout')), config.timeout);
+            });
+            return await Promise.race([fetch, timeoutPromise]);
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < config.retries) {
+                // Exponential backoff: wait 1s, 2s, 4s, etc.
+                const delay = Math.pow(2, attempt) * 1000;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    throw new Error(`Failed to fetch after ${config.retries + 1} attempts. Last error: ${lastError instanceof Error ? lastError.message : JSON.stringify(lastError, null, 2)}`);
+}
+exports.proxyFetchRetries = proxyFetchRetries;
+function isValidSubaccountId(subaccountId) {
+    return (subaccountId << 16) >> 16 === subaccountId && subaccountId !== -0x8000;
+}
+exports.isValidSubaccountId = isValidSubaccountId;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@evaafi/sdk",
-    "version": "0.7.0",
+    "version": "0.9.0",
     "description": "The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.",
     "main": "dist/index.js",
     "files": [
@@ -19,7 +19,6 @@
     "license": "MIT",
     "homepage": "https://github.com/evaafi/sdk#readme",
     "devDependencies": {
-        "@orbs-network/ton-access": "^2.3.3",
         "@ton/core": "0.56.0",
         "@ton/crypto": "^3.3.0",
         "@tonconnect/sdk": "3.0.5",
@@ -38,6 +37,8 @@
         "crypto-js": ">=4.2.0"
     },
     "dependencies": {
+        "@pythnetwork/hermes-client": "^2.0.0",
+        "@pythnetwork/pyth-ton-js": "^0.1.2",
         "@ton/ton": "14.0.0",
         "dotenv": "16.4.5"
     },

package/src/api/feeds.ts

@@ -0,0 +1,90 @@
+import { Dictionary } from '@ton/ton';
+import { Buffer } from 'buffer';
+import { ASSET_ID } from '../constants/assets';
+
+export const PYTH_TON_PRICE_FEED_ID = '0x8963217838ab4cf5cadc172203c1f0b763fbaa45f346d8ee50ba994bbcac3026';
+export const PYTH_USDT_PRICE_FEED_ID = '0x2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b';
+export const PYTH_STTON_PRICE_FEED_ID = '0x9145e059026a4d5a46f3b96408f7e572e33b3257b9c2dbe8dba551c772762002';
+export const PYTH_TSTON_PRICE_FEED_ID = '0x3d1784128eeab5961ec60648fe497d3901eebd211b7f51e4bb0db9f024977d25';
+export const PYTH_USDC_PRICE_FEED_ID = '0xeaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a';
+export const PYTH_USDE_PRICE_FEED_ID = '0x6ec879b1e9963de5ee97e9c8710b742d6228252a5e2ca12d4ae81d7fe5ee8c5d';
+export const PYTH_TSUSDE_PRICE_FEED_ID = '0xcbe184846426619a60f51056d26efecb0537ad3a73b1e965fe695d06a257cb19';
+
+export function bigintToBuffer(value: bigint, size: number): Buffer {
+    if (value < 0n) {
+        throw new Error('Only non-negative bigint is supported');
+    }
+    // it's questionable whether it stores in LE or BE
+    // and what option will TVM use, now by default it's BE
+    const hex = value.toString(16);
+    const padded = hex.padStart(size * 2, '0');
+    return Buffer.from(padded, 'hex');
+}
+
+export const packConnectedFeeds = (evaa_id: bigint, reffered_id: bigint) => {
+    return Buffer.concat([bigintToBuffer(evaa_id, 32), bigintToBuffer(reffered_id, 32)]);
+};
+
+export const EVAA_TON_PRICE_FEED_ID = ASSET_ID.TON;
+export const EVAA_NOT_PRICE_FEED_ID = ASSET_ID.NOT;
+export const EVAA_DOGS_PRICE_FEED_ID = ASSET_ID.DOGS;
+export const EVAA_USDT_PRICE_FEED_ID = ASSET_ID.USDT;
+export const EVAA_STTON_PRICE_FEED_ID = ASSET_ID.stTON;
+export const EVAA_TSTON_PRICE_FEED_ID = ASSET_ID.tsTON;
+export const EVAA_JUSDC_PRICE_FEED_ID = ASSET_ID.jUSDC;
+export const EVAA_JUSDT_PRICE_FEED_ID = ASSET_ID.jUSDT;
+export const EVAA_USDE_PRICE_FEED_ID = ASSET_ID.USDe;
+export const EVAA_TSUSDE_PRICE_FEED_ID = ASSET_ID.tsUSDe;
+
+export const MAIN_POOL_FEEDS_MAP: Dictionary<bigint, Buffer> = (() => {
+    const map = Dictionary.empty<bigint, Buffer>();
+    map.set(BigInt(PYTH_TON_PRICE_FEED_ID), packConnectedFeeds(EVAA_TON_PRICE_FEED_ID, 0n));
+    map.set(BigInt(PYTH_USDT_PRICE_FEED_ID), packConnectedFeeds(EVAA_USDT_PRICE_FEED_ID, 0n));
+    map.set(
+        BigInt(PYTH_STTON_PRICE_FEED_ID),
+        packConnectedFeeds(EVAA_STTON_PRICE_FEED_ID, BigInt(PYTH_TON_PRICE_FEED_ID)),
+    );
+    map.set(
+        BigInt(PYTH_TSTON_PRICE_FEED_ID),
+        packConnectedFeeds(EVAA_TSTON_PRICE_FEED_ID, BigInt(PYTH_TON_PRICE_FEED_ID)),
+    );
+    map.set(BigInt(PYTH_USDC_PRICE_FEED_ID), packConnectedFeeds(EVAA_JUSDC_PRICE_FEED_ID, 0n));
+    map.set(BigInt(PYTH_USDT_PRICE_FEED_ID), packConnectedFeeds(EVAA_JUSDT_PRICE_FEED_ID, 0n));
+    map.set(BigInt(PYTH_USDE_PRICE_FEED_ID), packConnectedFeeds(EVAA_USDE_PRICE_FEED_ID, 0n));
+    map.set(BigInt(PYTH_TSUSDE_PRICE_FEED_ID), packConnectedFeeds(EVAA_TSUSDE_PRICE_FEED_ID, 0n));
+    return map;
+})();
+
+export type FeedMapItem = {
+    evaaId: bigint;
+    referredPythFeed: bigint;
+};
+
+export function parseFeedsMapDict(dict: Dictionary<bigint, Buffer>) {
+    const parsedData = new Map<bigint, FeedMapItem>();
+    for (const key of dict.keys()) {
+        const buffer = dict.get(key)!;
+
+        const hex1 = '0x' + buffer.toString('hex', 0, 32);
+        const hex2 = '0x' + buffer.toString('hex', 32);
+
+        const evaaId = BigInt(hex1);
+        const referredPythFeed = BigInt(hex2);
+
+        parsedData.set(key, { evaaId, referredPythFeed });
+    }
+
+    return parsedData;
+}
+
+export const TESTNET_ALLOWED_REF_TOKENS: Dictionary<bigint, bigint> = (() => {
+    const map = Dictionary.empty<bigint, bigint>();
+    map.set(BigInt(EVAA_JUSDT_PRICE_FEED_ID), BigInt(EVAA_USDT_PRICE_FEED_ID));
+    return map;
+})();
+
+export const TESTNET_FEEDS_MAP: Dictionary<bigint, Buffer> = (() => {
+    const map = Dictionary.empty<bigint, Buffer>();
+    map.set(BigInt(PYTH_TON_PRICE_FEED_ID), packConnectedFeeds(EVAA_TON_PRICE_FEED_ID, 0n));
+    return map;
+})();

package/src/api/liquidation.ts

@@ -174,7 +174,7 @@ export function calculateLiquidationAmounts(
 
     const _isBadDebt = isBadDebt(supplyAmount, borrowAmount, liquidationBonus, masterConstants);
     if (!_isBadDebt) {
-        allowedCollateralValue = BigMath.min(allowedCollateralValue, BigMath.max(allowedCollateralValue / 2n, collateralThreshold));
+        allowedCollateralValue = BigMath.min(allowedCollateralValue, BigMath.max(allowedCollateralValue / 3n, collateralThreshold));
     }
 
     const loanValue = toAssetWorth(loanInfo.balance, loanInfo.scale, loanInfo.price);

package/src/api/math.ts

@@ -452,7 +452,7 @@ export function calculateLiquidationData(
         const liquidationBonus = collateralAssetConfig.liquidationBonus;
         const loanScale = 10n ** loanAssetConfig.decimals;
         values.push(
-            (bigIntMax(collateralValue / 2n, bigIntMin(collateralValue, COLLATERAL_WORTH_THRESHOLD)) *
+            (bigIntMax(collateralValue / 3n, bigIntMin(collateralValue, COLLATERAL_WORTH_THRESHOLD)) *
                 loanScale *
                 poolConfig.masterConstants.ASSET_COEFFICIENT_SCALE) /
             liquidationBonus /