@evaafi/sdk 0.9.5 → 0.9.6

package/src/api/parser.ts

@@ -19,8 +19,11 @@ import {
     calculateLiquidationData,
     calculateMaximumWithdrawAmount,
     calculatePresentValue,
+    determineHeCategory,
+    exceedsStandardBorrowLimit,
     getAssetLiquidityMinusReserves,
     getAvailableToBorrow,
+    getAvailableToBorrowWithEMode,
     presentValue,
 } from './math';
 import { OracleParser } from './parsers/AbstractOracleParser';
@@ -130,8 +133,8 @@ export function createAssetConfig(): DictionaryValue<AssetConfig> {
             const baseTrackingBorrowSpeed = ref.loadUintBig(64);
             const borrowCap = ref.loadInt(64);
             const heCategory = ref.loadUint(8);
-            const heCollateralFactor = ref.loadUint(16);
-            const heLiquidationThreshold = ref.loadUint(16);
+            const heCollateralFactor = ref.loadUintBig(16);
+            const heLiquidationThreshold = ref.loadUintBig(16);
 
             return {
                 jwAddress,
@@ -242,8 +245,8 @@ export function parseUserLiteData(
     const userSlice = Cell.fromBase64(userDataBOC).beginParse();
 
     const codeVersion = userSlice.loadCoins();
-    const masterAddress = userSlice.loadAddress();
-    const userAddress = userSlice.loadAddress();
+    const masterAddress = userSlice.loadAddressAny();
+    const userAddress = userSlice.loadAddressAny();
     const realPrincipals = userSlice.loadDict(Dictionary.Keys.BigUint(256), Dictionary.Values.BigInt(64));
     const principalsDict = Dictionary.empty(Dictionary.Keys.BigUint(256), Dictionary.Values.BigInt(64));
     const userState = userSlice.loadInt(64);
@@ -256,18 +259,26 @@ export function parseUserLiteData(
     let backupCell1: Cell | null = null;
     let backupCell2: Cell | null = null;
     const bitsLeft = userSlice.remainingBits;
-    if (bitsLeft > 32) {
+    const refsLeft = userSlice.remainingRefs;
+    if (bitsLeft === 0 && refsLeft === 0) {
+        // Init format: no extra data after state
+    } else if (bitsLeft >= 64 + 64 + 32 && refsLeft >= 1) {
+        // Old format with tracking indexes
         trackingSupplyIndex = userSlice.loadUintBig(64);
         trackingBorrowIndex = userSlice.loadUintBig(64);
         dutchAuctionStart = userSlice.loadUint(32);
         backupCell = loadMyRef(userSlice);
-    } else {
+    } else if (bitsLeft >= 3 && refsLeft >= 1) {
+        // New format with rewards dict + maybe_refs
         rewards = userSlice.loadDict(Dictionary.Keys.BigUint(256), createUserRewards());
-        backupCell1 = userSlice.loadMaybeRef();
-        backupCell2 = userSlice.loadMaybeRef();
+        if (userSlice.remainingBits >= 2) {
+            backupCell1 = userSlice.loadMaybeRef();
+            backupCell2 = userSlice.loadMaybeRef();
+        }
     }
 
-    userSlice.endParse();
+    // Skip remaining data if any (for forward compatibility)
+    // userSlice.endParse();
     const userBalances = Dictionary.empty<bigint, UserBalance>();
 
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
@@ -327,6 +338,7 @@ export function parseUserData(
 
     const withdrawalLimits = Dictionary.empty<bigint, bigint>();
     const borrowLimits = Dictionary.empty<bigint, bigint>();
+    const borrowLimitsWithEmode = Dictionary.empty<bigint, bigint>();
 
     let supplyBalance = 0n;
     let borrowBalance = 0n;
@@ -379,6 +391,19 @@ export function parseUserData(
         prices,
         masterConstants,
     );
+    const { availableToBorrow: availableToBorrowWithEmode, heCategory: predictedHeCategory } =
+        getAvailableToBorrowWithEMode(
+            assetsConfig,
+            assetsData,
+            userLiteData.realPrincipals,
+            prices,
+            masterConstants,
+            poolConfig,
+        );
+    let activeHeCategory = determineHeCategory(assetsConfig, userLiteData.realPrincipals, poolConfig);
+    if (activeHeCategory > 0 && !exceedsStandardBorrowLimit(userLiteData.realPrincipals, assetsConfig, assetsData, prices, masterConstants)) {
+        activeHeCategory = -1;
+    }
 
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
@@ -396,7 +421,7 @@ export function parseUserData(
                         assetsData,
                         userLiteData.realPrincipals,
                         prices,
-                        masterConstants,
+                        poolConfig,
                         asset.assetId,
                     ),
                     assetData.balance,
@@ -406,6 +431,7 @@ export function parseUserData(
 
         if (!prices.has(asset.assetId)) {
             borrowLimits.set(asset.assetId, 0n);
+            borrowLimitsWithEmode.set(asset.assetId, 0n);
             continue;
         }
 
@@ -419,13 +445,27 @@ export function parseUserData(
                 ),
             ),
         );
+
+        borrowLimitsWithEmode.set(
+            asset.assetId,
+            bigIntMax(
+                0n,
+                bigIntMin(
+                    (availableToBorrowWithEmode * 10n ** assetConfig.decimals) / prices.get(asset.assetId)!,
+                    assetLiquidityMinusReserves,
+                ),
+            ),
+        );
     }
 
-    const limitUsed = borrowBalance + availableToBorrow;
+    const limitUsed = borrowBalance + availableToBorrowWithEmode;
     const limitUsedPercent =
         limitUsed === 0n
             ? 0
-            : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
+            : Number(
+                  BigInt(1e9) -
+                      (availableToBorrowWithEmode * BigInt(1e9)) / (borrowBalance + availableToBorrowWithEmode),
+              ) / 1e7;
 
     let healthFactor = 1;
     let liquidationData;
@@ -441,17 +481,22 @@ export function parseUserData(
             healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
         }
     }
+
     return {
         ...userLiteData,
         withdrawalLimits: withdrawalLimits,
         borrowLimits: borrowLimits,
+        borrowLimitsWithEmode: borrowLimitsWithEmode,
         supplyBalance: supplyBalance,
         borrowBalance: borrowBalance,
         availableToBorrow: availableToBorrow,
+        availableToBorrowWithEmode: availableToBorrowWithEmode,
+        predictedHeCategory: predictedHeCategory,
         limitUsedPercent: limitUsedPercent,
         limitUsed: limitUsed,
         liquidationData: liquidationData,
         healthFactor: healthFactor,
         havePrincipalWithoutPrice: havePrincipalWithoutPrice,
+        activeHeCategory: activeHeCategory,
     };
 }

package/src/constants/assets/assetId.ts

@@ -30,6 +30,10 @@ export const ASSET_ID = {
     PT_tsUSDe_01Sep2025: sha256Hash('PT_tsUSDe_01Sep2025'),
     PT_tsUSDe_18Dec2025: sha256Hash('PT_tsUSDe_18Dec2025'),
 
+    // Mainnet test assets
+    TUSDT: sha256Hash('TUSDT'),
+    TUSDe: sha256Hash('TUSDe'),
+
     // Testnet assets, faucet t.me/evaabuidl
     EUSDT: sha256Hash('EUSDT'),
     EUSDC: sha256Hash('EUSDC'),

package/src/constants/assets/mainnet.ts

@@ -216,3 +216,27 @@ export const EVAA_MAINNET: PoolAssetConfig = {
         ),
     )[0],
 };
+
+export const TUSDT_MAINNET: PoolAssetConfig = {
+    name: 'TUSDT',
+    assetId: ASSET_ID.TUSDT,
+    jettonMasterAddress: Address.parse('EQCA1saJX4oYdG38m1__Of6ym2GnKSGVuccAy6UU-ESeXjvb'),
+    jettonWalletCode: Cell.fromBoc(
+        Buffer.from(
+            'b5ee9c7201021101000323000114ff00f4a413f4bcf2c80b0102016202030202cc0405001ba0f605da89a1f401f481f481a8610201d40607020120080900c30831c02497c138007434c0c05c6c2544d7c0fc03383e903e900c7e800c5c75c87e800c7e800c1cea6d0000b4c7e08403e29fa954882ea54c4d167c0278208405e3514654882ea58c511100fc02b80d60841657c1ef2ea4d67c02f817c12103fcbc2000113e910c1c2ebcb853600201200a0b0083d40106b90f6a2687d007d207d206a1802698fc1080bc6a28ca9105d41083deecbef09dd0958f97162e99f98fd001809d02811e428027d012c678b00e78b6664f6aa401f1503d33ffa00fa4021f001ed44d0fa00fa40fa40d4305136a1522ac705f2e2c128c2fff2e2c254344270542013541403c85004fa0258cf1601cf16ccc922c8cb0112f400f400cb00c920f9007074c8cb02ca07cbffc9d004fa40f40431fa0020d749c200f2e2c4778018c8cb055008cf1670fa0217cb6b13cc80c0201200d0e009e8210178d4519c8cb1f19cb3f5007fa0222cf165006cf1625fa025003cf16c95005cc2391729171e25008a813a08209c9c380a014bcf2e2c504c98040fb001023c85004fa0258cf1601cf16ccc9ed5402f73b51343e803e903e90350c0234cffe80145468017e903e9014d6f1c1551cdb5c150804d50500f214013e809633c58073c5b33248b232c044bd003d0032c0327e401c1d3232c0b281f2fff274140371c1472c7cb8b0c2be80146a2860822625a019ad822860822625a028062849e5c412440e0dd7c138c34975c2c0600f1000d73b51343e803e903e90350c01f4cffe803e900c145468549271c17cb8b049f0bffcb8b08160824c4b402805af3cb8b0e0841ef765f7b232c7c572cfd400fe8088b3c58073c5b25c60063232c14933c59c3e80b2dab33260103ec01004f214013e809633c58073c5b3327b552000705279a018a182107362d09cc8cb1f5230cb3f58fa025007cf165007cf16c9718010c8cb0524cf165006fa0215cb6a14ccc971fb0010241023007cc30023c200b08e218210d53276db708010c8cb055008cf165004fa0216cb6a12cb1f12cb3fc972fb0093356c21e203c85004fa0258cf1601cf16ccc9ed54',
+            'hex',
+        ),
+    )[0],
+};
+
+export const TUSDE_MAINNET: PoolAssetConfig = {
+    name: 'TUSDe',
+    assetId: ASSET_ID.TUSDe,
+    jettonMasterAddress: Address.parse('EQC2cewpgyIzP9o1gTSGsQceuY1nt3bjpilek7ARKyhWtQKk'),
+    jettonWalletCode: Cell.fromBoc(
+        Buffer.from(
+            'b5ee9c7201021101000323000114ff00f4a413f4bcf2c80b0102016202030202cc0405001ba0f605da89a1f401f481f481a8610201d40607020120080900c30831c02497c138007434c0c05c6c2544d7c0fc03383e903e900c7e800c5c75c87e800c7e800c1cea6d0000b4c7e08403e29fa954882ea54c4d167c0278208405e3514654882ea58c511100fc02b80d60841657c1ef2ea4d67c02f817c12103fcbc2000113e910c1c2ebcb853600201200a0b0083d40106b90f6a2687d007d207d206a1802698fc1080bc6a28ca9105d41083deecbef09dd0958f97162e99f98fd001809d02811e428027d012c678b00e78b6664f6aa401f1503d33ffa00fa4021f001ed44d0fa00fa40fa40d4305136a1522ac705f2e2c128c2fff2e2c254344270542013541403c85004fa0258cf1601cf16ccc922c8cb0112f400f400cb00c920f9007074c8cb02ca07cbffc9d004fa40f40431fa0020d749c200f2e2c4778018c8cb055008cf1670fa0217cb6b13cc80c0201200d0e009e8210178d4519c8cb1f19cb3f5007fa0222cf165006cf1625fa025003cf16c95005cc2391729171e25008a813a08209c9c380a014bcf2e2c504c98040fb001023c85004fa0258cf1601cf16ccc9ed5402f73b51343e803e903e90350c0234cffe80145468017e903e9014d6f1c1551cdb5c150804d50500f214013e809633c58073c5b33248b232c044bd003d0032c0327e401c1d3232c0b281f2fff274140371c1472c7cb8b0c2be80146a2860822625a019ad822860822625a028062849e5c412440e0dd7c138c34975c2c0600f1000d73b51343e803e903e90350c01f4cffe803e900c145468549271c17cb8b049f0bffcb8b08160824c4b402805af3cb8b0e0841ef765f7b232c7c572cfd400fe8088b3c58073c5b25c60063232c14933c59c3e80b2dab33260103ec01004f214013e809633c58073c5b3327b552000705279a018a182107362d09cc8cb1f5230cb3f58fa025007cf165007cf16c9718010c8cb0524cf165006fa0215cb6a14ccc971fb0010241023007cc30023c200b08e218210d53276db708010c8cb055008cf165004fa0216cb6a12cb1f12cb3fc972fb0093356c21e203c85004fa0258cf1601cf16ccc9ed54',
+            'hex',
+        ),
+    )[0],
+};

package/src/constants/general/mainnet.ts

@@ -9,6 +9,10 @@ export const MAINNET_VERSION = 10;
 export const EVAA_LP_MAINNET = Address.parse('EQBIlZX2URWkXCSg3QF2MJZU-wC5XkBoLww-hdWk2G37Jc6N');
 export const EVAA_LP_MAINNET_VERSION = 6;
 
+/* LP POOL COPY */
+export const EVAA_LP_COPY_MAINNET = Address.parse('EQA8H9nNHly7yJ32UmUDzH97Je2l8bAI6P74yKIIwPwKKXrz');
+export const EVAA_LP_COPY_MAINNET_VERSION = 0;
+
 /* ALTS POOL */
 export const EVAA_ALTS_MAINNET = Address.parse('EQANURVS3fhBO9bivig34iyJQi97FhMbpivo1aUEAS2GYSu-');
 export const EVAA_ALTS_MAINNET_VERSION = 4;

package/src/constants/pools/mainnet.ts

@@ -1,7 +1,7 @@
 import { HexString } from '@pythnetwork/hermes-client';
 import { Address, Dictionary } from '@ton/core';
 import { FEED_ID, FeedMapItem } from '../../api/feeds';
-import { ClassicCollector, DefaultPythPriceSourcesConfig, PythCollector } from '../../oracles';
+import { ClassicCollector, DefaultPythPriceSourcesConfig, FakeCollector, PythCollector } from '../../oracles';
 import { PoolConfig } from '../../types/Master';
 import { EvaaRewardsConfig } from '../../types/MasterRewards';
 import {
@@ -24,11 +24,15 @@ import {
     USDE_MAINNET,
     USDT_MAINNET,
     USDT_STORM_MAINNET,
+    TUSDE_MAINNET,
+    TUSDT_MAINNET,
 } from '../assets';
 import {
     EVAA_ALTS_MAINNET,
     EVAA_ALTS_MAINNET_VERSION,
     EVAA_EVAA_REWARDS_MASTER_MAINNET,
+    EVAA_LP_COPY_MAINNET,
+    EVAA_LP_COPY_MAINNET_VERSION,
     EVAA_LP_MAINNET,
     EVAA_LP_MAINNET_VERSION,
     EVAA_MASTER_MAINNET,
@@ -105,6 +109,7 @@ export const MAINNET_POOL_CONFIG: PoolConfig = {
         },
     }),
     poolAssetsConfig: MAINNET_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [],
     lendingCode: LENDING_CODE,
 };
 
