@evaafi/sdk 0.2.0

package/src/api/parser.ts

@@ -0,0 +1,277 @@
+import { beginCell, Cell, Dictionary, DictionaryValue, Slice } from '@ton/core';
+import { AssetConfig, AssetData, ExtendedAssetData, MasterData } from '../types/Master';
+import { ASSET_ID, MASTER_CONSTANTS } from '../constants';
+import {
+    bigIntMax,
+    bigIntMin,
+    calculateAssetData,
+    calculateLiquidationData,
+    calculatePresentValue,
+    getAvailableToBorrow,
+    presentValue,
+} from './math';
+import { loadMaybeMyRef, loadMyRef } from './helpers';
+import { BalanceType, UserBalance, UserData, UserLiteData } from '../types/User';
+
+export function createAssetData(): DictionaryValue<AssetData> {
+    return {
+        serialize: (src: any, buidler: any) => {
+            buidler.storeUint(src.s_rate, 64);
+            buidler.storeUint(src.b_rate, 64);
+            buidler.storeUint(src.totalSupply, 64);
+            buidler.storeUint(src.totalBorrow, 64);
+            buidler.storeUint(src.lastAccural, 32);
+            buidler.storeUint(src.balance, 64);
+        },
+        parse: (src: Slice) => {
+            const sRate = BigInt(src.loadInt(64));
+            const bRate = BigInt(src.loadInt(64));
+            const totalSupply = BigInt(src.loadInt(64));
+            const totalBorrow = BigInt(src.loadInt(64));
+            const lastAccural = BigInt(src.loadInt(32));
+            const balance = BigInt(src.loadInt(64));
+            return { sRate, bRate, totalSupply, totalBorrow, lastAccural, balance };
+        },
+    };
+}
+
+export function createAssetConfig(): DictionaryValue<AssetConfig> {
+    return {
+        serialize: (src: any, builder: any) => {
+            builder.storeUint(src.oracle, 256);
+            builder.storeUint(src.decimals, 8);
+            const refBuild = beginCell();
+            refBuild.storeUint(src.collateralFactor, 16);
+            refBuild.storeUint(src.liquidationThreshold, 16);
+            refBuild.storeUint(src.liquidationPenalty, 16);
+            refBuild.storeUint(src.baseBorrowRate, 64);
+            refBuild.storeUint(src.borrowRateSlopeLow, 64);
+            refBuild.storeUint(src.borrowRateSlopeHigh, 64);
+            refBuild.storeUint(src.supplyRateSlopeLow, 64);
+            refBuild.storeUint(src.supplyRateSlopeHigh, 64);
+            refBuild.storeUint(src.targetUtilization, 64);
+            refBuild.storeUint(src.originationFee, 64);
+            builder.storeRef(refBuild.endCell());
+        },
+        parse: (src: Slice) => {
+            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));
+
+            return {
+                oracle,
+                decimals,
+                collateralFactor,
+                liquidationThreshold,
+                liquidationBonus,
+                baseBorrowRate,
+                borrowRateSlopeLow,
+                borrowRateSlopeHigh,
+                supplyRateSlopeLow,
+                supplyRateSlopeHigh,
+                targetUtilization,
+                originationFee,
+            };
+        },
+    };
+}
+
+export function parseMasterData(masterDataBOC: string): MasterData {
+    const masterSlice = Cell.fromBase64(masterDataBOC).beginParse();
+    const meta = masterSlice.loadRef().beginParse().loadStringTail();
+    const upgradeConfigParser = masterSlice.loadRef().beginParse();
+
+    const upgradeConfig = {
+        masterCodeVersion: Number(upgradeConfigParser.loadCoins()),
+        userCodeVersion: Number(upgradeConfigParser.loadCoins()),
+        timeout: upgradeConfigParser.loadUint(32),
+        updateTime: upgradeConfigParser.loadUint(64),
+        freezeTime: upgradeConfigParser.loadUint(64),
+        userCode: loadMyRef(upgradeConfigParser),
+        blankCode: loadMyRef(upgradeConfigParser),
+        newMasterCode: loadMaybeMyRef(upgradeConfigParser),
+        newUserCode: loadMaybeMyRef(upgradeConfigParser),
+    };
+    upgradeConfigParser.endParse();
+
+    const masterConfigSlice = masterSlice.loadRef().beginParse();
+
+    const assetsConfigDict = masterConfigSlice.loadDict(Dictionary.Keys.BigUint(256), createAssetConfig());
+    const assetsDataDict = masterSlice.loadDict(Dictionary.Keys.BigUint(256), createAssetData());
+    const assetsExtendedData = Dictionary.empty<bigint, ExtendedAssetData>();
+    const assetsReserves = Dictionary.empty<bigint, bigint>();
+    const apy = {
+        supply: Dictionary.empty<bigint, number>(),
+        borrow: Dictionary.empty<bigint, number>(),
+    };
+
+    for (const [tokenSymbol, assetID] of Object.entries(ASSET_ID)) {
+        const assetData = calculateAssetData(assetsConfigDict, assetsDataDict, assetID);
+        assetsExtendedData.set(assetID, assetData);
+    }
+
+    const masterConfig = {
+        ifActive: masterConfigSlice.loadInt(8),
+        admin: masterConfigSlice.loadAddress(),
+        adminPK: masterConfigSlice.loadBuffer(64),
+        tokenKeys: loadMaybeMyRef(masterConfigSlice),
+        walletToMaster: loadMaybeMyRef(masterConfigSlice),
+    };
+
+    masterConfigSlice.endParse();
+
+    for (const [_, assetID] of Object.entries(ASSET_ID)) {
+        const assetData = assetsExtendedData.get(assetID) as ExtendedAssetData;
+        const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply);
+        const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow);
+        assetsReserves.set(assetID, assetData.balance - totalSupply + totalBorrow);
+
+        apy.supply.set(assetID, (1 + (Number(assetData.supplyInterest) / 1e12) * 24 * 3600) ** 365 - 1);
+        apy.borrow.set(assetID, (1 + (Number(assetData.borrowInterest) / 1e12) * 24 * 3600) ** 365 - 1);
+    }
+
+    return {
+        meta: meta,
+        upgradeConfig: upgradeConfig,
+        masterConfig: masterConfig,
+        assetsConfig: assetsConfigDict,
+        assetsData: assetsExtendedData,
+        assetsReserves: assetsReserves,
+        apy: apy,
+    };
+}
+
+export function parseUserLiteData(
+    userDataBOC: string,
+    assetsData: Dictionary<bigint, ExtendedAssetData>,
+    assetsConfig: Dictionary<bigint, AssetConfig>,
+): UserLiteData {
+    const userSlice = Cell.fromBase64(userDataBOC).beginParse();
+
+    const codeVersion = userSlice.loadCoins();
+    const masterAddress = userSlice.loadAddress();
+    const userAddress = userSlice.loadAddress();
+    const principalsDict = userSlice.loadDict(Dictionary.Keys.BigUint(256), Dictionary.Values.BigInt(64));
+    const userState = userSlice.loadInt(64);
+    const trackingSupplyIndex = userSlice.loadUintBig(64);
+    const trackingBorrowIndex = userSlice.loadUintBig(64);
+    const dutchAuctionStart = userSlice.loadUint(32);
+    const backupCell = loadMyRef(userSlice);
+    userSlice.endParse();
+
+    const userBalances = Dictionary.empty<bigint, UserBalance>();
+
+    for (const [_, assetID] of Object.entries(ASSET_ID)) {
+        const assetData = assetsData.get(assetID) as ExtendedAssetData;
+        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
+        const balance = presentValue(assetData.sRate, assetData.bRate, principalsDict.get(assetID) || 0n);
+        userBalances.set(assetID, balance);
+    }
+
+    return {
+        type: 'active',
+        codeVersion: Number(codeVersion),
+        masterAddress: masterAddress,
+        ownerAddress: userAddress,
+        principals: principalsDict,
+        state: userState,
+        balances: userBalances,
+        trackingSupplyIndex: trackingSupplyIndex,
+        trackingBorrowIndex: trackingBorrowIndex,
+        dutchAuctionStart: dutchAuctionStart,
+        backupCell: backupCell,
+    };
+}
+
+export function parseUserData(
+    userLiteData: UserLiteData,
+    assetsData: Dictionary<bigint, ExtendedAssetData>,
+    assetsConfig: Dictionary<bigint, AssetConfig>,
+    prices: Dictionary<bigint, bigint>,
+): UserData {
+    const withdrawalLimits = Dictionary.empty<bigint, bigint>();
+    const borrowLimits = Dictionary.empty<bigint, bigint>();
+
+    let supplyBalance = 0n;
+    let borrowBalance = 0n;
+    for (const [_, assetID] of Object.entries(ASSET_ID)) {
+        const assetData = assetsData.get(assetID) as ExtendedAssetData;
+        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
+        const balance = presentValue(assetData.sRate, assetData.bRate, userLiteData.principals.get(assetID) || 0n);
+        userLiteData.balances.set(assetID, balance);
+    }
+
+    for (const [_, assetID] of Object.entries(ASSET_ID)) {
+        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
+        const balance = userLiteData.balances.get(assetID) as UserBalance;
+
+        if (balance.type === BalanceType.supply) {
+            supplyBalance += (balance.amount * prices.get(assetID)!) / 10n ** assetConfig.decimals;
+        }
+        if (balance.type === BalanceType.borrow) {
+            borrowBalance += (balance.amount * prices.get(assetID)!) / 10n ** assetConfig.decimals;
+        }
+    }
+
+    const availableToBorrow = getAvailableToBorrow(assetsConfig, assetsData, userLiteData.principals, prices);
+    for (const [_, assetID] of Object.entries(ASSET_ID)) {
+        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
+        const assetData = assetsData.get(assetID) as ExtendedAssetData;
+        const balance = userLiteData.balances.get(assetID) as UserBalance;
+
+        if (balance.type === BalanceType.supply) {
+            withdrawalLimits.set(
+                assetID,
+                bigIntMax(
+                    bigIntMin(
+                        assetData.balance,
+                        ((supplyBalance -
+                            (borrowBalance * MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE) / assetConfig.collateralFactor) *
+                            10n ** assetConfig.decimals) /
+                            prices.get(assetID)! -
+                            5n,
+                        balance.amount,
+                    ),
+                    0n,
+                ),
+            );
+        } else {
+            borrowLimits.set(
+                assetID,
+                bigIntMin((availableToBorrow * 10n ** assetConfig.decimals) / prices.get(assetID)!, assetData.balance),
+            );
+        }
+    }
+
+    const limitUsed = borrowBalance + availableToBorrow;
+    const limitUsedPercent =
+        limitUsed === 0n
+            ? 0
+            : Number(BigInt(1e9) - (availableToBorrow * BigInt(1e9)) / (borrowBalance + availableToBorrow)) / 1e7;
+
+    const liquidationData = calculateLiquidationData(assetsConfig, assetsData, userLiteData.principals, prices);
+    const healthFactor = 1 - Number(liquidationData.totalDebt) / Number(liquidationData.totalLimit);
+
+    return {
+        ...userLiteData,
+        withdrawalLimits: withdrawalLimits,
+        borrowLimits: borrowLimits,
+        supplyBalance: supplyBalance,
+        borrowBalance: borrowBalance,
+        availableToBorrow: availableToBorrow,
+        limitUsedPercent: limitUsedPercent,
+        limitUsed: limitUsed,
+        liquidationData: liquidationData,
+        healthFactor: healthFactor,
+    };
+}

