@evaafi/sdk 0.5.4 → 0.5.6

package/dist/types/Master.d.ts

@@ -5,16 +5,13 @@ export type MasterConstants = {
     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;
 };
-export type PoolAssetConfig = (PoolTonAssetConfig | PoolJettonAssetConfig) & {
-    name: string;
-};
 export type PoolAssetsConfig = PoolAssetConfig[];
-export type PoolTonAssetConfig = {
-    assetId: bigint;
-};
-export type PoolJettonAssetConfig = {
+export type PoolAssetConfig = {
+    name: string;
     assetId: bigint;
     jettonMasterAddress: Address;
     jettonWalletCode: Cell;
@@ -94,3 +91,7 @@ export type MasterData = {
         borrow: Dictionary<bigint, number>;
     };
 };
+export type AgregatedBalances = {
+    totalBorrow: bigint;
+    totalSupply: bigint;
+};

package/dist/types/User.d.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, Dictionary } from '@ton/core';
-import { ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants } from './Master';
+import { ExtendedAssetsConfig, ExtendedAssetsData, PoolAssetConfig, PoolConfig } from './Master';
 export declare enum BalanceType {
     supply = "supply",
     borrow = "borrow"
@@ -10,9 +10,9 @@ export type UserBalance = {
 };
 export type UserLiqudationData = {
     greatestCollateralValue: bigint;
-    greatestCollateralAsset: bigint;
+    greatestCollateralAsset: PoolAssetConfig;
     greatestLoanValue: bigint;
-    greatestLoanAsset: bigint;
+    greatestLoanAsset: PoolAssetConfig;
     totalDebt: bigint;
     totalLimit: bigint;
 };
@@ -68,9 +68,9 @@ export type PredictHealthFactorArgs = {
     balanceChangeType: BalanceChangeType;
     amount: bigint;
     tokenSymbol: string;
-    balances: Dictionary<bigint, bigint>;
+    principals: Dictionary<bigint, bigint>;
     prices: Dictionary<bigint, bigint>;
     assetsData: ExtendedAssetsData;
     assetsConfig: ExtendedAssetsConfig;
-    masterConstants: MasterConstants;
+    poolConfig: PoolConfig;
 };

package/dist/utils/merkleProof.d.ts

@@ -0,0 +1,4 @@
+import { Cell, Dictionary, DictionaryKey, DictionaryKeyTypes } from "@ton/core";
+export declare function convertToMerkleProof(c: Cell): Cell;
+export declare function generateMerkleProofDirect<K extends DictionaryKeyTypes, V>(dict: Dictionary<K, V>, keys: K[], keyObject: DictionaryKey<K>): Cell;
+export declare function generateMerkleProof<K extends DictionaryKeyTypes, V>(dict: Dictionary<K, V>, keys: K[], keyObject: DictionaryKey<K>): Cell;

package/dist/utils/merkleProof.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToMerkleProof = convertToMerkleProof;
+exports.generateMerkleProofDirect = generateMerkleProofDirect;
+exports.generateMerkleProof = generateMerkleProof;
+const core_1 = require("@ton/core");
+function readUnaryLength(slice) {
+    let res = 0;
+    while (slice.loadBit()) {
+        res++;
+    }
+    return res;
+}
+function endExoticCell(b) {
+    let c = b.endCell();
+    return new core_1.Cell({ exotic: true, bits: c.bits, refs: c.refs });
+}
+function convertToMerkleProof(c) {
+    return endExoticCell((0, core_1.beginCell)()
+        .storeUint(3, 8)
+        .storeBuffer(c.hash(0))
+        .storeUint(c.depth(0), 16)
+        .storeRef(c));
+}
+function convertToPrunedBranch(c) {
+    return endExoticCell((0, core_1.beginCell)()
+        .storeUint(1, 8)
+        .storeUint(1, 8)
+        .storeBuffer(c.hash(0))
+        .storeUint(c.depth(0), 16));
+}
+function doGenerateMerkleProof(prefix, slice, n, keys) {
+    // 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 (0, core_1.beginCell)()
+            .storeSlice(sl)
+            .storeRef(left)
+            .storeRef(right)
+            .endCell();
+    }
+}
+function generateMerkleProofDirect(dict, keys, keyObject) {
+    keys.forEach((key) => {
+        if (!dict.has(key)) {
+            throw new Error(`Trying to generate merkle proof for a missing key "${key}"`);
+        }
+    });
+    const s = (0, core_1.beginCell)().storeDictDirect(dict).asSlice();
+    return doGenerateMerkleProof('', s, keyObject.bits, keys.map((key) => keyObject.serialize(key).toString(2).padStart(keyObject.bits, '0')));
+}
+function generateMerkleProof(dict, keys, keyObject) {
+    return convertToMerkleProof(generateMerkleProofDirect(dict, keys, keyObject));
+}

