@affluent-org/sdk 0.0.4 → 0.0.5

package/dist/common/transform.d.ts

@@ -0,0 +1,93 @@
+import { Address, Cell } from "@ton/core";
+import { PoolState } from "../contracts/core/pool/type";
+import { ShareVaultState } from "../contracts/vault/share-vault";
+import { StrategyVaultState } from "../contracts/vault/strategy-vault";
+import { Prices, IPosition, ISharePosition, IValuePosition, IAmountPosition, IPoolAsset, IPoolContext, IVaultStateContext, IVaultAmountContext, IVaultValueContext, IPoolAmountPositions, IPoolValuePositions, IPoolSharePositions, IPoolContexts, IAmountPositionWithAddress } from "./types";
+export declare class Position implements IPosition {
+    supply: bigint;
+    borrow: bigint;
+    constructor(supply?: bigint, borrow?: bigint);
+    apply(supply: bigint, borrow: bigint): this;
+    applyPosition(position: typeof this): this;
+    clone(): this;
+}
+export declare class SharePosition extends Position implements ISharePosition {
+    readonly _brand: 'SharePosition';
+    toAmountPosition(poolAsset: IPoolAsset): AmountPosition;
+}
+export declare class ValuePosition extends Position implements IValuePosition {
+    readonly _brand: 'ValuePosition';
+    toAmountPosition(price: bigint): AmountPosition;
+    static from(data: IPosition): ValuePosition;
+    net(): bigint;
+}
+export declare class AmountPosition extends Position implements IAmountPosition {
+    readonly _brand: 'AmountPosition';
+    toValuePosition(price: bigint): ValuePosition;
+    net(): bigint;
+}
+export declare class AmountPositionWithAddress extends AmountPosition implements IAmountPositionWithAddress {
+    address: Address;
+    constructor(address: Address, supply: bigint, borrow: bigint);
+    static from(data: {
+        address: Address;
+        supply: bigint;
+        borrow: bigint;
+    }): AmountPositionWithAddress;
+}
+export declare class PoolAsset implements IPoolAsset {
+    amount: AmountPosition;
+    share: SharePosition;
+    constructor(amount: AmountPosition, share: SharePosition);
+}
+export declare class PoolContext implements IPoolContext {
+    readonly address: string;
+    readonly assets: Record<string, IPoolAsset>;
+    constructor(address: string, assets?: Record<string, IPoolAsset>);
+    static fromPoolState(poolState: PoolState): PoolContext;
+    getAmountFrom(address: string, share: SharePosition): AmountPosition;
+}
+export declare class VaultStateContext implements IVaultStateContext {
+    readonly address: string;
+    readonly totalSupply: bigint;
+    readonly assets: Record<string, IAmountPosition>;
+    readonly pools: IPoolSharePositions;
+    constructor(address: string, totalSupply: bigint, assets: Record<string, IAmountPosition>, pools: IPoolSharePositions);
+    static fromShareVaultStateCell(address: Address, cell: Cell): VaultStateContext;
+    static fromShareVaultState(vaultState: Omit<ShareVaultState, 'code' | 'balance'>): VaultStateContext;
+    static fromStrategyVaultStateCell(address: Address, cell: Cell): VaultStateContext;
+    static fromStrategyVaultState(vaultState: Omit<StrategyVaultState, 'code' | 'balance'>): VaultStateContext;
+    toAmountContext(poolContexts: IPoolContexts): VaultAmountContext;
+}
+export declare class VaultAmountContext implements IVaultAmountContext {
+    readonly address: string;
+    readonly totalSupply: bigint;
+    readonly assets: Record<string, IAmountPosition>;
+    readonly pools: IPoolAmountPositions;
+    constructor(address: string, totalSupply: bigint, assets: Record<string, IAmountPosition>, pools: IPoolAmountPositions);
+    static fromVaultStateContext(VaultStateContext: VaultStateContext, poolContexts: IPoolContexts): VaultAmountContext;
+    toValueContext(prices: Prices): VaultValueContext;
+    net(): Record<string, IAmountPosition>;
+}
+export declare class VaultValueContext implements IVaultValueContext {
+    readonly address: string;
+    readonly assets: Record<string, IValuePosition>;
+    readonly pools: IPoolValuePositions;
+    constructor(address: string, assets: Record<string, IValuePosition>, pools: IPoolValuePositions);
+    static fromAmountContext(amountContext: VaultAmountContext, prices: Prices): VaultValueContext;
+    get totalValue(): bigint;
+    net(): Record<string, IValuePosition>;
+}
+export declare class VaultNativeValueDecomposedContext extends VaultValueContext {
+    static fromValueContext(valueContext: VaultValueContext, prices: Prices): VaultNativeValueDecomposedContext;
+    static decomposeContext(valueContext: Record<string, IValuePosition>, prices: Prices, nativeAssets: Record<string, IValuePosition>): Record<string, IValuePosition>;
+    net(): Record<string, IValuePosition>;
+}
+export declare class VaultNativeAmountDecomposedContext {
+    readonly address: string;
+    readonly totalSupply: bigint;
+    readonly assets: Record<string, IAmountPosition>;
+    constructor(address: string, totalSupply: bigint, assets: Record<string, IAmountPosition>);
+    net(): Record<string, IAmountPosition>;
+    static fromDecomposedValueContext(decomposedValueContext: VaultValueContext, prices: Prices): VaultNativeAmountDecomposedContext;
+}

