@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/strategy_vault/base.js

@@ -0,0 +1,1199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyVaultBase = void 0;
+exports.createQueryId = createQueryId;
+const core_1 = require("@ton/core");
+const service_1 = require("../common/service");
+const utils_1 = require("../contracts/common/utils");
+const jetton_minter_1 = require("../contracts/jetton/jetton-minter");
+const redstone_onchain_oracle_1 = require("../contracts/oracle/redstone-onchain-oracle");
+const strategy_vault_1 = require("../contracts/vault/strategy-vault");
+const jetton_wallet_1 = require("../contracts/jetton/jetton-wallet");
+const pool_1 = require("../contracts/core/pool");
+const rfq_auction_1 = require("../contracts/rfq/rfq_auction");
+const type_1 = require("../contracts/oracle/redstone-onchain-oracle/type");
+const __1 = require("..");
+const jetton_minter_2 = require("../contracts/wton/jetton-minter");
+const jetton_wallet_2 = require("../contracts/wton/jetton-wallet");
+const sha256_1 = require("@noble/hashes/sha256");
+const monitorCacheV1_1 = require("../monitorCacheV1");
+const redstoneHelper_1 = require("../utils/oracle/redstone/redstoneHelper");
+const readonlyCachedRedstone_1 = require("../utils/oracle/redstone/readonlyCachedRedstone");
+const oracle_1 = require("../oracle/oracle");
+const unknown_contract_1 = require("../common/unknown-contract");
+function jsonReplacer(_, value) {
+    if (typeof value === "bigint") {
+        return { __type: "bigint", value: value.toString() };
+    }
+    if (value instanceof core_1.Address) {
+        return { __type: "address", value: value.toString() };
+    }
+    if (value instanceof core_1.Cell) {
+        return { __type: "cell", value: value.hash().toString("hex") };
+    }
+    return value;
+}
+function createQueryId(data, timestamp = Date.now()) {
+    const dataWithTime = {
+        ...data,
+        __timestamp: timestamp, // 키 이름은 prefix로 충돌 방지
+    };
+    const json = JSON.stringify(dataWithTime, jsonReplacer);
+    const hash = (0, sha256_1.sha256)(Buffer.from(json));
+    return BigInt("0x" + Buffer.from(hash).subarray(0, 8).toString("hex"));
+}
+function assertValidSlippageRange(value, name) {
+    if (value < 0) {
+        throw new Error(`Slippage ${name} must be greater than 0.`);
+    }
+}
+function toSlippageConfig(input) {
+    if (typeof input === "number") {
+        assertValidSlippageRange(input, "slippage");
+        return {
+            min: (0, core_1.toNano)(1 - input),
+            max: (0, core_1.toNano)(1 + input),
+        };
+    }
+    else {
+        const { min, max } = input;
+        assertValidSlippageRange(min, "slippage min");
+        assertValidSlippageRange(max, "slippage max");
+        if (min >= max) {
+            throw new Error("Slippage min must be less than max.");
+        }
+        return {
+            min: (0, core_1.toNano)(min),
+            max: (0, core_1.toNano)(max),
+        };
+    }
+}
+class StrategyVaultBase extends service_1.ServiceBaseV1 {
+    async getVaultData(strategyVaultAddress) {
+        const vault = this.getVault(strategyVaultAddress);
+        return await vault.getVaultData();
+    }
+    getVault(strategyVaultAddress) {
+        return this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(strategyVaultAddress));
+    }
+    async getVaultWallet(strategyVaultAddress, accountAddress) {
+        const vault = this.getVault(strategyVaultAddress);
+        return this.getByContract(jetton_wallet_1.JettonWallet, await vault.getWalletAddress((0, utils_1.toAddress)(accountAddress)));
+    }
+    async sendSetOwner(sender, params) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetOwnerAddress(sender, (0, core_1.toNano)(0.03), {
+            newOwner: (0, utils_1.toAddress)(params.owner),
+            queryID: params.queryId,
+        });
+    }
+    async sendSetGuardianAddress(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetGuardianAddress(sender, value ?? (0, core_1.toNano)(0.1), {
+            guardianAddress: (0, utils_1.toAddress)(params.guardianAddress),
+            queryID: params.queryId,
+        });
+    }
+    async sendSetManager(sender, params) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetManagerAddress(sender, (0, core_1.toNano)(0.03), {
+            managerAddress: (0, utils_1.toAddress)(params.manager),
+            queryID: params.queryId,
+        });
+    }
+    async sendSetPrivateVault(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetPrivateVault(sender, value ?? (0, core_1.toNano)(0.02), {
+            isPrivateVault: params.isPrivateVault,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetWhitelistedMinters(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(params.strategyVaultAddress));
+        const mintersDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.Address(), strategy_vault_1.StrategyVault.Dictionary.Values.Empty());
+        for (const minter of params.whitelistedMinters) {
+            mintersDict.set((0, utils_1.toAddress)(minter), null);
+        }
+        await strategyVault.sendSetWhitelistedMinters(sender, value ?? (0, core_1.toNano)(0.03), {
+            whitelistedMinters: (0, core_1.beginCell)().storeDictDirect(mintersDict).endCell(),
+            queryID: params.queryId,
+        });
+    }
+    async sendSetMaxLeverageRatio(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(params.strategyVaultAddress));
+        await strategyVault.sendSetMaxLeverageRatio(sender, value ?? (0, core_1.toNano)(0.03), {
+            maxLeverageRatio: params.maxLeverageRatio,
+            queryID: params.queryId,
+        });
+    }
+    async sendExecuteOwnerAction(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendExecuteOwnerAction(sender, value ?? (0, core_1.toNano)(0.1), {
+            updateIndex: params.updateIndex,
+        });
+    }
+    async sendRevertOwnerAction(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendRevertOwnerAction(sender, value ?? (0, core_1.toNano)(0.1), {
+            updateIndex: params.updateIndex,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetTimelock(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetTimelock(sender, value ?? (0, core_1.toNano)(0.1), {
+            timelock: params.timelock,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetManagementFeeRecipientAddress(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetManagementFeeRecipientAddress(sender, value ?? (0, core_1.toNano)(0.1), {
+            managementFeeRecipientAddress: (0, utils_1.toAddress)(params.managementFeeRecipientAddress),
+            queryID: params.queryId,
+        });
+    }
+    async sendSetProtocolFeeRatePerYear(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetProtocolFeeRatePerYear(sender, value ?? (0, core_1.toNano)(0.1), {
+            protocolFeeRate: params.protocolFeeRatePerYear,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetProtocolFeeManagerAddress(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetProtocolFeeManagerAddress(sender, value ?? (0, core_1.toNano)(0.1), {
+            protocolFeeManagerAddress: (0, utils_1.toAddress)(params.protocolFeeManagerAddress),
+            queryID: params.queryId,
+        });
+    }
+    async sendSetFactorialPoolConfig(sender, params) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(params.strategyVaultAddress));
+        const factorialPoolConfig = (0, core_1.beginCell)()
+            .storeDictDirect(strategy_vault_1.StrategyVault.createFactorialPoolUpdateConfig(params.configs.map((config) => [
+            (0, utils_1.toAddress)(config.poolAddress),
+            (0, utils_1.toAddress)(config.assetAddress),
+            config.isSupplyable,
+            config.isBorrowable,
+        ])))
+            .endCell();
+        await strategyVault.sendSetFactorialPoolConfig(sender, (0, core_1.toNano)(0.03), {
+            updateConfig: factorialPoolConfig,
+        });
+    }
+    async sendSetAssetConfig(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(params.strategyVaultAddress));
+        await strategyVault.sendSetAssetConfig(sender, value ?? (0, core_1.toNano)(0.02), {
+            assetAddress: (0, utils_1.toAddress)(params.assetAddress),
+            isWhitelisted: params.isWhitelisted,
+            isDepositable: params.isDepositable,
+            isWithdrawable: params.isWithdrawable,
+            exposureCap: params.exposureCap,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetRFQConfig(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(params.strategyVaultAddress));
+        await strategyVault.sendSetRFQConfig(sender, value ?? (0, core_1.toNano)(0.02), {
+            rfqConfig: (0, core_1.beginCell)()
+                .storeUint(params.priceDeviationTolerance, 14)
+                .storeAddress((0, utils_1.toAddress)(params.rfqEmitterAddress))
+                .endCell(),
+            queryID: params.queryId,
+        });
+    }
+    async getOracleParamsV2(vaultAddress, vaultData, extraAssets) {
+        const vault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+        vaultData = vaultData ?? (await vault.getVaultData());
+        const oracleConfig = vaultData.oracleConfig;
+        let { assets, vaultAssets } = await this.separateAssets(Object.keys(vaultData.assets), oracleConfig);
+        vaultAssets = [
+            ...new Set([
+                ...vaultAssets,
+                ...(extraAssets ? extraAssets.vaultAssets : []),
+            ]),
+        ];
+        const vaultPositions = await this.getParsedVaults([
+            ...vaultAssets,
+            (0, utils_1.toAddress)(vaultAddress),
+        ]);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [
+            ...new Set([
+                ...assets,
+                ...exposures.assets,
+                ...(extraAssets ? extraAssets.assets : []),
+            ]),
+        ];
+        let requestFactorialPoolsCell = exposurePools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(exposurePools.map((pool) => core_1.Address.parse(pool)))
+            : null;
+        let requestFactorialVaultsCell = vaultAssets.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaultAssets.map((vault) => core_1.Address.parse(vault)))
+            : null;
+        let requestFactorialCell = (0, core_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, 
+        // @ts-ignore
+        vaultData.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 getOracleParams(vaultAddress, additionalAssets = [], allFactorialVaults = [], vaultData) {
+        const vault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+        vaultData = vaultData ?? (await vault.getVaultData());
+        const assetsInfo = await this.splitPureAndVaultAsset([
+            ...new Set(additionalAssets
+                .map((item) => (0, utils_1.toAddress)(item).toString())
+                .concat(Object.keys(vaultData.assets))),
+        ]);
+        const pools = [];
+        for (const poolAddress of Object.keys(vaultData.factorialPools)) {
+            const assets = vaultData.factorialPools[poolAddress];
+            for (const assetAddress of Object.keys(assets)) {
+                if (assets[assetAddress].supply > 0 ||
+                    assets[assetAddress].borrow > 0) {
+                    pools.push(poolAddress);
+                    break;
+                }
+            }
+        }
+        const assets = [];
+        const vaults = assetsInfo.vaultAssetAddresses;
+        for (const assetAddress of assetsInfo.pureAssetAddresses) {
+            if (allFactorialVaults.includes(assetAddress)) {
+                vaults.push(assetAddress);
+            }
+            else {
+                assets.push(assetAddress);
+            }
+        }
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, 
+        // @ts-ignore
+        vaultData.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());
+        let requestFactorialPoolsCell = pools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(pools.map((item) => core_1.Address.parse(item)))
+            : null;
+        let requestFactorialVaultsCell = vaults.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaults.map((item) => core_1.Address.parse(item)))
+            : null;
+        let requestFactorialCell = (0, core_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        const oracleParams = (0, core_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        return oracleParams;
+    }
+    async sendDepositAsset(sender, params, value) {
+        const vault = this.getVault(params.strategyVaultAddress);
+        const vaultData = await vault.getVaultData();
+        const oracle = new oracle_1.OracleLibs(this.client, this.network);
+        // need all assets in vault
+        const oraclePayload = await oracle.getOracleParamsForStrategyVault(vaultData, [params.assetAddress.toString(), ...Object.keys(vaultData.assets)]);
+        const isWTON = params.assetAddress.toString() === this.contracts.WTON ? true : false;
+        const forwardPayload = strategy_vault_1.StrategyVault.createDepositPayload(oraclePayload, isWTON ? (0, core_1.toNano)(0.02) : 0n, isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined);
+        const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+        const fee = vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Deposit] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.DepositLogic] +
+            (isWTON ? (0, core_1.toNano)(0.02) : 0n);
+        const opts = {
+            recipient: vault.address,
+            amount: params.amount,
+            response: sender.address,
+            forwardTonAmount: fee,
+            forwardPayload,
+            queryId: params.queryId ?? createQueryId({ ...params, forwardPayload }),
+        };
+        if (assetAddress.toString() === (0, utils_1.toAddress)(this.contracts.WTON).toString()) {
+            // send to vault wton wallet
+            const wtonMaster = this.getByContract(jetton_minter_2.WTONMinter, assetAddress);
+            const wtonWallet = this.getByContract(jetton_wallet_2.WTONWallet, (0, utils_1.toAddress)(await wtonMaster.getWalletAddress(vault.address)));
+            await wtonWallet.sendExternalTransfer(sender, value ?? jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, opts);
+        }
+        else {
+            // send to sender jetton wallet
+            const jettonMaster = this.getByContract(jetton_minter_1.JettonMinter, assetAddress);
+            const jettonWalletAddress = await jettonMaster.getWalletAddress(sender.address);
+            const jettonWallet = this.getByContract(jetton_wallet_1.JettonWallet, jettonWalletAddress);
+            await jettonWallet.sendTransfer(sender, value ?? fee + (0, core_1.toNano)(0.1), opts);
+        }
+        return opts;
+    }
+    async sendBurnVaultAsset(sender, params, value) {
+        const vault = this.getVault(params.strategyVaultAddress);
+        const vaultData = await vault.getVaultData();
+        const vaultAssetWalllet = await this.getVaultWallet(params.strategyVaultAddress, sender.address);
+        const oraclePayload = await this.getOracleParamsV2(params.strategyVaultAddress);
+        const withdrawAssetAddress = (0, utils_1.toAddress)(params.withdrawAssetAddress);
+        const isWTON = withdrawAssetAddress.toString() === this.contracts.WTON ? true : false;
+        const forwardPayload = strategy_vault_1.StrategyVault.createWithdrawPayload(withdrawAssetAddress, oraclePayload, isWTON ? (0, core_1.toNano)(0.02) : 0n, isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined);
+        const fee = vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Withdraw] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.WithdrawLogic] +
+            (isWTON ? (0, core_1.toNano)(0.02) : 0n) +
+            (0, core_1.toNano)(0.1);
+        const opts = {
+            amount: params.vaultShareAmountForBurn,
+            response: sender.address,
+            forwardPayload: forwardPayload,
+            queryId: createQueryId({ ...params, forwardPayload }),
+        };
+        await vaultAssetWalllet.sendBurn(sender, value ?? fee, opts);
+        return opts;
+    }
+    async createInternalDepositAsset(sender, params, value) {
+        const vault = this.getVault(params.strategyVaultAddress);
+        const vaultData = await vault.getVaultData();
+        const oracle = new oracle_1.OracleLibs(this.client, this.network);
+        // need all assets in vault
+        const oraclePayload = await oracle.getOracleParamsForStrategyVault(vaultData, [params.assetAddress.toString(), ...Object.keys(vaultData.assets)]);
+        const isWTON = params.assetAddress.toString() === this.contracts.WTON ? true : false;
+        const forwardPayload = strategy_vault_1.StrategyVault.createDepositPayload(oraclePayload, isWTON ? (0, core_1.toNano)(0.02) : 0n, isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined);
+        const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+        const fee = vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Deposit] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.DepositLogic] +
+            (isWTON ? (0, core_1.toNano)(0.02) : 0n);
+        const opts = {
+            recipient: vault.address,
+            amount: params.amount,
+            response: sender.address,
+            forwardTonAmount: fee,
+            forwardPayload,
+            queryId: params.queryId ?? createQueryId({ ...params, forwardPayload }),
+        };
+        if (assetAddress.toString() === (0, utils_1.toAddress)(this.contracts.WTON).toString()) {
+            // send to vault wton wallet
+            const wtonMaster = this.getByContract(jetton_minter_2.WTONMinter, assetAddress);
+            const wtonWallet = this.getByContract(jetton_wallet_2.WTONWallet, (0, utils_1.toAddress)(await wtonMaster.getWalletAddress(vault.address)));
+            return wtonWallet.createInternalExternalTransfer(value ?? jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, opts);
+        }
+        else {
+            // send to sender jetton wallet
+            const jettonMaster = this.getByContract(jetton_minter_1.JettonMinter, assetAddress);
+            const jettonWalletAddress = await jettonMaster.getWalletAddress(sender.address);
+            const jettonWallet = this.getByContract(jetton_wallet_1.JettonWallet, jettonWalletAddress);
+            return jettonWallet.createInternalTransfer(value ?? fee + (0, core_1.toNano)(0.1), opts);
+        }
+    }
+    async createInternalBurnVaultAsset(sender, params, value) {
+        const vault = this.getVault(params.strategyVaultAddress);
+        const vaultData = await vault.getVaultData();
+        const vaultAssetWalllet = await this.getVaultWallet(params.strategyVaultAddress, sender.address);
+        const oraclePayload = await this.getOracleParamsV2(params.strategyVaultAddress);
+        const withdrawAssetAddress = (0, utils_1.toAddress)(params.withdrawAssetAddress);
+        const isWTON = withdrawAssetAddress.toString() === this.contracts.WTON ? true : false;
+        const forwardPayload = strategy_vault_1.StrategyVault.createWithdrawPayload(withdrawAssetAddress, oraclePayload, isWTON ? (0, core_1.toNano)(0.02) : 0n, isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined);
+        const fee = vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Withdraw] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.WithdrawLogic] +
+            (isWTON ? (0, core_1.toNano)(0.02) : 0n) +
+            (0, core_1.toNano)(0.1);
+        const opts = {
+            amount: params.vaultShareAmountForBurn,
+            response: sender.address,
+            forwardPayload: forwardPayload,
+            queryId: createQueryId({ ...params, forwardPayload }),
+        };
+        return vaultAssetWalllet.createInternalBurn(value ?? fee, opts);
+    }
+    async getRFQAuctionAddress(strategyVaultAddress, index) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, strategyVaultAddress);
+        return await strategyVault.getRfqAddress(index);
+    }
+    async getRFQAuction(strategyVaultAddress, index) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, strategyVaultAddress);
+        const rfqAuction = this.getByContract(rfq_auction_1.RFQAuction, await strategyVault.getRfqAddress(index));
+        return rfqAuction;
+    }
+    async sendCreateAmountRFQ(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        const vaultData = await strategyVault.getVaultData();
+        const rfqIndex = vaultData.rfqIndex;
+        const rfqAuctionAddress = await strategyVault.getRfqAddress(rfqIndex);
+        const sellAssetAddress = (0, utils_1.toAddress)(params.sellAssetAddress);
+        const buyAssetAddress = (0, utils_1.toAddress)(params.buyAssetAddress);
+        const sellAssetRFQWallet = await this.getByContract(jetton_minter_1.JettonMinter, sellAssetAddress).getWalletAddress(rfqAuctionAddress);
+        const buyAssetRFQWallet = await this.getByContract(jetton_minter_1.JettonMinter, buyAssetAddress).getWalletAddress(rfqAuctionAddress);
+        const oracleLibs = new oracle_1.OracleLibs(this.client, this.network);
+        const { oracleParams, bucket } = await oracleLibs.getOracleParamsForStrategyVaultV2(vaultData, [
+            ...Object.keys(vaultData.assets),
+        ]);
+        const oracleCalculateGas = BigInt(bucket.assets.size + bucket.pools.size + bucket.vaults.size) *
+            (0, core_1.toNano)(0.05);
+        await strategyVault.sendCreateRFQ(sender, value ??
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+                vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.CreateRFQ] +
+                oracleCalculateGas +
+                (0, core_1.toNano)(0.1), {
+            rfqIndex: rfqIndex,
+            sellAsset: sellAssetAddress,
+            buyAsset: buyAssetAddress,
+            sellAssetAmount: params.sellAssetAmount,
+            minBuyAssetValue: params.minBuyAssetAmount,
+            maxBuyAssetValue: params.maxBuyAssetAmount,
+            sellAssetRFQWallet,
+            buyAssetRFQWallet,
+            oracleParams,
+            period: params.period,
+            allowSellerCancel: params.allowSellerCancel,
+            allowBidderCancel: params.allowBidderCancel,
+            isAmountBid: true,
+            queryID: params.queryId,
+        });
+    }
+    async sendUnwrapWTON(sender, params, value) {
+        if (!(0, utils_1.toAddress)(params.wtonAddress).equals((0, utils_1.toAddress)(this.contracts.WTON))) {
+            throw new Error("WTON address is not valid");
+        }
+        const senderAddress = (0, utils_1.toAddress)(params.senderAddress);
+        const wtonAddress = (0, utils_1.toAddress)(params.wtonAddress);
+    }
+    async sendCreateSlippageRFQ(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        const vaultData = await strategyVault.getVaultData();
+        const rfqIndex = vaultData.rfqIndex;
+        const rfqAuctionAddress = await strategyVault.getRfqAddress(rfqIndex);
+        const sellAssetAddress = (0, utils_1.toAddress)(params.sellAssetAddress);
+        const buyAssetAddress = (0, utils_1.toAddress)(params.buyAssetAddress);
+        const sellAssetRFQWallet = await this.getByContract(jetton_minter_1.JettonMinter, sellAssetAddress).getWalletAddress(rfqAuctionAddress);
+        const buyAssetRFQWallet = await this.getByContract(jetton_minter_1.JettonMinter, buyAssetAddress).getWalletAddress(rfqAuctionAddress);
+        const oracleLibs = new oracle_1.OracleLibs(this.client, this.network);
+        const { oracleParams, bucket } = await oracleLibs.getOracleParamsForStrategyVaultV2(vaultData, [
+            ...Object.keys(vaultData.assets),
+        ]);
+        const oracleCalculateGas = BigInt(bucket.assets.size + bucket.pools.size + bucket.vaults.size) *
+            (0, core_1.toNano)(0.05);
+        const slippageBoundConfig = toSlippageConfig(params.slippageBound);
+        await strategyVault.sendCreateRFQ(sender, value ??
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+                vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.CreateRFQ] +
+                oracleCalculateGas +
+                (0, core_1.toNano)(0.1), {
+            rfqIndex: rfqIndex,
+            sellAsset: sellAssetAddress,
+            buyAsset: buyAssetAddress,
+            sellAssetAmount: params.sellAssetAmount,
+            minBuyAssetValue: slippageBoundConfig.min,
+            maxBuyAssetValue: slippageBoundConfig.max,
+            sellAssetRFQWallet,
+            buyAssetRFQWallet,
+            oracleParams,
+            period: params.period,
+            allowSellerCancel: params.allowSellerCancel,
+            allowBidderCancel: params.allowBidderCancel,
+            isAmountBid: false,
+            queryID: params.queryId,
+        });
+    }
+    async sendCancelRFQ(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+        await strategyVault.sendCancelRFQ(sender, value ?? (0, core_1.toNano)(0.05), {
+            rfqIndex: params.rfqIndex,
+        });
+    }
+    async sendSupplyToFactorial(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+        const vaultData = await strategyVault.getVaultData();
+        await strategyVault.sendSupplyToFactorial(sender, value ??
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferIn] +
+                vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+                (0, core_1.toNano)(0.1), {
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            asset: (0, utils_1.toAddress)(params.assetAddress),
+            amount: params.assetAmount,
+            response: sender.address,
+        });
+    }
+    async sendBorrowFromFactorial(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+        const targetPool = this.getByContract(pool_1.Pool, params.poolAddress);
+        const oracleLibs = new oracle_1.OracleLibs(this.client, this.network);
+        const vaultData = await strategyVault.getVaultData();
+        const oraclePayload = await oracleLibs.getOracleParamsForStrategyVault(vaultData, [params.assetAddress.toString(), ...Object.keys(vaultData.assets)]);
+        const poolData = await targetPool.getPoolData();
+        const poolOraclePayload = await oracleLibs.getOracleParamsForPool(poolData, [params.assetAddress.toString()]);
+        const oracleCalculateGas = BigInt(Object.keys(vaultData.assets).length +
+            Object.keys(vaultData.factorialPools).length) * (0, core_1.toNano)(0.05);
+        await strategyVault.sendBorrowFromFactorial(sender, value ??
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferOut] +
+                vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+                oracleCalculateGas +
+                (0, core_1.toNano)(0.1), {
+            oracleParams: oraclePayload,
+            poolOracleParams: poolOraclePayload,
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            asset: (0, utils_1.toAddress)(params.assetAddress),
+            amount: params.assetAmount,
+            isShare: params.isShare,
+            response: sender.address,
+        });
+    }
+    async sendRepayToFactorial(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+        const targetPool = this.getByContract(pool_1.Pool, params.poolAddress);
+        const vaultData = await strategyVault.getVaultData();
+        const poolData = await targetPool.getPoolData();
+        const oracleLibs = new oracle_1.OracleLibs(this.client, this.network);
+        const poolOraclePayload = await oracleLibs.getOracleParamsForPool(poolData, [params.assetAddress.toString()]);
+        await strategyVault.sendRepayToFactorial(sender, value ??
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferIn] +
+                vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+                (0, core_1.toNano)(0.1), {
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            asset: (0, utils_1.toAddress)(params.assetAddress),
+            amount: params.assetAmount,
+            response: sender.address,
+        });
+    }
+    async sendWithdrawFromFactorial(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+        const pool = this.getByContract(pool_1.Pool, params.poolAddress);
+        const oracleLibs = new oracle_1.OracleLibs(this.client, this.network);
+        const vaultData = await strategyVault.getVaultData();
+        const poolData = await pool.getPoolData();
+        const poolOraclePayload = await oracleLibs.getOracleParamsForPool(poolData, [params.assetAddress.toString()]);
+        await strategyVault.sendWithdrawFromFactorial(sender, value ??
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferOut] +
+                vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+                (0, core_1.toNano)(0.1), {
+            oracleParams: poolOraclePayload,
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            asset: (0, utils_1.toAddress)(params.assetAddress),
+            amount: params.assetAmount,
+            isShare: params.isShare,
+            response: sender.address,
+        });
+    }
+    async sendLiquidateToFactorial(sender, params, value) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+        const vaultData = await strategyVault.getVaultData();
+        const oraclePayload = await this.getOracleParamsV2(params.strategyVaultAddress);
+        const oracleCalculateGas = BigInt(Object.keys(vaultData.assets).length +
+            Object.keys(vaultData.factorialPools).length) * (0, core_1.toNano)(0.05);
+        await strategyVault.sendLiquidateToFactorial(sender, value ??
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialLiquidate] +
+                vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+                oracleCalculateGas +
+                (0, core_1.toNano)(0.1), {
+            oracleParams: oraclePayload,
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            borrower: (0, utils_1.toAddress)(params.borrowerAddress),
+            repayAsset: (0, utils_1.toAddress)(params.repayAssetAddress),
+            seizeAsset: (0, utils_1.toAddress)(params.seizeAssetAddress),
+            repayAmount: params.repayAmount,
+            response: sender.address,
+        });
+    }
+    async splitPureAndVaultAsset(addresses) {
+        const pureAssetAddresses = [];
+        const vaultAssetAddresses = [];
+        await Promise.all(addresses.map(utils_1.toAddress).map(async (assetAddress) => {
+            const address = assetAddress.toString();
+            if (await this.isVaultAsset(address)) {
+                vaultAssetAddresses.push(address);
+            }
+            else {
+                pureAssetAddresses.push(address);
+            }
+        }));
+        return {
+            vaultAssetAddresses,
+            pureAssetAddresses,
+        };
+    }
+    async isVaultAsset(address) {
+        try {
+            await this.client.runMethod((0, utils_1.toAddress)(address), "get_jetton_data"); // TODO: Network Error?
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
+    async getAssetPrices(strategyVaultAddress, vaultData) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, strategyVaultAddress);
+        vaultData = vaultData ?? (await strategyVault.getVaultData());
+        const monitor = new monitorCacheV1_1.MonitorCacheV1(this.client, this.network);
+        const allUnderlyingAssetAddresses = [
+            ...new Set(Object.keys(vaultData.assets)),
+        ];
+        const { pureAssetAddresses, vaultAssetAddresses } = await this.splitPureAndVaultAsset(allUnderlyingAssetAddresses);
+        const assetPrices = await monitor.getPricesNew(pureAssetAddresses, vaultData.oracleConfig);
+        await Promise.all(vaultAssetAddresses.map(async (vaultAssetAddress) => {
+            assetPrices[vaultAssetAddress] = {
+                type: type_1.AssetType.VaultAsset,
+                timestamp: Date.now(),
+                price: await this.getPrice(vaultAssetAddress),
+            };
+        }));
+        return assetPrices;
+    }
+    async getPrice(strategyVaultAddress, vaultData) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, strategyVaultAddress);
+        vaultData = vaultData ?? (await strategyVault.getVaultData());
+        const { totalSupply } = vaultData;
+        const vaultTokenPrice = totalSupply === 0n
+            ? 0n
+            : (await this.getTotalValue(strategyVaultAddress, vaultData)) /
+                totalSupply;
+        return vaultTokenPrice;
+    }
+    async getPriceV2(strategyVaultAddress, vaultData) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, strategyVaultAddress);
+        vaultData = vaultData ?? (await strategyVault.getVaultData());
+        const vault = this.open(strategy_vault_1.StrategyVault.createFromAddress((0, utils_1.toAddress)(strategyVaultAddress)));
+        const _assets = Object.keys(vaultData.assets);
+        const oracleConfig = vaultData.oracleConfig;
+        let { assets, vaultAssets } = await this.separateAssets(_assets, oracleConfig);
+        const vaultPositions = await this.getParsedVaults([
+            ...vaultAssets,
+            (0, utils_1.toAddress)(strategyVaultAddress),
+        ]);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, oracleConfig);
+        const onchainData2 = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        const exposurePoolsData = {};
+        for (let exposurePool of exposurePools) {
+            const pool = this.open(pool_1.Pool.createFromAddress((0, utils_1.toAddress)(exposurePool)));
+            const poolData = await pool.getPoolData();
+            exposurePoolsData[exposurePool] = poolData;
+        }
+        const vaultPrices = await this.calculateVaultPrices(prices, exposurePoolsData, vaultPositions);
+        return vaultPrices[(0, utils_1.toAddress)(strategyVaultAddress).toString()] ?? 0n;
+    }
+    async getAssetPricesV2(vaultAddress) {
+        const vault = this.open(strategy_vault_1.StrategyVault.createFromAddress((0, utils_1.toAddress)(vaultAddress)));
+        const vaultData = await vault.getVaultData();
+        const _assets = Object.keys(vaultData.assets);
+        const oracleConfig = vaultData.oracleConfig;
+        let { assets, vaultAssets } = await this.separateAssets(_assets, oracleConfig);
+        const vaultPositions = await this.getParsedVaults([...vaultAssets]);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, oracleConfig);
+        const onchainData2 = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        const exposurePoolsData = {};
+        for (let exposurePool of exposurePools) {
+            const pool = this.open(pool_1.Pool.createFromAddress((0, utils_1.toAddress)(exposurePool)));
+            const poolData = await pool.getPoolData();
+            exposurePoolsData[exposurePool] = poolData;
+        }
+        const vaultPrices = await this.calculateVaultPrices(prices, exposurePoolsData, vaultPositions);
+        return {
+            ...prices,
+            ...vaultPrices,
+        };
+    }
+    async calculateVaultPrices(price, poolInfos, vaults) {
+        const vaultPrices = {};
+        while (Object.keys(vaults).length > 0) {
+            const vaultAddresses = Object.keys(vaults);
+            for (let vaultAddress of vaultAddresses) {
+                try {
+                    const amountVaultPosition = shareToAmount(vaults[vaultAddress], poolInfos);
+                    let totalValue = 0n;
+                    for (const assetAddress of Object.keys(amountVaultPosition.assetAmounts)) {
+                        const assetPrice = price[assetAddress]?.price || vaultPrices[assetAddress].price;
+                        if (!assetPrice)
+                            throw "error";
+                        totalValue +=
+                            amountVaultPosition.assetAmounts[assetAddress] * assetPrice;
+                    }
+                    if (totalValue === 0n || amountVaultPosition.totalSupply === 0n) {
+                        vaultPrices[vaultAddress] = {
+                            type: 10,
+                            price: 0n,
+                            additionalData: {
+                                decomposed: {},
+                                totalSupply: 0n,
+                            },
+                        };
+                    }
+                    else {
+                        vaultPrices[vaultAddress] = {
+                            type: 10,
+                            price: totalValue / amountVaultPosition.totalSupply,
+                            additionalData: amountVaultPosition.additionalData,
+                        };
+                    }
+                    delete vaults[vaultAddress];
+                }
+                catch (e) { }
+            }
+        }
+        return vaultPrices;
+    }
+    async getParsedVaults(vaultAddresses) {
+        const decomposedVault = {};
+        for (let vaultAddress of vaultAddresses) {
+            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 {
+                    const vaultData = strategy_vault_1.StrategyVault.parseVaultData(data);
+                    const vaultDataa = {
+                        totalSupply: vaultData.totalSupply,
+                        assets: Object.keys(vaultData.assets).reduce((acc, asset) => {
+                            acc[asset] = vaultData.assets[asset].cash;
+                            return acc;
+                        }, {}),
+                        poolPositions: Object.keys(vaultData.factorialPools).reduce((acc, pool) => {
+                            acc[pool] = Object.keys(vaultData.factorialPools[pool]).reduce((acc, asset) => {
+                                acc[asset] = {
+                                    supply: vaultData.factorialPools[pool][asset].supply,
+                                    borrow: vaultData.factorialPools[pool][asset].borrow,
+                                };
+                                return acc;
+                            }, {});
+                            return acc;
+                        }, {}),
+                    };
+                    decomposedVault[vaultAddress.toString()] = vaultDataa;
+                }
+                catch (e) {
+                    const vaultData = __1.ShareVault.parseVaultData(data);
+                    const vaultDataa = {
+                        totalSupply: vaultData.totalSupply,
+                        assets: {
+                            [vaultData.asset.toString()]: vaultData.cash,
+                        },
+                        poolPositions: Object.values(vaultData.whitelistedPools).reduce((acc, pool) => {
+                            acc[pool.address.toString()] = {
+                                [vaultData.asset.toString()]: {
+                                    supply: pool.supply,
+                                    borrow: 0n,
+                                },
+                            };
+                            return acc;
+                        }, {}),
+                    };
+                    decomposedVault[vaultAddress.toString()] = vaultDataa;
+                }
+            }
+        }
+        return decomposedVault;
+    }
+    async getExposures(vaults) {
+        const assets = new Set();
+        const pools = new Set();
+        for (let vault of Object.values(vaults)) {
+            const _assets = vault.assets;
+            for (let asset of Object.keys(_assets)) {
+                const position = vault.assets[asset];
+                if (position > 0n) {
+                    assets.add(asset);
+                }
+            }
+            for (let pool of Object.keys(vault.poolPositions)) {
+                const _assets = vault.poolPositions[pool];
+                for (let asset of Object.keys(_assets)) {
+                    const position = vault.poolPositions[pool][asset];
+                    if (position.supply > 0n || position.borrow > 0n) {
+                        pools.add(pool);
+                        assets.add(asset);
+                    }
+                }
+            }
+        }
+        const result = { pools: [...pools], assets: [...assets] };
+        return result;
+    }
+    calculatePrices(_prices, oracleData) {
+        const prices = { ..._prices };
+        let oracles = Object.entries(oracleData);
+        while (oracles.length !== 0) {
+            const restOracles = [];
+            for (let [asset, onchainDataInfo] of oracles) {
+                if (!onchainDataInfo)
+                    throw "not found onchain data info1";
+                if (onchainDataInfo.assetType === type_1.AssetType.SingleAsset) {
+                    if (prices[onchainDataInfo.underlyingAddress.toString()]) {
+                        const underlyingPriceInfo = prices[onchainDataInfo.underlyingAddress.toString()];
+                        prices[asset.toString()] = {
+                            type: type_1.AssetType.SingleAsset,
+                            price: (underlyingPriceInfo.price *
+                                onchainDataInfo.underlyingReserve) /
+                                onchainDataInfo.totalSupply,
+                        };
+                    }
+                    else {
+                        restOracles.push([asset, onchainDataInfo]);
+                    }
+                }
+                else if (onchainDataInfo.assetType === type_1.AssetType.MultiAsset) {
+                    if (prices[onchainDataInfo.underlying0Address.toString()] &&
+                        prices[onchainDataInfo.underlying1Address.toString()]) {
+                        const underlying0PriceInfo = prices[onchainDataInfo.underlying0Address.toString()];
+                        const underlying1PriceInfo = prices[onchainDataInfo.underlying1Address.toString()];
+                        const price0 = (underlying0PriceInfo.price *
+                            onchainDataInfo.underlying0Reserve) /
+                            onchainDataInfo.totalSupply;
+                        const price1 = (underlying1PriceInfo.price *
+                            onchainDataInfo.underlying1Reserve) /
+                            onchainDataInfo.totalSupply;
+                        prices[asset.toString()] = {
+                            type: type_1.AssetType.MultiAsset,
+                            price: price0 + price1,
+                        };
+                    }
+                    else {
+                        restOracles.push([asset, onchainDataInfo]);
+                    }
+                }
+                else if (onchainDataInfo.assetType === type_1.AssetType.Native) {
+                }
+                else {
+                    throw `invalid asset type ${onchainDataInfo.assetType}`;
+                }
+            }
+            oracles = restOracles;
+        }
+        return prices;
+    }
+    async updateOnchainData(onchainDataInfo) {
+        for (let [asset, data] of Object.entries(onchainDataInfo)) {
+            if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.tonstakers &&
+                "underlyingAddress" in data) {
+                const result = await this.client
+                    .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                    .get("get_pool_state", []);
+                result.stack.readBigNumber();
+                data.underlyingReserve = result.stack.readBigNumber();
+                data.totalSupply = result.stack.readBigNumber();
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.dedust &&
+                data.assetType === type_1.AssetType.MultiAsset) {
+                if (this.network === "mainnet") {
+                    const results = await Promise.all([
+                        this.client
+                            .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                            .get("get_reserves", []),
+                        this.client
+                            .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                            .get("get_jetton_data", []),
+                    ]);
+                    data.underlying0Reserve = results[0].stack.readBigNumber();
+                    data.underlying1Reserve = results[0].stack.readBigNumber();
+                    data.totalSupply = results[1].stack.readBigNumber();
+                }
+                else {
+                    const result = await this.client
+                        .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_pool_state", []);
+                    result.stack.readBigNumber();
+                    data.underlying0Reserve = result.stack.readBigNumber();
+                    data.underlying1Reserve = result.stack.readBigNumber();
+                    data.totalSupply = result.stack.readBigNumber();
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.stonfi &&
+                data.assetType === type_1.AssetType.MultiAsset) {
+                if (this.network === "mainnet") {
+                    const result = await this.client
+                        .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_pool_data", []);
+                    result.stack.readNumber();
+                    result.stack.readAddress();
+                    data.totalSupply = result.stack.readBigNumber();
+                    data.underlying0Reserve = result.stack.readBigNumber();
+                    data.underlying1Reserve = result.stack.readBigNumber();
+                }
+                else {
+                    const result = await this.client
+                        .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_pool_state", []);
+                    result.stack.readBigNumber();
+                    data.underlying0Reserve = result.stack.readBigNumber();
+                    data.underlying1Reserve = result.stack.readBigNumber();
+                    data.totalSupply = result.stack.readBigNumber();
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.storm &&
+                data.assetType === type_1.AssetType.SingleAsset) {
+                if (this.network === "mainnet") {
+                    const results = await this.client
+                        .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                        .get("get_vault_data", []);
+                    const jettonWalletAddress = results.stack.readAddress();
+                    const lpRate = results.stack.readBigNumber();
+                    const lpTotalSupply = results.stack.readBigNumber();
+                    const freeBalance = results.stack.readBigNumber();
+                    const lockedBalance = results.stack.readBigNumber();
+                    const withdrawLockedBalance = results.stack.readBigNumber();
+                    const stakersBalance = results.stack.readBigNumber();
+                    const executorsBalance = results.stack.readBigNumber();
+                    data.underlyingReserve = lpRate;
+                    if (!data.totalSupply) {
+                        data.totalSupply = BigInt(1e9);
+                    }
+                }
+                else {
+                }
+            }
+            else if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.tradoor &&
+                data.assetType === type_1.AssetType.SingleAsset) {
+                if (this.network === "mainnet") {
+                    const results = await this.client
+                        .provider(core_1.Address.parse(data.sourceAddress.toString()))
+                        .get("tlpPrice", []);
+                    const lpRate = results.stack.readBigNumber();
+                    data.underlyingReserve = lpRate;
+                    if (!data.totalSupply) {
+                        data.totalSupply = BigInt(18e9);
+                    }
+                }
+            }
+        }
+        return onchainDataInfo;
+    }
+    async getRedstonePrices(assets, oracleConfig) {
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+        const redstonePrices = await readonlyCachedRedstone_1.ReadonlyCachedRedstone.getPrices(result.redstoneAssetNames);
+        const prices = {};
+        const onchainData = {};
+        redstonePrices.forEach((item) => {
+            try {
+                const rainfo = oracleConfig.redstoneAssetInfo[item.feedId.toString()];
+                if (rainfo.assetType === 0) {
+                    prices[rainfo.address.toString()] = {
+                        type: type_1.AssetType.Native,
+                        timestamp: item.timestamp,
+                        price: (item.price * BigInt(1e8)) / rainfo.precision,
+                    };
+                }
+                else if (rainfo.assetType === 1) {
+                    onchainData[rainfo.address.toString()] = {
+                        assetType: type_1.AssetType.SingleAsset,
+                        underlyingAddress: rainfo.underlyingAddress,
+                        underlyingReserve: item.price,
+                        totalSupply: rainfo.precision,
+                    };
+                }
+            }
+            catch (e) { }
+        });
+        return { redstonePrices: prices, onchainData };
+    }
+    async separateAssets(_assets, oracleConfig) {
+        const noVaultAssets = [
+            ...Object.values(oracleConfig.redstoneAssetInfo).map((item) => item.address.toString()),
+            ...Object.keys(oracleConfig.assetOnchainDataInfo).map((item) => item),
+        ];
+        const assets = [];
+        const vaultAssets = [];
+        for (const asset of _assets) {
+            if (noVaultAssets.includes(asset.toString())) {
+                assets.push(asset);
+            }
+            else {
+                vaultAssets.push(asset);
+            }
+        }
+        return {
+            assets,
+            vaultAssets,
+        };
+    }
+    async sendCollectProtocolFee(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendClaimProtocolFee(sender, value ?? (0, core_1.toNano)(0.1), {
+            receiverAddress: (0, utils_1.toAddress)(params.assetAddress),
+            queryID: params.queryId,
+        });
+    }
+    async sendClaimManagementFee(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendClaimManagementFee(sender, value ?? (0, core_1.toNano)(0.1), {
+            receiverAddress: (0, utils_1.toAddress)(params.receiverAddress),
+            queryID: params.queryId,
+        });
+    }
+    async sendSetManagementFeeRatePerYear(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetManagementFeeRatePerYear(sender, value ?? (0, core_1.toNano)(0.1), {
+            managementFeeRate: params.managementFeeRatePerYear,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetDepositCloseTimestamp(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetDepositCloseTimestamp(sender, value ?? (0, core_1.toNano)(0.1), {
+            depositCloseTimestamp: params.depositCloseTimestamp,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetWithdrawOpenTimestamp(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetWithdrawOpenTimestamp(sender, value ?? (0, core_1.toNano)(0.1), {
+            withdrawOpenTimestamp: params.withdrawOpenTimestamp,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetGasConfig(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetGasConfig(sender, value ?? (0, core_1.toNano)(0.1), {
+            gasConfig: params.gasConfig,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetOracleConfig(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetOracleConfig(sender, value ?? (0, core_1.toNano)(0.1), {
+            oracleConfig: params.oracleConfig,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetWalletCode(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetWalletCode(sender, value ?? (0, core_1.toNano)(0.1), {
+            walletCode: params.walletCode,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetDataAggregatorCode(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetDataAggregatorCode(sender, value ?? (0, core_1.toNano)(0.1), {
+            dataAggregatorCode: params.dataAggregatorCode,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetRFQCode(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetRFQCode(sender, value ?? (0, core_1.toNano)(0.1), {
+            rfqCode: params.rfqCode,
+            queryID: params.queryId,
+        });
+    }
+    async sendSetContent(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendSetContent(sender, value ?? (0, core_1.toNano)(0.1), {
+            content: params.content,
+            queryID: params.queryId,
+        });
+    }
+    async sendUpgradeCode(sender, params, value) {
+        const strategyVault = this.getVault(params.strategyVaultAddress);
+        await strategyVault.sendUpgradeCode(sender, value ?? (0, core_1.toNano)(0.1), {
+            newCode: params.newCode,
+            queryID: params.queryId,
+        });
+    }
+    async getTotalValue(strategyVaultAddress, vaultData) {
+        const strategyVault = this.getByContract(strategy_vault_1.StrategyVault, strategyVaultAddress);
+        vaultData = vaultData ?? (await strategyVault.getVaultData());
+        const monitor = new monitorCacheV1_1.MonitorCacheV1(this.client, this.network);
+        const allRelatedUnderlyingAssetAddresses = [
+            ...new Set(Object.values(vaultData.factorialPools).flatMap((pool) => Object.keys(pool))),
+        ];
+        let assetInfo = await this.splitPureAndVaultAsset(allRelatedUnderlyingAssetAddresses);
+        const assetPrices = await monitor.getPricesNew(assetInfo.pureAssetAddresses, vaultData.oracleConfig);
+        assetInfo = await this.splitPureAndVaultAsset(Object.keys(vaultData.assets));
+        let valueSum = 0n;
+        for (const assetAddress of assetInfo.pureAssetAddresses) {
+            valueSum +=
+                vaultData.assets[assetAddress].cash * assetPrices[assetAddress].price;
+        }
+        for (const [poolAddress, vaultPoolData] of Object.entries(vaultData.factorialPools)) {
+            const pool = this.getByContract(pool_1.Pool, poolAddress);
+            const poolData = pool_1.Pool.simulateAccrueInterest(await pool.getPoolData());
+            for (const [assetAddress, poolShares] of Object.entries(vaultPoolData)) {
+                const supplyAmount = poolShares.supply > 0n
+                    ? (poolShares.supply *
+                        poolData.assets[assetAddress].totalSupplyAmount) /
+                        poolData.assets[assetAddress].totalSupplyShare
+                    : 0n;
+                const borrowAmount = poolShares.borrow > 0n
+                    ? (poolShares.borrow *
+                        poolData.assets[assetAddress].totalBorrowAmount) /
+                        poolData.assets[assetAddress].totalBorrowShare
+                    : 0n;
+                valueSum +=
+                    (supplyAmount - borrowAmount) * assetPrices[assetAddress].price;
+            }
+        }
+        return valueSum;
+    }
+}
+exports.StrategyVaultBase = StrategyVaultBase;
+const shareToAmount = (vault, poolInfos) => {
+    const amountVaultPosition = {};
+    const assetAmount = {};
+    const decomposed = {};
+    for (let asset of Object.keys(vault.assets)) {
+        assetAmount[asset] = vault.assets[asset];
+        decomposed[asset] = {
+            supply: vault.assets[asset],
+            borrow: 0n,
+        };
+    }
+    for (let pool of Object.keys(vault.poolPositions)) {
+        const poolInfo = poolInfos[pool];
+        const assets = vault.poolPositions[pool];
+        for (let asset of Object.keys(assets)) {
+            const position = assets[asset];
+            let supply = 0n;
+            let borrow = 0n;
+            if (position.supply !== 0n &&
+                poolInfo.assets[asset].totalSupplyShare !== 0n) {
+                supply =
+                    (position.supply * poolInfo.assets[asset].totalSupplyAmount) /
+                        poolInfo.assets[asset].totalSupplyShare;
+            }
+            if (position.borrow !== 0n &&
+                poolInfo.assets[asset].totalBorrowShare !== 0n) {
+                borrow =
+                    (position.borrow * poolInfo.assets[asset].totalBorrowAmount) /
+                        poolInfo.assets[asset].totalBorrowShare;
+            }
+            amountVaultPosition[pool] ??= {};
+            amountVaultPosition[pool][asset] ??= {
+                supply,
+                borrow,
+            };
+            assetAmount[asset] ??= 0n;
+            assetAmount[asset] += supply - borrow;
+            decomposed[asset].supply += supply;
+            decomposed[asset].borrow += borrow;
+        }
+    }
+    return {
+        assets: vault.assets,
+        poolPositions: amountVaultPosition,
+        assetAmounts: assetAmount,
+        totalSupply: vault.totalSupply,
+        additionalData: {
+            decomposed: decomposed,
+            totalSupply: vault.totalSupply,
+        },
+    };
+};