@evaafi/sdk 0.6.1 → 0.6.2-b

package/src/prices/Types.ts

@@ -0,0 +1,44 @@
+import { Cell, Dictionary } from '@ton/core';
+
+/**
+ * Configuration for price source endpoints.
+ */
+export type PriceSourcesConfig = {
+    /** Endpoints for backend price data */
+    backendEndpoints: string[];
+    
+    /** Endpoints for IOTA price data */
+    iotaEndpoints: string[];
+    
+    /** Endpoints for ICP price data */
+    icpEndpoints: string[];
+};
+
+/**
+ * Default configuration for price source endpoints.
+ */
+export const DefaultPriceSourcesConfig: PriceSourcesConfig = {
+    backendEndpoints: ['evaa.space'],
+    iotaEndpoints: ['api.stardust-mainnet.iotaledger.net'],
+    icpEndpoints: ['6khmc-aiaaa-aaaap-ansfq-cai.raw.icp0.io'],
+}
+
+export type RawPriceData = {
+    dict: Dictionary<bigint, bigint>;
+    dataCell: Cell;
+    oracleId: number;
+    signature: Buffer;
+    pubkey: Buffer;
+    timestamp: number;
+};
+
+
+export type PriceData = {
+    dict: Dictionary<bigint, bigint>;
+    dataCell: Cell;
+};
+
+export type OraclePricesData = {
+    timestamp: number, 
+    prices: Dictionary<bigint, bigint>
+}

package/src/prices/constants.ts

@@ -0,0 +1 @@
+export const TTL_ORACLE_DATA_SEC = 120;

package/src/prices/index.ts

@@ -0,0 +1,6 @@
+export * from './sources';
+export * from './Types';
+export * from './constants';
+export * from './utils';
+export * from './Prices';
+export * from './PricesCollector';

package/src/prices/sources/Backend.ts

@@ -0,0 +1,62 @@
+import { beginCell, Cell, Dictionary } from "@ton/core";
+import { RawPriceData } from "..";
+import { PriceSource } from "./PriceSource";
+
+export class BackendPriceSource extends PriceSource {
+    protected priceSourceName: string = 'BackendPriceSource';
+
+    async getPrices(): Promise<RawPriceData[]> {
+        const data = await this.loadOracleData();
+        return data.map(outputData => this.parsePrices(outputData));
+    }
+
+    async loadOracleData(): Promise<OutputData[]> {
+        let response = await fetch(`https://${this._endpoint}/api/prices`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(5000)
+        });
+
+        const resp = (await response.json());
+        const data = resp as Record<string, string>;
+        let outputData: OutputData[] = [];
+
+        for (const nft of this._nfts) {
+            outputData.push({ oracleId: nft.id, data: data[nft.address] })
+        }
+    
+        return outputData;
+    }
+
+
+    parsePrices(outputData: OutputData): RawPriceData {
+        try {
+            //console.debug('outputData', outputData);
+            //console.debug(outputData.data.replace('0x', '').replace(/[0-9a-f]{2}/g, '%$&'))
+            const data = JSON.parse(
+                decodeURIComponent(outputData.data.replace('0x', '').replace(/[0-9a-f]{2}/g, '%$&')),
+            );
+            const pricesCell = Cell.fromBoc(Buffer.from(data['packedPrices'], 'hex'))[0];
+            const signature = Buffer.from(data['signature'], 'hex');
+            const publicKey = Buffer.from(data['publicKey'], 'hex');
+            const timestamp = Number(data['timestamp']);
+
+            return {
+                dict: pricesCell.beginParse().loadRef().beginParse().loadDictDirect(Dictionary.Keys.BigUint(256), Dictionary.Values.BigVarUint(4)),
+                dataCell: beginCell().storeRef(pricesCell).storeBuffer(signature).endCell(),
+                oracleId: outputData.oracleId,
+                signature: signature,
+                pubkey: publicKey,
+                timestamp: timestamp,
+            };
+        }
+        catch (error) {
+            //console.debug(`Price source error ${this.priceSourceName} ${outputData.oracleId} ${outputData.data} ${error}`);
+            throw error;
+        }
+    }
+}
+
+type OutputData = {
+    oracleId: number,
+    data: string
+};

