@evaafi/sdk 0.7.0 → 0.9.0

package/src/prices/sources/Icp.ts

@@ -1,23 +1,26 @@
 import { BackendPriceSource } from ".";
+import { FetchConfig, proxyFetchRetries, DefaultFetchConfig } from "../../utils/utils";
 
 export class IcpPriceSource extends BackendPriceSource {
     protected priceSourceName: string = 'IcpPriceSource';
 
-    async loadOracleData(): Promise<OutputData[]> {
-        let response = await fetch(`https://${this._endpoint}/prices`, {
+    async loadOracleData(fetchConfig: FetchConfig = DefaultFetchConfig): Promise<OutputData[]> {
+        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()) as Record<string, string>;
 
-        const data = (await response.json()) as Record<string, string>;
+            let outputData: OutputData[] = [];
 
-        let outputData: OutputData[] = [];
+            for (const nft of this._nfts) {
+                outputData.push({oracleId: nft.id, data: data[nft.address] })
+            }
 
-        for (const nft of this._nfts) {
-            outputData.push({oracleId: nft.id, data: data[nft.address] })
-        }
+            return outputData;
+        });
 
-        return outputData;
+        return await proxyFetchRetries(fetchPromise, fetchConfig);
     }
 }
 

package/src/prices/sources/PriceSource.ts

@@ -1,12 +1,13 @@
 import { RawPriceData } from "..";
-import { OracleNFT } from "../../types/Master";
+import { ExtendedEvaaOracle } from "../../types/Master";
+import { FetchConfig } from "../../utils/utils";
 
 export abstract class PriceSource {
     protected priceSourceName: string = 'BackendPriceSource';
     protected _endpoint: string;
-    protected _nfts: OracleNFT[];
+    protected _nfts: ExtendedEvaaOracle[];
 
-    constructor(endpoint: string, nfts: OracleNFT[]) {
+    constructor(endpoint: string, nfts: ExtendedEvaaOracle[]) {
         this._endpoint = endpoint;
         this._nfts = nfts;
     }
@@ -27,9 +28,9 @@ export abstract class PriceSource {
         this._endpoint = endpoint; 
     }
 
-    set nfts(nfts: OracleNFT[]) {
+    set nfts(nfts: ExtendedEvaaOracle[]) {
         this._nfts = nfts; 
     }
 
-    abstract getPrices(): Promise<RawPriceData[]>;
+    abstract getPrices(fetchConfig?: FetchConfig): Promise<RawPriceData[]>;
 }

package/src/prices/utils.ts

@@ -1,46 +1,28 @@
-import { beginCell, Cell, Dictionary, Slice } from "@ton/core"
-import { signVerify } from "@ton/crypto"
-import { BackendPriceSource, DefaultPriceSourcesConfig, IcpPriceSource, MAINNET_POOL_CONFIG, OraclePricesData, PriceData, PriceSource, PriceSourcesConfig, RawPriceData, TTL_ORACLE_DATA_SEC } from ".."
-import { Oracle, OracleNFT, PoolConfig } from "../types/Master"
-import { convertToMerkleProof, generateMerkleProofDirect } from "../utils/merkleProof"
+import { beginCell, Cell, Dictionary, Slice } from '@ton/core';
+import { signVerify } from '@ton/crypto';
+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 { BackendPriceSource } from './sources/Backend';
+import { IcpPriceSource } from './sources/Icp';
+import { PriceSource } from './sources/PriceSource';
+import { OraclePricesData, PriceData, PriceSourcesConfig, RawPriceData } from './Types';
 
 export function verifyPricesTimestamp() {
-    return function(priceData: RawPriceData): boolean {
+    return function (priceData: RawPriceData): boolean {
         const timestamp = Date.now() / 1000;
         const pricesTime = priceData.timestamp;
 
-        //console.debug('timestamp - pricesTime, pricesTime', timestamp - pricesTime, pricesTime);
         return timestamp - pricesTime < TTL_ORACLE_DATA_SEC;
-    }
+    };
 }
 
-export function verifyPricesSign(nfts: OracleNFT[]) {
-    return function(priceData: RawPriceData): boolean {
-        if (nfts.findIndex(x => x.pubkey.equals(priceData.pubkey)) == -1) {
-            //console.debug('[verifyPricesSign] nft not found');
-            return false;
-        }
-
-        return verifyRawPriceDataSign(priceData)
-    }
-}
-
-/* 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;
-    }
-} */
-
 export function getMedianPrice(pricesData: PriceData[], asset: bigint): bigint | null {
     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;
         }
@@ -51,38 +33,33 @@ export function getMedianPrice(pricesData: PriceData[], asset: bigint): bigint |
         } else {
             return sorted[mid];
         }
-    }
-    catch {
+    } catch {
         return null;
     }
 }
 
