@affluent-org/sdk 0.0.4 → 0.0.6

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

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOracleExposures = createOracleExposures;
-exports.applyPrice = applyPrice;
 exports.calculateSyntheticPrices = calculateSyntheticPrices;
-exports.computePoolPositionsValue = computePoolPositionsValue;
 exports.computeVaultValue = computeVaultValue;
 exports.calculateVaultPrices = calculateVaultPrices;
+exports.nativeDecomposeContext = nativeDecomposeContext;
 exports.computeCompositePrices = computeCompositePrices;
 exports.getExposures = getExposures;
 exports.separateAssets = separateAssets;
@@ -13,11 +12,13 @@ exports.updateOnchainInternalData = updateOnchainInternalData;
 exports.buildOracleParamsCellFromPayload = buildOracleParamsCellFromPayload;
 exports.buildOracleParamsCell = buildOracleParamsCell;
 const core_1 = require("@ton/core");
-const types_1 = require("./types");
-const pool_1 = require("../../contracts/core/pool");
+const types_1 = require("../../common/types");
 const type_1 = require("../../contracts/oracle/redstone-onchain-oracle/type");
 const redstone_onchain_oracle_1 = require("../../contracts/oracle/redstone-onchain-oracle");
 const redstoneHelper_1 = require("../../utils/oracle/redstone/redstoneHelper");
+const utils_1 = require("../../contracts/common/utils");
+const transform_1 = require("../../common/transform");
+const helper_1 = require("../../common/helper");
 function createOracleExposures() {
     return {
         assets: new Set(),
@@ -28,9 +29,6 @@ function createOracleExposures() {
         },
     };
 }
