@affluent-org/sdk 0.0.1

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

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOracleExposures = createOracleExposures;
+exports.applyPrice = applyPrice;
+exports.calculateSyntheticPrices = calculateSyntheticPrices;
+exports.computePoolPositionsValue = computePoolPositionsValue;
+exports.computeVaultValue = computeVaultValue;
+exports.calculateVaultPrices = calculateVaultPrices;
+exports.computeCompositePrices = computeCompositePrices;
+exports.getExposures = getExposures;
+exports.separateAssets = separateAssets;
+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 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");
+function createOracleExposures() {
+    return {
+        assets: new Set(),
+        pools: new Set(),
+        vaults: new Set(),
+        totalSize() {
+            return this.assets.size + this.pools.size + this.vaults.size;
+        },
+    };
+}
+function applyPrice(amount, price) {
+    return (amount * price) / types_1.DECIMALS_OF_PRICE;
+}
+function calculateSyntheticPrices(rawPrices, syntheticCompositions) {
+    const prices = { ...rawPrices };
+    let pendingAssets = Object.entries(syntheticCompositions);
+    while (pendingAssets.length > 0) {
+        const stillPending = [];
+        for (const [assetAddress, data] of pendingAssets) {
+            if (data.assetType === types_1.CompositeAssetType.SYNTHETIC1) {
+                const underlyingPrice = prices[data.underlyingAddress.toString()];
+                if (underlyingPrice) {
+                    prices[assetAddress] = {
+                        type: types_1.CompositeAssetType.SYNTHETIC1,
+                        price: (underlyingPrice.price * data.underlyingReserve) / data.totalSupply,
+                    };
+                }
+                else {
+                    stillPending.push([assetAddress, data]);
+                }
+            }
+            else if (data.assetType === types_1.CompositeAssetType.SYNTHETIC2) {
+                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;
+                    prices[assetAddress] = {
+                        type: types_1.CompositeAssetType.SYNTHETIC2,
+                        price: value0 + value1,
+                    };
+                }
+                else {
+                    stillPending.push([assetAddress, data]);
+                }
+            }
+        }
+        if (stillPending.length === pendingAssets.length && stillPending.length > 0) {
+            throw new Error(`Circular dependency: ${stillPending.map(([addr]) => addr).join(", ")}`);
+        }
+        pendingAssets = stillPending;
+    }
+    return prices;
+}
+function computePoolPositionsValue(poolPositions, poolInfos, prices) {
+    const decomposed = {};
+    const assetAmounts = {};
+    let totalValue = 0n;
+    for (const [poolAddress, assetPositions] of Object.entries(poolPositions)) {
+        const poolInfo = poolInfos[poolAddress];
+        if (!poolInfo)
+            continue;
+        for (const [assetAddress, position] of Object.entries(assetPositions)) {
+            const assetInfo = poolInfo[assetAddress];
+            if (!assetInfo)
+                continue;
+            const amounts = (0, pool_1.positionShareToAmount)(position, assetInfo);
+            if (!decomposed[assetAddress]) {
+                decomposed[assetAddress] = { supply: 0n, borrow: 0n };
+            }
+            decomposed[assetAddress].supply += amounts.supply;
+            decomposed[assetAddress].borrow += amounts.borrow;
+            const netAmount = amounts.supply - amounts.borrow;
+            assetAmounts[assetAddress] = (assetAmounts[assetAddress] ?? 0n) + netAmount;
+            const price = prices[assetAddress];
+            if (price) {
+                totalValue += applyPrice(netAmount, price.price);
+            }
+        }
+    }
+    return { totalValue, decomposed, assetAmounts };
+}
+function computeVaultValue(vault, poolInfos, prices) {
+    let cashValue = 0n;
+    const decomposed = {};
+    for (const [assetAddress, amount] of Object.entries(vault.assets)) {
+        const price = prices[assetAddress];
+        if (price && amount > 0n) {
+            cashValue += applyPrice(amount, price.price);
+        }
+        decomposed[assetAddress] = { supply: amount, borrow: 0n };
+    }
+    const poolResult = computePoolPositionsValue(vault.poolPositions, poolInfos, prices);
+    for (const [assetAddress, amounts] of Object.entries(poolResult.decomposed)) {
+        if (decomposed[assetAddress]) {
+            decomposed[assetAddress].supply += amounts.supply;
+            decomposed[assetAddress].borrow += amounts.borrow;
+        }
+        else {
+            decomposed[assetAddress] = amounts;
+        }
+    }
+    const totalValue = cashValue + poolResult.totalValue;
+    const price = vault.totalSupply === 0n ? 0n : (totalValue * types_1.DECIMALS_OF_PRICE) / vault.totalSupply;
+    return { totalValue, price, decomposed };
+}
+function calculateVaultPrices(vaultPositions, poolInfos, assetPrices) {
+    const vaultPrices = {};
+    const combinedPrices = { ...assetPrices };
+    const pendingVaults = { ...vaultPositions };
+    while (Object.keys(pendingVaults).length > 0) {
+        const vaultAddresses = Object.keys(pendingVaults);
+        let resolved = false;
+        for (const vaultAddress of vaultAddresses) {
+            const vault = pendingVaults[vaultAddress];
+            try {
+                const requiredAssets = new Set();
+                for (const assetAddress of Object.keys(vault.assets)) {
+                    if (vault.assets[assetAddress] > 0n) {
+                        requiredAssets.add(assetAddress);
+                    }
+                }
+                for (const poolPositions of Object.values(vault.poolPositions)) {
+                    for (const [assetAddress, position] of Object.entries(poolPositions)) {
+                        if (position.supply > 0n || position.borrow > 0n) {
+                            requiredAssets.add(assetAddress);
+                        }
+                    }
+                }
+                let allPricesAvailable = true;
+                for (const asset of requiredAssets) {
+                    if (!combinedPrices[asset]) {
+                        allPricesAvailable = false;
+                        break;
+                    }
+                }
+                if (!allPricesAvailable)
+                    continue;
+                const result = computeVaultValue(vault, poolInfos, combinedPrices);
+                vaultPrices[vaultAddress] = {
+                    type: types_1.CompositeAssetType.VAULT,
+                    price: result.price,
+                    additionalData: {
+                        decomposed: result.decomposed,
+                        totalSupply: vault.totalSupply,
+                    },
+                };
+                combinedPrices[vaultAddress] = {
+                    type: types_1.CompositeAssetType.VAULT,
+                    price: result.price,
+                };
+                delete pendingVaults[vaultAddress];
+                resolved = true;
+            }
+            catch (e) {
+                // Continue to next vault
+            }
+        }
+        if (!resolved && Object.keys(pendingVaults).length > 0) {
+            for (const vaultAddress of Object.keys(pendingVaults)) {
+                vaultPrices[vaultAddress] = {
+                    type: types_1.CompositeAssetType.VAULT,
+                    price: 0n,
+                    additionalData: {
+                        decomposed: {},
+                        totalSupply: pendingVaults[vaultAddress].totalSupply,
+                    },
+                };
+                delete pendingVaults[vaultAddress];
+            }
+        }
+    }
+    return vaultPrices;
+}
+function computeCompositePrices(input) {
+    const assetPrices = calculateSyntheticPrices(input.rawPrices, input.syntheticCompositions);
+    const vaultPrices = calculateVaultPrices(input.vaultPositions, input.poolInfos, assetPrices);
+    const allPrices = { ...assetPrices };
+    for (const [address, entry] of Object.entries(vaultPrices)) {
+        allPrices[address] = { type: entry.type, price: entry.price };
+    }
+    return { assetPrices, vaultPrices, allPrices };
+}
+function getExposures(vaultPositions) {
+    const assets = new Set();
+    const pools = new Set();
+    for (const vault of Object.values(vaultPositions)) {
+        for (const [asset, amount] of Object.entries(vault.assets)) {
+            if (amount > 0n)
+                assets.add(asset);
+        }
+        for (const [poolAddress, poolPositions] of Object.entries(vault.poolPositions)) {
+            for (const [asset, position] of Object.entries(poolPositions)) {
+                if (position.supply > 0n || position.borrow > 0n) {
+                    pools.add(poolAddress);
+                    assets.add(asset);
+                }
+            }
+        }
+    }
+    return { assets: [...assets], pools: [...pools] };
+}
+function separateAssets(allAssets, oracleConfig) {
+    const knownAssets = new Set();
+    if (oracleConfig.redstoneAssetInfo) {
+        for (const info of Object.values(oracleConfig.redstoneAssetInfo)) {
+            knownAssets.add(info.address.toString());
+        }
+    }
+    if (oracleConfig.assetOnchainDataInfo) {
+        for (const address of Object.keys(oracleConfig.assetOnchainDataInfo)) {
+            knownAssets.add(address);
+        }
+    }
+    const assets = [];
+    const vaultAssets = [];
+    for (const asset of allAssets) {
+        if (knownAssets.has(asset)) {
+            assets.push(asset);
+        }
+        else {
+            vaultAssets.push(asset);
+        }
+    }
+    return { assets, vaultAssets };
+}
+function updateOnchainInternalData(prices, onchainData) {
+    for (const [asset, data] of Object.entries(onchainData)) {
+        if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.internal) {
+            prices[asset] = {
+                type: type_1.AssetType.Native,
+                price: data.price,
+                timestamp: Date.now(),
+            };
+        }
+    }
+    return prices;
+}
+// ============================================================
+// Oracle Params Cell Building
+// ============================================================
+/**
+ * Build oracle params Cell from pre-fetched Redstone payload
+ * Pure computation - no network calls
+ */
+function buildOracleParamsCellFromPayload(assets, oracleConfig, payload, pools, vaults) {
+    const requestParams = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+    const requestAssetCell = redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(requestParams.requestAssets);
+    const dataFeedIdsTupleBuilder = new core_1.TupleBuilder();
+    requestParams.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+    const feedIdCell = (0, core_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+    const requestFactorialPoolsCell = pools.length > 0 ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(pools.map((p) => core_1.Address.parse(p))) : null;
+    const requestFactorialVaultsCell = vaults.length > 0 ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaults.map((v) => core_1.Address.parse(v))) : null;
+    const requestFactorialCell = (0, core_1.beginCell)()
+        .storeMaybeRef(requestFactorialPoolsCell)
+        .storeMaybeRef(requestFactorialVaultsCell)
+        .endCell();
+    return (0, core_1.beginCell)()
+        .storeRef(feedIdCell)
+        .storeRef(payload)
+        .storeRef(requestAssetCell)
+        .storeRef(requestFactorialCell)
+        .endCell();
+}
+/**
+ * Build oracle params Cell - fetches Redstone payload and builds Cell
+ */
+async function buildOracleParamsCell(assets, oracleConfig, pools, vaults) {
+    const requestParams = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+    // Fetch Redstone payload
+    const helper = (0, redstoneHelper_1.createRedstoneHelper)("prod");
+    const payload = await helper.createPayload(requestParams.redstoneAssetNames);
+    // Pure computation
+    return buildOracleParamsCellFromPayload(assets, oracleConfig, payload, pools, vaults);
+}

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