@@ -118,6 +123,7 @@ export const MAINNET_STABLE_POOL_CONFIG: PoolConfig = {
         evaaOracles: ORACLES_MAINNET,
     }),
     poolAssetsConfig: MAINNET_STABLE_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [],
     lendingCode: LENDING_CODE,
 };
 
@@ -131,6 +137,24 @@ export const MAINNET_LP_POOL_CONFIG: PoolConfig = {
         evaaOracles: ORACLES_LP,
     }),
     poolAssetsConfig: MAINNET_LP_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [],
+    lendingCode: LENDING_CODE,
+};
+
+export const MAINNET_LP_POOL_COPY_CONFIG: PoolConfig = {
+    masterAddress: EVAA_LP_COPY_MAINNET,
+    masterVersion: EVAA_LP_COPY_MAINNET_VERSION,
+    masterConstants: MASTER_CONSTANTS,
+    collector: new ClassicCollector({
+        poolAssetsConfig: MAINNET_LP_POOL_ASSETS_CONFIG,
+        minimalOracles: 3,
+        evaaOracles: ORACLES_LP,
+    }),
+    poolAssetsConfig: MAINNET_LP_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [
+        { title: 'ton', assets: [TON_MAINNET, TON_STORM_MAINNET], heCategory: 1 },
+        { title: 'stable', assets: [USDT_MAINNET, USDT_STORM_MAINNET], heCategory: 2 },
+    ],
     lendingCode: LENDING_CODE,
 };
 
