@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/oracle/oracle-v2.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleLibsV2 = exports.AddressBucket = void 0;
+const core_1 = require("@ton/core");
+const service_1 = require("../common/service");
+const utils_1 = require("../contracts/common/utils");
+const redstone_onchain_oracle_1 = require("../contracts/oracle/redstone-onchain-oracle");
+const strategy_vault_1 = require("../contracts/vault/strategy-vault");
+const redstoneHelper_1 = require("../utils/oracle/redstone/redstoneHelper");
+const pool_1 = require("../contracts/core/pool");
+const account_1 = require("../contracts/core/account");
+class AddressBucket {
+    assets;
+    pools;
+    vaults;
+    constructor(assets = new Set(), pools = new Set(), vaults = new Set()) {
+        this.assets = assets;
+        this.pools = pools;
+        this.vaults = vaults;
+    }
+    getAssets() {
+        return [...this.assets];
+    }
+    getVaultAssets() {
+        return [...this.vaults];
+    }
+    getPools() {
+        return [...this.pools];
+    }
+    add(other) {
+        other.assets.forEach((asset) => this.assets.add(asset));
+        other.pools.forEach((pool) => this.pools.add(pool));
+        other.vaults.forEach((vault) => this.vaults.add(vault));
+        return this;
+    }
+    array() {
+        return {
+            assets: [...this.assets],
+            pools: [...this.pools],
+            vaults: [...this.vaults],
+        };
+    }
+    totalSize() {
+        return this.assets.size + this.pools.size + this.vaults.size;
+    }
+}
+exports.AddressBucket = AddressBucket;
+class OracleLibsV2 extends service_1.ServiceBaseV1 {
+    async getOracleParamsForPoolSupplyAndRepay(poolAddress, assetAddress, poolData, bucket = new AddressBucket()) {
+        const pool = this.getByContract(pool_1.Pool, poolAddress);
+        poolData ??= await pool.getPoolData();
+        bucket ??= await this.makeAnyAddressBucket((0, utils_1.toAddress)(assetAddress), bucket);
+        const oracleParams = await this.makeOracleParams(bucket, poolData.oracleConfig);
+        return {
+            oracleParams,
+            bucket,
+        };
+    }
+    async getOracleParamsForPoolBorrowAndWithdraw(poolAddress, actorAddress, assetAddress, poolData, accountData, bucket = new AddressBucket()) {
+        const pool = this.getByContract(pool_1.Pool, poolAddress);
+        const actorAccount = this.getByContract(account_1.Account, await pool.getAccountAddress((0, utils_1.toAddress)(actorAddress)));
+        poolData ??= await pool.getPoolData();
+        accountData ??= await actorAccount.getAccountData();
+        for (const [asset, position] of Object.entries(accountData.status)) {
+            if (position.supply > 0 || position.borrow > 0) {
+                await this.makeAnyAddressBucket((0, utils_1.toAddress)(asset), bucket);
+            }
+        }
+        bucket ??= await this.makeAnyAddressBucket((0, utils_1.toAddress)(assetAddress), bucket);
+        const oracleParams = await this.makeOracleParams(bucket, poolData.oracleConfig);
+        return {
+            oracleParams,
+            bucket,
+        };
+    }
+    async getOracleParamsForStrategyVault(vaultAddress, vaultData, bucket = new AddressBucket()) {
+        const vault = this.getByContract(strategy_vault_1.StrategyVault, vaultAddress);
+        vaultData ??= await vault.getVaultData();
+        bucket = await this.strategyVaultAddressBucket(vault.address, bucket);
+        const oracleParams = await this.makeOracleParams(bucket, vaultData.oracleConfig);
+        return {
+            oracleParams,
+            bucket,
+        };
+    }
+    async makeOracleParams(bucket, oracleConfig) {
+        const { assets, pools, vaults } = bucket.array();
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, 
+        // @ts-ignore
+        oracleConfig);
+        const dataFeedIdsTupleBuilder = new core_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, core_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const payload = await (0, redstoneHelper_1.createRedstoneHelper)("prod").createPayload(result.redstoneAssetNames);
+        const requestAssetCell = redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(result.requestAssets);
+        const requestFactorialCell = (0, core_1.beginCell)()
+            .storeMaybeRef(pools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(pools.map((pool) => core_1.Address.parse(pool)))
+            : null)
+            .storeMaybeRef(vaults.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaults.map((vault) => core_1.Address.parse(vault)))
+            : null)
+            .endCell();
+        const oracleParams = (0, core_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        return oracleParams;
+    }
+    async strategyVaultAddressBucket(vault, bucket = new AddressBucket()) {
+        const vaultAddress = vault.toString();
+        const assetType = await this.getAssetType(vaultAddress);
+        if (assetType.type !== "strategy-vault") {
+            throw new Error("Vault is not a strategy vault");
+        }
+        for (const poolAddress of Object.keys(assetType.data.factorialPools)) {
+            bucket.pools.add(poolAddress);
+        }
+        await Promise.all(Object.keys(assetType.data.assets)
+            .map((asset) => core_1.Address.parse(asset))
+            .map((asset) => this.makeAnyAddressBucket(asset, bucket)));
+        return bucket;
+    }
+    async makeAnyAddressBucket(asset, bucket = new AddressBucket()) {
+        const assetAddress = asset.toString();
+        const assetType = await this.getAssetType(assetAddress);
+        if (assetType.type === "underlying-asset") {
+            bucket.assets.add(assetAddress.toString());
+        }
+        else if (assetType.type === "share-vault") {
+            bucket.vaults.add(assetAddress.toString());
+            for (const poolAddress of Object.keys(assetType.data.whitelistedPools)) {
+                bucket.pools.add(poolAddress);
+            }
+        }
+        else if (assetType.type === "strategy-vault") {
+            bucket.vaults.add(assetAddress.toString());
+            for (const poolAddress of Object.keys(assetType.data.factorialPools)) {
+                bucket.pools.add(poolAddress);
+            }
+            await Promise.all(Object.keys(assetType.data.assets)
+                .map((asset) => core_1.Address.parse(asset))
+                .map((asset) => this.makeAnyAddressBucket(asset, bucket)));
+        }
+        // unknown or (should) pool address
+        return bucket;
+    }
+}
+exports.OracleLibsV2 = OracleLibsV2;