package/dist/common/transform.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaultNativeAmountDecomposedContext = exports.VaultNativeValueDecomposedContext = exports.VaultValueContext = exports.VaultAmountContext = exports.VaultStateContext = exports.PoolContext = exports.PoolAsset = exports.AmountPositionWithAddress = exports.AmountPosition = exports.ValuePosition = exports.SharePosition = exports.Position = void 0;
+const pool_1 = require("../contracts/core/pool");
+const share_vault_1 = require("../contracts/vault/share-vault");
+const strategy_vault_1 = require("../contracts/vault/strategy-vault");
+const types_1 = require("./types");
+class Position {
+    supply;
+    borrow;
+    constructor(supply = 0n, borrow = 0n) {
+        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(poolAsset) {
+        return new AmountPosition((0, pool_1.shareToAmount)(this.supply, poolAsset.amount.supply, poolAsset.share.supply), (0, pool_1.shareToAmount)(this.borrow, poolAsset.amount.borrow, poolAsset.share.borrow));
+    }
+}
+exports.SharePosition = SharePosition;
+class ValuePosition extends Position {
+    toAmountPosition(price) {
+        return new AmountPosition(this.supply / price, this.borrow / price);
+    }
+    static from(data) {
+        return new this(data.supply, data.borrow);
+    }
+    net() {
+        return this.supply - this.borrow;
+    }
+}
+exports.ValuePosition = ValuePosition;
+class AmountPosition extends Position {
+    toValuePosition(price) {
+        return new ValuePosition(this.supply * price, this.borrow * price);
+    }
+    net() {
+        return this.supply - this.borrow;
+    }
+}
+exports.AmountPosition = AmountPosition;
+class AmountPositionWithAddress extends AmountPosition {
+    address;
+    constructor(address, supply, borrow) {
+        super(supply, borrow);
+        this.address = address;
+    }
+    static from(data) {
+        return new this(data.address, data.supply, data.borrow);
+    }
+}
+exports.AmountPositionWithAddress = AmountPositionWithAddress;
+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);
+    }
+    getAmountFrom(address, share) {
+        const asset = this.assets[address];
+        if (!asset)
+            throw new Error(`Asset not found: ${address}`);
+        return new AmountPosition((0, pool_1.shareToAmount)(share.supply, asset.amount.supply, asset.share.supply), (0, pool_1.shareToAmount)(share.borrow, asset.amount.borrow, asset.share.borrow));
+    }
+}
+exports.PoolContext = PoolContext;
+class VaultStateContext {
+    address;
+    totalSupply;
+    assets;
+    pools;
+    constructor(address, totalSupply, assets, pools) {
+        this.address = address;
+        this.totalSupply = totalSupply;
+        this.assets = assets;
+        this.pools = pools;
+    }
+    static fromShareVaultStateCell(address, cell) {
+        const vaultData = share_vault_1.ShareVault.parseVaultData(cell);
+        return this.fromShareVaultState({ address, ...vaultData });
+    }
+    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 fromStrategyVaultStateCell(address, cell) {
+        const vaultData = strategy_vault_1.StrategyVault.parseVaultData(cell);
+        return this.fromStrategyVaultState({ address, ...vaultData });
+    }
+    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, poolPosition]) => {
+            const poolEntry = {};
+            Object.entries(poolPosition)
+                .forEach(([asset, sharePosition]) => poolEntry[asset] = poolContexts[pool].getAmountFrom(asset, sharePosition));
+            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, poolPosition]) => {
+            Object.entries(poolPosition)
+                .forEach(([asset, amountPosition]) => {
+                net[asset] = (net[asset] ?? new AmountPosition()).applyPosition(amountPosition);
+            });
+        });
+        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.net());
+        Object.entries(this.pools)
+            .forEach(([_pool, poolPosition]) => Object.entries(poolPosition)
+            .forEach(([_, position]) => totalValue += position.net()));
+        return totalValue;
+    }
+    net() {
+        const net = {};
+        Object.entries(this.assets)
+            .forEach(([asset, position]) => {
+            net[asset] = position.clone();
+        });
+        Object.entries(this.pools)
+            .forEach(([_, poolPosition]) => {
+            Object.entries(poolPosition)
+                .forEach(([asset, position]) => {
+                net[asset] = (net[asset] ?? new ValuePosition()).applyPosition(position);
+            });
+        });
+        return net;
+    }
+}
+exports.VaultValueContext = VaultValueContext;
+class VaultNativeValueDecomposedContext extends VaultValueContext {
+    static fromValueContext(valueContext, prices) {
+        const assetsNativePositions = {};
+        VaultNativeValueDecomposedContext.decomposeContext(valueContext.assets, prices, assetsNativePositions);
+        const poolsNativePositions = {};
+        Object.entries(valueContext.pools)
+            .forEach(([pool, poolPosition]) => {
+            const nativePoolPosition = {};
+            VaultNativeValueDecomposedContext.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()).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())
+                    .apply(position.supply, position.borrow);
+            }
+            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 totalValue = price.additionalData0.reserve * price0 + price.additionalData1.reserve * price1;
+                nativeAssets[price.additionalData0.underlying] = (nativeAssets[price.additionalData0.underlying] ?? new ValuePosition())
+                    .apply(position.supply * price.additionalData0.reserve * price0 / totalValue, position.borrow * price.additionalData0.reserve * price0 / totalValue);
+                nativeAssets[price.additionalData1.underlying] = (nativeAssets[price.additionalData1.underlying] ?? new ValuePosition())
+                    .apply(position.supply * price.additionalData1.reserve * price1 / totalValue, position.borrow * price.additionalData1.reserve * price1 / totalValue);
+            }
+            else if (price.type === types_1.CompositeAssetType.VAULT) {
+                // dependencyVaultValue
+                const depVaultValue = price.price * price.additionalData.totalSupply;
+                const decomposedPosition = {};
+                Object.entries(price.additionalData.decomposed)
+                    .forEach(([depAsset, depPosition]) => {
+                    const decomposedAssetPrice = prices[depAsset].price;
+                    const depVaultPosition = new AmountPosition(depPosition.supply, depPosition.borrow)
+                        .toValuePosition(decomposedAssetPrice);
+                    decomposedPosition[depAsset] = new ValuePosition((position.supply * depVaultPosition.supply + position.borrow * depVaultPosition.borrow) / depVaultValue, (position.supply * depVaultPosition.borrow + position.borrow * depVaultPosition.supply) / depVaultValue);
+                });
+                VaultNativeValueDecomposedContext.decomposeContext(decomposedPosition, prices, nativeAssets);
+            }
+            else {
+                throw new Error(`Invalid asset type: ${price}`);
+            }
+        });
+        return nativeAssets;
+    }
+    net() {
+        const net = {};
+        Object.entries(this.assets)
+            .forEach(([asset, position]) => {
+            net[asset] ??= new ValuePosition();
+            net[asset].applyPosition(position);
+        });
+        Object.entries(this.pools)
+            .forEach(([_pool, poolPosition]) => Object.entries(poolPosition)
+            .forEach(([asset, position]) => {
+            net[asset] ??= new ValuePosition();
+            net[asset].applyPosition(position);
+        }));
+        return net;
+    }
+}
+exports.VaultNativeValueDecomposedContext = VaultNativeValueDecomposedContext;
+class VaultNativeAmountDecomposedContext {
+    address;
+    totalSupply;
+    assets;
+    constructor(address, totalSupply, assets) {
+        this.address = address;
+        this.totalSupply = totalSupply;
+        this.assets = assets;
+    }
+    net() {
+        throw new Error("Method not implemented.");
+    }
+    static fromDecomposedValueContext(decomposedValueContext, prices) {
+        const totalSupply = decomposedValueContext.totalValue / prices[decomposedValueContext.address].price;
+        const net = decomposedValueContext.net();
+        const assets = {};
+        Object.entries(net)
+            .forEach(([asset, position]) => {
+            assets[asset] = position.toAmountPosition(prices[asset].price);
+        });
+        return new this(decomposedValueContext.address, totalSupply, assets);
+    }
+}
+exports.VaultNativeAmountDecomposedContext = VaultNativeAmountDecomposedContext;

