@evaafi/sdk 0.5.6 → 0.6.0-a

package/src/types/Master.ts

@@ -24,7 +24,8 @@ export type PoolConfig = {
     masterAddress: Address;
     masterVersion: number;
     masterConstants: MasterConstants;
-    nftId: string;
+    oracles: OracleNFT[];
+    minimalOracles: number;
     poolAssetsConfig: PoolAssetsConfig;
     lendingCode: Cell;
 };
@@ -36,7 +37,7 @@ export type UpgradeConfig = {
     updateTime: number;
     freezeTime: number;
     userCode: Cell;
-    blankCode: Cell;
+    //blankCode: Cell;
     newMasterCode: Cell | null;
     newUserCode: Cell | null;
 };
@@ -58,18 +59,22 @@ export type AssetConfig = {
     maxTotalSupply: bigint;
     reserveFactor: bigint;
     liquidationReserveFactor: bigint;
-    /* Will be in v6 
     minPrincipalForRewards: bigint;
     baseTrackingSupplySpeed: bigint;
-    baseTrackingBorrowSpeed: bigint; */
+    baseTrackingBorrowSpeed: bigint;
 };
 
 export type MasterConfig = {
     ifActive: number;
     admin: Address;
-    adminPK: bigint;
+    oraclesInfo: OraclesInfo
     tokenKeys: Cell | null;
-    walletToMaster: Cell | null;
+};
+
+export type OraclesInfo = {
+    numOracles: number;
+    threshold: number;
+    oracles: Cell | null;
 };
 
 export type AssetData = {
@@ -79,10 +84,9 @@ export type AssetData = {
     totalBorrow: bigint;
     lastAccural: bigint;
     balance: bigint;
-    /* Will be in v6 
     trackingSupplyIndex: bigint;
     trackingBorrowIndex: bigint;
-    lastTrackingAccural: bigint; */
+    awaitedSupply?: bigint;
 };
 
 export type AssetInterest = {
@@ -115,4 +119,14 @@ export type MasterData = {
 export type AgregatedBalances = {
     totalBorrow: bigint;
     totalSupply: bigint;
-}
+}
+
+export type OracleNFT = {
+    id: number,
+    address: string
+}
+
+export type Oracle = {
+    id: number,
+    pubkey: Buffer
+}

package/src/types/User.ts

@@ -44,10 +44,9 @@ export type UserLiteData = {
     trackingBorrowIndex: bigint;
     dutchAuctionStart: number;
     backupCell: Cell;
-    /* Will be in v6 
     rewards: Dictionary<bigint, UserRewards>;
     backupCell1: Cell | null;
-    backupCell2: Cell | null; */
+    backupCell2: Cell | null;
 };
 
 export type UserDataActive = UserLiteData & {
@@ -85,7 +84,7 @@ export enum BalanceChangeType {
 export type PredictHealthFactorArgs = {
     balanceChangeType: BalanceChangeType;
     amount: bigint;  // always positive
-    tokenSymbol: string;
+    asset: PoolAssetConfig;
     principals: Dictionary<bigint, bigint>;
     prices: Dictionary<bigint, bigint>;
     assetsData: ExtendedAssetsData;

package/src/utils/merkleProof.ts

@@ -0,0 +1,141 @@
+import { Builder, Cell, Dictionary, DictionaryKey, DictionaryKeyTypes, Slice, beginCell } from "@ton/core";
+
+function readUnaryLength(slice: Slice) {
+    let res = 0;
+    while (slice.loadBit()) {
+        res++;
+    }
+    return res;
+}
+
+function endExoticCell(b: Builder): Cell {
+    let c = b.endCell();
+    return new Cell({exotic: true, bits: c.bits, refs: c.refs});
+}
+
+export function convertToMerkleProof(c: Cell): Cell {
+    return endExoticCell(beginCell()
+        .storeUint(3, 8)
+        .storeBuffer(c.hash(0))
+        .storeUint(c.depth(0), 16)
+        .storeRef(c));
+}
+
+function convertToPrunedBranch(c: Cell): Cell {
+    return endExoticCell(beginCell()
+        .storeUint(1, 8)
+        .storeUint(1, 8)
+        .storeBuffer(c.hash(0))
+        .storeUint(c.depth(0), 16));
+}
+
+function doGenerateMerkleProof(
+    prefix: string,
+    slice: Slice,
+    n: number,
+    keys: string[]
+): Cell {
+    // Reading label
+    const originalCell = slice.asCell();
+
+    if (keys.length == 0) {
+        // no keys to prove, prune the whole subdict
+        return convertToPrunedBranch(originalCell);
+    }
+
+    let lb0 = slice.loadBit() ? 1 : 0;
+    let prefixLength = 0;
+    let pp = prefix;
+
+    if (lb0 === 0) {
+        // Short label detected
+
+        // Read
+        prefixLength = readUnaryLength(slice);
+
+        // Read prefix
+        for (let i = 0; i < prefixLength; i++) {
+            pp += slice.loadBit() ? '1' : '0';
+        }
+    } else {
+        let lb1 = slice.loadBit() ? 1 : 0;
+        if (lb1 === 0) {
+            // Long label detected
+            prefixLength = slice.loadUint(Math.ceil(Math.log2(n + 1)));
+            for (let i = 0; i < prefixLength; i++) {
+                pp += slice.loadBit() ? '1' : '0';
+            }
+        } else {
+            // Same label detected
+            let bit = slice.loadBit() ? '1' : '0';
+            prefixLength = slice.loadUint(Math.ceil(Math.log2(n + 1)));
+            for (let i = 0; i < prefixLength; i++) {
+                pp += bit;
+            }
+        }
+    }
+
+    if (n - prefixLength === 0) {
+        return originalCell;
+    } else {
+        let sl = originalCell.beginParse();
+        let left = sl.loadRef();
+        let right = sl.loadRef();
+        // NOTE: Left and right branches are implicitly contain prefixes '0' and '1'
+        if (!left.isExotic) {
+            const leftKeys = keys.filter((key) => {
+                return pp + '0' === key.slice(0, pp.length + 1);
+            });
+            left = doGenerateMerkleProof(
+                pp + '0',
+                left.beginParse(),
+                n - prefixLength - 1,
+                leftKeys
+            );
+        }
+        if (!right.isExotic) {
+            const rightKeys = keys.filter((key) => {
+                return pp + '1' === key.slice(0, pp.length + 1);
+            });
+            right = doGenerateMerkleProof(
+                pp + '1',
+                right.beginParse(),
+                n - prefixLength - 1,
+                rightKeys
+            );
+        }
+
+        return beginCell()
+            .storeSlice(sl)
+            .storeRef(left)
+            .storeRef(right)
+            .endCell();
+    }
+}
+
+export function generateMerkleProofDirect<K extends DictionaryKeyTypes, V>(
+    dict: Dictionary<K, V>,
+    keys: K[],
+    keyObject: DictionaryKey<K>
+): Cell {
+    keys.forEach((key) => {
+        if (!dict.has(key)) {
+            throw new Error(`Trying to generate merkle proof for a missing key "${key}"`)
+        }
+    })
+    const s = beginCell().storeDictDirect(dict).asSlice();
+    return doGenerateMerkleProof(
+            '',
+            s,
+            keyObject.bits,
+            keys.map((key) => keyObject.serialize(key).toString(2).padStart(keyObject.bits, '0'))
+    );
+}
+
+export function generateMerkleProof<K extends DictionaryKeyTypes, V>(
+    dict: Dictionary<K, V>,
+    keys: K[],
+    keyObject: DictionaryKey<K>
+): Cell {
+    return convertToMerkleProof(generateMerkleProofDirect(dict, keys, keyObject));
+}

package/src/utils/priceUtils.ts

@@ -0,0 +1,177 @@
+import { beginCell, Cell, Dictionary, Slice } from "@ton/core";
+import { PriceData, RawPriceData } from "../types/Common";
+import { TTL_ORACLE_DATA_SEC } from "../config";
+import { Oracle, PoolAssetsConfig } from "../types/Master";
+import { convertToMerkleProof, generateMerkleProofDirect } from "./merkleProof";
+
+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;
+        }[];
+    };
+};
+
+export type OraclePricesData = {
+    timestamp: number, 
+    prices: Dictionary<bigint, bigint>
+}
+
+export async function loadPrices(oracleNftId: String, endpoints: String[]): Promise<OutputData> {
+    return await Promise.any(endpoints.map(x => loadOracleData(oracleNftId, x)));
+}
+
+
+async function loadOracleData(oracleNftId: String, endpoint: String): Promise<OutputData> {
+    let result = await fetch(`https://${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://${endpoint}/api/core/v2/outputs/${outputId.items[0]}`, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(5000)
+    });
+    return (await result.json() as OutputData);
+}
+
+export async function parsePrices(outputData: OutputData, oracleId: number): Promise<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.log(oracleId, data, error);
+        throw Error();
+    }
+}
+
+export function verifyPrices(assets: PoolAssetsConfig) {
+    return function(priceData: RawPriceData): boolean {
+        const timestamp = Date.now() / 1000;
+        const pricesTime = priceData.timestamp;
+
+        for (const asset of assets) {
+            if(!priceData.dict.has(asset.assetId)) {
+                return false;
+            }
+        }
+        // console.log('timestamp', timestamp, 'pricestime', pricesTime, timestamp - pricesTime);
+        return timestamp - pricesTime < TTL_ORACLE_DATA_SEC;
+    }
+}
+
+export function getMedianPrice(pricesData: PriceData[], asset: bigint): bigint {
+    const sorted = pricesData.map(x => x.dict.get(asset)!).sort((a, b) => Number(a) - Number(b));
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return (sorted[mid - 1] + sorted[mid]) / 2n;
+    } else {
+        return sorted[mid];
+    }
+}
+
+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)!;
+}
+
+
+// : String = "api.stardust-mainnet.iotaledger.net"
+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);
+    }
+}