@evaafi/sdk 0.2.0 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # EVAA SDK
 
-The EVAA SDK is designed to easily integrate with EVAA lending protocol.
+The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.
 
 ## Documentation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evaafi/sdk",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "SDK for EVAA contracts",
   "main": "dist/index.js",
   "files": [
@@ -18,21 +18,17 @@
   "license": "MIT",
   "homepage": "https://github.com/evaafi/sdk#readme",
   "devDependencies": {
-    "@types/node": "^20.10.4",
-    "prettier": "^3.2.4",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.3.3",
     "@ton/core": "0.56.0",
     "@tonconnect/sdk": "^3.0.0",
+    "@types/node": "^20.10.4",
     "crypto-js": "^4.2.0",
-    "ethereumjs-util": "7.0.10",
-    "ethers": "5.6.9"
+    "prettier": "^3.2.4",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.3"
   },
   "peerDependencies": {
     "@ton/core": ">=0.56.0",
     "@tonconnect/sdk": ">=3.0.0",
-    "crypto-js": ">=4.2.0",
-    "ethereumjs-util": "7.0.10",
-    "ethers": "5.6.9"
+    "crypto-js": ">=4.2.0"
   }
 }

package/src/api/parser.ts

@@ -57,16 +57,17 @@ export function createAssetConfig(): DictionaryValue<AssetConfig> {
             const oracle = src.loadUintBig(256);
             const decimals = BigInt(src.loadUint(8));
             const ref = src.loadRef().beginParse();
-            const collateralFactor = BigInt(ref.loadUint(16));
-            const liquidationThreshold = BigInt(ref.loadUint(16));
-            const liquidationBonus = BigInt(ref.loadUint(16));
-            const baseBorrowRate = BigInt(ref.loadUint(64));
-            const borrowRateSlopeLow = BigInt(ref.loadUint(64));
-            const borrowRateSlopeHigh = BigInt(ref.loadUint(64));
-            const supplyRateSlopeLow = BigInt(ref.loadUint(64));
-            const supplyRateSlopeHigh = BigInt(ref.loadUint(64));
-            const targetUtilization = BigInt(ref.loadUint(64));
-            const originationFee = BigInt(ref.loadUint(64));
+            const collateralFactor = ref.loadUintBig(16);
+            const liquidationThreshold = ref.loadUintBig(16);
+            const liquidationBonus = ref.loadUintBig(16);
+            const baseBorrowRate = ref.loadUintBig(64);
+            const borrowRateSlopeLow = ref.loadUintBig(64);
+            const borrowRateSlopeHigh = ref.loadUintBig(64);
+            const supplyRateSlopeLow = ref.loadUintBig(64);
+            const supplyRateSlopeHigh = ref.loadUintBig(64);
+            const targetUtilization = ref.loadUintBig(64);
+            const originationFee = ref.loadUintBig(64);
+            const dust = ref.loadUintBig(64);
 
             return {
                 oracle,
@@ -81,6 +82,7 @@ export function createAssetConfig(): DictionaryValue<AssetConfig> {
                 supplyRateSlopeHigh,
                 targetUtilization,
                 originationFee,
+                dust,
             };
         },
     };
