@affluent-org/sdk 0.0.4 → 0.0.5

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

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultNativeDecomposedValueContext = exports.VaultValueContext = exports.VaultAmountContext = exports.VaultStateContext = exports.PoolContext = exports.PoolAsset = exports.AmountPosition = exports.ValuePosition = exports.SharePosition = exports.Position = void 0;
+const pool_1 = require("../../contracts/core/pool");
+const types_1 = require("./types");
+class Position {
+    supply;
+    borrow;
+    constructor(supply, borrow) {
+        this.supply = supply;
+        this.borrow = borrow;
+    }
+    apply(supply, borrow) {
+        this.supply += supply;
+        this.borrow += borrow;
+        return this;
+    }
+    applyPosition(position) {
+        this.supply += position.supply;
+        this.borrow += position.borrow;
+        return this;
+    }
+    clone() {
+        return new this.constructor(this.supply, this.borrow);
+    }
+}
+exports.Position = Position;
+class SharePosition extends Position {
+    toAmountPosition(PoolContext) {
+        return new AmountPosition((0, pool_1.shareToAmount)(this.supply, PoolContext.amount.supply, PoolContext.share.supply), (0, pool_1.shareToAmount)(this.borrow, PoolContext.amount.borrow, PoolContext.share.borrow));
+    }
+}
+exports.SharePosition = SharePosition;
+class ValuePosition extends Position {
+    // TODO: price?
+    net() {
+        return this.supply - this.borrow;
+    }
+}
+exports.ValuePosition = ValuePosition;
+class AmountPosition extends ValuePosition {
+    toValuePosition(price) {
+        return new ValuePosition(this.supply * price, this.borrow * price);
+    }
+    net() {
+        return this.supply - this.borrow;
+    }
+}
+exports.AmountPosition = AmountPosition;
+class PoolAsset {
+    amount;
+    share;
+    constructor(amount, share) {
+        this.amount = amount;
+        this.share = share;
+    }
+}
+exports.PoolAsset = PoolAsset;
+;
+class PoolContext {
+    address;
+    assets;
+    constructor(address, assets = {}) {
+        this.address = address;
+        this.assets = assets;
+    }
+    static fromPoolState(poolState) {
+        const assets = {};
+        Object.entries(poolState.assets)
+            .forEach(([asset, assetState]) => {
+            assets[asset] = {
+                amount: new AmountPosition(assetState.totalSupplyAmount, assetState.totalBorrowAmount),
+                share: new SharePosition(assetState.totalSupplyShare, assetState.totalBorrowShare),
+            };
+        });
+        return new this(poolState.address.toString(), assets);
+    }
+}
+exports.PoolContext = PoolContext;
+class VaultStateContext {
+    address;
+    totalSupply;
+    assets;
+    pools;
+    constructor(address, totalSupply, assets, // amount
+    pools // share
+    ) {
+        this.address = address;
+        this.totalSupply = totalSupply;
+        this.assets = assets;
+        this.pools = pools;
+    }
+    static fromShareVaultState(vaultState) {
+        const asset = vaultState.asset.toString();
+        const assets = {
+            [asset]: new AmountPosition(vaultState.cash, 0n),
+        };
+        const pools = {};
+        Object.entries(vaultState.whitelistedPools)
+            .forEach(([pool, poolState]) => {
+            pools[pool] = {
+                [asset]: new SharePosition(poolState.supply, 0n),
+            };
+        });
+        return new this(vaultState.address.toString(), vaultState.totalSupply, assets, pools);
+    }
+    static fromStrategyVaultState(vaultState) {
+        const assets = {};
+        Object.entries(vaultState.assets)
+            .forEach(([asset, assetState]) => {
+            assets[asset] = new AmountPosition(assetState.cash, 0n);
+        });
+        const pools = {};
+        Object.entries(vaultState.factorialPools)
+            .forEach(([pool, poolState]) => {
+            const poolEntry = {};
+            Object.entries(poolState)
+                .forEach(([asset, assetState]) => {
+                poolEntry[asset] = new SharePosition(assetState.supply, assetState.borrow);
+            });
+            pools[pool] = poolEntry;
+        });
+        return new this(vaultState.address.toString(), vaultState.totalSupply, assets, pools);
+    }
+    toAmountContext(poolContexts) {
+        return VaultAmountContext.fromVaultStateContext(this, poolContexts);
+    }
+}
+exports.VaultStateContext = VaultStateContext;
+class VaultAmountContext {
+    address;
+    totalSupply;
+    assets;
+    pools;
+    constructor(address, totalSupply, assets, pools) {
+        this.address = address;
+        this.totalSupply = totalSupply;
+        this.assets = assets;
+        this.pools = pools;
+    }
+    static fromVaultStateContext(VaultStateContext, poolContexts) {
+        const assets = {};
+        Object.entries(VaultStateContext.assets)
+            .forEach(([asset, amount]) => assets[asset] = amount.clone());
+        const pools = {};
+        Object.entries(VaultStateContext.pools)
+            .forEach(([pool, poolState]) => {
+            const poolEntry = {};
+            Object.entries(poolState)
+                .forEach(([asset, assetState]) => {
+                poolEntry[asset] = new AmountPosition((0, pool_1.shareToAmount)(assetState.supply, poolContexts[pool].assets[asset].amount.supply, poolContexts[pool].assets[asset].share.supply), (0, pool_1.shareToAmount)(assetState.borrow, poolContexts[pool].assets[asset].amount.borrow, poolContexts[pool].assets[asset].share.borrow));
+            });
+            pools[pool] = poolEntry;
+        });
+        return new this(VaultStateContext.address, VaultStateContext.totalSupply, assets, pools);
+    }
+    toValueContext(prices) {
+        return VaultValueContext.fromAmountContext(this, prices);
+    }
+    net() {
+        const net = {};
+        Object.entries(this.assets)
+            .forEach(([asset, position]) => {
+            net[asset] = position.clone();
+        });
+        Object.entries(this.pools)
+            .forEach(([pool, poolState]) => {
+            Object.entries(poolState)
+                .forEach(([asset, assetState]) => {
+                net[asset] = (net[asset] ?? new ValuePosition(0n, 0n)).applyPosition(assetState);
+            });
+        });
+        return net;
+    }
+}
+exports.VaultAmountContext = VaultAmountContext;
+class VaultValueContext {
+    address;
+    assets;
+    pools;
+    constructor(address, assets, pools) {
+        this.address = address;
+        this.assets = assets;
+        this.pools = pools;
+    }
+    static fromAmountContext(amountContext, prices) {
+        const assets = {};
+        Object.entries(amountContext.assets)
+            .forEach(([asset, position]) => assets[asset] = position.toValuePosition(prices[asset].price));
+        const pools = {};
+        Object.entries(amountContext.pools)
+            .forEach(([pool, poolState]) => {
+            const poolEntry = {};
+            Object.entries(poolState)
+                .forEach(([asset, assetState]) => poolEntry[asset] = assetState.toValuePosition(prices[asset].price));
+            pools[pool] = poolEntry;
+        });
+        return new this(amountContext.address, assets, pools);
+    }
+    get totalValue() {
+        let totalValue = 0n;
+        Object.entries(this.assets)
+            .forEach(([asset, position]) => {
+            totalValue += position.supply;
+        });
+        Object.entries(this.pools)
+            .forEach(([pool, poolState]) => {
+            Object.entries(poolState)
+                .forEach(([asset, assetState]) => {
+                totalValue += assetState.supply - assetState.borrow;
+            });
+        });
+        return totalValue;
+    }
+    net() {
+        const net = {};
+        Object.entries(this.assets)
+            .forEach(([asset, position]) => {
+            net[asset] = position.clone();
+        });
+        Object.entries(this.pools)
+            .forEach(([pool, poolState]) => {
+            Object.entries(poolState)
+                .forEach(([asset, assetState]) => {
+                net[asset] = (net[asset] ?? new ValuePosition(0n, 0n)).applyPosition(assetState);
+            });
+        });
+        return net;
+    }
+    nativeDecompose(prices) {
+        return VaultNativeDecomposedValueContext.fromValueContext(this, prices);
+    }
+}
+exports.VaultValueContext = VaultValueContext;
+class VaultNativeDecomposedValueContext extends VaultValueContext {
+    static fromValueContext(valueContext, prices) {
+        const assetsNativePositions = {};
+        VaultNativeDecomposedValueContext.decomposeContext(valueContext.assets, prices, assetsNativePositions);
+        const poolsNativePositions = {};
+        Object.entries(valueContext.pools)
+            .forEach(([pool, poolPosition]) => {
+            const nativePoolPosition = {};
+            VaultNativeDecomposedValueContext.decomposeContext(poolPosition, prices, nativePoolPosition);
+            poolsNativePositions[pool] = nativePoolPosition;
+        });
+        return new this(valueContext.address, assetsNativePositions, poolsNativePositions);
+    }
+    static decomposeContext(valueContext, prices, nativeAssets) {
+        Object.entries(valueContext)
+            .forEach(([asset, position]) => {
+            const price = prices[asset];
+            if (price.type === types_1.CompositeAssetType.NATIVE) {
+                nativeAssets[asset] = (nativeAssets[asset] ?? new ValuePosition(0n, 0n)).applyPosition(position);
+            }
+            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}`);
+                nativeAssets[price.additionalData.underlying] = (nativeAssets[price.additionalData.underlying] ?? new ValuePosition(0n, 0n))
+                    .apply(position.supply * price.additionalData.reserve / price.additionalData.totalSupply, position.borrow * price.additionalData.reserve / price.additionalData.totalSupply);
+            }
+            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}`);
+                nativeAssets[price.additionalData0.underlying] = (nativeAssets[price.additionalData0.underlying] ?? new ValuePosition(0n, 0n))
+                    .apply(position.supply * price.additionalData0.reserve / price.additionalData0.totalSupply, position.borrow * price.additionalData0.reserve / price.additionalData0.totalSupply);
+                nativeAssets[price.additionalData1.underlying] = (nativeAssets[price.additionalData1.underlying] ?? new ValuePosition(0n, 0n))
+                    .apply(position.supply * price.additionalData1.reserve / price.additionalData1.totalSupply, position.borrow * price.additionalData1.reserve / price.additionalData1.totalSupply);
+            }
+            else if (price.type === types_1.CompositeAssetType.VAULT) {
+                VaultNativeDecomposedValueContext.decomposeContext(valueContext, prices, nativeAssets);
+            }
+            else {
+                throw new Error(`Invalid asset type: ${price}`);
+            }
+        });
+        return nativeAssets;
+    }
+}
+exports.VaultNativeDecomposedValueContext = VaultNativeDecomposedValueContext;

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

