@affluent-org/sdk 0.0.4 → 0.0.5

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

@@ -12,8 +12,9 @@ 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 types_1 = require("../../common/types");
 const utils_1 = require("../../contracts/common/utils");
+const transform_1 = require("../../common/transform");
 // ============================================================
 // Position Decomposition Helpers
 // ============================================================
@@ -23,7 +24,7 @@ const utils_1 = require("../../contracts/common/utils");
  */
 function tryDecomposeAsset(asset, position, syntheticCompositions, vaultCompositions) {
     const data = syntheticCompositions[asset];
-    // SYNTHETIC1: stTON, tsTON 같은 단일 underlying asset
+    // SYNTHETIC1: single underlying asset (e.g. stTON, tsTON)
     if (data?.assetType === types_1.CompositeAssetType.SYNTHETIC1 &&
         "underlyingReserve" in data &&
         data.underlyingReserve &&
@@ -31,14 +32,10 @@ function tryDecomposeAsset(asset, position, syntheticCompositions, vaultComposit
         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,
-            },
+            new transform_1.AmountPositionWithAddress((0, utils_1.toAddress)(data.underlyingAddress), (position.supply * ratio) / total, (position.borrow * ratio) / total),
         ];
     }
-    // SYNTHETIC2: LP 토큰 같은 2개 underlying assets
+    // SYNTHETIC2: two underlying assets (e.g. LP tokens)
     if (data?.assetType === types_1.CompositeAssetType.SYNTHETIC2 &&
         "underlying0Reserve" in data &&
         data.underlying0Reserve &&
@@ -46,28 +43,17 @@ function tryDecomposeAsset(asset, position, syntheticCompositions, vaultComposit
         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,
-            },
+            new transform_1.AmountPositionWithAddress((0, utils_1.toAddress)(data.underlying0Address), (position.supply * data.underlying0Reserve) / total, (position.borrow * data.underlying0Reserve) / total),
+            new transform_1.AmountPositionWithAddress((0, utils_1.toAddress)(data.underlying1Address), (position.supply * data.underlying1Reserve) / total, (position.borrow * data.underlying1Reserve) / total),
         ];
     }
-    // VAULT: Strategy Vault - decomposed positions 사용
+    // VAULT: Strategy Vault - uses 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 Object.entries(decomposed).map(([addr, pos]) => new transform_1.AmountPositionWithAddress(core_1.Address.parse(addr), 
+        // Vault supply/borrow cross each other
+        (position.supply * pos.supply + position.borrow * pos.borrow) / totalSupply, (position.supply * pos.borrow + position.borrow * pos.supply) / totalSupply));
     }
     return null; // Native asset
 }
