@affluent-org/sdk 0.0.3 → 0.0.5

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

@@ -7,11 +7,11 @@ exports.getRFQAuctionAddress = getRFQAuctionAddress;
 exports.getRFQAuction = getRFQAuction;
 exports.isVaultAsset = isVaultAsset;
 exports.splitPureAndVaultAsset = splitPureAndVaultAsset;
-exports.getPoolInfoForStrategyVault = getPoolInfoForStrategyVault;
-exports.getPoolPositionsForStrategyVault = getPoolPositionsForStrategyVault;
+exports.getPoolDataForStrategyVault = getPoolDataForStrategyVault;
 exports.getValuationContext = getValuationContext;
 exports.getPrice = getPrice;
 exports.getUnderlyingPrices = getUnderlyingPrices;
+exports.getNativeAmountDecomposedContext = getNativeAmountDecomposedContext;
 const core_1 = require("@ton/core");
 const utils_1 = require("../../contracts/common/utils");
 const jetton_wallet_1 = require("../../contracts/jetton/jetton-wallet");
@@ -19,6 +19,7 @@ const rfq_auction_1 = require("../../contracts/rfq/rfq_auction");
 const strategy_vault_1 = require("../../contracts/vault/strategy-vault");
 const composite_oracle_1 = require("../composite-oracle");
 const pool_1 = require("../../contracts/core/pool");
+const transform_1 = require("../../common/transform");
 function getVault(ctx, strategyVaultAddress) {
     return ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(strategyVaultAddress));
 }
@@ -65,62 +66,54 @@ async function splitPureAndVaultAsset(ctx, addresses) {
         pureAssetAddresses,
     };
 }