package/dist/utils/priceUtils.d.ts

@@ -0,0 +1,55 @@
+import { Cell, Dictionary, Slice } from "@ton/core";
+import { PriceData, RawPriceData } from "../types/Common";
+import { Oracle, PoolAssetsConfig } from "../types/Master";
+import 'promise.any';
+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 declare function loadPrices(oracleNftId: String, endpoints: String[], timeout: number): Promise<OutputData>;
+export declare function parsePrices(outputData: OutputData, oracleId: number): Promise<RawPriceData>;
+export declare function verifyPrices(assets: PoolAssetsConfig): (priceData: RawPriceData) => boolean;
+export declare function getMedianPrice(pricesData: PriceData[], asset: bigint): bigint;
+export declare function packAssetsData(assetsData: {
+    assetId: bigint;
+    medianPrice: bigint;
+}[]): Cell;
+export declare function packPrices(assetsDataCell: Cell, oraclesDataCell: Cell): Cell;
+export declare function createOracleDataProof(oracle: Oracle, data: OraclePricesData, signature: Buffer, assets: Array<bigint>): Slice;
+export declare function packOraclesData(oraclesData: {
+    oracle: Oracle;
+    data: OraclePricesData;
+    signature: Buffer;
+}[], assets: Array<bigint>): Cell;
+export declare function sumDicts(result: Dictionary<bigint, bigint>, addendum: Dictionary<bigint, bigint>): void;
+export {};

package/dist/utils/priceUtils.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPrices = loadPrices;
+exports.parsePrices = parsePrices;
+exports.verifyPrices = verifyPrices;
+exports.getMedianPrice = getMedianPrice;
+exports.packAssetsData = packAssetsData;
+exports.packPrices = packPrices;
+exports.createOracleDataProof = createOracleDataProof;
+exports.packOraclesData = packOraclesData;
+exports.sumDicts = sumDicts;
+const core_1 = require("@ton/core");
+const config_1 = require("../config");
+const merkleProof_1 = require("./merkleProof");
+require("promise.any");
+async function loadPrices(oracleNftId, endpoints, timeout) {
+    return await Promise.any(endpoints.map(x => loadOracleData(oracleNftId, x, timeout)));
+}
+async function loadOracleData(oracleNftId, endpoint, timeout) {
+    let result = await fetch(`https://${endpoint}/api/indexer/v1/outputs/nft/${oracleNftId}`, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(timeout)
+    });
+    let outputId = (await result.json());
+    result = await fetch(`https://${endpoint}/api/core/v2/outputs/${outputId.items[0]}`, {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(timeout)
+    });
+    return await result.json();
+}
+async function parsePrices(outputData, oracleId) {
+    const data = JSON.parse(decodeURIComponent(outputData.output.features[0].data.replace('0x', '').replace(/[0-9a-f]{2}/g, '%$&')));
+    try {
+        const pricesCell = core_1.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(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.BigVarUint(4)),
+            dataCell: (0, core_1.beginCell)().storeRef(pricesCell).storeBuffer(signature).endCell(),
+            oracleId: oracleId,
+            signature: signature,
+            pubkey: publicKey,
+            timestamp: timestamp,
+        };
+    }
+    catch (error) {
+        console.log(oracleId, data, error);
+        throw Error();
+    }
+}
+function verifyPrices(assets) {
+    return function (priceData) {
+        const timestamp = Date.now() / 1000;
+        const pricesTime = priceData.timestamp;
+        for (const [key, asset] of Object.entries(assets)) {
+            if (!priceData.dict.has(asset.assetId)) {
+                return false;
+            }
+        }
+        // console.log('timestamp', timestamp, 'pricestime', pricesTime, timestamp - pricesTime);
+        return timestamp - pricesTime < config_1.TTL_ORACLE_DATA_SEC;
+    };
+}
+function getMedianPrice(pricesData, asset) {
+    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];
+    }
+}
+function packAssetsData(assetsData) {
+    if (assetsData.length == 0) {
+        throw new Error("No assets data to pack");
+    }
+    return assetsData.reduceRight((acc, { assetId, medianPrice }) => (0, core_1.beginCell)()
+        .storeUint(assetId, 256)
+        .storeCoins(medianPrice)
+        .storeMaybeRef(acc)
+        .endCell(), null);
+}
+function packPrices(assetsDataCell, oraclesDataCell) {
+    let pricesCell = (0, core_1.beginCell)()
+        .storeRef(assetsDataCell)
+        .storeRef(oraclesDataCell)
+        .endCell();
+    return pricesCell;
+}
+function createOracleDataProof(oracle, data, signature, assets) {
+    let prunedDict = (0, merkleProof_1.generateMerkleProofDirect)(data.prices, assets, core_1.Dictionary.Keys.BigUint(256));
+    let prunedData = (0, core_1.beginCell)().storeUint(data.timestamp, 32).storeMaybeRef(prunedDict).endCell();
+    let merkleProof = (0, merkleProof_1.convertToMerkleProof)(prunedData);
+    let oracleDataProof = (0, core_1.beginCell)().storeUint(oracle.id, 32).storeRef(merkleProof).storeBuffer(signature).asSlice();
+    return oracleDataProof;
+}
+function packOraclesData(oraclesData, assets) {
+    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, val) => (0, core_1.beginCell)().storeSlice(val).storeMaybeRef(acc).endCell(), null);
+}
+// : String = "api.stardust-mainnet.iotaledger.net"
+function sumDicts(result, addendum) {
+    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);
+    }
+}