package/src/prices/sources/Icp.ts

@@ -0,0 +1,27 @@
+import { BackendPriceSource } from ".";
+
+export class IcpPriceSource extends BackendPriceSource {
+    protected priceSourceName: string = 'IcpPriceSource';
+
+    async loadOracleData(): Promise<OutputData[]> {
+        let response = await fetch(`https://${this._endpoint}/prices`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(5000)
+        });
+
+        const data = (await response.json()) as Record<string, string>;
+
+        let outputData: OutputData[] = [];
+
+        for (const nft of this._nfts) {
+            outputData.push({oracleId: nft.id, data: data[nft.address] })
+        }
+
+        return outputData;
+    }
+}
+
+type OutputData = {
+    oracleId: number,
+    data: string
+};

package/src/prices/sources/Iota.ts

@@ -0,0 +1,90 @@
+import { beginCell, Cell, Dictionary } from "@ton/core";
+import { PriceSource } from "./PriceSource";
+import { RawPriceData } from "..";
+
+export class IotaPriceSource extends PriceSource {
+    protected priceSourceName: string = 'IotaPriceSource';
+
+    async getPrices(): Promise<RawPriceData[]> {
+        return await Promise.all(this.nfts.map(nft => this.loadOracleData(nft.address)
+                .then(x => this.parsePrices(x, nft.id))));
+    }
+
+    async loadOracleData(oracleNftId: String): Promise<OutputData> {
+        let result = await fetch(`https://${this._endpoint}/api/indexer/v1/outputs/nft/${oracleNftId}`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(5000)
+        });
+        let outputId = (await result.json()) as NftData;
+
+        result = await fetch(`https://${this._endpoint}/api/core/v2/outputs/${outputId.items[0]}`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(5000)
+        });
+        return (await result.json() as OutputData);
+    }
+
+
+    parsePrices(outputData: OutputData, oracleId: number): RawPriceData {
+        const data = JSON.parse(
+            decodeURIComponent(outputData.output.features[0].data.replace('0x', '').replace(/[0-9a-f]{2}/g, '%$&')),
+        );
+    
+        try {
+            const pricesCell = Cell.fromBoc(Buffer.from(data['packedPrices'], 'hex'))[0];
+            const signature = Buffer.from(data['signature'], 'hex');
+            const publicKey = Buffer.from(data['publicKey'], 'hex');
+            const timestamp = Number(data['timestamp']);
+
+            return {
+                dict: pricesCell.beginParse().loadRef().beginParse().loadDictDirect(Dictionary.Keys.BigUint(256), Dictionary.Values.BigVarUint(4)),
+                dataCell: beginCell().storeRef(pricesCell).storeBuffer(signature).endCell(),
+                oracleId: oracleId,
+                signature: signature,
+                pubkey: publicKey,
+                timestamp: timestamp,
+            };
+        }
+        catch (error) {
+            //console.debug(`Price source error ${this.priceSourceName} ${outputData} ${error}`);
+            throw error;
+        }
+    }
+}
+
+type NftData = {
+    ledgerIndex: number;
+    pageSize: number;
+    items: string[];
+};
+
+type OutputData = {
+    metadata: {
+        blockId: string;
+        transactionId: string;
+        outputIndex: number;
+        isSpent: boolean;
+        milestoneIndexSpent: number;
+        milestoneTimestampSpent: number;
+        transactionIdSpent: string;
+        milestoneIndexBooked: number;
+        milestoneTimestampBooked: number;
+        ledgerIndex: number;
+    };
+    output: {
+        type: number;
+        amount: string;
+        nftId: string;
+        unlockConditions: {
+            type: number;
+            address: {
+                type: number;
+                pubKeyHash: string;
+            };
+        }[];
+        features: {
+            type: number;
+            data: string;
+        }[];
+    };
+};

package/src/prices/sources/PriceSource.ts