@@ -111,21 +97,21 @@ 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)];
+    const queue = [...Object.values(positions)].map(position => transform_1.AmountPositionWithAddress.from(position));
     while (queue.length > 0) {
         const current = queue.shift();
         if (current.supply === 0n && current.borrow === 0n)
             continue;
-        // 모든 에셋을 누적 (synthetic/vault/native 모두)
+        // Accumulate all assets (synthetic/vault/native)
         const asset = current.address.toString();
-        accumulatedPositions[asset] ??= { supply: 0n, borrow: 0n };
+        accumulatedPositions[asset] ??= new transform_1.AmountPosition(0n, 0n);
         accumulatedPositions[asset].supply += current.supply;
         accumulatedPositions[asset].borrow += current.borrow;
-        // decompose 가능하면 underlying도 queue에 추가
+        // If decomposable, add underlying to queue
         const decomposed = tryDecomposeAsset(asset, current, syntheticCompositions, vaultCompositions);
         if (decomposed) {
             queue.push(...decomposed);

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

@@ -2,12 +2,12 @@ import { Cell } from "@ton/core";
 import { AffluentContext } from "../../context";
 import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { PoolState } from "../../contracts/core/pool/type";
-import { VaultPositions } from "../composite-oracle/types";
+import { IVaultStateContext } from "../../common/types";
 /**
  * Build oracle params Cell from pre-fetched vault positions
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions): Promise<Cell>;
+export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>): Promise<Cell>;
 /**
  * Get oracle params for a pool operation
  * Fetches account data and builds oracle params

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

@@ -5,7 +5,7 @@ import { Pool } from "../../contracts/core/pool";
 import { PoolState } from "../../contracts/core/pool/type";
 import { Account } from "../../contracts/core/account";
 import { AccountState, AccountAssetState } from "../../contracts/core/account/type";
-import { VaultCompositions, Prices } from "../composite-oracle/types";
+import { VaultCompositions, Prices } from "../../common/types";
 import { HealthResult, MaxBorrowableResult, MaxWithdrawableResult } from "./computation";
 /**
  * Get Pool contract instance

package/dist/services/rfq-auction/oracle.d.ts

@@ -2,13 +2,13 @@ import { Cell } from "@ton/core";
 import { AffluentContext } from "../../context";
 import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
-import { VaultPositions } from "../composite-oracle/types";
+import { IVaultStateContext } from "../../common/types";
 export { OracleExposures, createOracleExposures } from "../composite-oracle/computation";
 /**
  * Build oracle params Cell from pre-fetched data
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions): Promise<Cell>;
+export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>): Promise<Cell>;
 /**
  * Get oracle params for RFQ auction settlement
  */

package/dist/services/rfq-batch/oracle.d.ts

@@ -2,13 +2,13 @@ import { Cell } from "@ton/core";
 import { AffluentContext } from "../../context";
 import { AddressInput } from "../../contracts/common/type";
 import { OracleExposures } from "../composite-oracle/computation";
-import { VaultPositions } from "../composite-oracle/types";
+import { IVaultStateContext } from "../../common/types";
 export { OracleExposures, createOracleExposures } from "../composite-oracle/computation";
 /**
  * Build oracle params Cell from pre-fetched vault positions
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsCellFromData(assetAddresses: string[], oracleConfig: any, vaultPositions: VaultPositions): Promise<{
+export declare function buildOracleParamsCellFromData(assetAddresses: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>): Promise<{
     oracleParams: Cell;
     bucket: OracleExposures;
 }>;

package/dist/services/share-vault/index.d.ts

@@ -88,38 +88,8 @@ export declare class ShareVaultServiceV1 {
         queryId: bigint | undefined;
     }>;
     getValuationContext(vaultAddress: AddressInput): Promise<{
-        storage: {
-            totalSupply: bigint;
-            owner: Address | null;
-            manager: Address | null;
-            asset: Address;
-            balance: bigint;
-            cash: bigint;
-            totalTargetWeight: bigint;
-            nextAggregatorIndex: bigint;
-            isWtonVault: boolean;
-            assetWallet: Address | null;
-            whitelistedPools: Record<string, {
-                isWhitelisted: boolean;
-                targetWeight: bigint;
-                supply: bigint;
-            } & {
-                address: Address;
-            }>;
-            minimumGasFee: {
-                supply: bigint;
-                withdraw: bigint;
-                factorialSupply: bigint;
-                factorialWithdraw: bigint;
-                mintVaultShareTokens: bigint;
-            };
-            code: import("@ton/core").Cell;
-            address: Address;
-        };
-        totalSupply: bigint;
-        asset: Address;
-        reserve: bigint;
-        poolPositions: Record<string, query.PoolInfoForShareVault>;
+        vaultStateContext: import("../../common/transform").VaultStateContext;
+        amountContext: import("../../common/transform").VaultAmountContext;
         netAmount: bigint;
         exr: number;
     }>;

package/dist/services/share-vault/query.d.ts

@@ -4,6 +4,8 @@ import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { ShareVault, ShareVaultState } from "../../contracts/vault/share-vault";
 import { JettonWallet } from "../../contracts/jetton/jetton-wallet";
 import { PoolInfoForShareVault } from "./type";
+import { VaultStateContext } from "../../common/transform";
+import { PoolState } from "../../contracts/core/pool/type";
 export { PoolInfoForShareVault, PoolTuple } from "./type";
 /**
  * Get ShareVault contract instance
@@ -25,39 +27,10 @@ export declare function getVaultWallet(ctx: AffluentContext, vaultAddress: Addre
  * Get pool info for all whitelisted pools
  */
 export declare function getPoolInfoForShareVault(ctx: AffluentContext, vaultData: ShareVaultState): Promise<Record<string, PoolInfoForShareVault>>;
+export declare function getPoolDataForShareVault(ctx: AffluentContext, vaultAddress: AddressInput): Promise<Record<string, PoolState>>;
 export declare function getValuationContext(ctx: AffluentContext, vaultAddress: AddressInput): Promise<{
-    storage: {
-        totalSupply: bigint;
-        owner: Address | null;
-        manager: Address | null;
-        asset: Address;
-        balance: bigint;
-        cash: bigint;
-        totalTargetWeight: bigint;
-        nextAggregatorIndex: bigint;
-        isWtonVault: boolean;
-        assetWallet: Address | null;
-        whitelistedPools: Record<string, {
-            isWhitelisted: boolean;
-            targetWeight: bigint;
-            supply: bigint;
-        } & {
-            address: Address;
-        }>;
-        minimumGasFee: {
-            supply: bigint;
-            withdraw: bigint;
-            factorialSupply: bigint;
-            factorialWithdraw: bigint;
-            mintVaultShareTokens: bigint;
-        };
-        code: import("@ton/core").Cell;
-        address: Address;
-    };
-    totalSupply: bigint;
-    asset: Address;
-    reserve: bigint;
-    poolPositions: Record<string, PoolInfoForShareVault>;
+    vaultStateContext: VaultStateContext;
+    amountContext: import("../../common/transform").VaultAmountContext;
     netAmount: bigint;
     exr: number;
 }>;

package/dist/services/share-vault/query.js

@@ -38,6 +38,7 @@ exports.getVaultData = getVaultData;
 exports.getVaultWalletAddress = getVaultWalletAddress;
 exports.getVaultWallet = getVaultWallet;
 exports.getPoolInfoForShareVault = getPoolInfoForShareVault;
+exports.getPoolDataForShareVault = getPoolDataForShareVault;
 exports.getValuationContext = getValuationContext;
 exports.getEXR = getEXR;
 const core_1 = require("@ton/core");
@@ -45,7 +46,7 @@ const utils_1 = require("../../contracts/common/utils");
 const share_vault_1 = require("../../contracts/vault/share-vault");
 const pool_1 = require("../../contracts/core/pool");
 const jetton_wallet_1 = require("../../contracts/jetton/jetton-wallet");
-const computation_1 = require("./computation");
+const transform_1 = require("../../common/transform");
 /**
  * Get ShareVault contract instance
  */
@@ -109,23 +110,35 @@ async function getPoolInfoForShareVault(ctx, vaultData) {
     }
     return poolInfo;
 }
-async function getValuationContext(ctx, vaultAddress) {
+async function getPoolDataForShareVault(ctx, vaultAddress) {
     const vault = getVault(ctx, vaultAddress);
     const vaultData = await vault.getVaultData();
-    const poolInfo = await getPoolInfoForShareVault(ctx, vaultData);
-    const exrInfo = (0, computation_1.getExchangeRate)(vaultData, poolInfo);
+    const poolAddresses = Object.keys(vaultData.whitelistedPools);
+    const poolDataEntriesPromises = poolAddresses.map(async (poolAddress) => {
+        const pool = ctx.getByContract(pool_1.Pool, core_1.Address.parse(poolAddress));
+        return [poolAddress, await pool.getPoolData()];
+    });
+    const poolDataEntries = await Promise.all(poolDataEntriesPromises);
+    return Object.fromEntries(poolDataEntries);
+}
+async function getValuationContext(ctx, vaultAddress) {
+    const vault = ctx.getByContract(share_vault_1.ShareVault, (0, utils_1.toAddress)(vaultAddress));
+    const vaultData = await vault.getVaultData();
+    const poolPositions = await getPoolDataForShareVault(ctx, vaultAddress);
+    const poolContexts = {};
+    Object.entries(poolPositions).forEach(([poolAddress, poolState]) => poolContexts[poolAddress] = transform_1.PoolContext.fromPoolState(poolState));
+    const vaultStateContext = transform_1.VaultStateContext.fromShareVaultState(vaultData);
+    const amountContext = vaultStateContext.toAmountContext(poolContexts);
+    const netAmount = amountContext.net()[vaultData.asset.toString()].net();
     return {
-        storage: vaultData,
-        totalSupply: vaultData.totalSupply,
-        asset: vaultData.asset,
-        reserve: vaultData.cash,
-        poolPositions: poolInfo,
-        netAmount: exrInfo.netAmount,
-        exr: exrInfo.exr,
+        vaultStateContext,
+        amountContext,
+        netAmount,
+        exr: Number(netAmount) / Number(vaultData.totalSupply),
     };
 }
 async function getEXR(ctx, vaultAddress) {
-    return getValuationContext(ctx, vaultAddress).then((vaultCtx) => {
+    return getValuationContext(ctx, (0, utils_1.toAddress)(vaultAddress)).then((vaultCtx) => {
         return vaultCtx.exr;
     });
 }

package/dist/services/strategy-vault/index.d.ts

@@ -2122,142 +2122,17 @@ export declare class StrategyVaultV1 {
         queryId: bigint;
     }>;
     getValuationContext(vaultAddress: AddressLike): Promise<{
-        storage: {
-            globalDepositValueCap: bigint;
-            withdrawFeeRate: number;
-            queueWithdrawFeeRate: number;
-            depositQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
-            withdrawQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
-            interactiveVaultDict: Record<string, import("../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
-            xchainConnectorAddress: import("@ton/core").Address | null;
-            xchainConfig: Record<string, {
-                connected: boolean;
-                xchainAccountAddress: bigint;
-                oftConfig: Map<string, {
-                    destinationAddress: import("@ton/core").Address;
-                    forwardGas: bigint;
-                    forwardPayload?: import("@ton/core").Cell | null;
-                    lzTransferFeeRate?: bigint;
-                }> | null;
-                strategyConfig: Map<bigint, {
-                    isExecutable: boolean;
-                }> | null;
-                afterStrategyConfig: Map<bigint, {
-                    isExecutable: boolean;
-                }> | null;
-                lzGasFee: bigint;
-            }>;
-            xchainUpdateHash: bigint;
-            owner: import("@ton/core").Address;
-            manager: import("@ton/core").Address;
-            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
-            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
-            aggregatorIndex: bigint;
-            content: import("@ton/core").Cell;
-            totalSupply: bigint;
-            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
-            rfqConfig: {
-                priceDeviationTolerance: number;
-                rfqEventEmitterAddress: string | null;
-            } | null;
-            gasConfig: Record<string, bigint> | null;
-            isPrivateVault: boolean;
-            depositCloseTimestamp: number;
-            withdrawOpenTimestamp: number;
-            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
-            lastCollectTime: number;
-            managementFeeRatePerYear: number;
-            protocolFeeRatePerYear: number;
-            collectedManagementFee: bigint;
-            collectedProtocolFee: bigint;
-            rfqCode: import("@ton/core").Cell;
-            walletCode: import("@ton/core").Cell;
-            dataAggregatorCode: import("@ton/core").Cell;
-            protocolFeeManagerAddress: import("@ton/core").Address;
-            rfqIndex: bigint;
-            isExecutingStrategy: boolean;
-            maxLeverageRatio: number;
-            assetWalletDict: Record<string, string>;
-            walletAssetDict: Record<string, string>;
-            managementFeeRecipientAddress: import("@ton/core").Address | null;
-            guardianAddress: import("@ton/core").Address | null;
-            timelock: bigint;
-            pendingOwnerActionIndex: bigint;
-            pendingOwnerActionCount: bigint;
-            pendingOwnerAction: any;
-            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
-            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
-            version: string;
-            address: import("@ton/core").Address;
-            balance: bigint;
-            code: import("@ton/core").Cell;
-        } | {
-            globalDepositValueCap: bigint;
-            withdrawFeeRate: number;
-            queueWithdrawFeeRate: number;
-            depositQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
-            withdrawQueueManager: import("../../contracts/vault/strategy-vault").QueueManager;
-            interactiveVaultDict: Record<string, import("../../contracts/vault/strategy-vault").InteractiveVaultConfigItem>;
-            xchainConnectorAddress: null;
-            xchainConfig: null;
-            xchainUpdateHash: bigint;
-            owner: import("@ton/core").Address;
-            manager: import("@ton/core").Address;
-            assets: Record<string, import("../../contracts/vault/strategy-vault").AssetV2>;
-            factorialPools: Record<string, import("../../contracts/vault/strategy-vault").FactorialPool>;
-            aggregatorIndex: bigint;
-            content: import("@ton/core").Cell;
-            totalSupply: bigint;
-            oracleConfig: import("@ton/core").Cell | import("../../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../contracts/oracle/redstone-oracle/type").RedstonOracleConfig;
-            rfqConfig: {
-                priceDeviationTolerance: number;
-                rfqEventEmitterAddress: string | null;
-            } | null;
-            gasConfig: Record<string, bigint> | null;
-            isPrivateVault: boolean;
-            depositCloseTimestamp: number;
-            withdrawOpenTimestamp: number;
-            whitelistedMinters: import("@ton/core").Dictionary<import("@ton/core").Address, Boolean>;
-            lastCollectTime: number;
-            managementFeeRatePerYear: number;
-            protocolFeeRatePerYear: number;
-            collectedManagementFee: bigint;
-            collectedProtocolFee: bigint;
-            rfqCode: import("@ton/core").Cell;
-            walletCode: import("@ton/core").Cell;
-            dataAggregatorCode: import("@ton/core").Cell;
-            protocolFeeManagerAddress: import("@ton/core").Address;
-            rfqIndex: bigint;
-            isExecutingStrategy: boolean;
-            maxLeverageRatio: number;
-            assetWalletDict: Record<string, string>;
-            walletAssetDict: Record<string, string>;
-            managementFeeRecipientAddress: import("@ton/core").Address | null;
-            guardianAddress: import("@ton/core").Address | null;
-            timelock: bigint;
-            pendingOwnerActionIndex: bigint;
-            pendingOwnerActionCount: bigint;
-            pendingOwnerAction: any;
-            getFactorialPoolAsset: (poolAddress: import("@ton/core").Address, assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").FactorialPoolShare;
-            getAsset: (assetAddress: import("@ton/core").Address) => import("../../contracts/vault/strategy-vault").AssetV2;
-            version: string;
-            address: import("@ton/core").Address;
-            balance: bigint;
-            code: import("@ton/core").Cell;
-        };
-        totalSupply: bigint;
-        reserves: {
-            [k: string]: bigint;
+        vaultStateContext: import("../../common/transform").VaultStateContext;
+        amountContext: import("../../common/transform").VaultAmountContext;
+        valueContext: import("../../common/transform").VaultValueContext;
+        nativeValueDecomposedContext: import("../../common/transform").VaultNativeValueDecomposedContext;
+        nativeAmountDecomposedContext: import("../../common/transform").VaultNativeAmountDecomposedContext;
+        priceInfo: import("../composite-oracle").CompositeOracleResult & {
+            targetVaultAddress: string;
+            price: bigint;
         };
-        poolPositions: Record<string, Record<string, {
-            supplyShare: bigint;
-            supplyAmount: bigint;
-            borrowShare: bigint;
-            borrowAmount: bigint;
-        }>>;
-        price: bigint;
-        priceInfo: import("../composite-oracle").Prices;
     }>;
     getPrice(vaultAddress: AddressLike): Promise<bigint>;
     getUnderlyingPrices(vaultAddress: AddressLike): Promise<any>;
+    getNativeAmountDecomposedContext(vaultAddress: AddressLike): Promise<import("../../common/transform").VaultNativeAmountDecomposedContext>;
 }

package/dist/services/strategy-vault/index.js

@@ -48,6 +48,7 @@ const manager = __importStar(require("./manager"));
 exports.manager = manager;
 const user = __importStar(require("./user"));
 exports.user = user;
+const utils_1 = require("../../contracts/common/utils");
 var send_msg_2 = require("../../lib/send-msg");
 Object.defineProperty(exports, "sendMsg", { enumerable: true, get: function () { return send_msg_2.sendMsg; } });
 var computation_1 = require("../../contracts/vault/strategy-vault/computation");
@@ -265,7 +266,7 @@ class StrategyVaultV1 {
         return (0, send_msg_1.sendMsg)(sender, user.createCancelWithdrawQueueMsg(this.ctx, params));
     }
     async getValuationContext(vaultAddress) {
-        return query.getValuationContext(this.ctx, vaultAddress);
+        return query.getValuationContext(this.ctx, (0, utils_1.toAddress)(vaultAddress));
     }
     async getPrice(vaultAddress) {
         return query.getPrice(this.ctx, vaultAddress);
@@ -273,5 +274,8 @@ class StrategyVaultV1 {
     async getUnderlyingPrices(vaultAddress) {
         return query.getUnderlyingPrices(this.ctx, vaultAddress);
     }
+    async getNativeAmountDecomposedContext(vaultAddress) {
+        return query.getNativeAmountDecomposedContext(this.ctx, vaultAddress);
+    }
 }
 exports.StrategyVaultV1 = StrategyVaultV1;

package/dist/services/strategy-vault/oracle.d.ts

@@ -4,18 +4,18 @@ import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
 import { PoolState } from "../../contracts/core/pool/type";
 import { OracleExposures } from "../composite-oracle/computation";
-import { VaultPositions } from "../composite-oracle/types";
+import { IVaultStateContext } from "../../common/types";
 export { OracleExposures, createOracleExposures } from "../composite-oracle/computation";
 /**
  * Build oracle params Cell from pre-fetched data
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions, extraPools?: string[]): Promise<Cell>;
+export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>, extraPools?: string[]): Promise<Cell>;
 /**
  * Build oracle params with bucket from pre-fetched data
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsWithBucketFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions, initialBucket?: OracleExposures, extraPools?: string[]): {
+export declare function buildOracleParamsWithBucketFromData(assets: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>, initialBucket?: OracleExposures, extraPools?: string[]): {
     oracleParamsPromise: Promise<Cell>;
     bucket: OracleExposures;
 };