@@ -1,6 +1,6 @@
 import { Cell } from "@ton/core";
-import { Prices, SyntheticCompositions, VaultPosition, VaultPositions, PoolInfos, VaultPrices, CompositeOracleResult, CompositeOracleInput } from "./types";
-import { AssetPriceInfo, OnchainDataInfo } from "../../contracts/oracle/redstone-onchain-oracle/type";
+import { Prices, SyntheticCompositions, VaultPrices, CompositeOracleResult, CompositeOracleInput, IVaultStateContext, IPoolSharePositions, IPoolContext, IAmountPosition } from "../../common/types";
+import { AssetPrices, OnchainDataInfo } from "../../contracts/oracle/redstone-onchain-oracle/type";
 export type OracleExposures = {
     assets: Set<string>;
     pools: Set<string>;
@@ -10,25 +10,19 @@ export type OracleExposures = {
 export declare function createOracleExposures(): OracleExposures;
 export declare function applyPrice(amount: bigint, price: bigint): bigint;
 export declare function calculateSyntheticPrices(rawPrices: Prices, syntheticCompositions: SyntheticCompositions): Prices;
-export declare function computePoolPositionsValue(poolPositions: VaultPosition["poolPositions"], poolInfos: PoolInfos, prices: Prices): {
+export declare function computePoolPositionsValue(poolPositions: IPoolSharePositions, poolInfos: Record<string, IPoolContext>, prices: Prices): {
     totalValue: bigint;
-    decomposed: Record<string, {
-        supply: bigint;
-        borrow: bigint;
-    }>;
+    decomposed: Record<string, IAmountPosition>;
     assetAmounts: Record<string, bigint>;
 };
-export declare function computeVaultValue(vault: VaultPosition, poolInfos: PoolInfos, prices: Prices): {
+export declare function computeVaultValue(vault: IVaultStateContext, poolInfos: Record<string, IPoolContext>, prices: Prices): {
     totalValue: bigint;
     price: bigint;
-    decomposed: Record<string, {
-        supply: bigint;
-        borrow: bigint;
-    }>;
+    decomposed: Record<string, IAmountPosition>;
 };
-export declare function calculateVaultPrices(vaultPositions: VaultPositions, poolInfos: PoolInfos, assetPrices: Prices): VaultPrices;
+export declare function calculateVaultPrices(vaultPositions: Record<string, IVaultStateContext>, poolInfos: Record<string, IPoolContext>, assetPrices: Prices): VaultPrices;
 export declare function computeCompositePrices(input: CompositeOracleInput): CompositeOracleResult;
-export declare function getExposures(vaultPositions: VaultPositions): {
+export declare function getExposures(vaultPositions: Record<string, IVaultStateContext>): {
     assets: string[];
     pools: string[];
 };
@@ -43,7 +37,7 @@ export declare function separateAssets(allAssets: string[], oracleConfig: {
     assets: string[];
     vaultAssets: string[];
 };
-export declare function updateOnchainInternalData(prices: AssetPriceInfo, onchainData: OnchainDataInfo): AssetPriceInfo;
+export declare function updateOnchainInternalData(prices: AssetPrices, onchainData: OnchainDataInfo): AssetPrices;
 /**
  * Build oracle params Cell from pre-fetched Redstone payload
  * Pure computation - no network calls

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

@@ -13,11 +13,11 @@ 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");
 function createOracleExposures() {
     return {
         assets: new Set(),
@@ -43,6 +43,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 +58,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 {
@@ -81,21 +96,19 @@ function computePoolPositionsValue(poolPositions, poolInfos, prices) {
         if (!poolInfo)
             continue;
         for (const [assetAddress, position] of Object.entries(assetPositions)) {
-            const assetInfo = poolInfo[assetAddress];
+            const assetInfo = poolInfo.assets[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;
+            const amounts = position.toAmountPosition(assetInfo);
+            if (decomposed[assetAddress])
+                decomposed[assetAddress].applyPosition(amounts);
+            else
+                decomposed[assetAddress] = amounts.clone();
+            const netAmount = amounts.net();
             assetAmounts[assetAddress] = (assetAmounts[assetAddress] ?? 0n) + netAmount;
             const price = prices[assetAddress];
-            if (price) {
+            if (price)
                 totalValue += applyPrice(netAmount, price.price);
-            }
         }
     }
     return { totalValue, decomposed, assetAmounts };
@@ -105,20 +118,17 @@ function computeVaultValue(vault, poolInfos, prices) {
     const decomposed = {};
     for (const [assetAddress, amount] of Object.entries(vault.assets)) {
         const price = prices[assetAddress];
-        if (price && amount > 0n) {
-            cashValue += applyPrice(amount, price.price);
+        if (price && amount.supply > 0n) {
+            cashValue += applyPrice(amount.supply, price.price);
         }
-        decomposed[assetAddress] = { supply: amount, borrow: 0n };
+        decomposed[assetAddress] = amount.clone();
     }
-    const poolResult = computePoolPositionsValue(vault.poolPositions, poolInfos, prices);
+    const poolResult = computePoolPositionsValue(vault.pools, 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;
-        }
+        if (decomposed[assetAddress])
+            decomposed[assetAddress].applyPosition(amounts);
+        else
+            decomposed[assetAddress] = amounts.clone();
     }
     const totalValue = cashValue + poolResult.totalValue;
     const price = vault.totalSupply === 0n ? 0n : (totalValue * types_1.DECIMALS_OF_PRICE) / vault.totalSupply;
@@ -136,11 +146,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,7 +167,7 @@ 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: {
@@ -165,10 +175,8 @@ function calculateVaultPrices(vaultPositions, poolInfos, assetPrices) {
                         totalSupply: vault.totalSupply,
                     },
                 };
-                combinedPrices[vaultAddress] = {
-                    type: types_1.CompositeAssetType.VAULT,
-                    price: result.price,
-                };
+                vaultPrices[vaultAddress] = vaultPriceEntry;
+                combinedPrices[vaultAddress] = vaultPriceEntry;
                 delete pendingVaults[vaultAddress];
                 resolved = true;
             }
@@ -197,7 +205,7 @@ function computeCompositePrices(input) {
     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 +214,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);

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,10 @@ 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 types_1 = require("../../common/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; } });

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,
-                        timestamp: item.timestamp,
                         price: (item.price * types_1.DECIMALS_OF_PRICE) / rainfo.precision,
+                        timestamp: item.timestamp,
                     };
                 }
                 else if (rainfo.assetType === 1) {
@@ -181,13 +181,13 @@ class CompositeOracleFetcher {
                     const data = core_1.Cell.fromBoc(state.state.data)[0];
                     try {
                         const vaultData = strategy_vault_1.StrategyVault.parseVaultData(data);
-                        positions[addressStr] = extractStrategyVaultPosition(vaultData);
+                        // VaultStateContext.fromStrategyVaultState(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 +202,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 +210,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,
-    };
-}