package/dist/oracle/oracle.d.ts

@@ -0,0 +1,107 @@
+import { Address, Cell, OpenedContract } from "@ton/core";
+import { ServiceBaseV1 } from "../common/service";
+import { ShareVault } from "../contracts/vault/share-vault";
+import { StrategyVault } from "../contracts/vault/strategy-vault";
+import { ShareVaultState } from "../contracts/vault/share-vault/type";
+import { RFQAuction } from "../contracts/rfq/rfq_auction";
+import { Pool } from "../contracts/core/pool";
+import { PoolState } from "../contracts/core/pool/type";
+import { RFQBatch } from "../contracts/rfq/rfq_batch";
+type AssetAddress = string;
+type PoolAddress = string;
+declare class AssetPosition {
+    readonly cash: bigint;
+    constructor(cash: bigint);
+}
+declare class PoolAssetPosition {
+    readonly supply: bigint;
+    readonly borrow: bigint;
+    constructor(supply: bigint, borrow: bigint);
+    static fromPosition(position: {
+        supply: bigint;
+        borrow: bigint;
+    }): PoolAssetPosition;
+}
+type PoolPosition = Record<AssetAddress, PoolAssetPosition>;
+type AssetUnderPool = {
+    cash: bigint;
+    supply: bigint;
+    borrow: bigint;
+    supplyShare: bigint;
+    borrowShare: bigint;
+};
+export declare class PoolValueStatus {
+    readonly status: Record<AssetAddress, AssetUnderPool>;
+    readonly oracleConfig: any;
+    readonly underlyingAssets: Record<AssetAddress, AssetUnderPool>;
+    readonly vaultAssets: Record<AssetAddress, AssetUnderPool>;
+    readonly oracleAssets: Set<string>;
+    constructor(status: Record<AssetAddress, AssetUnderPool>, oracleConfig: any);
+    static fromPool(pool: OpenedContract<Pool>): Promise<PoolValueStatus>;
+    static fromPoolData(poolData: PoolState): PoolValueStatus;
+    bucket(bucket?: AddressBucket): AddressBucket;
+}
+export declare class ShareVaultValueStatus {
+    readonly assets: Record<AssetAddress, AssetPosition>;
+    readonly pools: Record<PoolAddress, PoolPosition>;
+    readonly totalSupply: bigint;
+    constructor(assets: Record<AssetAddress, AssetPosition>, pools: Record<PoolAddress, PoolPosition>, totalSupply: bigint);
+    static fromVault(vault: OpenedContract<ShareVault>): Promise<ShareVaultValueStatus>;
+    static fromVaultData(vaultData: ShareVaultState | ReturnType<typeof ShareVault.parseVaultData>): ShareVaultValueStatus;
+    bucket(bucket?: AddressBucket): AddressBucket;
+}
+export declare class StrategyVaultValueStatus {
+    readonly assets: Record<AssetAddress, AssetPosition>;
+    readonly pools: Record<PoolAddress, PoolPosition>;
+    readonly totalSupply: bigint;
+    readonly oracleConfig: any;
+    readonly underlyingAssets: Record<AssetAddress, AssetPosition>;
+    readonly vaultAssets: Record<AssetAddress, AssetPosition>;
+    readonly oracleAssets: Set<string>;
+    constructor(assets: Record<AssetAddress, AssetPosition>, pools: Record<PoolAddress, PoolPosition>, totalSupply: bigint, oracleConfig: any);
+    static fromVault(vault: OpenedContract<StrategyVault>): Promise<StrategyVaultValueStatus>;
+    static fromVaultData(vaultData: ReturnType<typeof StrategyVault.parseVaultData>): StrategyVaultValueStatus;
+    bucket(bucket?: AddressBucket): AddressBucket;
+}
+export declare class AddressBucket {
+    readonly assets: Set<string>;
+    readonly pools: Set<string>;
+    readonly vaults: Set<string>;
+    constructor(assets?: Set<string>, pools?: Set<string>, vaults?: Set<string>);
+    getAssets(): string[];
+    getVaultAssets(): string[];
+    getPools(): string[];
+    updatePoolAssetStatus(poolAssetStatus: Record<string, AssetUnderPool>): void;
+    updateVaultAssetPositions(vaultAssetPositions: Record<string, AssetPosition>): void;
+    updateVaultPoolPositions(vaultPoolPositions: Record<string, PoolPosition>): void;
+    add(other: AddressBucket): this;
+    object(): {
+        assets: string[];
+        pools: string[];
+        vaults: string[];
+    };
+}
+export declare class OracleLibs extends ServiceBaseV1 {
+    getOracleParamsForPool(poolData: PoolState, anyAssets?: string[], bucket?: AddressBucket): Promise<Cell>;
+    getOracleParamsForStrategyVault(vaultData: ReturnType<typeof StrategyVault.parseVaultData>, anyAssets?: string[], bucket?: AddressBucket): Promise<Cell>;
+    getOracleParamsForStrategyVaultV2(vaultData: ReturnType<typeof StrategyVault.parseVaultData>, anyAssets?: string[], bucket?: AddressBucket): Promise<{
+        oracleParams: Cell;
+        bucket: AddressBucket;
+    }>;
+    getOracleParamsForStrategyVaultRFQAuction(rfqAuctionData: ReturnType<typeof RFQAuction.parseRfqStorage>, bucket?: AddressBucket): Promise<Cell>;
+    getOracleParamsForRFQBatch(rfqBatchData: ReturnType<typeof RFQBatch.parseRFQBatchStorage>, bucket?: AddressBucket): Promise<{
+        oracleParams: Cell;
+        bucket: AddressBucket;
+    }>;
+    flattenOraclePool(pool: PoolValueStatus, bucket?: AddressBucket): Promise<AddressBucket>;
+    flattenOracleShareVault(shareVault: ShareVaultValueStatus, bucket?: AddressBucket): Promise<AddressBucket>;
+    flattenOracleStrategyVault(strategyVault: StrategyVaultValueStatus, bucket?: AddressBucket): Promise<AddressBucket>;
+    getUnderlyingAssetFilter(oracleConfig: any, noneVaultFilter?: AddressBucket): AddressBucket;
+    flattenAssets(oracleConfig: any, anyAssets?: string[], bucket?: AddressBucket): Promise<AddressBucket>;
+    makeOracleParams(bucket: AddressBucket, oracleConfig: any): Promise<Cell>;
+    getParsedVaults(vaultAddresses: (Address | string)[], bucket?: AddressBucket): Promise<{
+        strategyVaults: Record<string, StrategyVaultValueStatus>;
+        shareVaults: Record<string, ShareVaultValueStatus>;
+    }>;
+}
+export {};