@@ -144,6 +168,7 @@ export const MAINNET_ALTS_POOL_CONFIG: PoolConfig = {
         evaaOracles: ORACLES_ALTS,
     }),
     poolAssetsConfig: MAINNET_ALTS_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [],
     lendingCode: LENDING_CODE,
 };
 
@@ -166,6 +191,7 @@ export const MAINNET_PYTH_V8_TOB_POOL_CONFIG: PoolConfig = {
         },
     }),
     poolAssetsConfig: MAINNET_PYTH_V8_TOB_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [],
     lendingCode: LENDING_CODE,
 };
 
@@ -181,6 +207,7 @@ export const MAINNET_V8_TOB_POOL_CONFIG: PoolConfig = {
         evaaOracles: ORACLES_MAINNET,
     }),
     poolAssetsConfig: MAINNET_V8_TOB_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [],
     lendingCode: LENDING_CODE,
 };
 
@@ -214,6 +241,25 @@ export const MAINNET_MASTER_EVAA_REWARD_CONFIG: EvaaRewardsConfig = {
     publicKey: Buffer.from('b8eb0e312a9aa6394edceef21573f2d45e7d7a616a924e33190bd52fa31c8bb1', 'hex'), // adminAddress publicKey
 };
 
+export const MAINNET_CLASSIC_HE_POOL_CONFIG: PoolConfig = {
+    masterAddress: Address.parse('EQAI_O_VqUhqFQ-AW969xl1eXOi4euSWl1puxEroekJ5xpOt'),
+    masterVersion: 0,
+    masterConstants: MASTER_CONSTANTS,
+    collector: new FakeCollector(
+        Dictionary.empty<bigint, bigint>()
+            .set(ASSET_ID.TON, 1_300_000_000n)
+            .set(ASSET_ID.tsTON, 1_500_000_000n)
+            .set(ASSET_ID.TUSDT, 1_000_000_000n)
+            .set(ASSET_ID.TUSDe, 1_000_000_000n),
+    ),
+    poolAssetsConfig: [TON_MAINNET, TSTON_MAINNET, TUSDE_MAINNET, TUSDT_MAINNET],
+    poolAssetsHEConfig: [
+        { title: 'ton', assets: [TON_MAINNET, TSTON_MAINNET], heCategory: 1 },
+        { title: 'stable', assets: [TUSDT_MAINNET, TUSDE_MAINNET], heCategory: 2 },
+    ],
+    lendingCode: LENDING_CODE,
+};
+
 export const ALL_MAINNET_POOLS: PoolConfig[] = [
     MAINNET_POOL_CONFIG,
     MAINNET_LP_POOL_CONFIG,

package/src/constants/pools/testnet.ts

@@ -1,10 +1,19 @@
-import { HexString } from '@pythnetwork/hermes-client';
+import type { HexString } from '@pythnetwork/hermes-client';
+import type { PoolConfig } from '../../types/Master';
+import type { EvaaRewardsConfig } from '../../types/MasterRewards';
 import { Address, Dictionary } from '@ton/core';
-import { FEED_ID, FeedMapItem } from '../../api/feeds';
+import { FEED_ID, type FeedMapItem } from '../../api/feeds';
 import { ClassicCollector, DefaultPythPriceSourcesConfig, PythCollector } from '../../oracles';
-import { PoolConfig } from '../../types/Master';
-import { EvaaRewardsConfig } from '../../types/MasterRewards';
-import { ASSET_ID, EUSDT_TESTNET, JUSDC_TESTNET, TON_TESTNET } from '../assets';
+import {
+    ASSET_ID,
+    EUSDT_TESTNET,
+    JUSDC_TESTNET,
+    TON_MAINNET,
+    TON_TESTNET,
+    TSTON_MAINNET,
+    USDE_MAINNET,
+    USDT_MAINNET,
+} from '../assets';
 import {
     EVAA_MASTER_TESTNET_CLASSIC_TOB_AUDITED,
     EVAA_MASTER_TESTNET_PYTH_TOB_AUDITED,
@@ -45,6 +54,7 @@ export const TESTNET_PYTH_POOL_CONFIG_TOB_AUDITED: PoolConfig = {
         pythConfig: DefaultPythPriceSourcesConfig,
     }),
     poolAssetsConfig: TESTNET_POOL_ASSETS_CONFIG_TOB_AUDITED,
+    poolAssetsHEConfig: [],
     lendingCode: LENDING_CODE,
 };
 