-function applyPrice(amount, price) {
-    return (amount * price) / types_1.DECIMALS_OF_PRICE;
-}
 function calculateSyntheticPrices(rawPrices, syntheticCompositions) {
     const prices = { ...rawPrices };
     let pendingAssets = Object.entries(syntheticCompositions);
@@ -43,6 +41,11 @@ function calculateSyntheticPrices(rawPrices, syntheticCompositions) {
                     prices[assetAddress] = {
                         type: types_1.CompositeAssetType.SYNTHETIC1,
                         price: (underlyingPrice.price * data.underlyingReserve) / data.totalSupply,
+                        additionalData: {
+                            underlying: (0, utils_1.toAddress)(data.underlyingAddress).toString(),
+                            reserve: data.underlyingReserve,
+                            totalSupply: data.totalSupply,
+                        },
                     };
                 }
                 else {
@@ -53,11 +56,21 @@ function calculateSyntheticPrices(rawPrices, syntheticCompositions) {
                 const price0 = prices[data.underlying0Address.toString()];
                 const price1 = prices[data.underlying1Address.toString()];
                 if (price0 && price1) {
-                    const value0 = (price0.price * data.underlying0Reserve) / data.totalSupply;
-                    const value1 = (price1.price * data.underlying1Reserve) / data.totalSupply;
+                    const value0 = price0.price * data.underlying0Reserve;
+                    const value1 = price1.price * data.underlying1Reserve;
                     prices[assetAddress] = {
                         type: types_1.CompositeAssetType.SYNTHETIC2,
-                        price: value0 + value1,
+                        price: (value0 + value1) / data.totalSupply,
+                        additionalData0: {
+                            underlying: (0, utils_1.toAddress)(data.underlying0Address).toString(),
+                            reserve: data.underlying0Reserve,
+                            totalSupply: data.totalSupply,
+                        },
+                        additionalData1: {
+                            underlying: (0, utils_1.toAddress)(data.underlying1Address).toString(),
+                            reserve: data.underlying1Reserve,
+                            totalSupply: data.totalSupply,
+                        },
                     };
                 }
                 else {
@@ -72,57 +85,12 @@ function calculateSyntheticPrices(rawPrices, syntheticCompositions) {
     }
     return prices;
 }
-function computePoolPositionsValue(poolPositions, poolInfos, prices) {
-    const decomposed = {};
-    const assetAmounts = {};
-    let totalValue = 0n;
-    for (const [poolAddress, assetPositions] of Object.entries(poolPositions)) {
-        const poolInfo = poolInfos[poolAddress];
-        if (!poolInfo)
-            continue;
-        for (const [assetAddress, position] of Object.entries(assetPositions)) {
-            const assetInfo = poolInfo[assetAddress];
-            if (!assetInfo)
-                continue;
-            const amounts = (0, pool_1.positionShareToAmount)(position, assetInfo);
-            if (!decomposed[assetAddress]) {
-                decomposed[assetAddress] = { supply: 0n, borrow: 0n };
-            }
-            decomposed[assetAddress].supply += amounts.supply;
-            decomposed[assetAddress].borrow += amounts.borrow;
-            const netAmount = amounts.supply - amounts.borrow;
-            assetAmounts[assetAddress] = (assetAmounts[assetAddress] ?? 0n) + netAmount;
-            const price = prices[assetAddress];
-            if (price) {
-                totalValue += applyPrice(netAmount, price.price);
-            }
-        }
-    }
-    return { totalValue, decomposed, assetAmounts };
-}
 function computeVaultValue(vault, poolInfos, prices) {
-    let cashValue = 0n;
-    const decomposed = {};
-    for (const [assetAddress, amount] of Object.entries(vault.assets)) {
-        const price = prices[assetAddress];
-        if (price && amount > 0n) {
-            cashValue += applyPrice(amount, price.price);
-        }
-        decomposed[assetAddress] = { supply: amount, borrow: 0n };
-    }
-    const poolResult = computePoolPositionsValue(vault.poolPositions, poolInfos, prices);
-    for (const [assetAddress, amounts] of Object.entries(poolResult.decomposed)) {
-        if (decomposed[assetAddress]) {
-            decomposed[assetAddress].supply += amounts.supply;
-            decomposed[assetAddress].borrow += amounts.borrow;
-        }
-        else {
-            decomposed[assetAddress] = amounts;
-        }
-    }
-    const totalValue = cashValue + poolResult.totalValue;
-    const price = vault.totalSupply === 0n ? 0n : (totalValue * types_1.DECIMALS_OF_PRICE) / vault.totalSupply;
-    return { totalValue, price, decomposed };
+    const amountContext = vault.toAmountContext(poolInfos);
+    const valueContext = amountContext.toValueContext(prices);
+    const totalValue = valueContext.totalValue;
+    const price = vault.totalSupply === 0n ? 0n : (totalValue / vault.totalSupply);
+    return { totalValue, price, amountContext };
 }
 function calculateVaultPrices(vaultPositions, poolInfos, assetPrices) {
     const vaultPrices = {};
@@ -136,11 +104,11 @@ function calculateVaultPrices(vaultPositions, poolInfos, assetPrices) {
             try {
                 const requiredAssets = new Set();
                 for (const assetAddress of Object.keys(vault.assets)) {
-                    if (vault.assets[assetAddress] > 0n) {
+                    if (vault.assets[assetAddress].supply > 0n) {
                         requiredAssets.add(assetAddress);
                     }
                 }
-                for (const poolPositions of Object.values(vault.poolPositions)) {
+                for (const poolPositions of Object.values(vault.pools)) {
                     for (const [assetAddress, position] of Object.entries(poolPositions)) {
                         if (position.supply > 0n || position.borrow > 0n) {
                             requiredAssets.add(assetAddress);
@@ -157,18 +125,15 @@ function calculateVaultPrices(vaultPositions, poolInfos, assetPrices) {
                 if (!allPricesAvailable)
                     continue;
                 const result = computeVaultValue(vault, poolInfos, combinedPrices);
-                vaultPrices[vaultAddress] = {
+                const vaultPriceEntry = {
                     type: types_1.CompositeAssetType.VAULT,
                     price: result.price,
                     additionalData: {
-                        decomposed: result.decomposed,
-                        totalSupply: vault.totalSupply,
+                        amountContext: result.amountContext,
                     },
                 };
-                combinedPrices[vaultAddress] = {
-                    type: types_1.CompositeAssetType.VAULT,
-                    price: result.price,
-                };
+                vaultPrices[vaultAddress] = vaultPriceEntry;
+                combinedPrices[vaultAddress] = vaultPriceEntry;
                 delete pendingVaults[vaultAddress];
                 resolved = true;
             }
@@ -182,8 +147,7 @@ function calculateVaultPrices(vaultPositions, poolInfos, assetPrices) {
                     type: types_1.CompositeAssetType.VAULT,
                     price: 0n,
                     additionalData: {
-                        decomposed: {},
-                        totalSupply: pendingVaults[vaultAddress].totalSupply,
+                        amountContext: new transform_1.VaultAmountContext(vaultAddress, pendingVaults[vaultAddress].totalSupply, {}, {}),
                     },
                 };
                 delete pendingVaults[vaultAddress];
@@ -192,12 +156,58 @@ function calculateVaultPrices(vaultPositions, poolInfos, assetPrices) {
     }
     return vaultPrices;
 }
+function nativeDecomposeContext(amountContext, prices) {
+    const nativeDecomposed = {};
+    Object.entries(amountContext)
+        .forEach(([asset, position]) => {
+        const price = prices[asset];
+        if (price.type === types_1.CompositeAssetType.NATIVE) {
+            nativeDecomposed[asset] = position.addPosition(nativeDecomposed[asset]);
+        }
+        else if (price.type === types_1.CompositeAssetType.SYNTHETIC1) {
+            if (prices[price.additionalData.underlying].type !== types_1.CompositeAssetType.NATIVE)
+                throw new Error(`Invalid underlying asset type: ${price.additionalData.underlying}`);
+            const underlyingNativeDecomposed = nativeDecomposeContext({ [price.additionalData.underlying]: position.muldiv(price.additionalData.reserve, price.additionalData.totalSupply) }, prices);
+            (0, helper_1.applyPositions)(nativeDecomposed, underlyingNativeDecomposed);
+        }
+        else if (price.type === types_1.CompositeAssetType.SYNTHETIC2) {
+            if (prices[price.additionalData0.underlying].type !== types_1.CompositeAssetType.NATIVE)
+                throw new Error(`Invalid underlying asset type: ${price.additionalData0.underlying}`);
+            if (prices[price.additionalData1.underlying].type !== types_1.CompositeAssetType.NATIVE)
+                throw new Error(`Invalid underlying asset type: ${price.additionalData1.underlying}`);
+            const price0 = prices[price.additionalData0.underlying].price;
+            const price1 = prices[price.additionalData1.underlying].price;
+            const value0 = price.additionalData0.reserve * price0;
+            const value1 = price.additionalData1.reserve * price1;
+            const totalValue = value0 + value1;
+            const underlyingNativeDecomposed = nativeDecomposeContext({
+                [price.additionalData0.underlying]: position.muldiv(value0, totalValue),
+                [price.additionalData1.underlying]: position.muldiv(value1, totalValue)
+            }, prices);
+            (0, helper_1.applyPositions)(nativeDecomposed, underlyingNativeDecomposed);
+        }
+        else if (price.type === types_1.CompositeAssetType.VAULT) {
+            const depVaultValue = price.price * price.additionalData.amountContext.totalSupply;
+            const depDecomposed = {};
+            Object.entries(price.additionalData.amountContext.decompose())
+                .forEach(([depAsset, depPosition]) => {
+                depDecomposed[depAsset] = position.cross(depPosition.toValuePosition(prices[depAsset].price), depVaultValue);
+            });
+            const depNativeDecomposed = nativeDecomposeContext(depDecomposed, prices);
+            (0, helper_1.applyPositions)(nativeDecomposed, depNativeDecomposed);
+        }
+        else {
+            throw new Error(`Invalid asset type: ${price}`);
+        }
+    });
+    return nativeDecomposed;
+}
 function computeCompositePrices(input) {
     const assetPrices = calculateSyntheticPrices(input.rawPrices, input.syntheticCompositions);
     const vaultPrices = calculateVaultPrices(input.vaultPositions, input.poolInfos, assetPrices);
     const allPrices = { ...assetPrices };
     for (const [address, entry] of Object.entries(vaultPrices)) {
-        allPrices[address] = { type: entry.type, price: entry.price };
+        allPrices[address] = entry;
     }
     return { assetPrices, vaultPrices, allPrices };
 }
@@ -206,10 +216,10 @@ function getExposures(vaultPositions) {
     const pools = new Set();
     for (const vault of Object.values(vaultPositions)) {
         for (const [asset, amount] of Object.entries(vault.assets)) {
-            if (amount > 0n)
+            if (amount.supply > 0n)
                 assets.add(asset);
         }
-        for (const [poolAddress, poolPositions] of Object.entries(vault.poolPositions)) {
+        for (const [poolAddress, poolPositions] of Object.entries(vault.pools)) {
             for (const [asset, position] of Object.entries(poolPositions)) {
                 if (position.supply > 0n || position.borrow > 0n) {
                     pools.add(poolAddress);
@@ -287,9 +297,42 @@ function buildOracleParamsCellFromPayload(assets, oracleConfig, payload, pools,
  */
 async function buildOracleParamsCell(assets, oracleConfig, pools, vaults) {
     const requestParams = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
-    // Fetch Redstone payload
-    const helper = (0, redstoneHelper_1.createRedstoneHelper)("prod");
+    const signers = new Set(oracleConfig.signers
+        .map((s) => s.toLowerCase()));
+    let helper;
+    if (setEqual(signers, restonSigners)) {
+        helper = (0, redstoneHelper_1.createRedstoneHelper)("prod");
+    }
+    else if (setEqual(signers, affluentSigners)) {
+        helper = (0, redstoneHelper_1.createRedstoneCustomHelper)("http://aggregatora3loa-ktesxzhb-780180176.ap-northeast-2.elb.amazonaws.com");
+    }
+    else {
+        throw new Error(`Invalid signers: ${[...signers]}`);
+    }
+    // Fetch payload
     const payload = await helper.createPayload(requestParams.redstoneAssetNames);
     // Pure computation
     return buildOracleParamsCellFromPayload(assets, oracleConfig, payload, pools, vaults);
 }
+const restonSigners = new Set([
+    '51Ce04Be4b3E32572C4Ec9135221d0691Ba7d202',
+    '8BB8F32Df04c8b654987DAaeD53D6B6091e3B774',
+    '9c5AE89C4Af6aA32cE58588DBaF90d18a855B6de',
+    'DD682daEC5A90dD295d14DA4b0bec9281017b5bE',
+    'dEB22f54738d54976C4c0fe5ce6d408E40d88499'
+].map((s) => s.toLowerCase()));
+const affluentSigners = new Set([
+    "938b33477fdcebcb1ca4dd9502af775a0c4f2e2c",
+    "7d8d5e5be15338797183652d401f290c21d08e73",
+    "95abc793f212a11330ddafd337edb8b1903f62f5",
+    "4d0a8877125e889004facfdef35fc256548ce038",
+    "fb023d5b920b1c13be0c4cdde27e7b75ef67c627",
+].map((s) => s.toLowerCase()));
+function setEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const v of a)
+        if (!b.has(v))
+            return false;
+    return true;
+}

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

@@ -1,8 +1,8 @@
 import { AddressLike } from "../../contracts/common/type";
 import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
-import { Prices, CompositeOracleResult, CompositeOracleInput } from "./types";
+import { Prices, CompositeOracleResult, CompositeOracleInput } from "../../common/types";
 import { CompositeOracleFetcher } from "./query";
-export * from "./types";
+export * from "../../common/types";
 export * from "./computation";
 export { CompositeOracleFetcher, OracleContext } from "./query";
 export declare class CompositeOracleV1 extends CompositeOracleFetcher {

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

@@ -16,10 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompositeOracleV1 = exports.CompositeOracleFetcher = void 0;
 const utils_1 = require("../../contracts/common/utils");
-const types_1 = require("./types");
 const computation_1 = require("./computation");
 const query_1 = require("./query");
-__exportStar(require("./types"), exports);
+__exportStar(require("../../common/types"), exports);
 __exportStar(require("./computation"), exports);
 var query_2 = require("./query");
 Object.defineProperty(exports, "CompositeOracleFetcher", { enumerable: true, get: function () { return query_2.CompositeOracleFetcher; } });
@@ -83,10 +82,10 @@ class CompositeOracleV1 extends query_1.CompositeOracleFetcher {
         const result = this.compute(input);
         const targetVaultAddress = (0, utils_1.toAddress)(vaultAddress).toString();
         const vaultPriceEntry = result.vaultPrices[targetVaultAddress];
-        if (!vaultPriceEntry || vaultPriceEntry.additionalData.totalSupply === 0n) {
+        if (!vaultPriceEntry || vaultPriceEntry.additionalData.amountContext.totalSupply === 0n) {
             return 0n;
         }
-        return (vaultPriceEntry.price * vaultPriceEntry.additionalData.totalSupply) / types_1.DECIMALS_OF_PRICE;
+        return vaultPriceEntry.price * vaultPriceEntry.additionalData.amountContext.totalSupply;
     }
     // ============================================================
     // Static computation methods (no instance needed)
@@ -101,10 +100,10 @@ class CompositeOracleV1 extends query_1.CompositeOracleFetcher {
     static getTotalValueFromInput(input, vaultAddress) {
         const result = (0, computation_1.computeCompositePrices)(input);
         const vaultPriceEntry = result.vaultPrices[vaultAddress];
-        if (!vaultPriceEntry || vaultPriceEntry.additionalData.totalSupply === 0n) {
+        if (!vaultPriceEntry || vaultPriceEntry.additionalData.amountContext.totalSupply === 0n) {
             return 0n;
         }
-        return (vaultPriceEntry.price * vaultPriceEntry.additionalData.totalSupply) / types_1.DECIMALS_OF_PRICE;
+        return vaultPriceEntry.price * vaultPriceEntry.additionalData.amountContext.totalSupply;
     }
 }
 exports.CompositeOracleV1 = CompositeOracleV1;

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

@@ -3,13 +3,13 @@ import { AffluentContext } from "../../context";
 import { AddressLike } from "../../contracts/common/type";
 import { OnchainDataInfo } from "../../contracts/oracle/redstone-onchain-oracle/type";
 import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
-import { Prices, OnchainDataMap, VaultPositions, PoolInfos } from "./types";
+import { Prices, SyntheticCompositions, IVaultStateContext, IPoolContext } from "../../common/types";
 export type OracleContext = {
     vaultData: StrategyVaultState;
     oracleConfig: any;
     assets: string[];
     vaultAssets: string[];
-    vaultPositions: VaultPositions;
+    vaultPositions: Record<string, IVaultStateContext>;
     exposures: {
         assets: string[];
         pools: string[];
@@ -28,9 +28,9 @@ export declare class CompositeOracleFetcher {
     }): Promise<OracleContext>;
     fetchRawPrices(assets: string[], oracleConfig: any): Promise<{
         rawPrices: Prices;
-        onchainData: OnchainDataMap;
+        onchainData: SyntheticCompositions;
     }>;
-    fetchOnchainData(onchainDataInfo: OnchainDataInfo): Promise<OnchainDataMap>;
-    fetchVaultPositions(vaultAddresses: (Address | string)[]): Promise<VaultPositions>;
-    fetchPoolInfos(poolAddresses: string[]): Promise<PoolInfos>;
+    fetchOnchainData(onchainDataInfo: OnchainDataInfo): Promise<SyntheticCompositions>;
+    fetchVaultPositions(vaultAddresses: (Address | string)[]): Promise<Record<string, IVaultStateContext>>;
+    fetchPoolInfos(poolAddresses: string[]): Promise<Record<string, IPoolContext>>;
 }

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

@@ -7,12 +7,12 @@ 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 types_1 = require("../../common/types");
 const computation_1 = require("./computation");
+const transform_1 = require("../../common/transform");
 // ============================================================
 // Query Class (I/O - fetching data)
 // ============================================================
@@ -59,8 +59,8 @@ class CompositeOracleFetcher {
                 if (rainfo.assetType === 0) {
                     rawPrices[rainfo.address.toString()] = {
                         type: types_1.CompositeAssetType.NATIVE,
+                        price: (item.price * types_1.VALUE_SCALE) / rainfo.precision,
                         timestamp: item.timestamp,
-                        price: (item.price * types_1.DECIMALS_OF_PRICE) / rainfo.precision,
                     };
                 }
                 else if (rainfo.assetType === 1) {
@@ -180,14 +180,12 @@ class CompositeOracleFetcher {
                 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);
+                        positions[addressStr] = transform_1.VaultStateContext.fromStrategyVaultStateCell((0, utils_1.toAddress)(vaultAddress), data);
                         return;
                     }
                     catch (e) { }
                     try {
-                        const vaultData = share_vault_1.ShareVault.parseVaultData(data);
-                        positions[addressStr] = extractShareVaultPosition(vaultData);
+                        positions[addressStr] = transform_1.VaultStateContext.fromShareVaultStateCell((0, utils_1.toAddress)(vaultAddress), data);
                     }
                     catch (e) { }
                 }
@@ -202,15 +200,7 @@ class CompositeOracleFetcher {
             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,
-                    };
-                }
+                poolInfos[poolAddress] = transform_1.PoolContext.fromPoolState(poolData);
             }
             catch (e) { }
         }));
@@ -218,34 +208,3 @@ class CompositeOracleFetcher {
     }
 }
 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/pool/computation.d.ts

@@ -1,6 +1,6 @@
 import { PoolState } from "../../contracts/core/pool/type";
 import { AccountState, AccountAssetState } from "../../contracts/core/account/type";
-import { Prices, VaultCompositions, SyntheticCompositions } from "../composite-oracle/types";
+import { Prices, VaultCompositions, SyntheticCompositions, IAmountPosition } from "../../common/types";
 export type HealthResult = {
     result: boolean;
     healthy: boolean;
@@ -25,11 +25,6 @@ export type MaxWithdrawableResult = {
     beforeAccountHealth?: HealthResult;
     afterAccountHealth?: HealthResult;
 };
-type Position = {
-    supply: bigint;
-    borrow: bigint;
-};
-type PositionMap = Record<string, Position>;
 /**
  * Simulate interest accrual on pool data
  */
@@ -57,9 +52,9 @@ export declare function applyDelta(accountData: AccountState, delta: Record<stri
  * - SYNTHETIC2: LP-TON-USDT(100) → TON(50) + USDT(50)
  * - VAULT: StrategyVault(100) → TON(30) + USDT(70)
  *
- * 같은 native asset이 여러 경로로 나오면 누적됨
+ * Same native asset from multiple paths will be accumulated
  */
-export declare function decomposePositions(positions: Record<string, AccountAssetState>, syntheticCompositions: SyntheticCompositions, vaultCompositions?: VaultCompositions): PositionMap;
+export declare function decomposePositions(positions: Record<string, AccountAssetState>, syntheticCompositions: SyntheticCompositions, vaultCompositions?: VaultCompositions): Record<string, IAmountPosition>;
 /** @deprecated Use decomposePositions instead */
 export declare const decomposeAccountStatus: typeof decomposePositions;
 /**
@@ -72,4 +67,3 @@ export declare function calculateRisk(decomposedAccountStatus: Record<string, Om
  * 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

@@ -9,68 +9,12 @@ 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
-}
+const types_1 = require("../../common/types");
+const transform_1 = require("../../common/transform");
+const computation_1 = require("../../common/computation");
+const helper_1 = require("../../common/helper");
 // ============================================================
 // Pure Computation (no I/O)
 // ============================================================
@@ -111,26 +55,16 @@ function applyDelta(accountData, delta) {
  * - SYNTHETIC2: LP-TON-USDT(100) → TON(50) + USDT(50)
  * - VAULT: StrategyVault(100) → TON(30) + USDT(70)
  *
- * 같은 native asset이 여러 경로로 나오면 누적됨
+ * Same native asset from multiple paths will be accumulated
  */
 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);
-        }
-    }
+    Object.values(positions)
+        .forEach(position => {
+        const asset = position.address.toString();
+        const decomposed = (0, computation_1.tryNativeDecomposeAsset)(asset, new transform_1.AmountPosition(position.supply, position.borrow), syntheticCompositions, vaultCompositions);
+        (0, helper_1.applyPositions)(accumulatedPositions, decomposed);
+    });
     return accumulatedPositions;
 }
 /** @deprecated Use decomposePositions instead */
@@ -213,7 +147,7 @@ function calculateRisk(decomposedAccountStatus, prices, poolData) {
  * 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);
+    const simulatedPoolData = simulateAccrueInterest(poolData);
     return calculateRisk(decomposed, prices, simulatedPoolData);
 }