@@ -123,7 +125,7 @@ export function parseMasterData(masterDataBOC: string): MasterData {
     const masterConfig = {
         ifActive: masterConfigSlice.loadInt(8),
         admin: masterConfigSlice.loadAddress(),
-        adminPK: masterConfigSlice.loadBuffer(64),
+        adminPK: masterConfigSlice.loadUintBig(256),
         tokenKeys: loadMaybeMyRef(masterConfigSlice),
         walletToMaster: loadMaybeMyRef(masterConfigSlice),
     };

package/src/api/prices.ts

@@ -1,127 +1,70 @@
-import { beginCell, Cell, Dictionary } from '@ton/core';
-import { ethers } from 'ethers';
-import { CoinData } from '../types/Redstone';
-import { ASSET_ID } from '../constants';
-import { PriceData } from '../types/Common';
-
-type SerializedPrice = {
-    symbol: string;
-    value: number;
-    timestamp: number;
-};
-
-type PriceRawData = {
-    data: Buffer;
-    signature: Buffer;
-    dictKey: bigint;
-    dictValue: bigint;
-};
-
-function hexToArrayBuffer(input: any) {
-    if (typeof input !== 'string') {
-        throw new TypeError('Expected input to be a string');
-    }
-    if (input.length % 2 !== 0) {
-        throw new RangeError('Expected string to be an even number of characters');
-    }
-
-    if (input.startsWith('0x')) {
-        input = input.slice(2);
-    }
-    const view = new Uint8Array(input.length / 2);
-    for (let i = 0; i < input.length; i += 2) {
-        view[i / 2] = parseInt(input.substring(i, i + 2), 16);
-    }
-    return Buffer.from(view.buffer);
-}
-
-function convertStringToBytes32String(str: string) {
-    if (str.length > 31) {
-        const bytes32StringLength = 32 * 2 + 2; // 32 bytes (each byte uses 2 symbols) + 0x
-        if (str.length === bytes32StringLength && str.startsWith('0x')) {
-            return str;
-        } else {
-            return ethers.utils.id(str);
-        }
-    } else {
-        return ethers.utils.formatBytes32String(str);
-    }
-}
-
-export function getLiteDataBytesString(priceData: SerializedPrice): string {
-    let data = priceData.symbol.substr(2) + priceData.value.toString(16).padStart(64, '0');
-
-    data += Math.ceil(priceData.timestamp / 1000)
-        .toString(16)
-        .padStart(64, '0');
-    return data;
-}
-
-async function getPrice(symbol: string): Promise<PriceRawData> {
-    const res = await fetch(`https://api.redstone.finance/prices?symbol=${symbol}&provider=redstone&limit=1`);
-    const data = (await res.json()) as CoinData[];
-    const price = data[0];
-
-    const message = {
-        symbol: convertStringToBytes32String(price.symbol),
-        value: Math.round(price.value * 10 ** 8),
-        timestamp: price.timestamp,
-    };
-
-    let dictKey: bigint;
-    const dictValue = BigInt(message.value) * 10n;
-    switch (message.symbol) {
-        case '0x544f4e0000000000000000000000000000000000000000000000000000000000':
-            dictKey = ASSET_ID.TON;
-            break;
-        case '0x5553445400000000000000000000000000000000000000000000000000000000':
-            dictKey = ASSET_ID.jUSDT;
-            break;
-        case '0x5553444300000000000000000000000000000000000000000000000000000000':
-            dictKey = ASSET_ID.jUSDC;
-            break;
-        default:
-            throw new Error('Unknown symbol');
-    }
-
-    const signature = hexToArrayBuffer(price.liteEvmSignature);
-
-    return {
-        data: Buffer.from(getLiteDataBytesString(message), 'hex'),
-        signature: signature,
-        dictKey: dictKey,
-        dictValue: dictValue,
-    };
-}
-
-export async function getPrices(): Promise<PriceData | undefined> {
-    try {
-        const symbols = ['TON', 'USDT', 'USDC'];
-        const rawPriceData: {
-            data: Buffer;
-            signature: Buffer;
-        }[] = [];
-        const priceDict = Dictionary.empty(Dictionary.Keys.BigUint(256), Dictionary.Values.BigUint(64));
-        const pricePromises = symbols.map(async (symbol) => {
-            const price = await getPrice(symbol);
-            priceDict.set(price.dictKey, price.dictValue);
-            rawPriceData.push(price);
-        });
-        await Promise.all(pricePromises);
-
-        const rawPricesDict = Dictionary.empty<Buffer, Cell>();
-        for (const data of rawPriceData) {
-            rawPricesDict.set(data.signature, beginCell().storeBuffer(data.data).endCell());
-        }
-
-        return {
-            dict: priceDict,
-            dataCell: beginCell()
-                .storeDictDirect(rawPricesDict, Dictionary.Keys.Buffer(65), Dictionary.Values.Cell())
-                .endCell(),
-        };
-    } catch (error) {
-        console.error(error);
-        return undefined;
-    }
-}
+import { beginCell, Cell, Dictionary } from '@ton/core';
+import { NFT_ID } from '../constants';
+import { PriceData } from '../types/Common';
+
+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 async function getPrices(): Promise<PriceData | undefined> {
+    try {
+        let result = await fetch('https://api.stardust-mainnet.iotaledger.net/api/indexer/v1/outputs/nft/' + NFT_ID, {
+            headers: { accept: 'application/json' },
+        });
+        let outputId = (await result.json()) as NftData;
+
+        result = await fetch('https://api.stardust-mainnet.iotaledger.net/api/core/v2/outputs/' + outputId.items[0], {
+            headers: { accept: 'application/json' },
+        });
+
+        let resData = (await result.json()) as OutputData;
+
+        const data = JSON.parse(
+            decodeURIComponent(resData.output.features[0].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');
+
+        return {
+            dict: pricesCell.beginParse().loadDictDirect(Dictionary.Keys.BigUint(256), Dictionary.Values.BigUint(64)),
+            dataCell: beginCell().storeRef(pricesCell).storeBuffer(signature).endCell(),
+        };
+    } catch (error) {
+        console.error(error);
+        return undefined;
+    }
+}

package/src/constants.ts

@@ -2,21 +2,26 @@ import { Address, Cell, toNano } from '@ton/core';
 import { sha256Hash } from './utils/sha256BigInt';
 
 export const EVAA_MASTER_MAINNET = Address.parse('EQC8rUZqR_pWV1BylWUlPNBzyiTYVoBEmQkMIQDZXICfnuRr');
-export const MAINNET_VERSION = 2;
-export const EVAA_MASTER_TESTNET = Address.parse('kQBi2jDaq_-Oi62V7u_j_Vr1We8EqC3h0jkhB4Gf4JW741vX');
-export const TESTNET_VERSION = 1;
+export const MAINNET_VERSION = 3;
+export const EVAA_MASTER_TESTNET = Address.parse('kQClWdMebpK90b6imEUreQJ4M3oz8Gqwd3xkVIowR8LDX98-');
+export const TESTNET_VERSION = 3;
+
+export const NFT_ID = '0xfb9874544d76ca49c5db9cc3e5121e4c018bc8a2fb2bfe8f2a38c5b9963492f5';
 
 export const ASSET_ID = {
     TON: sha256Hash('TON'),
     jUSDT: sha256Hash('jUSDT'),
     jUSDC: sha256Hash('jUSDC'),
+    stTON: sha256Hash('stTON'),
 };
 
 export const JETTON_MASTER_ADDRESSES = {
     jUSDT_MAINNET: Address.parse('EQBwbF0otxLyA3VrRjjC1q7i3G7LtoEpdyBjZEuNtrhC4drm'),
-    jUSDT_TESTNET: Address.parse('kQAGvWIETv29VRXLBL3lugxdLeCZ3r7jcuUvqKeZpbcwiQo0'),
+    jUSDT_TESTNET: Address.parse('kQBtFVedUkg9Q7M5eMx_gxAdP5R7QCLR-3RCYQNrm_DZYr6Z'),
     jUSDC_MAINNET: Address.parse('EQCEHZi-CLX2ghdsNbY35umR1OFODG5ySHrtK6GItMdWv7dS'),
-    jUSDC_TESTNET: Address.parse('kQCwj7zrRnBIYUhM7BShqupouNgubrdJUmmA3AAuPH9CK0Kj'),
+    jUSDC_TESTNET: Address.parse('kQCZWZD_rBZ1vrqF22aX4AZrU1a1q-YKZH_R2VlALoVNCvXd'),
+    stTON_MAINNET: Address.parse('EQBOn-1b-315ogeCl5lfPYW0ut6sjA2eq4LTdRv5vJJ1SsxX'),
+    stTON_TESTNET: Address.parse('kQCpm8ixF6STW7aidxn_Qkp4sR73msPlrduCeRZfo-Zu7dxt'),
 };
 
 export const MASTER_CONSTANTS = {

package/src/types/Master.ts

@@ -25,12 +25,13 @@ export type AssetConfig = {
     supplyRateSlopeHigh: bigint;
     targetUtilization: bigint;
     originationFee: bigint;
+    dust: bigint;
 };
 
 export type MasterConfig = {
     ifActive: number;
     admin: Address;
-    adminPK: Buffer;
+    adminPK: bigint;
     tokenKeys: Cell | null;
     walletToMaster: Cell | null;
 };

package/src/utils/userJettonWallet.ts

@@ -1,34 +1,41 @@
-import { Address, beginCell, storeStateInit } from '@ton/core';
-import { ASSET_ID, JETTON_MASTER_ADDRESSES, JETTON_WALLET_CODE } from '../constants';
-
-export function getUserJettonWallet(ownerAddress: Address, assetID: bigint, network: 'mainnet' | 'testnet'): Address {
-    const builder = beginCell().storeCoins(0).storeAddress(ownerAddress);
-    switch (assetID) {
-        case ASSET_ID.jUSDT:
-            if (network === 'mainnet') {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_MAINNET);
-            } else {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_TESTNET);
-            }
-            break;
-        case ASSET_ID.jUSDC:
-            if (network === 'mainnet') {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_MAINNET);
-            } else {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_TESTNET);
-            }
-            break;
-        default:
-            throw new Error('Unsupported asset');
-    }
-    const data = builder.storeRef(JETTON_WALLET_CODE).endCell();
-    const stateInit = beginCell()
-        .store(
-            storeStateInit({
-                code: JETTON_WALLET_CODE,
-                data: data,
-            }),
-        )
-        .endCell();
-    return new Address(0, stateInit.hash());
-}
+import { Address, beginCell, storeStateInit } from '@ton/core';
+import { ASSET_ID, JETTON_MASTER_ADDRESSES, JETTON_WALLET_CODE } from '../constants';
+
+export function getUserJettonWallet(ownerAddress: Address, assetID: bigint, network: 'mainnet' | 'testnet'): Address {
+    const builder = beginCell().storeCoins(0).storeAddress(ownerAddress);
+    switch (assetID) {
+        case ASSET_ID.jUSDT:
+            if (network === 'mainnet') {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_MAINNET);
+            } else {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_TESTNET);
+            }
+            break;
+        case ASSET_ID.jUSDC:
+            if (network === 'mainnet') {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_MAINNET);
+            } else {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_TESTNET);
+            }
+            break;
+        case ASSET_ID.stTON:
+            if (network === 'mainnet') {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.stTON_MAINNET);
+            } else {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.stTON_TESTNET);
+            }
+            break;
+        default:
+            throw new Error('Unsupported asset');
+    }
+    const data = builder.storeRef(JETTON_WALLET_CODE).endCell();
+    const stateInit = beginCell()
+        .store(
+            storeStateInit({
+                code: JETTON_WALLET_CODE,
+                data: data,
+            }),
+        )
+        .endCell();
+    return new Address(0, stateInit.hash());
+}

package/src/types/Redstone.ts

@@ -1,15 +0,0 @@
-export type CoinData = {
-    id: string;
-    symbol: string;
-    provider: string;
-    value: number;
-    liteEvmSignature: string;
-    permawebTx: string;
-    version: string;
-    source: {
-        coingecko: number;
-    };
-    timestamp: number;
-    minutes: number;
-    providerPublicKey: string;
-};