@@ -59,6 +69,21 @@ export const TESTNET_CLASSIC_POOL_CONFIG_TOB_AUDITED: PoolConfig = {
     }),
     lendingCode: LENDING_CODE,
     poolAssetsConfig: TESTNET_POOL_ASSETS_CONFIG,
+    poolAssetsHEConfig: [],
+};
+
+export const TESTNET_CLASSIC_HE_POOL_CONFIG: PoolConfig = {
+    masterAddress: Address.parse('EQBykKj3k97Mx_EEGwzmnqFLteFRAt0BIg-ig96ifNkdV3Wn'),
+    masterVersion: 0,
+    masterConstants: MASTER_CONSTANTS,
+    collector: new ClassicCollector({
+        poolAssetsConfig: [TON_MAINNET, TSTON_MAINNET, USDT_MAINNET, USDE_MAINNET],
+        minimalOracles: 1,
+        evaaOracles: ORACLES_TESTNET,
+    }),
+    lendingCode: LENDING_CODE,
+    poolAssetsConfig: [TON_MAINNET, TSTON_MAINNET, USDT_MAINNET, USDE_MAINNET],
+    poolAssetsHEConfig: [],
 };
 
 export const TESTNET_MASTER_REWARD_CONFIG: EvaaRewardsConfig = {

package/src/oracles/collectors/ClassicCollector.ts

@@ -1,7 +1,7 @@
 import { Dictionary } from '@ton/core';
 import { checkNotInDebtAtAll } from '../../api/math';
 import { ExtendedEvaaOracle, PoolAssetConfig } from '../../types/Master';
-import { FetchConfig, proxyFetchRetries } from '../../utils/utils';
+import { FetchConfig } from '../../utils/utils';
 import { ClassicPrices, ClassicPricesMode, ClassicPricesOffset } from '../prices/ClassicPrices';
 import { PriceSource } from '../sources';
 import { DefaultPriceSourcesConfig, PriceSourcesConfig, RawPriceData } from '../Types';
@@ -181,20 +181,16 @@ export class ClassicCollector extends AbstractCollector {
     }
 
     async #collectPrices(fetchConfig?: FetchConfig): Promise<boolean> {
-        for (const priceSource of this.#priceSources) {
-            try {
-                this.#prices = await proxyFetchRetries(
-                    () => collectAndFilterPrices(priceSource, this.#minimalOracles, fetchConfig),
-                    fetchConfig,
-                );
-                return true;
-            } catch (error) {
-                // Try next source
-                continue;
-            }
+        try {
+            this.#prices = await Promise.any(
+                this.#priceSources.map((source) =>
+                    collectAndFilterPrices(source, this.#minimalOracles, fetchConfig),
+                ),
+            );
+            return true;
+        } catch {
+            return false;
         }
-
-        return false;
     }
 
     async #collectPricesWithValidation(fetchConfig?: FetchConfig): Promise<void> {