package/dist/utils/sha256BigInt.js

@@ -3,11 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256Hash = void 0;
+exports.sha256Hash = sha256Hash;
 const sha256_1 = __importDefault(require("crypto-js/sha256"));
 function sha256Hash(input) {
     const hash = (0, sha256_1.default)(input);
     const hashHex = hash.toString();
     return BigInt('0x' + hashHex);
 }
-exports.sha256Hash = sha256Hash;

package/dist/utils/tonConnectSender.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTonConnectSender = exports.getLastSentBoc = void 0;
+exports.getLastSentBoc = getLastSentBoc;
+exports.getTonConnectSender = getTonConnectSender;
 const core_1 = require("@ton/core");
 /*
 This is not the best solution to get the BOC of the sent external message, however the Sender
@@ -11,7 +12,6 @@ let lastSentBoc;
 function getLastSentBoc() {
     return lastSentBoc;
 }
-exports.getLastSentBoc = getLastSentBoc;
 function getTonConnectSender(connector) {
     return {
         get address() {
@@ -34,4 +34,3 @@ function getTonConnectSender(connector) {
         },
     };
 }
-exports.getTonConnectSender = getTonConnectSender;

package/dist/utils/userJettonWallet.d.ts

@@ -1,3 +1,3 @@
 import { Address } from '@ton/core';
-import { PoolAssetConfig, PoolJettonAssetConfig } from '../types/Master';
-export declare function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig & PoolJettonAssetConfig): Address;
+import { PoolAssetConfig } from '../types/Master';
+export declare function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig): Address;

package/dist/utils/userJettonWallet.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUserJettonWallet = void 0;
+exports.getUserJettonWallet = getUserJettonWallet;
 const core_1 = require("@ton/core");
+const assets_1 = require("../constants/assets");
 function getUserJettonWallet(ownerAddress, poolAssetConfig) {
+    if (poolAssetConfig.name == 'TON' || poolAssetConfig.assetId === assets_1.UNDEFINED_ASSET.assetId) {
+        throw new Error(`Cant getUserJettonWallet for ${poolAssetConfig.name} asset`);
+    }
     const jettonMasterAddress = poolAssetConfig.jettonMasterAddress;
     const jettonWalletCode = poolAssetConfig.jettonWalletCode;
     if (poolAssetConfig.name === 'USDT') {
@@ -55,4 +59,3 @@ function getUserJettonWallet(ownerAddress, poolAssetConfig) {
         .endCell();
     return new core_1.Address(0, stateInit.hash());
 }
-exports.getUserJettonWallet = getUserJettonWallet;

package/dist/utils/utils.d.ts

@@ -0,0 +1,2 @@
+import { PoolAssetConfig } from "../types/Master";
+export declare function isTonAsset(asset: PoolAssetConfig): boolean;

package/dist/utils/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTonAsset = isTonAsset;
+function isTonAsset(asset) {
+    return asset.name === 'TON';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evaafi/sdk",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "SDK for EVAA contracts",
   "main": "dist/index.js",
   "files": [
@@ -20,7 +20,7 @@
   "devDependencies": {
     "@orbs-network/ton-access": "^2.3.3",
     "@ton/core": "0.56.0",
-    "@tonconnect/sdk": "^3.0.0",
+    "@tonconnect/sdk": "^3.0.5",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.10.4",
     "crypto-js": "^4.2.0",