package/dist/oracle/oracle.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleLibs = exports.AddressBucket = exports.StrategyVaultValueStatus = exports.ShareVaultValueStatus = exports.PoolValueStatus = void 0;
+const core_1 = require("@ton/core");
+const service_1 = require("../common/service");
+const redstone_onchain_oracle_1 = require("../contracts/oracle/redstone-onchain-oracle");
+const share_vault_1 = require("../contracts/vault/share-vault");
+const strategy_vault_1 = require("../contracts/vault/strategy-vault");
+const redstoneHelper_1 = require("../utils/oracle/redstone/redstoneHelper");
+const unknown_contract_1 = require("../common/unknown-contract");
+class AssetPosition {
+    cash;
+    constructor(cash) {
+        this.cash = cash;
+    }
+}
+class PoolAssetPosition {
+    supply;
+    borrow;
+    constructor(supply, borrow) {
+        this.supply = supply;
+        this.borrow = borrow;
+    }
+    static fromPosition(position) {
+        return new PoolAssetPosition(position.supply, position.borrow);
+    }
+}
+class PoolValueStatus {
+    status;
+    oracleConfig;
+    underlyingAssets = {};
+    vaultAssets = {};
+    oracleAssets = new Set();
+    constructor(status, oracleConfig) {
+        this.status = status;
+        this.oracleConfig = oracleConfig;
+        Object.values(oracleConfig.redstoneAssetInfo).forEach((item) => {
+            this.oracleAssets.add(item.address.toString());
+        });
+        Object.keys(oracleConfig.assetOnchainDataInfo).forEach((item) => {
+            this.oracleAssets.add(item);
+        });
+        Object.entries(this.status).forEach(([asset, position]) => {
+            if (this.oracleAssets.has(asset)) {
+                this.underlyingAssets[asset] = position;
+            }
+            else {
+                this.vaultAssets[asset] = position;
+            }
+        });
+    }
+    static async fromPool(pool) {
+        const poolData = await pool.getPoolData();
+        return PoolValueStatus.fromPoolData(poolData);
+    }
+    static fromPoolData(poolData) {
+        const poolStatus = {};
+        Object.entries(poolData.assets).forEach(([asset, assetData]) => {
+            poolStatus[asset] = {
+                cash: assetData.cash,
+                supply: assetData.totalSupplyAmount,
+                borrow: assetData.totalBorrowAmount,
+                supplyShare: assetData.totalSupplyShare,
+                borrowShare: assetData.totalBorrowShare,
+            };
+        });
+        return new PoolValueStatus(poolStatus, poolData.oracleConfig);
+    }
+    bucket(bucket = new AddressBucket()) {
+        for (const [asset, position] of Object.entries(this.underlyingAssets)) {
+            if (position.supply > 0 || position.borrow > 0) {
+                bucket.assets.add(asset);
+            }
+        }
+        for (const [asset, position] of Object.entries(this.vaultAssets)) {
+            if (position.supply > 0 || position.borrow > 0) {
+                bucket.vaults.add(asset);
+            }
+        }
+        return bucket;
+    }
+}
+exports.PoolValueStatus = PoolValueStatus;
+class ShareVaultValueStatus {
+    assets;
+    pools;
+    totalSupply;
+    constructor(assets, pools, totalSupply) {
+        this.assets = assets;
+        this.pools = pools;
+        this.totalSupply = totalSupply;
+    }
+    static async fromVault(vault) {
+        const vaultData = await vault.getVaultData();
+        return ShareVaultValueStatus.fromVaultData(vaultData);
+    }
+    static fromVaultData(vaultData) {
+        const asset = vaultData.asset.toString();
+        const assets = {
+            [asset]: new AssetPosition(vaultData.cash),
+        };
+        const pools = {};
+        Object.values(vaultData.whitelistedPools).map((pool) => {
+            pools[pool.address.toString()] = {
+                [asset]: new PoolAssetPosition(pool.supply, 0n),
+            };
+        });
+        return new ShareVaultValueStatus(assets, pools, vaultData.totalSupply);
+    }
+    bucket(bucket = new AddressBucket()) {
+        bucket.updateVaultAssetPositions(this.assets);
+        bucket.updateVaultPoolPositions(this.pools);
+        return bucket;
+    }
+}
+exports.ShareVaultValueStatus = ShareVaultValueStatus;
+class StrategyVaultValueStatus {
+    assets;
+    pools;
+    totalSupply;
+    oracleConfig;
+    underlyingAssets = {};
+    vaultAssets = {};
+    oracleAssets = new Set();
+    constructor(assets, pools, totalSupply, oracleConfig) {
+        this.assets = assets;
+        this.pools = pools;
+        this.totalSupply = totalSupply;
+        this.oracleConfig = oracleConfig;
+        Object.values(oracleConfig.redstoneAssetInfo).forEach((item) => {
+            this.oracleAssets.add(item.address.toString());
+        });
+        Object.keys(oracleConfig.assetOnchainDataInfo).forEach((item) => {
+            this.oracleAssets.add(item);
+        });
+        Object.entries(this.assets).forEach(([asset, position]) => {
+            if (this.oracleAssets.has(asset)) {
+                this.underlyingAssets[asset] = position;
+            }
+            else {
+                this.vaultAssets[asset] = position;
+            }
+        });
+    }
+    static async fromVault(vault) {
+        const vaultData = await vault.getVaultData();
+        return StrategyVaultValueStatus.fromVaultData(vaultData);
+    }
+    static fromVaultData(vaultData) {
+        const assets = {};
+        Object.entries(vaultData.assets).forEach(([asset, assetData]) => {
+            assets[asset] = new AssetPosition(assetData.cash);
+        });
+        const pools = {};
+        Object.entries(vaultData.factorialPools).forEach(([pool, poolAssets]) => {
+            const poolPosition = {};
+            Object.entries(poolAssets).forEach(([asset, position]) => {
+                poolPosition[asset] = PoolAssetPosition.fromPosition(position);
+            });
+            pools[pool] = poolPosition;
+        });
+        return new StrategyVaultValueStatus(assets, pools, vaultData.totalSupply, vaultData.oracleConfig);
+    }
+    bucket(bucket = new AddressBucket()) {
+        bucket.updateVaultAssetPositions(this.underlyingAssets);
+        bucket.updateVaultPoolPositions(this.pools);
+        return bucket;
+    }
+}
+exports.StrategyVaultValueStatus = StrategyVaultValueStatus;
+class AddressBucket {
+    assets;
+    pools;
+    vaults;
+    constructor(assets = new Set(), pools = new Set(), vaults = new Set()) {
+        this.assets = assets;
+        this.pools = pools;
+        this.vaults = vaults;
+    }
+    getAssets() {
+        return [...this.assets];
+    }
+    getVaultAssets() {
+        return [...this.vaults];
+    }
+    getPools() {
+        return [...this.pools];
+    }
+    updatePoolAssetStatus(poolAssetStatus) {
+        for (const [asset, position] of Object.entries(poolAssetStatus)) {
+            if (position.supply > 0 || position.borrow > 0) {
+                this.assets.add(asset);
+            }
+        }
+    }
+    updateVaultAssetPositions(vaultAssetPositions) {
+        for (const [asset, position] of Object.entries(vaultAssetPositions)) {
+            if (position.cash > 0) {
+                this.assets.add(asset);
+            }
+        }
+    }
+    updateVaultPoolPositions(vaultPoolPositions) {
+        for (const [poolAddress, poolPosition] of Object.entries(vaultPoolPositions)) {
+            for (const [_, position] of Object.entries(poolPosition)) {
+                if (position.supply > 0 || position.borrow > 0) {
+                    this.pools.add(poolAddress);
+                    break;
+                }
+            }
+        }
+    }
+    add(other) {
+        other.assets.forEach((asset) => this.assets.add(asset));
+        other.pools.forEach((pool) => this.pools.add(pool));
+        other.vaults.forEach((vault) => this.vaults.add(vault));
+        return this;
+    }
+    object() {
+        return {
+            assets: [...this.assets],
+            pools: [...this.pools],
+            vaults: [...this.vaults],
+        };
+    }
+}
+exports.AddressBucket = AddressBucket;
+class OracleLibs extends service_1.ServiceBaseV1 {
+    async getOracleParamsForPool(poolData, anyAssets = [], bucket = new AddressBucket()) {
+        const poolValueStatus = PoolValueStatus.fromPoolData(poolData);
+        await this.flattenOraclePool(poolValueStatus, bucket);
+        await this.flattenAssets(poolData.oracleConfig, anyAssets, bucket);
+        return this.makeOracleParams(bucket, poolData.oracleConfig);
+    }
+    async getOracleParamsForStrategyVault(vaultData, anyAssets = [], bucket = new AddressBucket()) {
+        const vaultStatus = StrategyVaultValueStatus.fromVaultData(vaultData);
+        await this.flattenOracleStrategyVault(vaultStatus, bucket);
+        await this.flattenAssets(vaultData.oracleConfig, anyAssets, bucket);
+        return this.makeOracleParams(bucket, vaultData.oracleConfig);
+    }
+    async getOracleParamsForStrategyVaultV2(vaultData, anyAssets = [], bucket = new AddressBucket()) {
+        const oracleParams = await this.getOracleParamsForStrategyVault(vaultData, anyAssets, bucket);
+        return {
+            oracleParams,
+            bucket,
+        };
+    }
+    async getOracleParamsForStrategyVaultRFQAuction(rfqAuctionData, bucket = new AddressBucket()) {
+        await this.flattenAssets(rfqAuctionData.oracleConfig, [
+            rfqAuctionData.sellAssetAddress.toString(),
+            rfqAuctionData.buyAssetAddress.toString(),
+        ], bucket);
+        return this.makeOracleParams(bucket, rfqAuctionData.oracleConfig);
+    }
+    async getOracleParamsForRFQBatch(rfqBatchData, bucket = new AddressBucket()) {
+        await this.flattenAssets(rfqBatchData.oracleConfig, [
+            rfqBatchData.asset0Address.toString(),
+            rfqBatchData.asset1Address.toString(),
+        ], bucket);
+        const oracleParams = await this.makeOracleParams(bucket, rfqBatchData.oracleConfig);
+        return {
+            oracleParams,
+            bucket,
+        };
+    }
+    async flattenOraclePool(pool, bucket = new AddressBucket()) {
+        bucket.updatePoolAssetStatus(pool.underlyingAssets);
+        const parsedVault = await this.getParsedVaults(Object.entries(pool.vaultAssets)
+            .filter(([_, position]) => position.cash > 0)
+            .map(([asset, _]) => asset), bucket);
+        Object.values(parsedVault.strategyVaults).forEach((vault) => {
+            this.flattenOracleStrategyVault(vault, bucket);
+        });
+        Object.values(parsedVault.shareVaults).forEach((vault) => {
+            this.flattenOracleShareVault(vault, bucket);
+        });
+        return bucket;
+    }
+    async flattenOracleShareVault(shareVault, bucket = new AddressBucket()) {
+        bucket.updateVaultAssetPositions(shareVault.assets);
+        bucket.updateVaultPoolPositions(shareVault.pools);
+        return bucket;
+    }
+    async flattenOracleStrategyVault(strategyVault, bucket = new AddressBucket()) {
+        bucket.updateVaultAssetPositions(strategyVault.underlyingAssets);
+        bucket.updateVaultPoolPositions(strategyVault.pools);
+        const parsedVault = await this.getParsedVaults(Object.entries(strategyVault.vaultAssets)
+            .filter(([_, position]) => position.cash > 0)
+            .map(([asset, _]) => asset), bucket);
+        Object.values(parsedVault.strategyVaults).forEach((vault) => {
+            this.flattenOracleStrategyVault(vault, bucket);
+        });
+        Object.values(parsedVault.shareVaults).forEach((vault) => {
+            this.flattenOracleShareVault(vault, bucket);
+        });
+        return bucket;
+    }
+    getUnderlyingAssetFilter(oracleConfig, noneVaultFilter = new AddressBucket()) {
+        Object.values(oracleConfig.redstoneAssetInfo).map((item) => {
+            noneVaultFilter.assets.add(item.address.toString());
+        });
+        Object.keys(oracleConfig.assetOnchainDataInfo).map((item) => {
+            noneVaultFilter.assets.add(item);
+        });
+        return noneVaultFilter;
+    }
+    async flattenAssets(oracleConfig, anyAssets = [], bucket = new AddressBucket()) {
+        const noneVaultFilter = this.getUnderlyingAssetFilter(oracleConfig);
+        const assets = new Set();
+        const anyVaults = new Set();
+        anyAssets.forEach((asset) => {
+            if (noneVaultFilter.assets.has(asset)) {
+                bucket.assets.add(asset);
+                assets.add(asset);
+            }
+            else {
+                anyVaults.add(asset);
+            }
+        });
+        const { strategyVaults, shareVaults } = await this.getParsedVaults([...anyVaults], bucket);
+        Object.values(strategyVaults).forEach((vault) => {
+            this.flattenOracleStrategyVault(vault, bucket);
+        });
+        Object.values(shareVaults).forEach((vault) => {
+            this.flattenOracleShareVault(vault, bucket);
+        });
+        return bucket;
+    }
+    async makeOracleParams(bucket, oracleConfig) {
+        const { assets, pools, vaults } = bucket.object();
+        const requestFactorialPoolsCell = pools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(pools.map((pool) => core_1.Address.parse(pool)))
+            : null;
+        const requestFactorialVaultsCell = vaults.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaults.map((vault) => core_1.Address.parse(vault)))
+            : null;
+        const requestFactorialCell = (0, core_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, 
+        // @ts-ignore
+        oracleConfig);
+        const helper = (0, redstoneHelper_1.createRedstoneHelper)("prod");
+        const payload = await helper.createPayload(result.redstoneAssetNames);
+        const requestAssetCell = redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(result.requestAssets);
+        const dataFeedIdsTupleBuilder = new core_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, core_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, core_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        return oracleParams;
+    }
+    async getParsedVaults(vaultAddresses, bucket = new AddressBucket()) {
+        const strategyVaults = {};
+        const shareVaults = {};
+        await Promise.all(vaultAddresses.map(async (vaultAddress) => {
+            if (bucket.vaults.has(vaultAddress.toString())) {
+                return;
+            }
+            const state = await this.getByContract(unknown_contract_1.UnknownContract, vaultAddress).getState();
+            if (state.state.type === "active" && state.state.data) {
+                const data = core_1.Cell.fromBoc(state.state.data)[0];
+                try {
+                    bucket.vaults.add(vaultAddress.toString());
+                    const vaultData = strategy_vault_1.StrategyVault.parseVaultData(data);
+                    await this.flattenAssets(vaultData.oracleConfig, Object.keys(vaultData.assets), bucket);
+                    const vaultStatus = StrategyVaultValueStatus.fromVaultData(vaultData);
+                    strategyVaults[vaultAddress.toString()] = vaultStatus;
+                    Object.keys(vaultStatus.pools).forEach((pool) => {
+                        bucket.pools.add(pool);
+                    });
+                }
+                catch (e) {
+                    bucket.vaults.add(vaultAddress.toString());
+                    const vaultData = share_vault_1.ShareVault.parseVaultData(data);
+                    const vaultStatus = ShareVaultValueStatus.fromVaultData(vaultData);
+                    shareVaults[vaultAddress.toString()] = vaultStatus;
+                    Object.keys(vaultStatus.pools).forEach((pool) => {
+                        bucket.pools.add(pool);
+                    });
+                }
+            }
+        }));
+        return { strategyVaults, shareVaults };
+    }
+}
+exports.OracleLibs = OracleLibs;