package/src/oracles/collectors/FakeCollector.ts

@@ -0,0 +1,153 @@
+import { beginCell, Cell, Dictionary } from '@ton/core';
+import { ClassicPrices, ClassicPricesMode } from '../prices/ClassicPrices';
+import { PoolAssetConfig } from '../../types/Master';
+import { FetchConfig } from '../../utils/utils';
+import { AbstractCollector } from './AbstractCollector';
+import { packAssetsData, packPrices, packOraclesData } from '../utils';
+import { keyPairFromSeed, sign } from '@ton/crypto';
+
+function createFakeOracle(id: number, seed: Buffer) {
+    const keypair = keyPairFromSeed(seed);
+    return {
+        id,
+        pubkey: keypair.publicKey,
+        secret: keypair.secretKey,
+    };
+}
+
+const fakeOracles = [
+    createFakeOracle(0, Buffer.alloc(32, 0)),
+    createFakeOracle(1, Buffer.alloc(32, 1)),
+    createFakeOracle(2, Buffer.alloc(32, 2)),
+    createFakeOracle(3, Buffer.alloc(32, 3)),
+];
+
+function packPricesData(timestamp: number, prices: Dictionary<bigint, bigint>): Cell {
+    return beginCell()
+        .storeUint(timestamp, 32)
+        .storeDict(prices, Dictionary.Keys.BigUint(256), Dictionary.Values.BigVarUint(4))
+        .endCell();
+}
+
+function signPricesData(
+    oracle: { secret: Buffer },
+    data: { timestamp: number; prices: Dictionary<bigint, bigint> },
+): Buffer {
+    const packedData = packPricesData(data.timestamp, data.prices);
+    return sign(packedData.hash(), oracle.secret);
+}
+
+function withSerializers(src: Dictionary<bigint, bigint>): Dictionary<bigint, bigint> {
+    const dict = Dictionary.empty(Dictionary.Keys.BigUint(256), Dictionary.Values.BigVarUint(4));
+    for (const key of src.keys()) {
+        dict.set(key, src.get(key)!);
+    }
+    return dict;
+}
+
+function buildPricesCell(
+    pricesDict: Dictionary<bigint, bigint>,
+    assetIds: bigint[],
+    timestamp: number,
+): { dict: Dictionary<bigint, bigint>; dataCell: Cell } {
+    const serializedPrices = withSerializers(pricesDict);
+    const oraclesData = fakeOracles.map((oracle) => {
+        const data = { timestamp, prices: serializedPrices };
+        const signature = signPricesData(oracle, data);
+        return {
+            oracle: { id: oracle.id, pubkey: oracle.pubkey },
+            data,
+            signature,
+        };
+    });
+
+    const medianData = assetIds.map((assetId) => ({
+        assetId,
+        medianPrice: pricesDict.get(assetId)!,
+    }));
+
+    const assetsDataCell = packAssetsData(medianData);
+    const oraclesDataCell = packOraclesData(oraclesData, assetIds);
+    const dataCell = packPrices(assetsDataCell, oraclesDataCell);
+
+    const dict = Dictionary.empty<bigint, bigint>();
+    for (const { assetId, medianPrice } of medianData) {
+        dict.set(assetId, medianPrice);
+    }
+
+    return { dict, dataCell };
+}
+
+/**
+ * FakeCollector for testing smart contracts.
+ *
+ * Accepts a Dictionary<bigint, bigint> mapping assetId to price
+ * (in ASSET_PRICE_SCALE, i.e. USD price * 1e9) and produces valid
+ * ClassicPrices without any network calls.
+ *
+ * @example
+ * ```ts
+ * const prices = Dictionary.empty<bigint, bigint>();
+ * prices.set(TON_ASSET_ID, 5_000_000_000n);  // $5.00
+ * prices.set(USDT_ASSET_ID, 1_000_000_000n); // $1.00
+ *
+ * const collector = new FakeCollector(prices);
+ * const classicPrices = await collector.getPrices();
+ * ```
+ */
+export class FakeCollector extends AbstractCollector {
+    readonly #pricesDict: Dictionary<bigint, bigint>;
+
+    constructor(prices: Dictionary<bigint, bigint>) {
+        super();
+        this.#pricesDict = prices;
+    }
+
+    async getPricesForLiquidate(
+        _realPrincipals: Dictionary<bigint, bigint>,
+        _fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        return this.#buildClassicPrices(ClassicPricesMode.SPOT);
+    }
+
+    async getPricesForWithdraw(
+        realPrincipals: Dictionary<bigint, bigint>,
+        withdrawAsset: PoolAssetConfig,
+        collateralToDebt = false,
+        fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        return await this.getPrices();
+    }
+
+    async getPricesForSupplyWithdraw(
+        _realPrincipals: Dictionary<bigint, bigint>,
+        _supplyAsset: PoolAssetConfig | undefined,
+        _withdrawAsset: PoolAssetConfig | undefined,
+        _collateralToDebt: boolean,
+        _fetchConfig?: FetchConfig,
+    ): Promise<ClassicPrices> {
+        return this.#buildClassicPrices(ClassicPricesMode.TWAP);
+    }
+
+    async getPrices(_assets?: PoolAssetConfig[], _fetchConfig?: FetchConfig): Promise<ClassicPrices> {
+        return this.#buildClassicPrices();
+    }
+
+    #buildClassicPrices(mode?: ClassicPricesMode): ClassicPrices {
+        const keys = this.#pricesDict.keys();
+        if (keys.length === 0) {
+            return ClassicPrices.createEmptyPrices();
+        }
+
+        const timestamp = Math.floor(Date.now() / 1000);
+        const { dict, dataCell } = buildPricesCell(this.#pricesDict, keys, timestamp);
+
+        return new ClassicPrices({
+            mode,
+            dict,
+            dataCell,
+            minPublishTime: undefined,
+            maxPublishTime: undefined,
+        });
+    }
+}