package/src/api/prices.ts

@@ -0,0 +1,127 @@
+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;
+    }
+}

package/src/constants.ts

@@ -0,0 +1,53 @@
+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 ASSET_ID = {
+    TON: sha256Hash('TON'),
+    jUSDT: sha256Hash('jUSDT'),
+    jUSDC: sha256Hash('jUSDC'),
+};
+
+export const JETTON_MASTER_ADDRESSES = {
+    jUSDT_MAINNET: Address.parse('EQBwbF0otxLyA3VrRjjC1q7i3G7LtoEpdyBjZEuNtrhC4drm'),
+    jUSDT_TESTNET: Address.parse('kQAGvWIETv29VRXLBL3lugxdLeCZ3r7jcuUvqKeZpbcwiQo0'),
+    jUSDC_MAINNET: Address.parse('EQCEHZi-CLX2ghdsNbY35umR1OFODG5ySHrtK6GItMdWv7dS'),
+    jUSDC_TESTNET: Address.parse('kQCwj7zrRnBIYUhM7BShqupouNgubrdJUmmA3AAuPH9CK0Kj'),
+};
+
+export const MASTER_CONSTANTS = {
+    FACTOR_SCALE: BigInt(1e12),
+    ASSET_COEFFICIENT_SCALE: 10000n,
+    ASSET_PRICE_SCALE: BigInt(1e8),
+};
+
+export const LENDING_CODE = Cell.fromBoc(
+    Buffer.from(
+        'b5ee9c72c1010e0100fd000d12182a555a6065717691969efd0114ff00f4a413f4bcf2c80b010202c8050202039f740403001ff2f8276a2687d2018fd201800f883b840051d38642c678b64e4400780e58fc10802faf07f80e59fa801e78b096664c02078067c07c100627a7978402014807060007a0ddb0c60201c709080013a0fd007a026900aa90400201200b0a0031b8e1002191960aa00b9e2ca007f4042796d225e8019203f6010201200d0c000bf7c147d2218400b9d10e86981fd201840b07f8138d809797976a2687d2029116382f970fd9178089910374daf81b619fd20182c7883b8701981684100627910eba56001797a6a6ba610fd8200e8768f76a9f6aa00cc2a32a8292878809bef2f1889f883bbcdeb86f01',
+        'hex',
+    ),
+)[0];
+export const JETTON_WALLET_CODE = Cell.fromBase64(
+    'te6cckECEQEAAyMAART/APSkE/S88sgLAQIBYgIDAgLMBAUAG6D2BdqJofQB9IH0gahhAgHUBgcCASAICQDDCDHAJJfBOAB0NMDAXGwlRNfA/AM4PpA+kAx+gAxcdch+gAx+gAwc6m0AALTH4IQD4p+pVIgupUxNFnwCeCCEBeNRRlSILqWMUREA/AK4DWCEFlfB7y6k1nwC+BfBIQP8vCAAET6RDBwuvLhTYAIBIAoLAIPUAQa5D2omh9AH0gfSBqGAJpj8EIC8aijKkQXUEIPe7L7wndCVj5cWLpn5j9ABgJ0CgR5CgCfQEsZ4sA54tmZPaqQB8VA9M/+gD6QCHwAe1E0PoA+kD6QNQwUTahUirHBfLiwSjC//LiwlQ0QnBUIBNUFAPIUAT6AljPFgHPFszJIsjLARL0APQAywDJIPkAcHTIywLKB8v/ydAE+kD0BDH6ACDXScIA8uLEd4AYyMsFUAjPFnD6AhfLaxPMgMAgEgDQ4AnoIQF41FGcjLHxnLP1AH+gIizxZQBs8WJfoCUAPPFslQBcwjkXKRceJQCKgToIIJycOAoBS88uLFBMmAQPsAECPIUAT6AljPFgHPFszJ7VQC9ztRND6APpA+kDUMAjTP/oAUVGgBfpA+kBTW8cFVHNtcFQgE1QUA8hQBPoCWM8WAc8WzMkiyMsBEvQA9ADLAMn5AHB0yMsCygfL/8nQUA3HBRyx8uLDCvoAUaihggiYloBmtgihggiYloCgGKEnlxBJEDg3XwTjDSXXCwGAPEADXO1E0PoA+kD6QNQwB9M/+gD6QDBRUaFSSccF8uLBJ8L/8uLCBYIJMS0AoBa88uLDghB73ZfeyMsfFcs/UAP6AiLPFgHPFslxgBjIywUkzxZw+gLLaszJgED7AEATyFAE+gJYzxYBzxbMye1UgAHBSeaAYoYIQc2LQnMjLH1Iwyz9Y+gJQB88WUAfPFslxgBDIywUkzxZQBvoCFctqFMzJcfsAECQQIwB8wwAjwgCwjiGCENUydttwgBDIywVQCM8WUAT6AhbLahLLHxLLP8ly+wCTNWwh4gPIUAT6AljPFgHPFszJ7VSV6u3X',
+);
+
+export const OPCODES = {
+    SUPPLY: 0x1,
+    WITHDRAW: 0x2,
+    LIQUIDATE: 0x3,
+    JETTON_TRANSFER: 0xf8a7ea5,
+};
+
+export const FEES = {
+    SUPPLY: toNano('0.3'),
+    WITHDRAW: toNano('0.5'),
+    SUPPLY_JETTON: toNano('0.8'),
+    SUPPLY_JETTON_FWD: toNano('0.5'),
+    LIQUIDATION: toNano('0.8'),
+    LIQUIDATION_JETTON: toNano('1'),
+    LIQUIDATION_JETTON_FWD: toNano('0.8'),
+};

package/src/contracts/JettonWallet.ts

@@ -0,0 +1,20 @@
+import { Address, Cell, Contract, ContractProvider, Sender, SendMode } from '@ton/core';
+
+export class JettonWallet implements Contract {
+    readonly address: Address;
+    static createFromAddress(address: Address) {
+        return new JettonWallet(address);
+    }
+
+    private constructor(address: Address) {
+        this.address = address;
+    }
+
+    async sendTransfer(provider: ContractProvider, via: Sender, value: bigint, payload: Cell) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
+            body: payload,
+        });
+    }
+}