@evaafi/sdk 0.2.0

package/dist/types/Common.d.ts

@@ -0,0 +1,5 @@
+import { Cell, Dictionary } from '@ton/core';
+export type PriceData = {
+    dict: Dictionary<bigint, bigint>;
+    dataCell: Cell;
+};

package/dist/types/Common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/Master.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="node" />
+import { Address, Cell, Dictionary } from '@ton/core';
+export type UpgradeConfig = {
+    masterCodeVersion: number;
+    userCodeVersion: number;
+    timeout: number;
+    updateTime: number;
+    freezeTime: number;
+    userCode: Cell;
+    blankCode: Cell;
+    newMasterCode: Cell | null;
+    newUserCode: Cell | null;
+};
+export type AssetConfig = {
+    oracle: bigint;
+    decimals: bigint;
+    collateralFactor: bigint;
+    liquidationThreshold: bigint;
+    liquidationBonus: bigint;
+    baseBorrowRate: bigint;
+    borrowRateSlopeLow: bigint;
+    borrowRateSlopeHigh: bigint;
+    supplyRateSlopeLow: bigint;
+    supplyRateSlopeHigh: bigint;
+    targetUtilization: bigint;
+    originationFee: bigint;
+};
+export type MasterConfig = {
+    ifActive: number;
+    admin: Address;
+    adminPK: Buffer;
+    tokenKeys: Cell | null;
+    walletToMaster: Cell | null;
+};
+export type AssetData = {
+    sRate: bigint;
+    bRate: bigint;
+    totalSupply: bigint;
+    totalBorrow: bigint;
+    lastAccural: bigint;
+    balance: bigint;
+};
+export type AssetInterest = {
+    supplyInterest: bigint;
+    borrowInterest: bigint;
+};
+export type AssetApy = {
+    supplyApy: number;
+    borrowApy: number;
+};
+export type ExtendedAssetData = AssetData & AssetInterest & AssetApy;
+export type MasterData = {
+    meta: string;
+    upgradeConfig: UpgradeConfig;
+    masterConfig: MasterConfig;
+    assetsConfig: Dictionary<bigint, AssetConfig>;
+    assetsData: Dictionary<bigint, ExtendedAssetData>;
+    assetsReserves: Dictionary<bigint, bigint>;
+    apy: {
+        supply: Dictionary<bigint, number>;
+        borrow: Dictionary<bigint, number>;
+    };
+};

package/dist/types/Master.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/Redstone.d.ts

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

package/dist/types/Redstone.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/User.d.ts

@@ -0,0 +1,55 @@
+import { Address, Cell, Dictionary } from '@ton/core';
+export declare enum BalanceType {
+    supply = "supply",
+    borrow = "borrow"
+}
+export type UserBalance = {
+    amount: bigint;
+    type?: BalanceType;
+};
+export type UserLiqudationData = {
+    greatestCollateralValue: bigint;
+    greatestCollateralAsset: bigint;
+    greatestLoanValue: bigint;
+    greatestLoanAsset: bigint;
+    totalDebt: bigint;
+    totalLimit: bigint;
+};
+export type LiquidableData = UserLiqudationData & {
+    liquidable: true;
+    liquidationAmount: bigint;
+    minCollateralAmount: bigint;
+};
+export type NonLiquidableData = UserLiqudationData & {
+    liquidable: false;
+};
+export type LiquidationData = LiquidableData | NonLiquidableData;
+export type UserLiteData = {
+    type: 'active';
+    codeVersion: number;
+    masterAddress: Address;
+    ownerAddress: Address;
+    principals: Dictionary<bigint, bigint>;
+    state: number;
+    balances: Dictionary<bigint, UserBalance>;
+    trackingSupplyIndex: bigint;
+    trackingBorrowIndex: bigint;
+    dutchAuctionStart: number;
+    backupCell: Cell;
+};
+export type UserDataActive = UserLiteData & {
+    withdrawalLimits: Dictionary<bigint, bigint>;
+    borrowLimits: Dictionary<bigint, bigint>;
+    repayLimits?: Dictionary<bigint, bigint>;
+    supplyBalance: bigint;
+    borrowBalance: bigint;
+    availableToBorrow: bigint;
+    limitUsedPercent: number;
+    limitUsed: bigint;
+    healthFactor: number;
+    liquidationData: LiquidationData;
+};
+export type UserDataInactive = {
+    type: 'inactive';
+};
+export type UserData = UserDataActive | UserDataInactive;