-async function getPoolInfoForStrategyVault(ctx, strategyVaultAddress) {
+async function getPoolDataForStrategyVault(ctx, strategyVaultAddress) {
     const vaultData = await getVault(ctx, strategyVaultAddress).getVaultData();
-    return Object.fromEntries(await Promise.all(Object.keys(vaultData.factorialPools)
-        .map(async (poolAddress) => {
-        const poolData = await ctx.getByContract(pool_1.Pool, core_1.Address.parse(poolAddress)).getPoolData();
-        return [poolAddress, poolData];
-    })));
+    const poolAddresses = Object.keys(vaultData.factorialPools);
+    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 getPoolPositionsForStrategyVault(ctx, strategyVaultAddress) {
-    const strategyVault = getVault(ctx, strategyVaultAddress);
-    const vaultData = await strategyVault.getVaultData();
-    const poolInfo = {};
-    const poolDatas = await getPoolInfoForStrategyVault(ctx, strategyVaultAddress);
-    for (const [poolAddress, poolPosition] of Object.entries(vaultData.factorialPools)) {
-        const poolData = poolDatas[poolAddress];
-        const position = {};
-        for (const [assetAddress, assetPosition] of Object.entries(poolPosition)) {
-            const amountPosition = (0, pool_1.positionShareToAmount)(assetPosition, poolData.assets[assetAddress]);
-            position[assetAddress] = {
-                supplyShare: assetPosition.supply,
-                supplyAmount: amountPosition.supply,
-                borrowShare: assetPosition.borrow,
-                borrowAmount: amountPosition.borrow,
-            };
-        }
-        poolInfo[poolAddress] = position;
-    }
-    return poolInfo;
-}
-async function getValuationContext(ctx, strategyVaultAddress) {
+async function getValuationContext(ctx, vaultAddress) {
     const compositeOracle = new composite_oracle_1.CompositeOracleV1(ctx);
-    const vaultData = await getVaultData(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
-    const { allPrices: priceInfo } = await compositeOracle.getVaultPriceWithDetails((0, utils_1.toAddress)(strategyVaultAddress));
-    const vaultPrice = priceInfo[(0, utils_1.toAddress)(strategyVaultAddress).toString()].price;
-    if (!vaultPrice)
-        throw new Error("Vault price not found");
-    const poolPositions = await getPoolPositionsForStrategyVault(ctx, strategyVaultAddress);
+    const vault = ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+    const vaultData = await vault.getVaultData();
+    const priceInfo = await compositeOracle.getVaultPriceWithDetails(vaultAddress, vaultData);
+    const poolPositions = await getPoolDataForStrategyVault(ctx, vaultAddress);
+    const poolContexts = {};
+    Object.entries(poolPositions).forEach(([poolAddress, poolState]) => poolContexts[poolAddress] = transform_1.PoolContext.fromPoolState(poolState));
+    const vaultStateContext = transform_1.VaultStateContext.fromStrategyVaultState(vaultData);
+    const amountContext = vaultStateContext.toAmountContext(poolContexts);
+    const valueContext = amountContext.toValueContext(priceInfo.allPrices);
+    const nativeValueDecomposedContext = transform_1.VaultNativeValueDecomposedContext.fromValueContext(valueContext, priceInfo.allPrices);
+    const nativeAmountDecomposedContext = transform_1.VaultNativeAmountDecomposedContext.fromDecomposedValueContext(nativeValueDecomposedContext, priceInfo.allPrices);
     return {
-        storage: vaultData,
-        totalSupply: vaultData.totalSupply,
-        reserves: Object.fromEntries(Object.entries(vaultData.assets)
-            .map(([assetAddress, assetData]) => [assetAddress, assetData.cash])),
-        poolPositions,
-        price: vaultPrice,
+        vaultStateContext,
+        amountContext,
+        valueContext,
+        nativeValueDecomposedContext,
+        nativeAmountDecomposedContext,
         priceInfo,
     };
 }
 async function getPrice(ctx, strategyVaultAddress) {
-    const valuationCtx = await getValuationContext(ctx, strategyVaultAddress);
-    return valuationCtx.price;
+    const valuationCtx = await getValuationContext(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
+    return valuationCtx.priceInfo.price;
 }
 async function getUnderlyingPrices(ctx, strategyVaultAddress) {
-    const valuationCtx = await getValuationContext(ctx, strategyVaultAddress);
-    const priceInfoEntries = Object.entries(valuationCtx.priceInfo);
-    const underlyingPriceEntries = priceInfoEntries
-        .filter(([assetAddress, _]) => valuationCtx.storage.assets[assetAddress])
-        .map(([assetAddress, priceInfo]) => [assetAddress, priceInfo.price]);
+    const valuationCtx = await getValuationContext(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
+    const underlyingPriceEntries = Object.keys(valuationCtx.vaultStateContext.assets)
+        .map(assetAddress => {
+        const priceData = valuationCtx.priceInfo.allPrices[assetAddress];
+        if (!priceData)
+            throw new Error(`Price data not found for asset ${assetAddress}`);
+        return [assetAddress, priceData.price];
+    });
     return Object.fromEntries(underlyingPriceEntries);
 }
+async function getNativeAmountDecomposedContext(ctx, strategyVaultAddress) {
+    const valuationCtx = await getValuationContext(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
+    return valuationCtx.nativeAmountDecomposedContext;
+}

package/dist/types/address.d.ts

@@ -0,0 +1,7 @@
+export type Brand<T, B> = T & {
+    readonly __brand: B;
+};
+export type AssetAddress = Brand<string, 'AssetAddress'>;
+export type PoolAddress = Brand<string, 'PoolAddress'>;
+export type PoolAccountAddress = Brand<string, 'PoolAccountAddress'>;
+export type VaultAddress = Brand<string, 'VaultAddress'>;

package/dist/types/address.js

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

package/dist/utils/risk_calculator/risk_calculator.d.ts

@@ -1,16 +1,16 @@
 import { AccountAssetState, AccountAssetStateWithDelta } from "../../contracts/core/account/type";
-import { AssetPrice, AssetPriceInfo, OnchainDataInfo } from "../../contracts/oracle/redstone-onchain-oracle/type";
+import { AssetPrice, AssetPrices, OnchainDataInfo } from "../../contracts/oracle/redstone-onchain-oracle/type";
 import { PoolState } from "../../contracts/core/pool/type";
 export declare class RiskCalculator {
     accountStatus: Record<string, AccountAssetState>;
-    prices: AssetPriceInfo;
+    prices: AssetPrices;
     onchainData: OnchainDataInfo;
     poolData: PoolState;
     PRICE_DECIMALS: number;
     DELTA_DECIMALS: number;
     RATIO_DECIMALS: number;
     LEVERAGE_DECIMALS: number;
-    constructor(accountStatus: Record<string, AccountAssetState>, prices: AssetPriceInfo, onchainData: OnchainDataInfo, poolData: PoolState);
+    constructor(accountStatus: Record<string, AccountAssetState>, prices: AssetPrices, onchainData: OnchainDataInfo, poolData: PoolState);
     calculateDeltaForTargetRiskRatio(_targetRiskRatio: bigint, // ex : 6000n
     targetAsset: string, dualAsset?: string): SolutionForTargetRatio[];
     calculateDeltaForTargetLeverage(_targetLeverage: bigint, // ex : 6000n

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@affluent-org/sdk",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "affluent-sdk",
   "main": "dist/index.js",
   "scripts": {