@@ -0,0 +1,45 @@
+import { AddressLike } from "../../contracts/common/type";
+import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
+import { Prices, CompositeOracleResult, CompositeOracleInput } from "./types";
+import { CompositeOracleFetcher } from "./query";
+export * from "./types";
+export * from "./computation";
+export { CompositeOracleFetcher, OracleContext } from "./query";
+export declare class CompositeOracleV1 extends CompositeOracleFetcher {
+    /**
+     * Fetch all data needed for price computation
+     * Call once, compute multiple times
+     */
+    fetchAll(vaultAddress: AddressLike, vaultData?: StrategyVaultState, extraAssets?: {
+        assets: string[];
+        vaultAssets: string[];
+    }): Promise<CompositeOracleInput & {
+        oracleConfig: any;
+    }>;
+    /**
+     * Compute prices from pre-fetched data (pure computation, no I/O)
+     */
+    compute(input: CompositeOracleInput): CompositeOracleResult;
+    /**
+     * Get vault price (convenience method: fetch + compute)
+     */
+    getVaultPrice(vaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<bigint>;
+    /**
+     * Get vault price with full details (convenience method: fetch + compute)
+     */
+    getVaultPriceWithDetails(vaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<CompositeOracleResult & {
+        targetVaultAddress: string;
+        price: bigint;
+    }>;
+    /**
+     * Get all asset prices (convenience method: fetch + compute)
+     */
+    getAllAssetPrices(vaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<Prices>;
+    /**
+     * Get total vault value (convenience method: fetch + compute)
+     */
+    getTotalValue(vaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<bigint>;
+    static compute(input: CompositeOracleInput): CompositeOracleResult;
+    static getVaultPriceFromInput(input: CompositeOracleInput, vaultAddress: string): bigint;
+    static getTotalValueFromInput(input: CompositeOracleInput, vaultAddress: string): bigint;
+}

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

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeOracleV1 = exports.CompositeOracleFetcher = void 0;
+const utils_1 = require("../../contracts/common/utils");
+const types_1 = require("./types");
+const computation_1 = require("./computation");
+const query_1 = require("./query");
+__exportStar(require("./types"), exports);
+__exportStar(require("./computation"), exports);
+var query_2 = require("./query");
+Object.defineProperty(exports, "CompositeOracleFetcher", { enumerable: true, get: function () { return query_2.CompositeOracleFetcher; } });
+class CompositeOracleV1 extends query_1.CompositeOracleFetcher {
+    /**
+     * Fetch all data needed for price computation
+     * Call once, compute multiple times
+     */
+    async fetchAll(vaultAddress, vaultData, extraAssets) {
+        const ctx = await this.getOracleContext(vaultAddress, vaultData, extraAssets);
+        const { rawPrices, onchainData: redstoneSyntheticData } = await this.fetchRawPrices(ctx.allRequiredAssets, ctx.oracleConfig);
+        const additionalSyntheticData = await this.fetchOnchainData(ctx.oracleConfig.assetOnchainDataInfo ?? {});
+        const syntheticCompositions = { ...redstoneSyntheticData, ...additionalSyntheticData };
+        (0, computation_1.updateOnchainInternalData)(rawPrices, ctx.oracleConfig.assetOnchainDataInfo ?? {});
+        const poolInfos = await this.fetchPoolInfos(ctx.exposures.pools);
+        return {
+            rawPrices,
+            syntheticCompositions,
+            vaultPositions: ctx.vaultPositions,
+            poolInfos,
+            oracleConfig: ctx.oracleConfig,
+        };
+    }
+    /**
+     * Compute prices from pre-fetched data (pure computation, no I/O)
+     */
+    compute(input) {
+        return (0, computation_1.computeCompositePrices)(input);
+    }
+    /**
+     * Get vault price (convenience method: fetch + compute)
+     */
+    async getVaultPrice(vaultAddress, vaultData) {
+        const input = await this.fetchAll(vaultAddress, vaultData);
+        const result = this.compute(input);
+        return result.vaultPrices[(0, utils_1.toAddress)(vaultAddress).toString()]?.price ?? 0n;
+    }
+    /**
+     * Get vault price with full details (convenience method: fetch + compute)
+     */
+    async getVaultPriceWithDetails(vaultAddress, vaultData) {
+        const input = await this.fetchAll(vaultAddress, vaultData);
+        const result = this.compute(input);
+        const targetVaultAddress = (0, utils_1.toAddress)(vaultAddress).toString();
+        const price = result.vaultPrices[targetVaultAddress]?.price ?? 0n;
+        return { ...result, targetVaultAddress, price };
+    }
+    /**
+     * Get all asset prices (convenience method: fetch + compute)
+     */
+    async getAllAssetPrices(vaultAddress, vaultData) {
+        const input = await this.fetchAll(vaultAddress, vaultData);
+        const result = this.compute(input);
+        return result.allPrices;
+    }
+    /**
+     * Get total vault value (convenience method: fetch + compute)
+     */
+    async getTotalValue(vaultAddress, vaultData) {
+        const input = await this.fetchAll(vaultAddress, vaultData);
+        const result = this.compute(input);
+        const targetVaultAddress = (0, utils_1.toAddress)(vaultAddress).toString();
+        const vaultPriceEntry = result.vaultPrices[targetVaultAddress];
+        if (!vaultPriceEntry || vaultPriceEntry.additionalData.totalSupply === 0n) {
+            return 0n;
+        }
+        return (vaultPriceEntry.price * vaultPriceEntry.additionalData.totalSupply) / types_1.DECIMALS_OF_PRICE;
+    }
+    // ============================================================
+    // Static computation methods (no instance needed)
+    // ============================================================
+    static compute(input) {
+        return (0, computation_1.computeCompositePrices)(input);
+    }
+    static getVaultPriceFromInput(input, vaultAddress) {
+        const result = (0, computation_1.computeCompositePrices)(input);
+        return result.vaultPrices[vaultAddress]?.price ?? 0n;
+    }
+    static getTotalValueFromInput(input, vaultAddress) {
+        const result = (0, computation_1.computeCompositePrices)(input);
+        const vaultPriceEntry = result.vaultPrices[vaultAddress];
+        if (!vaultPriceEntry || vaultPriceEntry.additionalData.totalSupply === 0n) {
+            return 0n;
+        }
+        return (vaultPriceEntry.price * vaultPriceEntry.additionalData.totalSupply) / types_1.DECIMALS_OF_PRICE;
+    }
+}
+exports.CompositeOracleV1 = CompositeOracleV1;

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

@@ -0,0 +1,36 @@
+import { Address } from "@ton/core";
+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";
+export type OracleContext = {
+    vaultData: StrategyVaultState;
+    oracleConfig: any;
+    assets: string[];
+    vaultAssets: string[];
+    vaultPositions: VaultPositions;
+    exposures: {
+        assets: string[];
+        pools: string[];
+    };
+    allRequiredAssets: string[];
+};
+export declare class CompositeOracleFetcher {
+    protected ctx: AffluentContext;
+    constructor(ctx?: AffluentContext);
+    /**
+     * Get oracle context - shared data needed for both price computation and on-chain params
+     */
+    getOracleContext(vaultAddress: AddressLike, vaultData?: StrategyVaultState, extraAssets?: {
+        assets: string[];
+        vaultAssets: string[];
+    }): Promise<OracleContext>;
+    fetchRawPrices(assets: string[], oracleConfig: any): Promise<{
+        rawPrices: Prices;
+        onchainData: OnchainDataMap;
+    }>;
+    fetchOnchainData(onchainDataInfo: OnchainDataInfo): Promise<OnchainDataMap>;
+    fetchVaultPositions(vaultAddresses: (Address | string)[]): Promise<VaultPositions>;
+    fetchPoolInfos(poolAddresses: string[]): Promise<PoolInfos>;
+}