-export function packAssetsData(assetsData: {assetId: bigint, medianPrice: bigint}[]): Cell {
+export function packAssetsData(assetsData: { assetId: bigint; medianPrice: bigint }[]): Cell {
     if (assetsData.length == 0) {
-        throw new Error("No assets data to pack");
+        throw new Error('No assets data to pack');
     }
     return assetsData.reduceRight(
-        (acc: Cell | null, {assetId, medianPrice}) => beginCell()
-                                                          .storeUint(assetId, 256)
-                                                          .storeCoins(medianPrice)
-                                                          .storeMaybeRef(acc)
-                                                        .endCell(), 
-        null
+        (acc: Cell | null, { assetId, medianPrice }) =>
+            beginCell().storeUint(assetId, 256).storeCoins(medianPrice).storeMaybeRef(acc).endCell(),
+        null,
     )!;
 }
 
 export function packPrices(assetsDataCell: Cell, oraclesDataCell: Cell): Cell {
-    let pricesCell = beginCell()
-      .storeRef(assetsDataCell)
-      .storeRef(oraclesDataCell)
-    .endCell();
+    let pricesCell = beginCell().storeRef(assetsDataCell).storeRef(oraclesDataCell).endCell();
     return pricesCell;
 }
 
-export function createOracleDataProof(oracle: Oracle, 
-    data: OraclePricesData, 
+export function createOracleDataProof(
+    oracle: EvaaOracle,
+    data: OraclePricesData,
     signature: Buffer,
-    assets: Array<bigint>): Slice {
+    assets: Array<bigint>,
+): Slice {
     let prunedDict = generateMerkleProofDirect(data.prices, assets, Dictionary.Keys.BigUint(256));
     let prunedData = beginCell().storeUint(data.timestamp, 32).storeMaybeRef(prunedDict).endCell();
     let merkleProof = convertToMerkleProof(prunedData);
@@ -90,15 +67,20 @@ export function createOracleDataProof(oracle: Oracle,
     return oracleDataProof;
 }
 
-export function packOraclesData(oraclesData: {oracle: Oracle, data: OraclePricesData, signature: Buffer}[], 
-    assets: Array<bigint>): Cell {
+export function packOraclesData(
+    oraclesData: { oracle: EvaaOracle; data: OraclePricesData; signature: Buffer }[],
+    assets: Array<bigint>,
+): Cell {
     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)
-    );
-    return proofs.reduceRight((acc: Cell | null, val) => beginCell().storeSlice(val).storeMaybeRef(acc).endCell(), null)!;
+    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: Cell | null, val) => beginCell().storeSlice(val).storeMaybeRef(acc).endCell(),
+        null,
+    )!;
 }
 
 export function sumDicts(result: Dictionary<bigint, bigint>, addendum: Dictionary<bigint, bigint>) {
@@ -115,27 +97,31 @@ export function sumDicts(result: Dictionary<bigint, bigint>, addendum: Dictionar
     }
 }
 