package/src/oracles/collectors/index.ts

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

package/src/types/Master.ts

@@ -23,11 +23,18 @@ export type PoolAssetConfig = {
     jettonWalletCode: Cell;
 };
 
+export type PoolAssetHEConfig = {
+    title: string;
+    assets: PoolAssetConfig[];
+    heCategory: number;
+};
+
 export type PoolConfig = {
     masterAddress: Address;
     masterVersion: number;
     masterConstants: MasterConstants;
     poolAssetsConfig: PoolAssetConfig[];
+    poolAssetsHEConfig: PoolAssetHEConfig[];
     lendingCode: Cell;
     collector: AbstractCollector;
 };
@@ -66,8 +73,8 @@ export type AssetConfig = {
     baseTrackingBorrowSpeed: bigint;
     borrowCap: number | bigint;
     heCategory: number;
-    heCollateralFactor: number;
-    heLiquidationThreshold: number;
+    heCollateralFactor: bigint;
+    heLiquidationThreshold: bigint;
 };
 
 export type AssetData = {

package/src/types/User.ts

@@ -1,4 +1,4 @@
-import { Address, Cell, Dictionary } from '@ton/core';
+import { Address, Cell, Dictionary, ExternalAddress } from '@ton/core';
 import {
     AssetConfig,
     AssetData,
@@ -43,8 +43,8 @@ export type LiquidationData = LiquidableData | NonLiquidableData;
 export type UserLiteData = {
     type: 'active';
     codeVersion: number;
-    masterAddress: Address;
-    ownerAddress: Address;
+    masterAddress: Address | ExternalAddress | null;
+    ownerAddress: Address | ExternalAddress | null;
     principals: Dictionary<bigint, bigint>;
     realPrincipals: Dictionary<bigint, bigint>; // principals before applying dusts
     state: number;
@@ -62,15 +62,19 @@ export type UserLiteData = {
 export type UserDataActive = UserLiteData & {
     withdrawalLimits: Dictionary<bigint, bigint>;
     borrowLimits: Dictionary<bigint, bigint>;
+    borrowLimitsWithEmode: Dictionary<bigint, bigint>;
     repayLimits?: Dictionary<bigint, bigint>;
     supplyBalance: bigint;
     borrowBalance: bigint;
     availableToBorrow: bigint;
+    availableToBorrowWithEmode: bigint;
     limitUsedPercent: number;
     limitUsed: bigint;
     healthFactor: number;
     liquidationData: LiquidationData;
     havePrincipalWithoutPrice: boolean;
+    predictedHeCategory: number;
+    activeHeCategory: number;
 };
 
 export type UserDataInactive = {