@@ -0,0 +1,35 @@
+import { RawPriceData } from "..";
+import { OracleNFT } from "../../types/Master";
+
+export abstract class PriceSource {
+    protected priceSourceName: string = 'BackendPriceSource';
+    protected _endpoint: string;
+    protected _nfts: OracleNFT[];
+
+    constructor(endpoint: string, nfts: OracleNFT[]) {
+        this._endpoint = endpoint;
+        this._nfts = nfts;
+    }
+
+    get sourceName() {
+        return this.priceSourceName;
+    }
+
+    get endpoint() {
+        return this._endpoint;
+    }
+
+    get nfts() {
+        return this._nfts;
+    }
+
+    set endpoint(endpoint: string) {
+        this._endpoint = endpoint; 
+    }
+
+    set nfts(nfts: OracleNFT[]) {
+        this._nfts = nfts; 
+    }
+
+    abstract getPrices(): Promise<RawPriceData[]>;
+}

package/src/prices/sources/index.ts

@@ -0,0 +1,4 @@
+export * from './Backend';
+export * from './Iota';
+export * from './Icp';
+export * from './PriceSource';

package/src/prices/utils.ts

@@ -0,0 +1,170 @@
+import { beginCell, Cell, Dictionary, Slice } from "@ton/core";
+import { BackendPriceSource, DefaultPriceSourcesConfig, IcpPriceSource, IotaPriceSource, 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 { signVerify } from "@ton/crypto";
+
+export function verifyPricesTimestamp() {
+    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));
+        
+        if (sorted.length == 0) {
+            return null;
+        }
+
+        const mid = Math.floor(sorted.length / 2);
+        if (sorted.length % 2 === 0) {
+            return (sorted[mid - 1] + sorted[mid]) / 2n;
+        } else {
+            return sorted[mid];
+        }
+    }
+    catch {
+        return null;
+    }
+}
+
+export function packAssetsData(assetsData: {assetId: bigint, medianPrice: bigint}[]): Cell {
+    if (assetsData.length == 0) {
+        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
+    )!;
+}
+
+export function packPrices(assetsDataCell: Cell, oraclesDataCell: Cell): Cell {
+    let pricesCell = beginCell()
+      .storeRef(assetsDataCell)
+      .storeRef(oraclesDataCell)
+    .endCell();
+    return pricesCell;
+}
+
+export function createOracleDataProof(oracle: Oracle, 
+    data: OraclePricesData, 
+    signature: Buffer,
+    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);
+    let oracleDataProof = beginCell().storeUint(oracle.id, 32).storeRef(merkleProof).storeBuffer(signature).asSlice();
+    return oracleDataProof;
+}
+
+export function packOraclesData(oraclesData: {oracle: Oracle, data: OraclePricesData, signature: Buffer}[], 
+    assets: Array<bigint>): Cell {
+    if (oraclesData.length == 0) {
+        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)!;
+}
+
+export function sumDicts(result: Dictionary<bigint, bigint>, addendum: Dictionary<bigint, bigint>) {
+    for (const key of addendum.keys()) {
+        const current = result.get(key)!;
+        const value = addendum.get(key)!;
+
+        if (current === undefined) {
+            result.set(key, value);
+            continue;
+        }
+
+        result.set(key, current + value);
+    }
+}
+
+export function generatePriceSources(config: PriceSourcesConfig = DefaultPriceSourcesConfig, nfts: OracleNFT[] = MAINNET_POOL_CONFIG.oracles) {
+    let result: PriceSource[] = config.backendEndpoints.map(x => new BackendPriceSource(x, nfts));
+
+    result.push(...config.icpEndpoints.map(x => new IcpPriceSource(x, nfts)));
+    result.push(...config.iotaEndpoints.map(x => new IotaPriceSource(x, nfts)));
+
+    return result;
+}
+
+export async function collectAndFilterPrices(priceSource: PriceSource, poolConfig: PoolConfig): Promise<RawPriceData[]> {
+    const prices = await priceSource.getPrices();
+         
+    //console.debug('[FILTERING] before filtering prices len ', priceSource.sourceName, prices.length);
+    return await (async () => {
+            const acceptedPrices: RawPriceData[] = prices.filter(
+            price => verifyPricesTimestamp()(price) && verifyPricesSign(poolConfig.oracles)(price)
+        );
+
+        //console.debug('[FILTERING] after filtering prices len ', priceSource.sourceName, acceptedPrices.length);
+
+        if (acceptedPrices.length < poolConfig.minimalOracles) {
+            throw new Error("Prices are outdated");
+        }
+
+        return acceptedPrices;
+    })();
+}
+
+export function unpackMedianPrices(pricesCell: Cell): Dictionary<bigint, bigint> | undefined {
+    if (!pricesCell) return undefined;
+    const slice = pricesCell.beginParse();
+    let assetCell: Cell | null = slice.loadRef();
+    const res = Dictionary.empty<bigint, bigint>();
+    while (assetCell != Cell.EMPTY && assetCell !== null) {
+        const slice = assetCell.beginParse();
+        const assetId = slice.loadUintBig(256);
+        const medianPrice = slice.loadCoins();
+        res.set(assetId, medianPrice);
+        assetCell = slice.loadMaybeRef();
+    }
+    return res;
+}
+
+export function verifyRawPriceDataSign(priceData: RawPriceData): boolean {
+    const message = priceData.dataCell.refs[0].hash()
+    const signature = priceData.signature;
+    const publicKey = priceData.pubkey;
+
+    const valid: boolean = signVerify(message, signature, publicKey);
+    //console.debug('[verifyRawPriceDataSign] sign is valid:', valid);
+
+    return valid;
+}