-export function generatePriceSources(config: PriceSourcesConfig = DefaultPriceSourcesConfig, nfts: OracleNFT[] = MAINNET_POOL_CONFIG.oracles) {
-    let result: PriceSource[] = config.backendEndpoints.map(x => new BackendPriceSource(x, nfts));
+export function generatePriceSources(config: PriceSourcesConfig, nfts: ExtendedEvaaOracle[]) {
+    let result: PriceSource[] = config.backendEndpoints.map((x) => new BackendPriceSource(x, nfts));
 
-    result.push(...config.icpEndpoints.map(x => new IcpPriceSource(x, nfts)));
+    result.push(...config.icpEndpoints.map((x) => new IcpPriceSource(x, nfts)));
 
     return result;
 }
 
-export async function collectAndFilterPrices(priceSource: PriceSource, poolConfig: PoolConfig): Promise<RawPriceData[]> {
-    const prices = await priceSource.getPrices();
-         
+export async function collectAndFilterPrices(
+    priceSource: PriceSource,
+    minimalOracles: number,
+    fetchConfig?: FetchConfig,
+): Promise<RawPriceData[]> {
+    const prices = await priceSource.getPrices(fetchConfig);
+
     //console.debug('[FILTERING] before filtering prices len ', priceSource.sourceName, prices.length);
     return (async () => {
-            const acceptedPrices: RawPriceData[] = prices.filter(
-            price => verifyPricesTimestamp()(price) && verifyPricesSign(poolConfig.oracles)(price)
+        const acceptedPrices: RawPriceData[] = 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;
@@ -157,8 +143,19 @@ export function unpackMedianPrices(pricesCell: Cell): Dictionary<bigint, bigint>
     return res;
 }
 
+export function verifyPricesSign(nfts: ExtendedEvaaOracle[]) {
+    return function (priceData: RawPriceData): boolean {
+        if (nfts.findIndex((x) => x.pubkey.equals(priceData.pubkey as Uint8Array)) == -1) {
+            //console.debug('[verifyPricesSign] nft not found');
+            return false;
+        }
+
+        return verifyRawPriceDataSign(priceData);
+    };
+}
+
 export function verifyRawPriceDataSign(priceData: RawPriceData): boolean {
-    const message = priceData.dataCell.refs[0].hash()
+    const message = priceData.dataCell.refs[0].hash();
     const signature = priceData.signature;
     const publicKey = priceData.pubkey;
 

package/src/types/Master.ts

@@ -1,17 +1,19 @@
-import { Address, Cell, Dictionary } from '@ton/core'
+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,
-    ASSET_PRICE_SCALE: bigint,
-    ASSET_RESERVE_FACTOR_SCALE: bigint,
-    ASSET_LIQUIDATION_RESERVE_FACTOR_SCALE: bigint,
-    ASSET_LIQUIDATION_THRESHOLD_SCALE: bigint,
-    ASSET_LIQUIDATION_BONUS_SCALE: bigint,
-    ASSET_ORIGINATION_FEE_SCALE: bigint,
-    ASSET_SRATE_SCALE: bigint,
-    ASSET_BRATE_SCALE: bigint,
-    COLLATERAL_WORTH_THRESHOLD: bigint,
+    FACTOR_SCALE: bigint;
+    ASSET_COEFFICIENT_SCALE: bigint;
+    ASSET_PRICE_SCALE: bigint;
+    ASSET_RESERVE_FACTOR_SCALE: bigint;
+    ASSET_LIQUIDATION_RESERVE_FACTOR_SCALE: bigint;
+    ASSET_LIQUIDATION_THRESHOLD_SCALE: bigint;
+    ASSET_LIQUIDATION_BONUS_SCALE: bigint;
+    ASSET_ORIGINATION_FEE_SCALE: bigint;
+    ASSET_SRATE_SCALE: bigint;
+    ASSET_BRATE_SCALE: bigint;
+    COLLATERAL_WORTH_THRESHOLD: bigint;
 };
 
 export type PoolAssetsConfig = PoolAssetConfig[];
@@ -21,16 +23,15 @@ export type PoolAssetConfig = {
     assetId: bigint;
     jettonMasterAddress: Address;
     jettonWalletCode: Cell;
-}
+};
 
 export type PoolConfig = {
     masterAddress: Address;
     masterVersion: number;
     masterConstants: MasterConstants;
-    oracles: OracleNFT[];
-    minimalOracles: number;
     poolAssetsConfig: PoolAssetsConfig;
     lendingCode: Cell;
+    oracles: Oracle;
 };
 
 export type UpgradeConfig = {
@@ -46,7 +47,7 @@ export type UpgradeConfig = {
 };
 
 export type AssetConfig = {
-    oracle: bigint;
+    jwAddress: bigint;
     decimals: bigint;
     collateralFactor: bigint;
     liquidationThreshold: bigint;
@@ -65,19 +66,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 = {
@@ -106,31 +98,16 @@ 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,
-    address: string,
-    pubkey: Buffer
-}
+export type ExtendedEvaaOracle = EvaaOracle & {
+    address: string;
+};
 
-export type Oracle = {
-    id: number,
-    pubkey: Buffer
-}
+export type EvaaOracle = {
+    id: number;
+    pubkey: Buffer;
+};

package/src/types/User.ts

@@ -1,5 +1,13 @@
-import { Address, BitBuilder, Cell, Dictionary } from '@ton/core';
-import { AssetConfig, AssetData, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants, PoolAssetConfig, PoolConfig } from './Master';
+import { Address, Cell, Dictionary } from '@ton/core';
+import {
+    AssetConfig,
+    AssetData,
+    ExtendedAssetsConfig,
+    ExtendedAssetsData,
+    MasterConstants,
+    PoolAssetConfig,
+    PoolConfig,
+} from './Master';
 
 export enum BalanceType {
     supply = 'supply',
@@ -38,7 +46,7 @@ export type UserLiteData = {
     masterAddress: Address;
     ownerAddress: Address;
     principals: Dictionary<bigint, bigint>;
-    realPrincipals: Dictionary<bigint, bigint>;  // principals before applying dusts
+    realPrincipals: Dictionary<bigint, bigint>; // principals before applying dusts
     state: number;
     balances: Dictionary<bigint, UserBalance>;
     trackingSupplyIndex: bigint;
@@ -82,18 +90,18 @@ export type HealthParamsArgs = {
     principals: Dictionary<bigint, bigint>;
     prices: Dictionary<bigint, bigint>;
     poolConfig: PoolConfig;
-}
+};
 
 export enum BalanceChangeType {
     Borrow = 0,
     Repay = 1,
     Supply = 2,
-    Withdraw = 3
+    Withdraw = 3,
 }
 
 export type PredictHealthFactorArgs = {
     balanceChangeType: BalanceChangeType;
-    amount: bigint;  // always positive
+    amount: bigint; // always positive
     asset: PoolAssetConfig;
     principals: Dictionary<bigint, bigint>;
     prices: Dictionary<bigint, bigint>;
@@ -104,7 +112,7 @@ export type PredictHealthFactorArgs = {
 
 export type PredictAPYArgs = {
     balanceChangeType: BalanceChangeType;
-    amount: bigint;  // always positive
+    amount: bigint; // always positive
     assetData: AssetData;
     assetConfig: AssetConfig;
     masterConstants: MasterConstants;

package/src/utils/userJettonWallet.ts

@@ -4,14 +4,6 @@ import { UNDEFINED_ASSET } from '../constants/assets';
 
 function getUserJettonData(ownerAddress: Address, assetName: string, jettonWalletCode: Cell, jettonMasterAddress: Address) {
   switch (assetName) {
-      case 'uTON':
-          return beginCell()
-              .storeCoins(0)
-              .storeUint(0, 64)
-              .storeAddress(ownerAddress)
-              .storeAddress(jettonMasterAddress)
-              .storeRef(jettonWalletCode)
-              .endCell();
       case 'DOGS':
       case 'NOT':
       case 'USDT':

package/src/utils/utils.ts

@@ -1,5 +1,5 @@
-import { PoolAssetConfig } from "../types/Master";
 import { ASSET_ID } from '../constants/assets';
+import { PoolAssetConfig } from '../types/Master';
 
 export function isTonAsset(asset: PoolAssetConfig) {
     return asset.name === 'TON';
@@ -10,5 +10,44 @@ export function isTonAssetId(assetId: bigint) {
 }
 
 export function delay(ms: number) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export interface FetchConfig {
+    retries: number;
+    timeout: number;
+}
+
+export const DefaultFetchConfig: FetchConfig = {
+    retries: 3,
+    timeout: 1000,
+};
+
+export async function proxyFetchRetries<T>(fetch: Promise<T>, config: FetchConfig = DefaultFetchConfig) {
+    let lastError: Error | null = null;
+    for (let attempt = 0; attempt <= config.retries; attempt++) {
+        try {
+            const timeoutPromise = new Promise<never>((_, 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)}`,
+    );
+}
+
+export function isValidSubaccountId(subaccountId: number) {
+    return (subaccountId << 16) >> 16 === subaccountId && subaccountId !== -0x8000;
 }