package/dist/types/User.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BalanceType = void 0;
+var BalanceType;
+(function (BalanceType) {
+    BalanceType["supply"] = "supply";
+    BalanceType["borrow"] = "borrow";
+})(BalanceType || (exports.BalanceType = BalanceType = {}));

package/dist/utils/sha256BigInt.d.ts

@@ -0,0 +1 @@
+export declare function sha256Hash(input: string): bigint;

package/dist/utils/sha256BigInt.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256Hash = void 0;
+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.d.ts

@@ -0,0 +1,4 @@
+import { ITonConnect, SendTransactionResponse } from '@tonconnect/sdk';
+import { Sender } from '@ton/core';
+export declare function getLastSentBoc(): SendTransactionResponse | undefined;
+export declare function getTonConnectSender(connector: ITonConnect): Sender;

package/dist/utils/tonConnectSender.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTonConnectSender = exports.getLastSentBoc = void 0;
+const core_1 = require("@ton/core");
+/*
+This is not the best solution to get the BOC of the sent external message, however the Sender
+interface does not support returning any value from send(), so at the moment you can get it from
+this global variable.
+ */
+let lastSentBoc;
+function getLastSentBoc() {
+    return lastSentBoc;
+}
+exports.getLastSentBoc = getLastSentBoc;
+function getTonConnectSender(connector) {
+    return {
+        get address() {
+            return connector.account ? core_1.Address.parse(connector.account.address) : undefined;
+        },
+        async send(args) {
+            lastSentBoc = await connector.sendTransaction({
+                validUntil: Date.now() + 2 * 60 * 1000, // 1 minutes
+                messages: [
+                    {
+                        address: args.to.toString(),
+                        amount: args.value.toString(),
+                        payload: args.body?.toBoc().toString('base64'),
+                        stateInit: args.init
+                            ? (0, core_1.beginCell)().store((0, core_1.storeStateInit)(args.init)).endCell().toBoc().toString('base64')
+                            : undefined,
+                    },
+                ],
+            });
+        },
+    };
+}
+exports.getTonConnectSender = getTonConnectSender;

package/dist/utils/userJettonWallet.d.ts

@@ -0,0 +1,2 @@
+import { Address } from '@ton/core';
+export declare function getUserJettonWallet(ownerAddress: Address, assetID: bigint, network: 'mainnet' | 'testnet'): Address;

package/dist/utils/userJettonWallet.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserJettonWallet = void 0;
+const core_1 = require("@ton/core");
+const constants_1 = require("../constants");
+function getUserJettonWallet(ownerAddress, assetID, network) {
+    const builder = (0, core_1.beginCell)().storeCoins(0).storeAddress(ownerAddress);
+    switch (assetID) {
+        case constants_1.ASSET_ID.jUSDT:
+            if (network === 'mainnet') {
+                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDT_MAINNET);
+            }
+            else {
+                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDT_TESTNET);
+            }
+            break;
+        case constants_1.ASSET_ID.jUSDC:
+            if (network === 'mainnet') {
+                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDC_MAINNET);
+            }
+            else {
+                builder.storeAddress(constants_1.JETTON_MASTER_ADDRESSES.jUSDC_TESTNET);
+            }
+            break;
+        default:
+            throw new Error('Unsupported asset');
+    }
+    const data = builder.storeRef(constants_1.JETTON_WALLET_CODE).endCell();
+    const stateInit = (0, core_1.beginCell)()
+        .store((0, core_1.storeStateInit)({
+        code: constants_1.JETTON_WALLET_CODE,
+        data: data,
+    }))
+        .endCell();
+    return new core_1.Address(0, stateInit.hash());
+}
+exports.getUserJettonWallet = getUserJettonWallet;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@evaafi/sdk",
+  "version": "0.2.0",
+  "description": "SDK for EVAA contracts",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc --declaration"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/evaafi/sdk.git"
+  },
+  "author": "EVAA Finance",
+  "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",
+    "crypto-js": "^4.2.0",
+    "ethereumjs-util": "7.0.10",
+    "ethers": "5.6.9"
+  },
+  "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"
+  }
+}