package/src/types/Master.ts

@@ -89,7 +89,7 @@ export type AssetData = {
     balance: bigint;
     trackingSupplyIndex: bigint;
     trackingBorrowIndex: bigint;
-    awaitedSupply?: bigint;
+    awaitedSupply: bigint;
 };
 
 export type AssetInterest = {
@@ -126,7 +126,8 @@ export type AgregatedBalances = {
 
 export type OracleNFT = {
     id: number,
-    address: string
+    address: string,
+    pubkey: Buffer
 }
 
 export type Oracle = {

package/src/types/User.ts

@@ -1,5 +1,5 @@
-import { Address, Cell, Dictionary } from '@ton/core';
-import { AssetConfig, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants, PoolAssetConfig, PoolConfig } from './Master';
+import { Address, BitBuilder, Cell, Dictionary } from '@ton/core';
+import { AssetConfig, AssetData, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants, PoolAssetConfig, PoolConfig } from './Master';
 
 export enum BalanceType {
     supply = 'supply',
@@ -38,6 +38,7 @@ export type UserLiteData = {
     masterAddress: Address;
     ownerAddress: Address;
     principals: Dictionary<bigint, bigint>;
+    realPrincipals: Dictionary<bigint, bigint>;  // principals before applying dusts
     state: number;
     balances: Dictionary<bigint, UserBalance>;
     trackingSupplyIndex: bigint;
@@ -47,6 +48,7 @@ export type UserLiteData = {
     rewards: Dictionary<bigint, UserRewards>;
     backupCell1: Cell | null;
     backupCell2: Cell | null;
+    fullyParsed: boolean;
 };
 
 export type UserDataActive = UserLiteData & {
@@ -59,8 +61,8 @@ export type UserDataActive = UserLiteData & {
     limitUsedPercent: number;
     limitUsed: bigint;
     healthFactor: number;
-
     liquidationData: LiquidationData;
+    havePrincipalWithoutPrice: boolean;
 };
 
 export type UserDataInactive = {
@@ -99,3 +101,11 @@ export type PredictHealthFactorArgs = {
     assetsConfig: ExtendedAssetsConfig;
     poolConfig: PoolConfig;
 };
+
+export type PredictAPYArgs = {
+    balanceChangeType: BalanceChangeType;
+    amount: bigint;  // always positive
+    assetData: AssetData;
+    assetConfig: AssetConfig;
+    masterConstants: MasterConstants;
+};

package/src/utils/userJettonWallet.ts

@@ -2,66 +2,56 @@ import { Address, beginCell, Cell, storeStateInit } from '@ton/core';
 import { PoolAssetConfig } from '../types/Master';
 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':
+      return beginCell()
+        .storeUint(0, 4)
+        .storeCoins(0)
+        .storeAddress(ownerAddress)
+        .storeAddress(jettonMasterAddress)
+        .endCell();
+    case 'tsTON':
+        return beginCell()
+          .storeCoins(0)
+          .storeAddress(ownerAddress)
+          .storeAddress(jettonMasterAddress)
+          .storeRef(jettonWalletCode)
+          .storeCoins(0)
+          .storeUint(0, 48)
+          .endCell();
+    default:
+      return beginCell().storeCoins(0)
+        .storeAddress(ownerAddress)
+        .storeAddress(jettonMasterAddress)
+        .storeRef(jettonWalletCode)
+        .endCell();
+
+  }
+}
 export function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig) {
-  if (poolAssetConfig.name == 'TON' || poolAssetConfig.assetId === UNDEFINED_ASSET.assetId) {
+  const assetName = poolAssetConfig.name;
+  if (assetName == 'TON' || poolAssetConfig.assetId === UNDEFINED_ASSET.assetId) {
     throw new Error(`Cant getUserJettonWallet for ${poolAssetConfig.name} asset`)
   }
-    const jettonMasterAddress = poolAssetConfig.jettonMasterAddress;
-    const jettonWalletCode = poolAssetConfig.jettonWalletCode;
-
-  if (poolAssetConfig.name === 'USDT') {
-    const lib_prep = beginCell().storeUint(2, 8).storeBuffer(jettonWalletCode.hash()).endCell();
-    const jwallet_code = new Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
-
-    const jettonData = beginCell()
-      .storeUint(0, 4)
-      .storeCoins(0)
-      .storeAddress(ownerAddress)
-      .storeAddress(jettonMasterAddress)
-      .endCell();
-
-    const stateInit = beginCell()
-      .store(
-        storeStateInit({
-          code: jwallet_code,
-          data: jettonData
-        })
-      )
-      .endCell();
-    return new Address(0, stateInit.hash());
-  }
+  let jettonWalletCode = poolAssetConfig.jettonWalletCode;
 
-  if (poolAssetConfig.name === 'tsTON') {
+  if (assetName === 'USDT' || assetName === 'tsTON') {
     const lib_prep = beginCell().storeUint(2, 8).storeBuffer(jettonWalletCode.hash()).endCell();
-    const jwallet_code = new Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
-
-    const jettonData = beginCell()
-      .storeCoins(0)
-      .storeAddress(ownerAddress)
-      .storeAddress(jettonMasterAddress)
-      .storeRef(jwallet_code)
-      .storeCoins(0)
-      .storeUint(0, 48)
-      .endCell();
-
-    const stateInit = beginCell()
-      .store(
-        storeStateInit({
-          code: jwallet_code,
-          data: jettonData
-        })
-      )
-      .endCell();
-
-    return new Address(0, stateInit.hash());
+    jettonWalletCode = new Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
   }
 
-  const jettonData = beginCell()
-    .storeCoins(0)
-    .storeAddress(ownerAddress)
-    .storeAddress(jettonMasterAddress)
-    .storeRef(jettonWalletCode)
-    .endCell();
+  const jettonData = getUserJettonData(ownerAddress, assetName, jettonWalletCode, poolAssetConfig.jettonMasterAddress);
 
   const stateInit = beginCell()
     .store(

package/src/utils/utils.ts

@@ -7,4 +7,8 @@ export function isTonAsset(asset: PoolAssetConfig) {
 
 export function isTonAssetId(assetId: bigint) {
     return assetId === ASSET_ID.TON;
-}
+}
+
+export function delay(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/config.ts

@@ -1 +0,0 @@
-export const TTL_ORACLE_DATA_SEC = 120;  // todo back to 120

package/src/types/Common.ts

@@ -1,16 +0,0 @@
-import { Cell, Dictionary } from '@ton/core';
-
-export type RawPriceData = {
-    dict: Dictionary<bigint, bigint>;
-    dataCell: Cell;
-    oracleId: number;
-    signature: Buffer;
-    pubkey: Buffer;
-    timestamp: number;
-};
-
-
-export type PriceData = {
-    dict: Dictionary<bigint, bigint>;
-    dataCell: Cell;
-};