@affluent-org/sdk 0.0.1

package/dist/services/composite-oracle/query.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeOracleFetcher = void 0;
+const core_1 = require("@ton/core");
+const context_1 = require("../../context");
+const utils_1 = require("../../contracts/common/utils");
+const pool_1 = require("../../contracts/core/pool");
+const redstone_onchain_oracle_1 = require("../../contracts/oracle/redstone-onchain-oracle");
+const type_1 = require("../../contracts/oracle/redstone-onchain-oracle/type");
+const share_vault_1 = require("../../contracts/vault/share-vault");
+const strategy_vault_1 = require("../../contracts/vault/strategy-vault");
+const readonlyCachedRedstone_1 = require("../../utils/oracle/redstone/readonlyCachedRedstone");
+const unknown_contract_1 = require("../../contracts/unknown-contract");
+const types_1 = require("./types");
+const computation_1 = require("./computation");
+// ============================================================
+// Query Class (I/O - fetching data)
+// ============================================================
+class CompositeOracleFetcher {
+    ctx;
+    constructor(ctx = context_1.AffluentContext.getInstance()) {
+        this.ctx = ctx;
+    }
+    /**
+     * Get oracle context - shared data needed for both price computation and on-chain params
+     */
+    async getOracleContext(vaultAddress, vaultData, extraAssets) {
+        const vault = this.ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+        vaultData = vaultData ?? (await vault.getVaultData());
+        const oracleConfig = vaultData.oracleConfig;
+        let { assets, vaultAssets } = (0, computation_1.separateAssets)(Object.keys(vaultData.assets), oracleConfig);
+        if (extraAssets) {
+            assets = [...new Set([...assets, ...extraAssets.assets])];
+            vaultAssets = [...new Set([...vaultAssets, ...extraAssets.vaultAssets])];
+        }
+        const vaultPositions = await this.fetchVaultPositions([...vaultAssets, (0, utils_1.toAddress)(vaultAddress)]);
+        const exposures = (0, computation_1.getExposures)(vaultPositions);
+        const allRequiredAssets = [...new Set([...assets, ...exposures.assets])];
+        return {
+            vaultData,
+            oracleConfig,
+            assets,
+            vaultAssets,
+            vaultPositions,
+            exposures,
+            allRequiredAssets,
+        };
+    }
+    async fetchRawPrices(assets, oracleConfig) {
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+        const redstonePrices = await readonlyCachedRedstone_1.ReadonlyCachedRedstone.getPrices(result.redstoneAssetNames);
+        const rawPrices = {};
+        const onchainData = {};
+        for (const item of redstonePrices) {
+            try {
+                const rainfo = oracleConfig.redstoneAssetInfo[item.feedId.toString()];
+                if (!rainfo)
+                    continue;
+                if (rainfo.assetType === 0) {
+                    rawPrices[rainfo.address.toString()] = {
+                        type: types_1.CompositeAssetType.NATIVE,
+                        timestamp: item.timestamp,
+                        price: (item.price * types_1.DECIMALS_OF_PRICE) / rainfo.precision,
+                    };
+                }
+                else if (rainfo.assetType === 1) {
+                    onchainData[rainfo.address.toString()] = {
+                        assetType: types_1.CompositeAssetType.SYNTHETIC1,
+                        underlyingAddress: rainfo.underlyingAddress,
+                        underlyingReserve: item.price,
+                        totalSupply: rainfo.precision,
+                    };
+                }
+            }
+            catch (e) { }
+        }
+        return { rawPrices, onchainData };
+    }
+    async fetchOnchainData(onchainDataInfo) {
+        const result = {};
+        for (const [asset, data] of Object.entries(onchainDataInfo)) {
+            if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.tonstakers && data.assetType === type_1.AssetType.SingleAsset) {
+                const state = await this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("get_pool_state", []);
+                state.stack.readBigNumber();
+                result[asset] = {
+                    assetType: types_1.CompositeAssetType.SYNTHETIC1,
+                    underlyingAddress: data.underlyingAddress,
+                    underlyingReserve: state.stack.readBigNumber(),
+                    totalSupply: state.stack.readBigNumber(),
+                };
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.dedust && data.assetType === type_1.AssetType.MultiAsset) {
+                if (this.ctx.network === "mainnet") {
+                    const [reserves, jettonData] = await Promise.all([
+                        this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("get_reserves", []),
+                        this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("get_jetton_data", []),
+                    ]);
+                    result[asset] = {
+                        assetType: types_1.CompositeAssetType.SYNTHETIC2,
+                        underlying0Address: data.underlying0Address,
+                        underlying1Address: data.underlying1Address,
+                        underlying0Reserve: reserves.stack.readBigNumber(),
+                        underlying1Reserve: reserves.stack.readBigNumber(),
+                        totalSupply: jettonData.stack.readBigNumber(),
+                    };
+                }
+                else {
+                    const state = await this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("get_pool_state", []);
+                    state.stack.readBigNumber();
+                    result[asset] = {
+                        assetType: types_1.CompositeAssetType.SYNTHETIC2,
+                        underlying0Address: data.underlying0Address,
+                        underlying1Address: data.underlying1Address,
+                        underlying0Reserve: state.stack.readBigNumber(),
+                        underlying1Reserve: state.stack.readBigNumber(),
+                        totalSupply: state.stack.readBigNumber(),
+                    };
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.stonfi && data.assetType === type_1.AssetType.MultiAsset) {
+                if (this.ctx.network === "mainnet") {
+                    const state = await this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("get_pool_data", []);
+                    state.stack.readNumber();
+                    state.stack.readAddress();
+                    const totalSupply = state.stack.readBigNumber();
+                    result[asset] = {
+                        assetType: types_1.CompositeAssetType.SYNTHETIC2,
+                        underlying0Address: data.underlying0Address,
+                        underlying1Address: data.underlying1Address,
+                        underlying0Reserve: state.stack.readBigNumber(),
+                        underlying1Reserve: state.stack.readBigNumber(),
+                        totalSupply,
+                    };
+                }
+                else {
+                    const state = await this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("get_pool_state", []);
+                    state.stack.readBigNumber();
+                    result[asset] = {
+                        assetType: types_1.CompositeAssetType.SYNTHETIC2,
+                        underlying0Address: data.underlying0Address,
+                        underlying1Address: data.underlying1Address,
+                        underlying0Reserve: state.stack.readBigNumber(),
+                        underlying1Reserve: state.stack.readBigNumber(),
+                        totalSupply: state.stack.readBigNumber(),
+                    };
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.storm && data.assetType === type_1.AssetType.SingleAsset) {
+                if (this.ctx.network === "mainnet") {
+                    const state = await this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("get_vault_data", []);
+                    state.stack.readAddress();
+                    result[asset] = {
+                        assetType: types_1.CompositeAssetType.SYNTHETIC1,
+                        underlyingAddress: data.underlyingAddress,
+                        underlyingReserve: state.stack.readBigNumber(),
+                        totalSupply: data.totalSupply ?? BigInt(1e9),
+                    };
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.tradoor && data.assetType === type_1.AssetType.SingleAsset) {
+                if (this.ctx.network === "mainnet") {
+                    const state = await this.ctx.client.provider(core_1.Address.parse(data.sourceAddress.toString())).get("tlpPrice", []);
+                    result[asset] = {
+                        assetType: types_1.CompositeAssetType.SYNTHETIC1,
+                        underlyingAddress: data.underlyingAddress,
+                        underlyingReserve: state.stack.readBigNumber(),
+                        totalSupply: data.totalSupply ?? BigInt(18e9),
+                    };
+                }
+            }
+        }
+        return result;
+    }
+    async fetchVaultPositions(vaultAddresses) {
+        const positions = {};
+        await Promise.all(vaultAddresses.map(async (vaultAddress) => {
+            const addressStr = vaultAddress.toString();
+            try {
+                const state = await this.ctx.getByContract(unknown_contract_1.UnknownContract, vaultAddress).getState();
+                if (state.state.type === "active" && state.state.data) {
+                    const data = core_1.Cell.fromBoc(state.state.data)[0];
+                    try {
+                        const vaultData = strategy_vault_1.StrategyVault.parseVaultData(data);
+                        positions[addressStr] = extractStrategyVaultPosition(vaultData);
+                        return;
+                    }
+                    catch (e) { }
+                    try {
+                        const vaultData = share_vault_1.ShareVault.parseVaultData(data);
+                        positions[addressStr] = extractShareVaultPosition(vaultData);
+                    }
+                    catch (e) { }
+                }
+            }
+            catch (e) { }
+        }));
+        return positions;
+    }
+    async fetchPoolInfos(poolAddresses) {
+        const poolInfos = {};
+        await Promise.all(poolAddresses.map(async (poolAddress) => {
+            try {
+                const pool = this.ctx.getByContract(pool_1.Pool, (0, utils_1.toAddress)(poolAddress));
+                const poolData = await pool.getPoolData();
+                poolInfos[poolAddress] = {};
+                for (const [asset, assetData] of Object.entries(poolData.assets)) {
+                    poolInfos[poolAddress][asset] = {
+                        totalSupplyAmount: assetData.totalSupplyAmount,
+                        totalSupplyShare: assetData.totalSupplyShare,
+                        totalBorrowAmount: assetData.totalBorrowAmount,
+                        totalBorrowShare: assetData.totalBorrowShare,
+                    };
+                }
+            }
+            catch (e) { }
+        }));
+        return poolInfos;
+    }
+}
+exports.CompositeOracleFetcher = CompositeOracleFetcher;
+// ============================================================
+// Helper Functions
+// ============================================================
+function extractStrategyVaultPosition(vaultData) {
+    const assets = {};
+    const poolPositions = {};
+    for (const [asset, assetData] of Object.entries(vaultData.assets)) {
+        assets[asset] = assetData.cash;
+    }
+    for (const [pool, poolAssets] of Object.entries(vaultData.factorialPools)) {
+        poolPositions[pool] = {};
+        for (const [asset, position] of Object.entries(poolAssets)) {
+            poolPositions[pool][asset] = { supply: position.supply, borrow: position.borrow };
+        }
+    }
+    return { assets, poolPositions, totalSupply: vaultData.totalSupply };
+}
+function extractShareVaultPosition(vaultData) {
+    const asset = vaultData.asset.toString();
+    const poolPositions = {};
+    for (const pool of Object.values(vaultData.whitelistedPools)) {
+        poolPositions[pool.address.toString()] = {
+            [asset]: { supply: pool.supply, borrow: 0n },
+        };
+    }
+    return {
+        assets: { [asset]: vaultData.cash },
+        poolPositions,
+        totalSupply: vaultData.totalSupply,
+    };
+}

package/dist/services/composite-oracle/types.d.ts

@@ -0,0 +1,82 @@
+import { Address } from "@ton/core";
+export declare const DECIMALS_OF_PRICE = 100000000n;
+export declare enum CompositeAssetType {
+    NATIVE = 0,
+    SYNTHETIC1 = 1,
+    SYNTHETIC2 = 2,
+    VAULT = 10
+}
+export type PriceEntry = {
+    type: CompositeAssetType;
+    price: bigint;
+    timestamp?: number;
+};
+export type Prices = Record<string, PriceEntry>;
+export type PoolAssetPosition = {
+    supply: bigint;
+    borrow: bigint;
+};
+export type PoolPositions = Record<string, PoolAssetPosition>;
+export type VaultPosition = {
+    assets: Record<string, bigint>;
+    poolPositions: Record<string, PoolPositions>;
+    totalSupply: bigint;
+};
+export type PoolShareInfo = {
+    totalSupplyAmount: bigint;
+    totalSupplyShare: bigint;
+    totalBorrowAmount: bigint;
+    totalBorrowShare: bigint;
+};
+export type PoolInfos = Record<string, Record<string, PoolShareInfo>>;
+export type SingleAssetData = {
+    assetType: CompositeAssetType.SYNTHETIC1;
+    underlyingAddress: Address | string;
+    underlyingReserve: bigint;
+    totalSupply: bigint;
+};
+export type MultiAssetData = {
+    assetType: CompositeAssetType.SYNTHETIC2;
+    underlying0Address: Address | string;
+    underlying1Address: Address | string;
+    underlying0Reserve: bigint;
+    underlying1Reserve: bigint;
+    totalSupply: bigint;
+};
+export type SyntheticComposition = SingleAssetData | MultiAssetData;
+export type SyntheticCompositions = Record<string, SyntheticComposition>;
+/** @deprecated Use SyntheticComposition instead */
+export type OnchainData = SyntheticComposition;
+/** @deprecated Use SyntheticCompositions instead */
+export type OnchainDataMap = SyntheticCompositions;
+export type VaultPositions = Record<string, VaultPosition>;
+export type VaultComposition = {
+    decomposed: Record<string, {
+        supply: bigint;
+        borrow: bigint;
+    }>;
+    totalSupply: bigint;
+};
+export type VaultCompositions = Record<string, VaultComposition>;
+export type VaultPriceEntry = PriceEntry & {
+    additionalData: VaultComposition;
+};
+export type VaultPrices = Record<string, VaultPriceEntry>;
+export type CompositeOracleResult = {
+    assetPrices: Prices;
+    vaultPrices: VaultPrices;
+    allPrices: Prices;
+};
+export type CompositeOracleInput = {
+    rawPrices: Prices;
+    syntheticCompositions: SyntheticCompositions;
+    vaultPositions: VaultPositions;
+    poolInfos: PoolInfos;
+};
+/** @deprecated Use CompositeOracleInput with syntheticCompositions instead */
+export type CompositeOracleInputLegacy = {
+    rawPrices: Prices;
+    onchainData: OnchainDataMap;
+    vaultPositions: VaultPositions;
+    poolInfos: PoolInfos;
+};

package/dist/services/composite-oracle/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeAssetType = exports.DECIMALS_OF_PRICE = void 0;
+exports.DECIMALS_OF_PRICE = 100000000n;
+var CompositeAssetType;
+(function (CompositeAssetType) {
+    CompositeAssetType[CompositeAssetType["NATIVE"] = 0] = "NATIVE";
+    CompositeAssetType[CompositeAssetType["SYNTHETIC1"] = 1] = "SYNTHETIC1";
+    CompositeAssetType[CompositeAssetType["SYNTHETIC2"] = 2] = "SYNTHETIC2";
+    CompositeAssetType[CompositeAssetType["VAULT"] = 10] = "VAULT";
+})(CompositeAssetType || (exports.CompositeAssetType = CompositeAssetType = {}));

package/dist/services/pool/computation.d.ts

@@ -0,0 +1,75 @@
+import { PoolState } from "../../contracts/core/pool/type";
+import { AccountState, AccountAssetState } from "../../contracts/core/account/type";
+import { Prices, VaultCompositions, SyntheticCompositions } from "../composite-oracle/types";
+export type HealthResult = {
+    result: boolean;
+    healthy: boolean;
+    unhealthy: boolean;
+    collateral: bigint;
+    debt: bigint;
+    risk: bigint;
+    riskRatio: bigint;
+    leverageRatio: bigint;
+};
+/** @deprecated Use HealthResult instead */
+export type RiskResult = HealthResult;
+export type MaxBorrowableResult = {
+    amount: bigint;
+    reason: "RISK_RATIO_CONSTRAINT" | "LEVERAGE_CONSTRAINT" | "POOL_CASH_CONSTRAINT";
+    beforeAccountHealth: HealthResult;
+    afterAccountHealth: HealthResult;
+};
+export type MaxWithdrawableResult = {
+    amount: bigint;
+    reason: "RISK_RATIO_CONSTRAINT" | "LEVERAGE_CONSTRAINT" | "POOL_CASH_CONSTRAINT" | "USER_SUPPLY_CONSTRAINT";
+    beforeAccountHealth?: HealthResult;
+    afterAccountHealth?: HealthResult;
+};
+type Position = {
+    supply: bigint;
+    borrow: bigint;
+};
+type PositionMap = Record<string, Position>;
+/**
+ * Simulate interest accrual on pool data
+ */
+export declare function simulateAccrueInterest(poolData: PoolState, time?: number): PoolState;
+/**
+ * Convert share-based position to actual amounts
+ */
+export declare function convertShareToAmount(accountData: AccountState, poolData: PoolState): AccountState;
+/**
+ * Check if account has any borrow positions
+ */
+export declare function haveBorrow(accountData: AccountState): boolean;
+/**
+ * Get list of assets the account has positions in
+ */
+export declare function haveAssets(accountData: AccountState): string[];
+/**
+ * Apply delta to account state
+ */
+export declare function applyDelta(accountData: AccountState, delta: Record<string, AccountAssetState>): AccountState;
+/**
+ * Decompose synthetic/vault positions to native assets
+ *
+ * - SYNTHETIC1: stTON(100) → TON(105)
+ * - SYNTHETIC2: LP-TON-USDT(100) → TON(50) + USDT(50)
+ * - VAULT: StrategyVault(100) → TON(30) + USDT(70)
+ *
+ * 같은 native asset이 여러 경로로 나오면 누적됨
+ */
+export declare function decomposePositions(positions: Record<string, AccountAssetState>, syntheticCompositions: SyntheticCompositions, vaultCompositions?: VaultCompositions): PositionMap;
+/** @deprecated Use decomposePositions instead */
+export declare const decomposeAccountStatus: typeof decomposePositions;
+/**
+ * Calculate risk metrics from decomposed account status
+ * Pure computation
+ */
+export declare function calculateRisk(decomposedAccountStatus: Record<string, Omit<AccountAssetState, "address">>, prices: Prices, poolData: PoolState): HealthResult;
+/**
+ * Check if account is healthy (pure computation)
+ * Takes pre-fetched pool data, account status, and prices
+ */
+export declare function isHealthyFromData(poolData: PoolState, accountStatus: Record<string, AccountAssetState>, prices: Prices, syntheticCompositions: SyntheticCompositions, vaultCompositions?: VaultCompositions): HealthResult;
+export {};

package/dist/services/pool/computation.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decomposeAccountStatus = void 0;
+exports.simulateAccrueInterest = simulateAccrueInterest;
+exports.convertShareToAmount = convertShareToAmount;
+exports.haveBorrow = haveBorrow;
+exports.haveAssets = haveAssets;
+exports.applyDelta = applyDelta;
+exports.decomposePositions = decomposePositions;
+exports.calculateRisk = calculateRisk;
+exports.isHealthyFromData = isHealthyFromData;
+const core_1 = require("@ton/core");
+const pool_1 = require("../../contracts/core/pool");
+const account_1 = require("../../contracts/core/account");
+const types_1 = require("../composite-oracle/types");
+const utils_1 = require("../../contracts/common/utils");
+// ============================================================
+// Position Decomposition Helpers
+// ============================================================
+/**
+ * Try to decompose a synthetic/vault asset to its underlying assets
+ * Returns null if asset is native (no decomposition needed)
+ */
+function tryDecomposeAsset(asset, position, syntheticCompositions, vaultCompositions) {
+    const data = syntheticCompositions[asset];
+    // SYNTHETIC1: stTON, tsTON 같은 단일 underlying asset
+    if (data?.assetType === types_1.CompositeAssetType.SYNTHETIC1 &&
+        "underlyingReserve" in data &&
+        data.underlyingReserve &&
+        data.totalSupply) {
+        const ratio = data.underlyingReserve;
+        const total = data.totalSupply;
+        return [
+            {
+                address: (0, utils_1.toAddress)(data.underlyingAddress),
+                supply: (position.supply * ratio) / total,
+                borrow: (position.borrow * ratio) / total,
+            },
+        ];
+    }
+    // SYNTHETIC2: LP 토큰 같은 2개 underlying assets
+    if (data?.assetType === types_1.CompositeAssetType.SYNTHETIC2 &&
+        "underlying0Reserve" in data &&
+        data.underlying0Reserve &&
+        data.underlying1Reserve &&
+        data.totalSupply) {
+        const total = data.totalSupply;
+        return [
+            {
+                address: (0, utils_1.toAddress)(data.underlying0Address),
+                supply: (position.supply * data.underlying0Reserve) / total,
+                borrow: (position.borrow * data.underlying0Reserve) / total,
+            },
+            {
+                address: (0, utils_1.toAddress)(data.underlying1Address),
+                supply: (position.supply * data.underlying1Reserve) / total,
+                borrow: (position.borrow * data.underlying1Reserve) / total,
+            },
+        ];
+    }
+    // VAULT: Strategy Vault - decomposed positions 사용
+    const vault = vaultCompositions[asset];
+    if (vault) {
+        const { decomposed, totalSupply } = vault;
+        return Object.entries(decomposed).map(([addr, pos]) => ({
+            address: core_1.Address.parse(addr),
+            // Vault는 supply/borrow가 교차됨
+            supply: (position.supply * pos.supply + position.borrow * pos.borrow) / totalSupply,
+            borrow: (position.supply * pos.borrow + position.borrow * pos.supply) / totalSupply,
+        }));
+    }
+    return null; // Native asset
+}
+// ============================================================
+// Pure Computation (no I/O)
+// ============================================================
+/**
+ * Simulate interest accrual on pool data
+ */
+function simulateAccrueInterest(poolData, time) {
+    return pool_1.Pool.simulateAccrueInterest(poolData, time);
+}
+/**
+ * Convert share-based position to actual amounts
+ */
+function convertShareToAmount(accountData, poolData) {
+    return account_1.Account.convertShareToAmount(accountData, poolData);
+}
+/**
+ * Check if account has any borrow positions
+ */
+function haveBorrow(accountData) {
+    return account_1.Account.haveBorrow(accountData);
+}
+/**
+ * Get list of assets the account has positions in
+ */
+function haveAssets(accountData) {
+    return account_1.Account.haveAssets(accountData);
+}
+/**
+ * Apply delta to account state
+ */
+function applyDelta(accountData, delta) {
+    return account_1.Account.applyDelta(accountData, delta);
+}
+/**
+ * Decompose synthetic/vault positions to native assets
+ *
+ * - SYNTHETIC1: stTON(100) → TON(105)
+ * - SYNTHETIC2: LP-TON-USDT(100) → TON(50) + USDT(50)
+ * - VAULT: StrategyVault(100) → TON(30) + USDT(70)
+ *
+ * 같은 native asset이 여러 경로로 나오면 누적됨
+ */
+function decomposePositions(positions, syntheticCompositions, vaultCompositions = {}) {
+    const accumulatedPositions = {};
+    const queue = [...Object.values(positions)];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current.supply === 0n && current.borrow === 0n)
+            continue;
+        // 모든 에셋을 누적 (synthetic/vault/native 모두)
+        const asset = current.address.toString();
+        accumulatedPositions[asset] ??= { supply: 0n, borrow: 0n };
+        accumulatedPositions[asset].supply += current.supply;
+        accumulatedPositions[asset].borrow += current.borrow;
+        // decompose 가능하면 underlying도 queue에 추가
+        const decomposed = tryDecomposeAsset(asset, current, syntheticCompositions, vaultCompositions);
+        if (decomposed) {
+            queue.push(...decomposed);
+        }
+    }
+    return accumulatedPositions;
+}
+/** @deprecated Use decomposePositions instead */
+exports.decomposeAccountStatus = decomposePositions;
+/**
+ * Calculate risk metrics from decomposed account status
+ * Pure computation
+ */
+function calculateRisk(decomposedAccountStatus, prices, poolData) {
+    let collateral = 0n;
+    let debt = 0n;
+    let risk = 0n;
+    for (const [asset, status] of Object.entries(decomposedAccountStatus)) {
+        const price = prices[asset];
+        if (!price)
+            continue;
+        const suppliedValue = (status.supply * price.price) / BigInt(1e8);
+        const borrowedValue = (status.borrow * price.price) / BigInt(1e8);
+        const assetConfig = poolData.assets[asset];
+        if (!assetConfig)
+            continue;
+        const isCollateral = assetConfig.isCollateral;
+        if (price.type === types_1.CompositeAssetType.NATIVE) {
+            if (isCollateral) {
+                collateral += suppliedValue;
+            }
+            debt += borrowedValue;
+        }
+        if (isCollateral) {
+            const delta = suppliedValue > borrowedValue ? suppliedValue - borrowedValue : borrowedValue - suppliedValue;
+            risk += (delta * assetConfig.riskFactor) / BigInt(1e4);
+        }
+        else {
+            risk += (borrowedValue * assetConfig.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,
+    };
+}
+/**
+ * Check if account is healthy (pure computation)
+ * Takes pre-fetched pool data, account status, and prices
+ */
+function isHealthyFromData(poolData, accountStatus, prices, syntheticCompositions, vaultCompositions = {}) {
+    const simulatedPoolData = simulateAccrueInterest(poolData);
+    const decomposed = decomposePositions(accountStatus, syntheticCompositions, vaultCompositions);
+    return calculateRisk(decomposed, prices, simulatedPoolData);
+}