package/src/api/helpers.ts

@@ -0,0 +1,32 @@
+import { Cell, Slice } from '@ton/core';
+
+class MyCell extends Cell {
+    toString() {
+        return this.hashBigInt().toString();
+    }
+
+    hashBigInt() {
+        return BigInt('0x' + this.hash().toString('hex'));
+    }
+}
+
+export function loadMyRef(slice: Slice): MyCell {
+    const cell = slice.loadRef();
+    return new MyCell({
+        exotic: cell.isExotic,
+        bits: cell.bits,
+        refs: cell.refs,
+    });
+}
+
+export function loadMaybeMyRef(slice: Slice): Cell | null {
+    const cell = slice.loadMaybeRef();
+    if (cell === null) {
+        return null;
+    }
+    return new MyCell({
+        exotic: cell.isExotic,
+        bits: cell.bits,
+        refs: cell.refs,
+    });
+}

package/src/api/math.ts

@@ -0,0 +1,252 @@
+import { AssetConfig, AssetData, AssetInterest, ExtendedAssetData } from '../types/Master';
+import { MASTER_CONSTANTS } from '../constants';
+import { Dictionary } from '@ton/core';
+import { BalanceType, LiquidationData, UserBalance } from '../types/User';
+
+export function mulFactor(decimal: bigint, a: bigint, b: bigint): bigint {
+    return (a * b) / decimal;
+}
+
+export function mulDiv(x: bigint, y: bigint, z: bigint): bigint {
+    return (x * y) / z;
+}
+
+export function bigIntMax(...args: bigint[]): bigint {
+    return args.reduce((m, e) => (e > m ? e : m));
+}
+export function bigIntMin(...args: bigint[]): bigint {
+    return args.reduce((m, e) => (e < m ? e : m));
+}
+
+export function calculatePresentValue(index: bigint, principalValue: bigint): bigint {
+    return (principalValue * index) / MASTER_CONSTANTS.FACTOR_SCALE;
+}
+
+export function calculateCurrentRates(assetConfig: AssetConfig, assetData: AssetData) {
+    const now = BigInt(Math.floor(Date.now() / 1000));
+    const timeElapsed = now - assetData.lastAccural;
+    const { supplyInterest, borrowInterest } = calculateAssetInterest(assetConfig, assetData);
+
+    if (timeElapsed > 0) {
+        const updatedSRate =
+            assetData.sRate + mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetData.sRate, supplyInterest * timeElapsed);
+        const updatedBRate =
+            assetData.bRate + mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetData.bRate, borrowInterest * timeElapsed);
+        return {
+            sRate: updatedSRate,
+            bRate: updatedBRate,
+            supplyInterest,
+            borrowInterest,
+            now,
+        };
+    }
+
+    return {
+        sRate: assetData.sRate,
+        bRate: assetData.bRate,
+        supplyInterest,
+        borrowInterest,
+        now,
+    };
+}
+
+export function calculateAssetData(
+    assetsConfigDict: Dictionary<bigint, AssetConfig>,
+    assetsDataDict: Dictionary<bigint, AssetData>,
+    assetId: bigint,
+): ExtendedAssetData {
+    const config = assetsConfigDict.get(assetId); // maybe it's a huge mistake could be
+    const data = assetsDataDict.get(assetId);
+
+    if (!data || !config) {
+        throw new Error('Asset Data or Config is not accessible');
+    }
+
+    const { sRate, bRate, supplyInterest, borrowInterest, now } = calculateCurrentRates(config, data);
+    data.sRate = sRate || 0n;
+    data.bRate = bRate || 0n;
+    data.lastAccural = now;
+
+    const supplyApy = (1 + (Number(supplyInterest) / 1e12) * 24 * 3600) ** 365 - 1;
+    const borrowApy = (1 + (Number(borrowInterest) / 1e12) * 24 * 3600) ** 365 - 1;
+
+    return {
+        ...data,
+        ...{ supplyInterest, borrowInterest },
+        ...{ supplyApy, borrowApy },
+    };
+}
+
+export function calculateAssetInterest(assetConfig: AssetConfig, assetData: AssetData): AssetInterest {
+    const totalSupply = calculatePresentValue(assetData.sRate, assetData.totalSupply);
+    const totalBorrow = calculatePresentValue(assetData.bRate, assetData.totalBorrow);
+    let utilization = 0n;
+    let supplyInterest = 0n;
+    let borrowInterest = 0n;
+
+    if (totalSupply !== 0n) {
+        utilization = (totalBorrow * MASTER_CONSTANTS.FACTOR_SCALE) / totalSupply;
+    }
+
+    if (utilization <= assetConfig.targetUtilization) {
+        borrowInterest =
+            assetConfig.baseBorrowRate +
+            mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, utilization);
+    } else {
+        borrowInterest =
+            assetConfig.baseBorrowRate +
+            mulFactor(MASTER_CONSTANTS.FACTOR_SCALE, assetConfig.borrowRateSlopeLow, assetConfig.targetUtilization) +
+            mulFactor(
+                MASTER_CONSTANTS.FACTOR_SCALE,
+                assetConfig.borrowRateSlopeHigh,
+                utilization - assetConfig.targetUtilization,
+            );
+    }
+
+    const reserveFactor = 10n;
+    const reserveScale = 100n;
+    supplyInterest = mulDiv(
+        mulDiv(borrowInterest, utilization, MASTER_CONSTANTS.FACTOR_SCALE),
+        reserveScale - reserveFactor,
+        reserveScale,
+    );
+
+    return {
+        supplyInterest,
+        borrowInterest,
+    };
+}
+
+export function getAvailableToBorrow(
+    assetsConfig: Dictionary<bigint, AssetConfig>,
+    assetsData: Dictionary<bigint, ExtendedAssetData>,
+    principals: Dictionary<bigint, bigint>,
+    prices: Dictionary<bigint, bigint>,
+): bigint {
+    let borrowLimit = 0n;
+    let borrowAmount = 0n;
+
+    for (const assetID of principals.keys()) {
+        const assetConfig = assetsConfig.get(assetID) as AssetConfig;
+        const assetData = assetsData.get(assetID) as ExtendedAssetData;
+        const price = prices.get(assetID) as bigint;
+        const principal = principals.get(assetID) as bigint;
+
+        if (principal < 0) {
+            borrowAmount += (calculatePresentValue(assetData.bRate, -principal) * price) / 10n ** assetConfig.decimals;
+        } else if (principal > 0) {
+            borrowLimit +=
+                (calculatePresentValue(assetData.sRate, principal) * price * assetConfig.collateralFactor) /
+                10n ** assetConfig.decimals /
+                MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE;
+        }
+    }
+
+    return borrowLimit - borrowAmount;
+}
+
+export function presentValue(sRate: bigint, bRate: bigint, principalValue: bigint): UserBalance {
+    if (principalValue > 0) {
+        return {
+            amount: calculatePresentValue(sRate, principalValue),
+            type: BalanceType.supply,
+        };
+    } else if (principalValue < 0) {
+        return {
+            amount: calculatePresentValue(bRate, -principalValue),
+            type: BalanceType.borrow,
+        };
+    } else {
+        return {
+            amount: 0n,
+            type: undefined,
+        };
+    }
+}
+
+export function calculateLiquidationData(
+    assetsConfig: Dictionary<bigint, AssetConfig>,
+    assetsData: Dictionary<bigint, ExtendedAssetData>,
+    principals: Dictionary<bigint, bigint>,
+    prices: Dictionary<bigint, bigint>,
+): LiquidationData {
+    let gCollateralValue = 0n;
+    let gCollateralAsset = 0n;
+    let gLoanValue = 0n;
+    let gLoanAsset = 0n;
+    let totalDebt = 0n;
+    let totalLimit = 0n;
+
+    for (const key of principals.keys()) {
+        const principal = principals.get(key)!;
+        const assetConfig = assetsConfig.get(key)!;
+        const assetData = assetsData.get(key)!;
+        const balance =
+            principal > 0 ? (principal * assetData.sRate) / BigInt(1e12) : (principal * assetData.bRate) / BigInt(1e12);
+        if (balance > 0) {
+            const assetWorth = (balance * prices.get(key)!) / 10n ** assetConfig.decimals;
+            totalLimit += (assetWorth * assetConfig.liquidationThreshold) / MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE;
+            if (assetWorth > gCollateralValue) {
+                gCollateralValue = assetWorth;
+                gCollateralAsset = key;
+            }
+        } else if (balance < 0) {
+            const assetWorth = (-balance * prices.get(key)!) / 10n ** assetConfig.decimals;
+            totalDebt += assetWorth;
+            if (assetWorth > gLoanValue) {
+                gLoanValue = assetWorth;
+                gLoanAsset = key;
+            }
+        }
+    }
+
+    if (totalLimit < totalDebt) {
+        const gLoanAssetPrice = prices.get(gLoanAsset)!;
+        const values: bigint[] = [];
+        const gCollateralAssetConfig = assetsConfig.get(gCollateralAsset)!;
+        const gLoanAssetConfig = assetsConfig.get(gLoanAsset)!;
+        const liquidationBonus = gLoanAssetConfig.liquidationBonus;
+        const loanDecimal = 10n ** gLoanAssetConfig.decimals;
+        values.push(
+            (bigIntMax(gCollateralValue / 2n, bigIntMin(gCollateralValue, 10_000_000_000n)) *
+                loanDecimal *
+                MASTER_CONSTANTS.ASSET_COEFFICIENT_SCALE) /
+                liquidationBonus /
+                gLoanAssetPrice,
+        );
+        values.push((gLoanValue * loanDecimal) / gLoanAssetPrice);
+
+        const liquidationAmount = (bigIntMin(...values) as bigint) - 5n;
+        const gCollateralAssetPrice: bigint = prices.get(gCollateralAsset)!;
+        const collateralDecimal = 10n ** gCollateralAssetConfig.decimals;
+        let minCollateralAmount =
+            (((liquidationAmount * gLoanAssetPrice * liquidationBonus) / 10000n) * collateralDecimal) /
+                gCollateralAssetPrice /
+                loanDecimal -
+            10n;
+        minCollateralAmount = (minCollateralAmount * 97n) / 100n;
+        if (minCollateralAmount / collateralDecimal >= 1n) {
+            return {
+                greatestCollateralAsset: gCollateralAsset,
+                greatestCollateralValue: gCollateralValue,
+                greatestLoanAsset: gLoanAsset,
+                greatestLoanValue: gLoanValue,
+                totalDebt,
+                totalLimit,
+                liquidable: true,
+                liquidationAmount,
+                minCollateralAmount,
+            };
+        }
+    }
+
+    return {
+        greatestCollateralAsset: gCollateralAsset,
+        greatestCollateralValue: gCollateralValue,
+        greatestLoanAsset: gLoanAsset,
+        greatestLoanValue: gLoanValue,
+        totalDebt,
+        totalLimit,
+        liquidable: false,
+    };
+}