package/dist/common/types.d.ts

@@ -0,0 +1,144 @@
+import { Address } from "@ton/core";
+export declare const DECIMALS_OF_PRICE = 100000000n;
+export declare enum CompositeAssetType {
+    NATIVE = 0,
+    SYNTHETIC1 = 1,
+    SYNTHETIC2 = 2,
+    VAULT = 10
+}
+export type NativePriceEntry = {
+    type: CompositeAssetType.NATIVE;
+    price: bigint;
+    timestamp?: number;
+};
+export type SyntheticAssetAdditionalData = {
+    underlying: string;
+    reserve: bigint;
+    totalSupply: bigint;
+};
+export type Synthetic1PriceEntry = {
+    type: CompositeAssetType.SYNTHETIC1;
+    price: bigint;
+    timestamp?: number;
+    additionalData: SyntheticAssetAdditionalData;
+};
+export type Synthetic2PriceEntry = {
+    type: CompositeAssetType.SYNTHETIC2;
+    price: bigint;
+    timestamp?: number;
+    additionalData0: SyntheticAssetAdditionalData;
+    additionalData1: SyntheticAssetAdditionalData;
+};
+export type VaultPriceEntry = {
+    type: CompositeAssetType.VAULT;
+    price: bigint;
+    timestamp?: number;
+    additionalData: VaultComposition;
+};
+export type PriceEntry = NativePriceEntry | Synthetic1PriceEntry | Synthetic2PriceEntry | VaultPriceEntry;
+export type Prices = Record<string, PriceEntry>;
+export type PoolShareInfo = {
+    totalSupplyAmount: bigint;
+    totalSupplyShare: bigint;
+    totalBorrowAmount: bigint;
+    totalBorrowShare: bigint;
+};
+export type PoolInfos = Record<string, Record<string, PoolShareInfo>>;
+export type SingleAssetData = {
+    assetType: CompositeAssetType.SYNTHETIC1;
+    underlyingAddress: Address | string;
+    underlyingReserve: bigint;
+    totalSupply: bigint;
+};
+export type MultiAssetData = {
+    assetType: CompositeAssetType.SYNTHETIC2;
+    underlying0Address: Address | string;
+    underlying1Address: Address | string;
+    underlying0Reserve: bigint;
+    underlying1Reserve: bigint;
+    totalSupply: bigint;
+};
+export type SyntheticComposition = SingleAssetData | MultiAssetData;
+export type SyntheticCompositions = Record<string, SyntheticComposition>;
+/** @deprecated Use SyntheticComposition instead */
+export type OnchainData = SyntheticComposition;
+/** @deprecated Use SyntheticCompositions instead */
+export type OnchainDataMap = SyntheticCompositions;
+export type VaultComposition = {
+    decomposed: Record<string, {
+        supply: bigint;
+        borrow: bigint;
+    }>;
+    totalSupply: bigint;
+};
+export type VaultCompositions = Record<string, VaultComposition>;
+export type VaultPrices = Record<string, VaultPriceEntry>;
+export type CompositeOracleResult = {
+    assetPrices: Prices;
+    vaultPrices: VaultPrices;
+    allPrices: Prices;
+};
+export type CompositeOracleInput = {
+    rawPrices: Prices;
+    syntheticCompositions: SyntheticCompositions;
+    vaultPositions: Record<string, IVaultStateContext>;
+    poolInfos: Record<string, IPoolContext>;
+};
+export interface IPosition {
+    supply: bigint;
+    borrow: bigint;
+    apply(supply: bigint, borrow: bigint): this;
+    applyPosition(position: this): this;
+    clone(): this;
+}
+export interface ISharePosition extends IPosition {
+    readonly _brand: 'SharePosition';
+    toAmountPosition(poolAsset: IPoolAsset): IAmountPosition;
+}
+export interface IValuePosition extends IPosition {
+    readonly _brand: 'ValuePosition';
+    toAmountPosition(price: bigint): IAmountPosition;
+    net(): bigint;
+}
+export interface IAmountPosition extends IPosition {
+    readonly _brand: 'AmountPosition';
+    toValuePosition(price: bigint): IValuePosition;
+    net(): bigint;
+}
+export interface IAmountPositionWithAddress extends IAmountPosition {
+    address: Address;
+}
+export interface IPoolAsset {
+    amount: IAmountPosition;
+    share: ISharePosition;
+}
+export type IPoolAmountPositions = Record<string, Record<string, IAmountPosition>>;
+export type IPoolValuePositions = Record<string, Record<string, IValuePosition>>;
+export type IPoolSharePositions = Record<string, Record<string, ISharePosition>>;
+export interface IPoolContext {
+    readonly address: string;
+    readonly assets: Record<string, IPoolAsset>;
+    getAmountFrom(address: string, share: ISharePosition): IAmountPosition;
+}
+export type IPoolContexts = Record<string, IPoolContext>;
+export interface IVaultStateContext {
+    readonly address: string;
+    readonly totalSupply: bigint;
+    readonly assets: Record<string, IAmountPosition>;
+    readonly pools: IPoolSharePositions;
+    toAmountContext(poolContexts: IPoolContexts): IVaultAmountContext;
+}
+export interface IVaultAmountContext {
+    readonly address: string;
+    readonly totalSupply: bigint;
+    readonly assets: Record<string, IAmountPosition>;
+    readonly pools: IPoolAmountPositions;
+    net(): Record<string, IAmountPosition>;
+}
+export interface IVaultValueContext {
+    readonly address: string;
+    readonly assets: Record<string, IValuePosition>;
+    readonly pools: IPoolValuePositions;
+    readonly totalValue: bigint;
+    net(): Record<string, IValuePosition>;
+}

