@affluent-org/sdk 0.0.2 → 0.0.4

package/dist/monitorCacheV1.js

@@ -0,0 +1,504 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonitorCacheV1 = void 0;
+const ton_1 = require("@ton/ton");
+const pool_1 = require("./contracts/core/pool");
+const type_1 = require("./contracts/oracle/redstone-onchain-oracle/type");
+const account_1 = require("./contracts/core/account");
+const tracker_1 = require("./utils/tracker");
+const parser_1 = require("./utils/parser");
+const redstone_onchain_oracle_1 = require("./contracts/oracle/redstone-onchain-oracle");
+const strategy_vault_1 = require("./contracts/vault/strategy-vault");
+const service_1 = require("./common/service");
+const readonlyCachedRedstone_1 = require("./utils/oracle/redstone/readonlyCachedRedstone");
+const toAddress = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value;
+    }
+    return ton_1.Address.parse(value);
+};
+const toString = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value.toString();
+    }
+    return value;
+};
+class MonitorCacheV1 extends service_1.ServiceBaseV1 {
+    // user -> asset -> wallet
+    accountAddresses = {};
+    async getAccountAddress(owner, pool) {
+        this.accountAddresses[owner] ||= {};
+        if (!this.accountAddresses[owner][pool]) {
+            const poolContract = this.open(pool_1.Pool.createFromAddress(toAddress(pool)));
+            this.accountAddresses[owner][pool] = await poolContract.getAccountAddress(toAddress(owner));
+        }
+        return this.accountAddresses[owner][pool];
+    }
+    async findAndCallback(target, step, createdLt, callbackFn) {
+        const matchedTx = await (0, tracker_1.findTx)(this.client, toAddress(target), createdLt.toString(), step);
+        step.matchedTx = matchedTx;
+        if (matchedTx.inMessage?.body) {
+            const parsed = (0, parser_1.parseActionNotification)(matchedTx.inMessage.body);
+            if (parsed) {
+                step.actionNotificationResult = parsed;
+            }
+        }
+        if (callbackFn)
+            callbackFn(step);
+        return matchedTx;
+    }
+    async updateOnchainData(onchainDataInfo) {
+        for (let [asset, data] of Object.entries(onchainDataInfo)) {
+            if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.tonstakers &&
+                "underlyingAddress" in data) {
+                const result = await this.client
+                    .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                    .get("get_pool_state", []);
+                result.stack.readBigNumber();
+                data.underlyingReserve = result.stack.readBigNumber();
+                data.totalSupply = result.stack.readBigNumber();
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.dedust &&
+                data.assetType === type_1.AssetType.MultiAsset) {
+                if (this.network === "mainnet") {
+                    const results = await Promise.all([
+                        this.client
+                            .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                            .get("get_reserves", []),
+                        this.client
+                            .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                            .get("get_jetton_data", []),
+                    ]);
+                    data.underlying0Reserve = results[0].stack.readBigNumber();
+                    data.underlying1Reserve = results[0].stack.readBigNumber();
+                    data.totalSupply = results[1].stack.readBigNumber();
+                }
+                else {
+                    const result = await this.client
+                        .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_pool_state", []);
+                    result.stack.readBigNumber();
+                    data.underlying0Reserve = result.stack.readBigNumber();
+                    data.underlying1Reserve = result.stack.readBigNumber();
+                    data.totalSupply = result.stack.readBigNumber();
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.stonfi &&
+                data.assetType === type_1.AssetType.MultiAsset) {
+                if (this.network === "mainnet") {
+                    const result = await this.client
+                        .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_pool_data", []);
+                    result.stack.readNumber();
+                    result.stack.readAddress();
+                    data.totalSupply = result.stack.readBigNumber();
+                    data.underlying0Reserve = result.stack.readBigNumber();
+                    data.underlying1Reserve = result.stack.readBigNumber();
+                }
+                else {
+                    const result = await this.client
+                        .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_pool_state", []);
+                    result.stack.readBigNumber();
+                    data.underlying0Reserve = result.stack.readBigNumber();
+                    data.underlying1Reserve = result.stack.readBigNumber();
+                    data.totalSupply = result.stack.readBigNumber();
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.storm &&
+                data.assetType === type_1.AssetType.SingleAsset) {
+                if (this.network === "mainnet") {
+                    const results = await this.client
+                        .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_vault_data", []);
+                    const jettonWalletAddress = results.stack.readAddress();
+                    const lpRate = results.stack.readBigNumber();
+                    const lpTotalSupply = results.stack.readBigNumber();
+                    const freeBalance = results.stack.readBigNumber();
+                    const lockedBalance = results.stack.readBigNumber();
+                    const withdrawLockedBalance = results.stack.readBigNumber();
+                    const stakersBalance = results.stack.readBigNumber();
+                    const executorsBalance = results.stack.readBigNumber();
+                    data.underlyingReserve = lpRate;
+                    if (!data.totalSupply) {
+                        data.totalSupply = BigInt(1e9);
+                    }
+                }
+                else {
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.tradoor &&
+                data.assetType === type_1.AssetType.SingleAsset) {
+                if (this.network === "mainnet") {
+                    const results = await this.client
+                        .provider(ton_1.Address.parse(data.sourceAddress.toString()))
+                        .get("tlpPrice", []);
+                    const lpRate = results.stack.readBigNumber();
+                    data.underlyingReserve = lpRate;
+                    if (!data.totalSupply) {
+                        data.totalSupply = BigInt(18e9);
+                    }
+                }
+            }
+        }
+        return onchainDataInfo;
+    }
+    async getRedstonePrices(assets, poolData) {
+        return this.getRedstonePricesNew(assets, poolData.oracleConfig);
+    }
+    async getRedstonePricesNew(assets, oracleConfig) {
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+        const redstonePrices = await readonlyCachedRedstone_1.ReadonlyCachedRedstone.getPrices(result.redstoneAssetNames);
+        const prices = {};
+        const onchainData = {};
+        redstonePrices.forEach((item) => {
+            try {
+                const redstoneAssetInfo = oracleConfig.redstoneAssetInfo[item.feedId.toString()];
+                if (redstoneAssetInfo.assetType === 0) {
+                    prices[redstoneAssetInfo.address.toString()] = {
+                        type: type_1.AssetType.Native,
+                        timestamp: item.timestamp,
+                        price: (item.price * BigInt(1e8)) / redstoneAssetInfo.precision,
+                    };
+                }
+                else if (redstoneAssetInfo.assetType === 1) {
+                    onchainData[redstoneAssetInfo.address.toString()] = {
+                        assetType: type_1.AssetType.SingleAsset,
+                        underlyingAddress: redstoneAssetInfo.underlyingAddress,
+                        underlyingReserve: item.price,
+                        totalSupply: redstoneAssetInfo.precision,
+                    };
+                }
+            }
+            catch (e) {
+            }
+        });
+        return { redstonePrices: prices, onchainData };
+    }
+    calculatePrices(_prices, oracleData) {
+        const prices = { ..._prices };
+        let oracles = Object.entries(oracleData);
+        while (oracles.length !== 0) {
+            const restOracles = [];
+            for (let [asset, onchainDataInfo] of oracles) {
+                if (!onchainDataInfo)
+                    throw "not found onchain data info1";
+                if (onchainDataInfo.assetType === type_1.AssetType.SingleAsset) {
+                    if (prices[onchainDataInfo.underlyingAddress.toString()]) {
+                        const underlyingPriceInfo = prices[onchainDataInfo.underlyingAddress.toString()];
+                        prices[asset.toString()] = {
+                            type: type_1.AssetType.SingleAsset,
+                            price: (underlyingPriceInfo.price *
+                                onchainDataInfo.underlyingReserve) /
+                                onchainDataInfo.totalSupply,
+                        };
+                    }
+                    else {
+                        restOracles.push([asset, onchainDataInfo]);
+                    }
+                }
+                else if (onchainDataInfo.assetType === type_1.AssetType.MultiAsset) {
+                    if (prices[onchainDataInfo.underlying0Address.toString()] &&
+                        prices[onchainDataInfo.underlying1Address.toString()]) {
+                        const underlying0PriceInfo = prices[onchainDataInfo.underlying0Address.toString()];
+                        const underlying1PriceInfo = prices[onchainDataInfo.underlying1Address.toString()];
+                        const price0 = (underlying0PriceInfo.price *
+                            onchainDataInfo.underlying0Reserve) /
+                            onchainDataInfo.totalSupply;
+                        const price1 = (underlying1PriceInfo.price *
+                            onchainDataInfo.underlying1Reserve) /
+                            onchainDataInfo.totalSupply;
+                        prices[asset.toString()] = {
+                            type: type_1.AssetType.MultiAsset,
+                            price: price0 + price1,
+                        };
+                    }
+                    else {
+                        restOracles.push([asset, onchainDataInfo]);
+                    }
+                }
+                else if (onchainDataInfo.assetType === type_1.AssetType.Native) {
+                }
+                else {
+                    throw `invalid asset type ${onchainDataInfo.assetType}`;
+                }
+            }
+            oracles = restOracles;
+        }
+        return prices;
+    }
+    decomposeAccountStatus(accountStatus, prices, onchainData) {
+        const accumStatus = {};
+        let userAssets = Object.values(accountStatus);
+        while (userAssets.length !== 0) {
+            const restUserAssets = [];
+            for (let i = 0; i < userAssets.length; i++) {
+                const state = userAssets[i];
+                if (state.supply > 0n || state.borrow > 0n) {
+                    if (!accumStatus[userAssets[i].address.toString()])
+                        accumStatus[userAssets[i].address.toString()] = {
+                            supply: 0n,
+                            borrow: 0n,
+                        };
+                    if (state.supply > 0n) {
+                        accumStatus[userAssets[i].address.toString()].supply +=
+                            state.supply;
+                    }
+                    if (state.borrow > 0n) {
+                        accumStatus[userAssets[i].address.toString()].borrow +=
+                            state.borrow;
+                    }
+                    const onchainDataInfo = onchainData[state.address.toString()];
+                    if (!onchainDataInfo && !prices[state.address.toString()]) {
+                        throw "not found onchain data info2";
+                    }
+                    if (onchainDataInfo) {
+                        if (onchainDataInfo.assetType === type_1.AssetType.SingleAsset &&
+                            onchainDataInfo.underlyingReserve &&
+                            onchainDataInfo.totalSupply) {
+                            const underlyingSupply = (state.supply * onchainDataInfo.underlyingReserve) /
+                                onchainDataInfo.totalSupply;
+                            const underlyingBorrow = (state.borrow * onchainDataInfo.underlyingReserve) /
+                                onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlyingAddress,
+                                supply: underlyingSupply,
+                                borrow: underlyingBorrow,
+                            });
+                        }
+                        else if (onchainDataInfo.assetType === type_1.AssetType.MultiAsset &&
+                            onchainDataInfo.underlying0Reserve &&
+                            onchainDataInfo.underlying1Reserve &&
+                            onchainDataInfo.totalSupply) {
+                            const underlying0Supply = (state.supply * onchainDataInfo.underlying0Reserve) /
+                                onchainDataInfo.totalSupply;
+                            const underlying0Borrow = (state.borrow * onchainDataInfo.underlying0Reserve) /
+                                onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlying0Address,
+                                supply: underlying0Supply,
+                                borrow: underlying0Borrow,
+                            });
+                            const underlying1Supply = (state.supply * onchainDataInfo.underlying1Reserve) /
+                                onchainDataInfo.totalSupply;
+                            const underlying1Borrow = (state.borrow * onchainDataInfo.underlying1Reserve) /
+                                onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlying1Address,
+                                supply: underlying1Supply,
+                                borrow: underlying1Borrow,
+                            });
+                        }
+                    }
+                }
+            }
+            userAssets = restUserAssets;
+        }
+        return accumStatus;
+    }
+    calculateRisk(decomposedAccountStatus, prices, poolData) {
+        let collateral = 0n;
+        let debt = 0n;
+        let risk = 0n;
+        Object.entries(decomposedAccountStatus).forEach(([asset, status]) => {
+            const price = prices[asset];
+            const suppliedValue = (BigInt(status.supply) * price.price) / BigInt(1e8);
+            const borrowedValue = (BigInt(status.borrow) * price.price) / BigInt(1e8);
+            const isCollateral = poolData.assets[asset].isCollateral;
+            if (price.type === type_1.AssetType.Native) {
+                if (isCollateral) {
+                    collateral += suppliedValue;
+                }
+                debt += borrowedValue;
+            }
+            if (isCollateral) {
+                const delta = suppliedValue > borrowedValue
+                    ? suppliedValue - borrowedValue
+                    : borrowedValue - suppliedValue;
+                risk += (delta * poolData.assets[asset].riskFactor) / BigInt(1e4);
+            }
+            else {
+                risk +=
+                    (borrowedValue * poolData.assets[asset].riskFactor) / BigInt(1e4);
+            }
+        });
+        if (collateral === 0n && debt === 0n) {
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral,
+                debt,
+                risk,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const netValue = collateral - debt;
+        if (netValue <= 0n) {
+            return {
+                result: false,
+                healthy: false,
+                unhealthy: true,
+                collateral,
+                debt,
+                risk,
+                riskRatio: 2n ** 128n - 1n,
+                leverageRatio: 2n ** 128n - 1n,
+            };
+        }
+        const leverageRatio = (collateral * BigInt(1e4)) / netValue;
+        const riskRatio = (risk * BigInt(1e4)) / netValue;
+        const unhealthy = poolData.liquidateLeverageRatio === 0n
+            ? riskRatio > poolData.liquidateVarRatio
+            : leverageRatio > poolData.liquidateLeverageRatio ||
+                riskRatio > poolData.liquidateVarRatio;
+        return {
+            result: !unhealthy,
+            healthy: !unhealthy,
+            unhealthy: unhealthy,
+            collateral,
+            debt,
+            risk,
+            riskRatio,
+            leverageRatio,
+        };
+    }
+    async getOracleRequestParams(assets, oracleConfig) {
+        return redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+    }
+    async isHealthy(poolAddress, ownerAddress) {
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const borrowerAccountAddress = await this.getAccountAddress(toString(ownerAddress), toString(poolAddress));
+        const borrowerAccount = this.open(account_1.Account.createFromAddress(toAddress(borrowerAccountAddress)));
+        const poolData = pool_1.Pool.simulateAccrueInterest(await pool.getPoolData());
+        let accountData;
+        try {
+            accountData = account_1.Account.convertShareToAmount(await borrowerAccount.getAccountData(), poolData);
+        }
+        catch (e) {
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral: 0n,
+                debt: 0n,
+                risk: 0n,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const assets = account_1.Account.haveAssets(accountData);
+        if (assets.length === 0) {
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral: 0n,
+                debt: 0n,
+                risk: 0n,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.oracleConfig);
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
+        const onchainData2 = await this.updateOnchainData(poolData.oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        Object.keys(onchainData).forEach((key) => {
+            if (!result.requestAssets.map((item) => item.toString()).includes(key) &&
+                !result.redstoneAssets.map((item) => item.toString()).includes(key)) {
+                delete onchainData[key];
+            }
+        });
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        const decomposedAccountStatus = this.decomposeAccountStatus(accountData.status, prices, onchainData);
+        return this.calculateRisk(decomposedAccountStatus, prices, poolData);
+    }
+    async getPricesNew(assets, oracleConfig) {
+        const { redstonePrices, onchainData: od } = await this.getRedstonePricesNew(assets, oracleConfig);
+        const _onchainData = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ..._onchainData };
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        return prices;
+    }
+    async getAssetPricesInPool(poolAddress) {
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const poolData = (await pool.getPoolData());
+        const assets = Object.keys(poolData.assets);
+        return await this.getPricesNew(assets, poolData.oracleConfig);
+    }
+    async getAssetPricesInVault(vaultAddress) {
+        const vault = this.open(strategy_vault_1.StrategyVault.createFromAddress(toAddress(vaultAddress)));
+        const vaultData = (await vault.getVaultData());
+        const assets = Object.keys(vaultData.assets);
+        return await this.getPricesNew(assets, vaultData.oracleConfig);
+    }
+    async getPrices(poolAddress) {
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const poolData = (await pool.getPoolData());
+        const assets = Object.keys(poolData.assets);
+        return await this.getPricesNew(assets, poolData.oracleConfig);
+    }
+    async getPricesAndOnchainData(poolData) {
+        const assets = Object.keys(poolData.assets);
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
+        const onchainData2 = await this.updateOnchainData(poolData.oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        return { prices, onchainData };
+    }
+    async getPoolData(poolAddress) {
+        if (!(poolAddress instanceof ton_1.Address)) {
+            poolAddress = ton_1.Address.parse(poolAddress);
+        }
+        const pool = this.open(pool_1.Pool.createFromAddress(poolAddress));
+        return await pool.getPoolData();
+    }
+    async getAccountData(address) {
+        const account = this.open(account_1.Account.createFromAddress(toAddress(address)));
+        return await account.getAccountData();
+    }
+    calculateHealth(_poolData, _accountData, prices, onchainData) {
+        const poolData = pool_1.Pool.simulateAccrueInterest(_poolData);
+        let accountData;
+        try {
+            accountData = account_1.Account.convertShareToAmount(_accountData, poolData);
+        }
+        catch (e) {
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral: 0n,
+                debt: 0n,
+                risk: 0n,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const assets = account_1.Account.haveAssets(accountData);
+        if (assets.length === 0) {
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral: 0n,
+                debt: 0n,
+                risk: 0n,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.oracleConfig);
+        Object.keys(onchainData).forEach((key) => {
+            if (!result.requestAssets.map((item) => item.toString()).includes(key) &&
+                !result.redstoneAssets.map((item) => item.toString()).includes(key)) {
+                delete onchainData[key];
+            }
+        });
+        const decomposedAccountStatus = this.decomposeAccountStatus(accountData.status, prices, onchainData);
+        return this.calculateRisk(decomposedAccountStatus, prices, poolData);
+    }
+}
+exports.MonitorCacheV1 = MonitorCacheV1;

package/dist/oracle/oracle-v2.d.ts

@@ -0,0 +1,39 @@
+import { Address } from "@ton/core";
+import { ServiceBaseV1 } from "../common/service";
+import { AddressInput } from "../contracts/common/type";
+import { StrategyVaultState } from "../contracts/vault/strategy-vault";
+import { PoolState } from "../contracts/core/pool/type";
+import { AccountState } from "../contracts/core/account/type";
+export declare class AddressBucket {
+    readonly assets: Set<string>;
+    readonly pools: Set<string>;
+    readonly vaults: Set<string>;
+    constructor(assets?: Set<string>, pools?: Set<string>, vaults?: Set<string>);
+    getAssets(): string[];
+    getVaultAssets(): string[];
+    getPools(): string[];
+    add(other: AddressBucket): this;
+    array(): {
+        assets: string[];
+        pools: string[];
+        vaults: string[];
+    };
+    totalSize(): number;
+}
+export declare class OracleLibsV2 extends ServiceBaseV1 {
+    getOracleParamsForPoolSupplyAndRepay(poolAddress: AddressInput, assetAddress: AddressInput, poolData?: PoolState, bucket?: AddressBucket): Promise<{
+        oracleParams: import("@ton/core").Cell;
+        bucket: AddressBucket;
+    }>;
+    getOracleParamsForPoolBorrowAndWithdraw(poolAddress: AddressInput, actorAddress: AddressInput, assetAddress: AddressInput, poolData?: PoolState, accountData?: AccountState, bucket?: AddressBucket): Promise<{
+        oracleParams: import("@ton/core").Cell;
+        bucket: AddressBucket;
+    }>;
+    getOracleParamsForStrategyVault(vaultAddress: AddressInput, vaultData?: StrategyVaultState, bucket?: AddressBucket): Promise<{
+        oracleParams: import("@ton/core").Cell;
+        bucket: AddressBucket;
+    }>;
+    makeOracleParams(bucket: AddressBucket, oracleConfig: any): Promise<import("@ton/core").Cell>;
+    strategyVaultAddressBucket(vault: Address, bucket?: AddressBucket): Promise<AddressBucket>;
+    makeAnyAddressBucket(asset: Address, bucket?: AddressBucket): Promise<AddressBucket>;
+}