@evaafi/sdk 0.6.1 → 0.6.2-b

package/src/api/parser.ts

@@ -12,8 +12,7 @@ import {
 } from './math';
 import { loadMaybeMyRef, loadMyRef } from './helpers';
 import { BalanceType, UserBalance, UserData, UserLiteData, UserRewards } from '../types/User';
-import { MAINNET_POOL_CONFIG, TESTNET_POOL_CONFIG } from '../constants/pools';
-import { basename } from 'path';
+import { checkNotInDebtAtAll } from "../api/math";
 
 export function createUserRewards(): DictionaryValue<UserRewards> {
     return {
@@ -34,29 +33,24 @@ export function createAssetData(): DictionaryValue<AssetData> {
         serialize: (src: any, buidler: any) => {
             buidler.storeUint(src.sRate, 64);
             buidler.storeUint(src.bRate, 64);
-            buidler.storeUint(src.totalSupply, 64);
-            buidler.storeUint(src.totalBorrow, 64);
+            buidler.storeInt(src.totalSupply, 64);
+            buidler.storeInt(src.totalBorrow, 64);
             buidler.storeUint(src.lastAccural, 32);
             buidler.storeUint(src.balance, 64);
             buidler.storeUint(src.trackingSupplyIndex, 64);
             buidler.storeUint(src.trackingBorrowIndex, 64);
-            if (src.awaitedSupply) {
-                buidler.storeUint(src.awaitedSupply, 64);
-            }
+            buidler.storeUint(src.awaitedSupply, 64);
         },
         parse: (src: Slice) => {
-            const sRate = BigInt(src.loadInt(64));
-            const bRate = BigInt(src.loadInt(64));
-            const totalSupply = BigInt(src.loadInt(64));
-            const totalBorrow = BigInt(src.loadInt(64));
-            const lastAccural = BigInt(src.loadInt(32));
-            const balance = BigInt(src.loadInt(64));
-            const trackingSupplyIndex = BigInt(src.loadUint(64));
-            const trackingBorrowIndex = BigInt(src.loadUint(64));
-            let awaitedSupply: bigint | undefined = undefined;
-            if (src.remainingBits == 64) {
-                awaitedSupply = BigInt(src.loadUint(64));   
-            }
+            const sRate = BigInt(src.loadUintBig(64));
+            const bRate = BigInt(src.loadUintBig(64));
+            const totalSupply = BigInt(src.loadIntBig(64));
+            const totalBorrow = BigInt(src.loadIntBig(64));
+            const lastAccural = BigInt(src.loadUintBig(32));
+            const balance = BigInt(src.loadUintBig(64));
+            const trackingSupplyIndex = BigInt(src.loadUintBig(64));
+            const trackingBorrowIndex = BigInt(src.loadUintBig(64));
+            const awaitedSupply = BigInt(src.loadUintBig(64));  
 
             return { sRate, bRate, totalSupply, totalBorrow, lastAccural, balance, trackingSupplyIndex, trackingBorrowIndex, awaitedSupply};
         },
@@ -205,7 +199,7 @@ export function parseUserLiteData(
     assetsData: ExtendedAssetsData,
     assetsConfig: ExtendedAssetsConfig,
     poolConfig: PoolConfig,
-    applyDust: boolean = true
+    applyDust: boolean = false
 ): UserLiteData {
     const poolAssetsConfig = poolConfig.poolAssetsConfig;
     const masterConstants = poolConfig.masterConstants;
@@ -215,7 +209,8 @@ export function parseUserLiteData(
     const codeVersion = userSlice.loadCoins();
     const masterAddress = userSlice.loadAddress();
     const userAddress = userSlice.loadAddress();
-    const principalsDict = userSlice.loadDict(Dictionary.Keys.BigUint(256), Dictionary.Values.BigInt(64));
+    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);
 
     let trackingSupplyIndex = 0n;
@@ -244,7 +239,7 @@ export function parseUserLiteData(
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
 
-        let principal = principalsDict.get(asset.assetId) || 0n;
+        let principal = realPrincipals.get(asset.assetId) || 0n;
         let balance = presentValue(assetData.sRate, assetData.bRate, principal, masterConstants);
 
         if (applyDust && (principal > 0 && (principal < assetConfig.dust))) {
@@ -254,6 +249,8 @@ export function parseUserLiteData(
                 type: BalanceType.supply,
             };
             principalsDict.set(asset.assetId, 0n);
+        } else {
+            principalsDict.set(asset.assetId, principal);
         }
         userBalances.set(asset.assetId, balance);
     }
@@ -264,12 +261,14 @@ export function parseUserLiteData(
         masterAddress: masterAddress,
         ownerAddress: userAddress,
         principals: principalsDict,
+        realPrincipals: realPrincipals,
         state: userState,
         balances: userBalances,
         trackingSupplyIndex: trackingSupplyIndex,
         trackingBorrowIndex: trackingBorrowIndex,
         dutchAuctionStart: dutchAuctionStart,
         backupCell: backupCell,
+        fullyParsed: false,
         
         rewards: rewards,
         backupCell1: backupCell1,
@@ -283,8 +282,11 @@ export function parseUserData(
     assetsConfig: ExtendedAssetsConfig,
     prices: Dictionary<bigint, bigint>,
     poolConfig: PoolConfig,
-    applyDust: boolean = true
+    applyDust: boolean = false
 ): UserData {
+    userLiteData.fullyParsed = true;
+    let havePrincipalWithoutPrice = false;
+
     const poolAssetsConfig = poolConfig.poolAssetsConfig;
     const masterConstants = poolConfig.masterConstants;
 
@@ -294,6 +296,16 @@ export function parseUserData(
     let supplyBalance = 0n;
     let borrowBalance = 0n;
 
+    for (const [assetId, principal] of userLiteData.realPrincipals) {
+        if (!prices.has(assetId)) {
+            userLiteData.fullyParsed = false;
+
+            if (principal != 0n) {
+                havePrincipalWithoutPrice = true;
+            }
+        }
+    }
+
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
@@ -310,6 +322,10 @@ export function parseUserData(
     }
 
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
+        if (!prices.has(asset.assetId)) {
+            continue;
+        }
+
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
         const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
 
@@ -321,19 +337,25 @@ export function parseUserData(
         }
     }
 
-    const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants);
+    const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.realPrincipals, prices, masterConstants);
+
     for (const [_, asset] of Object.entries(poolAssetsConfig)) {
+        const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
         const assetConfig = assetsConfig.get(asset.assetId) as AssetConfig;
         const assetData = assetsData.get(asset.assetId) as ExtendedAssetData;
-        const balance = userLiteData.balances.get(asset.assetId) as UserBalance;
         
         if (balance.type === BalanceType.supply) {
             withdrawalLimits.set(
                 asset.assetId,
-                bigIntMin(calculateMaximumWithdrawAmount(assetsConfig, assetsData, userLiteData.principals, prices, masterConstants, asset.assetId), assetData.balance)
+                bigIntMin(calculateMaximumWithdrawAmount(assetsConfig, assetsData, userLiteData.realPrincipals, prices, masterConstants, asset.assetId), assetData.balance)
             );
         }
 
+        if (!prices.has(asset.assetId)) {
+            borrowLimits.set(asset.assetId, 0n);
+            continue;
+        }
+
         borrowLimits.set(
             asset.assetId,
             bigIntMax(0n, bigIntMin((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(asset.assetId)!, assetData.balance, assetData.totalSupply - assetData.totalBorrow)),
@@ -346,12 +368,14 @@ export function parseUserData(
             ? 0
             : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
 
-    const liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.principals, prices, poolConfig);
     let healthFactor = 1;
-    if (liquidationData.totalLimit != 0n) {
-        healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
-    } 
-
+    let liquidationData;
+    if (!havePrincipalWithoutPrice) {
+        liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.realPrincipals, prices, poolConfig);
+        if (liquidationData.totalLimit != 0n) {
+            healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
+        } 
+    }
     return {
         ...userLiteData,
         withdrawalLimits: withdrawalLimits,
@@ -363,5 +387,6 @@ export function parseUserData(
         limitUsed: limitUsed,
         liquidationData: liquidationData,
         healthFactor: healthFactor,
+        havePrincipalWithoutPrice: havePrincipalWithoutPrice
     };
 }

package/src/api/prices.ts

@@ -1,14 +1,27 @@
-import { Dictionary } from '@ton/core';
-import { PriceData, RawPriceData } from '../types/Common';
-import { getMedianPrice, loadPrices, packAssetsData, packOraclesData, packPrices, parsePrices, verifyPrices } from '../utils/priceUtils';
-import { OracleNFT, PoolConfig } from '../types/Master';
+import { PoolConfig } from '../types/Master';
 import { MAINNET_POOL_CONFIG } from '../constants/pools';
+import { DefaultPriceSourcesConfig, PriceData, PricesCollector, PriceSource, PriceSourcesConfig } from '../prices';
 
-export async function getPrices(endpoints: String[] = ["api.stardust-mainnet.iotaledger.net", "iota.evaa.finance"], poolConfig: PoolConfig = MAINNET_POOL_CONFIG): Promise<PriceData> {
+/**
+ * @deprecated Use PriceCollector istead of getPrices
+ */
+export async function getPrices(endpoints: string[] = ["api.stardust-mainnet.iotaledger.net"], poolConfig: PoolConfig = MAINNET_POOL_CONFIG): Promise<PriceData> {
     if (endpoints.length == 0) {
         throw new Error("Empty endpoint list");
     }
-    
+
+    const sources: PriceSourcesConfig = {
+        iotaEndpoints: endpoints,
+        icpEndpoints: DefaultPriceSourcesConfig.icpEndpoints,
+        backendEndpoints: DefaultPriceSourcesConfig.backendEndpoints,
+    }
+
+    const priceCollector = new PricesCollector(poolConfig, sources);
+    const prices = await priceCollector.getPrices();
+
+    return { dict: prices.dict, dataCell: prices.dataCell };
+    /*
+        Old code
     const prices = await Promise.all(poolConfig.oracles.map(async x => await parsePrices(await loadPrices(x.address, endpoints), x.id)));
     
     let acceptedPrices: RawPriceData[] = prices.filter(verifyPrices(poolConfig.poolAssetsConfig));
@@ -41,5 +54,5 @@ export async function getPrices(endpoints: String[] = ["api.stardust-mainnet.iot
     return {
         dict: dict,
         dataCell: packPrices(packedMedianData, packedOracleData)
-    };
+    };*/
 }

package/src/constants/assets.ts

@@ -10,10 +10,18 @@ export const ASSET_ID = {
     jUSDC:          sha256Hash('jUSDC'),
     stTON:          sha256Hash('stTON'),
     tsTON:          sha256Hash('tsTON'),
+    uTON:           sha256Hash('uTON'),
+
+    // LP
     TONUSDT_DEDUST: sha256Hash('TONUSDT_DEDUST'),
     TONUSDT_STONFI: sha256Hash('TONUSDT_STONFI'),
     TON_STORM:      sha256Hash('TON_STORM'),
     USDT_STORM:     sha256Hash('USDT_STORM'),
+
+    // ALTS
+    NOT:            sha256Hash('NOT'),
+    DOGS:           sha256Hash('DOGS'),
+    CATI:           sha256Hash('CATI'),
 };
 
 export const UNDEFINED_ASSET: PoolAssetConfig = { 
@@ -137,3 +145,52 @@ export const USDT_STORM_MAINNET: PoolAssetConfig = {
         ),
     )[0],
 }
+
+export const CATI_MAINNET: PoolAssetConfig = { 
+    name: 'CATI',
+    assetId: ASSET_ID.CATI,
+    jettonMasterAddress: Address.parse('EQD-cvR0Nz6XAyRBvbhz-abTrRC6sI5tvHvvpeQraV9UAAD7'),
+    jettonWalletCode: Cell.fromBoc(
+        Buffer.from(
+            'b5ee9c7241021101000323000114ff00f4a413f4bcf2c80b0102016202030202cc0405001ba0f605da89a1f401f481f481a8610201d40607020120080900c30831c02497c138007434c0c05c6c2544d7c0fc03383e903e900c7e800c5c75c87e800c7e800c1cea6d0000b4c7e08403e29fa954882ea54c4d167c0278208405e3514654882ea58c511100fc02b80d60841657c1ef2ea4d67c02f817c12103fcbc2000113e910c1c2ebcb853600201200a0b0083d40106b90f6a2687d007d207d206a1802698fc1080bc6a28ca9105d41083deecbef09dd0958f97162e99f98fd001809d02811e428027d012c678b00e78b6664f6aa401f1503d33ffa00fa4021f001ed44d0fa00fa40fa40d4305136a1522ac705f2e2c128c2fff2e2c254344270542013541403c85004fa0258cf1601cf16ccc922c8cb0112f400f400cb00c920f9007074c8cb02ca07cbffc9d004fa40f40431fa0020d749c200f2e2c4778018c8cb055008cf1670fa0217cb6b13cc80c0201200d0e009e8210178d4519c8cb1f19cb3f5007fa0222cf165006cf1625fa025003cf16c95005cc2391729171e25008a813a08209c9c380a014bcf2e2c504c98040fb001023c85004fa0258cf1601cf16ccc9ed5402f73b51343e803e903e90350c0234cffe80145468017e903e9014d6f1c1551cdb5c150804d50500f214013e809633c58073c5b33248b232c044bd003d0032c0327e401c1d3232c0b281f2fff274140371c1472c7cb8b0c2be80146a2860822625a019ad822860822625a028062849e5c412440e0dd7c138c34975c2c0600f1000d73b51343e803e903e90350c01f4cffe803e900c145468549271c17cb8b049f0bffcb8b08160824c4b402805af3cb8b0e0841ef765f7b232c7c572cfd400fe8088b3c58073c5b25c60063232c14933c59c3e80b2dab33260103ec01004f214013e809633c58073c5b3327b552000705279a018a182107362d09cc8cb1f5230cb3f58fa025007cf165007cf16c9718010c8cb0524cf165006fa0215cb6a14ccc971fb0010241023007cc30023c200b08e218210d53276db708010c8cb055008cf165004fa0216cb6a12cb1f12cb3fc972fb0093356c21e203c85004fa0258cf1601cf16ccc9ed5495eaedd7',
+            'hex',
+        ),
+    )[0],
+}
+
+export const DOGS_MAINNET: PoolAssetConfig = { 
+    name: 'DOGS',
+    assetId: ASSET_ID.DOGS,
+    jettonMasterAddress: Address.parse('EQCvxJy4eG8hyHBFsZ7eePxrRsUQSFE_jpptRAYBmcG_DOGS'),
+    jettonWalletCode: Cell.fromBoc(
+        Buffer.from(
+            'b5ee9c7241010101002300084202ba2918c8947e9b25af9ac1b883357754173e5812f807a3d6e642a14709595395237ae3c3',
+            'hex',
+        ),
+    )[0],
+}
+
+export const NOT_MAINNET: PoolAssetConfig = { 
+    name: 'NOT',
+    assetId: ASSET_ID.NOT,
+    jettonMasterAddress: Address.parse('EQAvlWFDxGF2lXm67y4yzC17wYKD9A0guwPkMs1gOsM__NOT'),
+    jettonWalletCode: Cell.fromBoc(
+        Buffer.from(
+            'b5ee9c7201010101002300084202ba2918c8947e9b25af9ac1b883357754173e5812f807a3d6e642a14709595395',
+            'hex',
+        ),
+    )[0],
+}
+
+export const UTON_MAINNET: PoolAssetConfig = { 
+    name: 'uTON',
+    assetId: ASSET_ID.uTON,
+    jettonMasterAddress: Address.parse('EQAfF5j3JMIpZlLmACv7Ub7RH7WmiVMuV4ivcgNYHvNnqHTz'),
+    jettonWalletCode: Cell.fromBoc(
+        Buffer.from(
+            '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',
+            'hex',
+        ),
+    )[0],
+}
+

package/src/constants/general.ts

@@ -1,5 +1,4 @@
 import { Address, Cell, toNano } from '@ton/core';
-import { sha256Hash } from '../utils/sha256BigInt';
 import { OracleNFT } from '../types/Master';
 
 
@@ -21,37 +20,26 @@ export const MASTER_CONSTANTS = {
 
 export const NULL_ADDRESS = Address.parse('UQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJKZ');
 
-
 export const EVAA_MASTER_MAINNET = Address.parse('EQC8rUZqR_pWV1BylWUlPNBzyiTYVoBEmQkMIQDZXICfnuRr');
 export const MAINNET_VERSION = 6;
 export const EVAA_MASTER_TESTNET = Address.parse('EQDLsg3w-iBj26Gww7neYoJAxiT2t77Zo8ro56b0yuHsPp3C');
-export const TESTNET_VERSION = 0;
+export const TESTNET_VERSION = 1;
 export const EVAA_LP_MAINNET = Address.parse('EQBIlZX2URWkXCSg3QF2MJZU-wC5XkBoLww-hdWk2G37Jc6N');
-export const EVAA_LP_MAINNET_VERSION = 2;
+export const EVAA_LP_MAINNET_VERSION = 3;
+export const EVAA_ALTS_MAINNET = Address.parse('EQANURVS3fhBO9bivig34iyJQi97FhMbpivo1aUEAS2GYSu-');
+export const EVAA_ALTS_MAINNET_VERSION = 0;
 
 export const ORACLES_MAINNET: OracleNFT[] = [
-    {id: 0, address: '0xd3a8c0b9fd44fd25a49289c631e3ac45689281f2f8cf0744400b4c65bed38e5d'}, 
-    {id: 1, address: '0x2c21cabdaa89739de16bde7bc44e86401fac334a3c7e55305fe5e7563043e191'},
-    {id: 2, address: '0x2eb258ce7b5d02466ab8a178ad8b0ba6ffa7b58ef21de3dc3b6dd359a1e16af0'},
-    {id: 3, address: '0xf9a0769954b4430bca95149fb3d876deb7799d8f74852e0ad4ccc5778ce68b52'},
+    {id: 0, address: '0xd3a8c0b9fd44fd25a49289c631e3ac45689281f2f8cf0744400b4c65bed38e5d', pubkey: Buffer.from('b404f4a2ebb62f2623b370c89189748a0276c071965b1646b996407f10d72eb9', 'hex') }, 
+    {id: 1, address: '0x2c21cabdaa89739de16bde7bc44e86401fac334a3c7e55305fe5e7563043e191', pubkey: Buffer.from('9ad115087520d91b6b45d6a8521eb4616ee6914af07fabdc2e9d1826dbb17078', 'hex') },
+    {id: 2, address: '0x2eb258ce7b5d02466ab8a178ad8b0ba6ffa7b58ef21de3dc3b6dd359a1e16af0', pubkey: Buffer.from('e503e02e8a9226b34e7c9deb463cbf7f19bce589362eb448a69a8ee7b2fca631', 'hex') },
+    {id: 3, address: '0xf9a0769954b4430bca95149fb3d876deb7799d8f74852e0ad4ccc5778ce68b52', pubkey: Buffer.from('9cbf8374cf1f2cf17110134871d580198416e101683f4a61f54cf2a3e4e32070', 'hex') },
 ];
 
-export const ORACLES_TESTNET: OracleNFT[] = [
-    {id: 0, address: '0x3bb147a37b7a7f874c39320440f352bddd2c9337e31a778731910f0266391650'}, 
-    {id: 1, address: '0x676767e93b05a21aec9023a65f73cffe1c725709c3c964a7c3f0fd4229089bfe'},
-    {id: 2, address: '0x9c9e65951b0c5920c286bdb3410babcaf21f85bc9c90c13172988630f1244e0f'},
-    {id: 3, address: '0x9dcf880229bfb68d7344fd294624b64f1e0b43b9d858f0fdb1bc6434616c08f5'},
-    {id: 4, address: '0x4d1afcf7c0426ca61c405c8cfaef0053a0f0d143740ffed04c8716beb99cd614'},
-    {id: 5, address: '0x11c6baa608ed10733051fd74134441d384e471722fbc496b43ea4e3c6652485f'},
-    {id: 6, address: '0x2b685672f38dc2fce59013bb740bf24c6037049a1c267bb3b5f6f55d5b195f5f'},
-];
+export const ORACLES_TESTNET: OracleNFT[] = ORACLES_MAINNET;
 
-export const ORACLES_LP: OracleNFT[] = [
-    {id: 0, address: '0xd3a8c0b9fd44fd25a49289c631e3ac45689281f2f8cf0744400b4c65bed38e5d'}, 
-    {id: 1, address: '0x2c21cabdaa89739de16bde7bc44e86401fac334a3c7e55305fe5e7563043e191'},
-    {id: 2, address: '0x2eb258ce7b5d02466ab8a178ad8b0ba6ffa7b58ef21de3dc3b6dd359a1e16af0'},
-    {id: 3, address: '0xf9a0769954b4430bca95149fb3d876deb7799d8f74852e0ad4ccc5778ce68b52'},
-];
+export const ORACLES_LP: OracleNFT[] = ORACLES_MAINNET;
+export const ORACLES_ALTS: OracleNFT[] = ORACLES_MAINNET;
 
 export const LENDING_CODE = Cell.fromBoc(
     Buffer.from(

package/src/constants/pools.ts

@@ -1,7 +1,6 @@
-import { Address } from "@ton/core";
-import { JUSDC_MAINNET, JUSDC_TESTNET, JUSDT_MAINNET, JUSDT_TESTNET, STTON_MAINNET, STTON_TESTNET, TON_MAINNET, TON_STORM_MAINNET, TONUSDT_DEDUST_MAINNET, TSTON_MAINNET, USDT_MAINNET, USDT_STORM_MAINNET } from "./assets";
+import { CATI_MAINNET, DOGS_MAINNET, JUSDC_MAINNET, JUSDC_TESTNET, JUSDT_MAINNET, JUSDT_TESTNET, NOT_MAINNET, STTON_MAINNET, STTON_TESTNET, TON_MAINNET, TON_STORM_MAINNET, TONUSDT_DEDUST_MAINNET, TSTON_MAINNET, USDT_MAINNET, USDT_STORM_MAINNET, UTON_MAINNET } from "./assets";
 import { PoolConfig } from "../types/Master";
-import { EVAA_MASTER_MAINNET, EVAA_MASTER_TESTNET, LENDING_CODE, MAINNET_VERSION, MASTER_CONSTANTS, TESTNET_VERSION, EVAA_LP_MAINNET, EVAA_LP_MAINNET_VERSION, ORACLES_MAINNET, ORACLES_LP, ORACLES_TESTNET } from "./general";
+import { EVAA_MASTER_MAINNET, EVAA_MASTER_TESTNET, LENDING_CODE, MAINNET_VERSION, MASTER_CONSTANTS, TESTNET_VERSION, EVAA_LP_MAINNET, EVAA_LP_MAINNET_VERSION, ORACLES_MAINNET, ORACLES_LP, ORACLES_TESTNET, EVAA_ALTS_MAINNET, EVAA_ALTS_MAINNET_VERSION, ORACLES_ALTS } from "./general";
 
 export const MAINNET_POOL_CONFIG: PoolConfig = {
     masterAddress: EVAA_MASTER_MAINNET,
@@ -15,7 +14,8 @@ export const MAINNET_POOL_CONFIG: PoolConfig = {
         JUSDC_MAINNET,
         STTON_MAINNET,
         TSTON_MAINNET,
-        USDT_MAINNET
+        USDT_MAINNET,
+        // UTON_MAINNET // announce
     ],
     lendingCode: LENDING_CODE
 };
@@ -25,7 +25,7 @@ export const TESTNET_POOL_CONFIG: PoolConfig = {
     masterVersion: TESTNET_VERSION,
     masterConstants: MASTER_CONSTANTS,
     oracles: ORACLES_TESTNET,
-    minimalOracles: 5,
+    minimalOracles: 3,
     poolAssetsConfig: [
         TON_MAINNET,
         JUSDT_TESTNET,
@@ -50,3 +50,19 @@ export const MAINNET_LP_POOL_CONFIG: PoolConfig = {
     ],
     lendingCode: LENDING_CODE
 };
+
+export const MAINNET_ALTS_POOL_CONFIG: PoolConfig = {
+    masterAddress: EVAA_ALTS_MAINNET,
+    masterVersion: EVAA_ALTS_MAINNET_VERSION,
+    masterConstants: MASTER_CONSTANTS,
+    oracles: ORACLES_ALTS,
+    minimalOracles: 3,
+    poolAssetsConfig: [
+        TON_MAINNET,
+        USDT_MAINNET,
+        CATI_MAINNET,
+        NOT_MAINNET,
+        DOGS_MAINNET
+    ],
+    lendingCode: LENDING_CODE
+};

package/src/contracts/MasterContract.ts

@@ -20,7 +20,7 @@ import { parseMasterData } from '../api/parser';
 import { MasterData, PoolAssetConfig, PoolConfig} from '../types/Master';
 import { JettonWallet } from './JettonWallet';
 import { getUserJettonWallet } from '../utils/userJettonWallet';
-import { getPrices, isTonAsset, isTonAssetId, MAINNET_POOL_CONFIG } from '..';
+import { DefaultPriceSourcesConfig, getPrices, isTonAsset, isTonAssetId, MAINNET_POOL_CONFIG, PricesCollector, PriceSourcesConfig } from '..';
 
 /**
  * Parameters for the Evaa contract
@@ -393,6 +393,9 @@ export class Evaa implements Contract {
         }
     }
 
+    /**
+     * @deprecated Use PriceCollector (createPriceCollector) istead of getPrices
+     */
     async getPrices(provider: ContractProvider, endpoints?: string[]) {
         if ((endpoints?.length ?? 0) > 0) {
             return await getPrices(endpoints, this._poolConfig);
@@ -400,4 +403,8 @@ export class Evaa implements Contract {
             return await getPrices(undefined, this._poolConfig);
         }
     }
+
+    createPriceCollector(priceSourcesConfig: PriceSourcesConfig = DefaultPriceSourcesConfig) : PricesCollector {
+        return new PricesCollector(this._poolConfig, priceSourcesConfig);
+    }
 }

package/src/index.ts

@@ -14,6 +14,8 @@ export {
     calculateLiquidationData,
     predictHealthFactor,
     calculateHealthParams,
+    calculateInterestWithSupplyBorrow,
+    predictAPY,
     BigMath,
 } from './api/math';
 
@@ -56,7 +58,6 @@ export {
 export { EvaaUser } from './contracts/UserContract';
 
 // Types
-export { PriceData } from './types/Common';
 export {
     UpgradeConfig,
     AssetConfig,
@@ -102,7 +103,8 @@ export {
 export {
     MAINNET_POOL_CONFIG,
     TESTNET_POOL_CONFIG,
-    MAINNET_LP_POOL_CONFIG
+    MAINNET_LP_POOL_CONFIG,
+    MAINNET_ALTS_POOL_CONFIG
 } from './constants/pools';
 
 export {
@@ -113,6 +115,10 @@ export {
     TONUSDT_DEDUST_MAINNET,
     TON_STORM_MAINNET,
     USDT_STORM_MAINNET,
+    DOGS_MAINNET,
+    CATI_MAINNET,
+    UTON_MAINNET,
+    NOT_MAINNET,
     JUSDT_MAINNET,
     JUSDC_MAINNET,
     STTON_MAINNET,
@@ -124,6 +130,7 @@ export {
 
 export * from './constants/assets';
 export * from './utils/utils';
+export * from './prices';
 
 // Utils
 export { getLastSentBoc, getTonConnectSender } from './utils/tonConnectSender';

package/src/prices/Prices.ts

@@ -0,0 +1,32 @@
+import { Cell, Dictionary } from "@ton/core";
+import { PoolAssetConfig } from "../types/Master";
+
+export class Prices {
+    #dict: Dictionary<bigint, bigint>;
+    #dataCell: Cell;
+    constructor(dict: Dictionary<bigint, bigint>, dataCell: Cell) {
+        this.#dict = dict;
+        this.#dataCell = dataCell;
+    }
+
+    get dict() {
+        const dict = Dictionary.empty<bigint, bigint>();
+        for (const [key, value] of this.#dict) {
+            dict.set(key, value);
+        }
+        return dict;
+    }
+
+    get dataCell() {
+        return new Cell(this.#dataCell);
+    }
+
+    getAssetPrice<T extends bigint | PoolAssetConfig>(asset: T): bigint | undefined {
+        const assetId = this.#extractAssetId(asset);
+        return this.#dict.get(assetId);
+    }
+
+    #extractAssetId(asset: bigint | PoolAssetConfig): bigint {
+        return typeof asset === 'bigint' ? asset : asset.assetId;
+    }
+}

package/src/prices/PricesCollector.ts

@@ -0,0 +1,139 @@
+import { Cell, Dictionary } from "@ton/core";
+import { MAINNET_POOL_CONFIG } from "../constants/pools";
+import { PoolAssetConfig, PoolAssetsConfig, PoolConfig } from "../types/Master";
+import { PriceSource } from "./sources";
+import { DefaultPriceSourcesConfig, PriceSourcesConfig, RawPriceData } from "./Types";
+import { collectAndFilterPrices, generatePriceSources, getMedianPrice, packAssetsData, packOraclesData, packPrices, verifyPricesSign, verifyPricesTimestamp } from "./utils";
+import { delay } from "../utils/utils";
+import { Prices } from "./Prices";
+import { checkNotInDebtAtAll } from "../api/math";
+
+
+export class PricesCollector {
+    #prices: RawPriceData[];
+    #poolConfig: PoolConfig;
+    #sourcesConfig: PriceSourcesConfig;
+    #priceSources: PriceSource[];
+
+    constructor(poolConfig: PoolConfig = MAINNET_POOL_CONFIG, sourcesConfig: PriceSourcesConfig = DefaultPriceSourcesConfig, additionalPriceSources?: PriceSource[]) {
+        this.#poolConfig = poolConfig;
+        this.#sourcesConfig = sourcesConfig;
+        this.#priceSources = generatePriceSources(this.#sourcesConfig, this.#poolConfig.oracles);
+
+        if (additionalPriceSources) {
+            this.#priceSources.push(...additionalPriceSources);
+        }
+
+        this.#prices = [];
+    }
+
+    // TODO Make UserData class and incapsulate raw bigintegers
+
+    async getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
+        const assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (assets.includes(undefined)) {
+            throw new Error("User from another pool");
+        }
+        return await this.getPrices(assets.map(x => x!), retries, timeout);
+    }
+
+
+    async getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt = false, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (checkNotInDebtAtAll(realPrincipals) && (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n && !collateralToDebt) {
+            return new Prices(Dictionary.empty<bigint, bigint>(), Cell.EMPTY);
+        }
+
+        if (assets.includes(undefined)) {
+            throw new Error("User from another pool");
+        }
+
+        if (!assets.includes(withdrawAsset)) {
+            assets.push(withdrawAsset);
+        }
+
+        if (collateralToDebt && assets.length == 1) {
+            throw new Error("Cannot debt only one supplied asset");
+        }
+
+        return await this.getPrices(assets.map(x => x!), retries, timeout);
+    }
+
+    async getPrices(assets: PoolAssetsConfig = this.#poolConfig.poolAssetsConfig, retries: number = 1, timeout: number = 3000): Promise<Prices> {
+        console.debug('[getPrices] Assets length', assets.length);
+
+        if (assets.length == 0) {
+            return new Prices(Dictionary.empty<bigint, bigint>(), Cell.EMPTY);
+        }
+
+        for (let i = 0; i <= retries; i++) {  // attemts = retries + 1
+            if (!this.#prices || this.#filterPrices() < this.#poolConfig.minimalOracles) {
+                //console.debug('[getPrices] Load prices attemp', i + 1)
+                if (i > 0) {
+                    await delay(timeout);
+                }
+                await this.#collectPrices();
+            } else {
+                break;
+            }
+        }
+
+        if (this.#prices.length < this.#poolConfig.minimalOracles) {
+            throw new Error(`Error per updating prices, valid ${this.#prices.length} of ${this.#poolConfig.minimalOracles}`);  // if still not enough data after retries
+        }
+        const prices = this.#getPricesByAssetList(assets);
+        return new Prices(prices.dict, prices.dataCell);
+    }
+
+    #getPricesByAssetList(assets: PoolAssetsConfig) {
+        //console.debug('[getPricesByAssetList] start')
+        let pricesFiltered = this.#prices;  // for strict check this.#prices.filter(x => assets.every(asset => x.dict.has(asset.assetId)));
+
+        if (pricesFiltered.length < this.#poolConfig.minimalOracles) {
+            throw new Error("Not enough price data");
+        }
+
+        if (pricesFiltered.length > this.#poolConfig.minimalOracles) {
+            const sortedByTimestamp = pricesFiltered.slice().sort((a, b) => b.timestamp - a.timestamp);
+            const newerPrices = sortedByTimestamp.slice(0, this.#poolConfig.minimalOracles);
+            pricesFiltered = newerPrices.sort((a, b) => a.oracleId - b.oracleId);
+        }
+
+        const medianData = assets.map(asset => ({ assetId: asset.assetId, medianPrice: getMedianPrice(this.#prices, asset.assetId)}));
+
+        const nonEmptymedianData = medianData.filter(x => x.medianPrice != null) as { assetId: bigint, medianPrice: bigint }[];
+
+        const packedMedianData = packAssetsData(nonEmptymedianData);
+
+        const oraclesData = this.#prices.map(x => ({oracle: {id: x.oracleId, pubkey: x.pubkey}, data: {timestamp: x.timestamp, prices: x.dict}, signature: x.signature}));
+        const packedOracleData = packOraclesData(oraclesData, nonEmptymedianData.map(x => x.assetId));
+
+        const dict = Dictionary.empty<bigint, bigint>();
+        for (const medianDataAsset of nonEmptymedianData) {
+            dict.set(medianDataAsset.assetId, medianDataAsset.medianPrice);
+        }
+
+        return {
+            dict: dict,
+            dataCell: packPrices(packedMedianData, packedOracleData)
+        }
+    }
+
+    async #collectPrices(): Promise<boolean> {
+        try {
+            this.#prices = await Promise.any(this.#priceSources.map(x => collectAndFilterPrices(x, this.#poolConfig)));
+            return true;
+        }
+        catch { }
+        return false;
+    }
+
+    #filterPrices(): number {  // filter again for expire check
+        this.#prices = this.#prices.filter(verifyPricesTimestamp());
+        return this.#prices.length;
+    }
+
+    #filterEmptyPrincipalsAndAssets(principals: Dictionary<bigint, bigint>) {
+        return principals.keys().filter(x => principals.get(x)! != 0n).map(x => this.#poolConfig.poolAssetsConfig.find(asset => asset.assetId == x));
+    }
+}