package/dist/common/types.js

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

package/dist/contracts/oracle/redstone-onchain-oracle/type.d.ts

@@ -49,7 +49,7 @@ export type OnchainDataInfoInternal = OnchainDataInfoBase & {
 };
 export type OnchainData = OnchainDataInfoNative | OnchainDataInfoSingleAsset | OnchainDataInfoMultiAsset;
 export type OnchainDataInfo = Record<string, OnchainData>;
-export type AssetPriceInfo = Record<string, AssetPrice>;
+export type AssetPrices = Record<string, AssetPrice>;
 export type AssetPrice = {
     type: AssetType;
     price: bigint;

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

@@ -0,0 +1,76 @@
+import { PoolState } from "../../contracts/core/pool/type";
+import { ShareVaultState } from "../../contracts/vault/share-vault";
+import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
+import { Prices } from "./types";
+export declare class Position {
+    supply: bigint;
+    borrow: bigint;
+    constructor(supply: bigint, borrow: bigint);
+    apply(supply: bigint, borrow: bigint): this;
+    applyPosition(position: typeof this): this;
+    clone(): typeof this;
+}
+export declare class SharePosition extends Position {
+    toAmountPosition(PoolContext: PoolAsset): AmountPosition;
+}
+export declare class ValuePosition extends Position {
+    net(): bigint;
+}
+export declare class AmountPosition extends ValuePosition {
+    toValuePosition(price: bigint): ValuePosition;
+    net(): bigint;
+}
+export declare class PoolAsset {
+    amount: AmountPosition;
+    share: SharePosition;
+    constructor(amount: AmountPosition, share: SharePosition);
+}
+export type PoolAssets = Record<string, PoolAsset>;
+export declare class PoolContext {
+    readonly address: string;
+    readonly assets: PoolAssets;
+    constructor(address: string, assets?: PoolAssets);
+    static fromPoolState(poolState: PoolState): PoolContext;
+}
+export type PoolContexts = Record<string, PoolContext>;
+export type AmountPositions = Record<string, AmountPosition>;
+export type SharePositions = Record<string, SharePosition>;
+export type ValuePositions = Record<string, ValuePosition>;
+export type PoolAmountPositions = Record<string, AmountPositions>;
+export type PoolValuePositions = Record<string, ValuePositions>;
+export type PoolSharePositions = Record<string, SharePositions>;
+export declare class VaultStateContext {
+    readonly address: string;
+    readonly totalSupply: bigint;
+    readonly assets: AmountPositions;
+    readonly pools: PoolSharePositions;
+    constructor(address: string, totalSupply: bigint, assets: AmountPositions, // amount
+    pools: PoolSharePositions);
+    static fromShareVaultState(vaultState: ShareVaultState): VaultStateContext;
+    static fromStrategyVaultState(vaultState: StrategyVaultState): VaultStateContext;
+    toAmountContext(poolContexts: PoolContexts): VaultAmountContext;
+}
+export declare class VaultAmountContext {
+    readonly address: string;
+    readonly totalSupply: bigint;
+    readonly assets: AmountPositions;
+    readonly pools: PoolAmountPositions;
+    constructor(address: string, totalSupply: bigint, assets: AmountPositions, pools: PoolAmountPositions);
+    static fromVaultStateContext(VaultStateContext: VaultStateContext, poolContexts: PoolContexts): VaultAmountContext;
+    toValueContext(prices: Prices): VaultValueContext;
+    net(): AmountPositions;
+}
+export declare class VaultValueContext {
+    readonly address: string;
+    readonly assets: ValuePositions;
+    readonly pools: PoolValuePositions;
+    constructor(address: string, assets: ValuePositions, pools: PoolValuePositions);
+    static fromAmountContext(amountContext: VaultAmountContext, prices: Prices): VaultValueContext;
+    get totalValue(): bigint;
+    net(): ValuePositions;
+    nativeDecompose(prices: Prices): VaultNativeDecomposedValueContext;
+}
+export declare class VaultNativeDecomposedValueContext extends VaultValueContext {
+    static fromValueContext(valueContext: VaultValueContext, prices: Prices): VaultNativeDecomposedValueContext;
+    static decomposeContext(valueContext: ValuePositions, prices: Prices, nativeAssets: ValuePositions): ValuePositions;
+}