@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/pool.js

@@ -0,0 +1,2298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolV1 = void 0;
+const ton_1 = require("@ton/ton");
+const pool_1 = require("./contracts/core/pool");
+const type_1 = require("./contracts/oracle/redstone-onchain-oracle/type");
+const account_1 = require("./contracts/core/account");
+const jetton_minter_1 = require("./contracts/jetton/jetton-minter");
+const jetton_wallet_1 = require("./contracts/jetton/jetton-wallet");
+const tracker_1 = require("./utils/tracker");
+const query_id_generactor_1 = require("./utils/tracker/query-id-generactor");
+const parser_1 = require("./utils/parser");
+const jetton_wallet_2 = require("./contracts/wton/jetton-wallet");
+const redstone_onchain_oracle_1 = require("./contracts/oracle/redstone-onchain-oracle");
+const redstoneHelper_1 = require("./utils/oracle/redstone/redstoneHelper");
+const jetton_minter_2 = require("./contracts/wton/jetton-minter");
+const strategy_vault_1 = require("./contracts/vault/strategy-vault");
+const share_vault_1 = require("./contracts/vault/share-vault");
+const service_1 = require("./common/service");
+const readonlyCachedRedstone_1 = require("./utils/oracle/redstone/readonlyCachedRedstone");
+const unknown_contract_1 = require("./common/unknown-contract");
+const utils_1 = require("./utils/utils");
+const risk_calculator_1 = require("./utils/risk_calculator/risk_calculator");
+const toAddress = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value;
+    }
+    return ton_1.Address.parse(value);
+};
+const toString = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value.toString();
+    }
+    return value;
+};
+class PoolV1 extends service_1.ServiceBaseV1 {
+    // user -> asset -> wallet
+    walletAddresses = {};
+    // user -> pool -> account
+    accountAddresses = {};
+    async getJettonWalletAddress(owner, jetton) {
+        this.walletAddresses[owner] ||= {};
+        if (!this.walletAddresses[owner][jetton]) {
+            const jettonMinter = this.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(jetton)));
+            this.walletAddresses[owner][jetton] = await jettonMinter.getWalletAddress(toAddress(owner));
+        }
+        return this.walletAddresses[owner][jetton];
+    }
+    async getAccountAddress(owner, pool) {
+        this.accountAddresses[owner] ||= {};
+        if (!this.accountAddresses[owner][pool]) {
+            const poolContract = this.open(pool_1.Pool.createFromAddress(toAddress(pool)));
+            this.accountAddresses[owner][pool] = await poolContract.getAccountAddress(toAddress(owner));
+        }
+        return this.accountAddresses[owner][pool];
+    }
+    async findAndCallback(target, step, createdLt, callbackFn) {
+        const matchedTx = await (0, tracker_1.findTx)(this.client, toAddress(target), createdLt.toString(), step);
+        step.matchedTx = matchedTx;
+        if (matchedTx.inMessage?.body) {
+            const parsed = (0, parser_1.parseActionNotification)(matchedTx.inMessage.body);
+            if (parsed) {
+                step.actionNotificationResult = parsed;
+            }
+        }
+        if (callbackFn)
+            callbackFn(step);
+        return matchedTx;
+    }
+    async supply(sender, params) {
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = await pool.getPoolData();
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Supply, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        if (toString(params.asset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            await poolWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                recipient: toAddress(params.pool),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+                forwardPayload: pool_1.Pool.createSupplyPayload({
+                    asset: toAddress(params.asset),
+                    recipient: toAddress(params.recipient),
+                    response: toAddress(params.response),
+                    jettonForwardTonAmount,
+                    jettonForwardPayload,
+                }),
+            });
+        }
+        else {
+            const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.asset));
+            const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                recipient: toAddress(params.pool),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+                forwardPayload: pool_1.Pool.createSupplyPayload({
+                    asset: toAddress(params.asset),
+                    recipient: toAddress(params.recipient),
+                    response: toAddress(params.response),
+                    jettonForwardTonAmount,
+                    jettonForwardPayload,
+                }),
+            });
+        }
+    }
+    async supplyAndWaitTx(sender, params, callbackFn) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.asset));
+        const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const recipientAccountAddress = await this.getAccountAddress(toString(params.recipient), toString(params.pool));
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const poolData = await pool.getPoolData();
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Supply, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        const opts = {
+            recipient: toAddress(params.pool),
+            response: toAddress(params.response),
+            amount: params.amount,
+            forwardTonAmount: gas,
+            forwardPayload: pool_1.Pool.createSupplyPayload({
+                asset: toAddress(params.asset),
+                recipient: toAddress(params.recipient),
+                response: toAddress(params.response),
+                jettonForwardTonAmount,
+                jettonForwardPayload,
+            }),
+        };
+        const body = senderJettonWallet.createTransferBody(opts);
+        const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(params.sender), body);
+        const steps = [];
+        if (toString(params.asset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            await poolWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                queryId: queryId,
+                ...opts,
+            });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Sending the tx",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+                {
+                    queryId,
+                    description: "Supplying jetton to the pool",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                queryId: queryId,
+                ...opts,
+            });
+            steps.push({
+                queryId,
+                description: "Sending the tx",
+                from: toAddress(params.sender),
+                to: senderJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            });
+            steps.push({
+                queryId,
+                description: "Supplying jetton to the pool",
+                from: senderJettonWalletAddress,
+                to: poolJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            });
+        }
+        steps.push(...[
+            {
+                queryId,
+                description: "Pool notification",
+                from: poolJettonWalletAddress,
+                to: pool.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: pool.address,
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: pool.address,
+                to: recipientAccountAddress,
+                opcode: pool_1.Pool.Op.UpdateAccountStatus,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(poolJettonWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(pool.address, steps[2], matchedTx1.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(toAddress(params.sender), steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(recipientAccountAddress, steps[4], matchedTx2.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-supply",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async findTx(action, callbackFn) {
+        if (action.type == "pool-supply") {
+            return this.findSupplyTx(BigInt(action.queryId), action.params, callbackFn);
+        }
+        else if (action.type == "pool-withdraw") {
+            return this.findWithdrawTx(BigInt(action.queryId), action.params, callbackFn);
+        }
+        else if (action.type == "pool-borrow") {
+            return this.findBorrowTx(BigInt(action.queryId), action.params, callbackFn);
+        }
+        else if (action.type == "pool-repay") {
+            return this.findRepayTx(BigInt(action.queryId), action.params, callbackFn);
+        }
+    }
+    async findSupplyTx(queryId, params, callbackFn) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.asset));
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const recipientAccountAddress = await this.getAccountAddress(toString(params.recipient), toString(params.pool));
+        const steps = [];
+        if (toString(params.asset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Sending the tx",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+                {
+                    queryId,
+                    description: "Supplying jetton to the pool",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            steps.push({
+                queryId,
+                description: "Sending the tx",
+                from: toAddress(params.sender),
+                to: senderJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            });
+            steps.push({
+                queryId,
+                description: "Supplying jetton to the pool",
+                from: senderJettonWalletAddress,
+                to: poolJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            });
+        }
+        steps.push(...[
+            {
+                queryId,
+                description: "Pool notification",
+                from: poolJettonWalletAddress,
+                to: pool.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: pool.address,
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: pool.address,
+                to: recipientAccountAddress,
+                opcode: pool_1.Pool.Op.UpdateAccountStatus,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(poolJettonWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(pool.address, steps[2], matchedTx1.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(toAddress(params.sender), steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(recipientAccountAddress, steps[4], matchedTx3.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-supply",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async withdraw(sender, params) {
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const senderAccount = this.open(account_1.Account.createFromAddress(senderAccountAddress));
+        const accountData = await senderAccount.getAccountData();
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        let oracleParams = null;
+        if (account_1.Account.haveBorrow(accountData)) {
+            const assets = [...new Set([...account_1.Account.haveAssets(accountData)])];
+            const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+            result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+            const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+            oracleParams = (0, ton_1.beginCell)()
+                .storeRef(feedIdCell)
+                .storeRef(payload)
+                .storeRef(requestAssetCell)
+                .endCell();
+        }
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Withdraw, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, !!oracleParams, poolData.minimumGasFee);
+        await pool.sendWithdraw(sender, gas, {
+            asset: toAddress(params.asset),
+            isShare: params.isShare,
+            amount: params.amount,
+            recipient: toAddress(params.recipient),
+            response: toAddress(params.response),
+            jettonForwardTonAmount,
+            jettonForwardPayload,
+            oracleParams: oracleParams,
+        });
+    }
+    async withdrawAndWaitTx(sender, params, callbackFn) {
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const senderAccount = this.open(account_1.Account.createFromAddress(senderAccountAddress));
+        const accountData = await senderAccount.getAccountData();
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const recipeintJettonWalletAddress = await this.getJettonWalletAddress(toString(params.recipient), toString(params.asset));
+        let oracleParams = null;
+        if (account_1.Account.haveBorrow(accountData)) {
+            const userAssets = [
+                ...new Set([
+                    ...account_1.Account.haveAssets(accountData),
+                    toString(params.asset),
+                ]),
+            ];
+            let { assets, vaultAssets } = await this.separateAssets(userAssets, poolData.oracleConfig);
+            const vaultPositions = await this.getParsedVaults(vaultAssets);
+            const exposures = await this.getExposures(vaultPositions);
+            const exposurePools = exposures.pools;
+            assets = [...new Set([...assets, ...exposures.assets])];
+            const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+            result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+            const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+            let requestFactorialPoolsCell = exposurePools.length > 0
+                ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(exposurePools.map((pool) => ton_1.Address.parse(pool)))
+                : null;
+            let requestFactorialVaultsCell = vaultAssets.length > 0
+                ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaultAssets.map((vault) => ton_1.Address.parse(vault)))
+                : null;
+            let requestFactorialCell = (0, ton_1.beginCell)()
+                .storeMaybeRef(requestFactorialPoolsCell)
+                .storeMaybeRef(requestFactorialVaultsCell)
+                .endCell();
+            oracleParams = (0, ton_1.beginCell)()
+                .storeRef(feedIdCell)
+                .storeRef(payload)
+                .storeRef(requestAssetCell)
+                .storeRef(requestFactorialCell)
+                .endCell();
+        }
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const opts = {
+            asset: toAddress(params.asset),
+            isShare: params.isShare,
+            amount: params.amount,
+            recipient: toAddress(params.recipient),
+            response: toAddress(params.response),
+            jettonForwardTonAmount,
+            jettonForwardPayload,
+            oracleParams: oracleParams,
+        };
+        const body = pool_1.Pool.createWithdrawMsgBody(opts);
+        const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(params.sender), body);
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Withdraw, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, !!oracleParams, poolData.minimumGasFee);
+        await pool.sendWithdraw(sender, gas + (0, ton_1.toNano)(0.4), {
+            ...opts,
+            queryId,
+        });
+        const steps = [
+            {
+                queryId,
+                description: "Sending the tx",
+                from: toAddress(params.sender),
+                to: toAddress(params.pool),
+                opcode: pool_1.Pool.Op.Withdraw,
+            },
+            {
+                queryId,
+                description: "Calculating oracle data",
+                from: toAddress(poolData.oracle ? poolData.oracle : params.pool),
+                to: toAddress(params.pool),
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: toAddress(params.pool),
+                to: senderAccountAddress,
+                opcode: pool_1.Pool.Op.ExecuteAction,
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: toAddress(params.pool),
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                queryId,
+                description: "Withdrawing jetton from the pool",
+                from: poolJettonWalletAddress,
+                to: recipeintJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ];
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            if (poolData.oracle && oracleParams) {
+                const matchedTx1 = await this.findAndCallback(toAddress(params.pool), steps[1], matchedTx0.lt.toString(), callbackFn);
+            }
+            const matchedTx2 = await this.findAndCallback(toAddress(senderAccountAddress), steps[2], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(toAddress(params.sender), steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(toAddress(recipeintJettonWalletAddress), steps[4], matchedTx2.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-withdraw",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async findWithdrawTx(queryId, params, callbackFn) {
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const senderAccount = this.open(account_1.Account.createFromAddress(senderAccountAddress));
+        const accountData = await senderAccount.getAccountData();
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const recipeintJettonWalletAddress = await this.getJettonWalletAddress(toString(params.recipient), toString(params.asset));
+        let oracleParams = null;
+        if (account_1.Account.haveBorrow(accountData)) {
+            const assets = [...new Set([...account_1.Account.haveAssets(accountData)])];
+            const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+            result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+            const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+            oracleParams = (0, ton_1.beginCell)()
+                .storeRef(feedIdCell)
+                .storeRef(payload)
+                .storeRef(requestAssetCell)
+                .endCell();
+        }
+        const steps = [
+            {
+                queryId,
+                description: "Sending the tx",
+                from: toAddress(params.sender),
+                to: toAddress(params.pool),
+                opcode: pool_1.Pool.Op.Withdraw,
+            },
+            {
+                queryId,
+                description: "Calculating oracle data",
+                from: toAddress(poolData.oracle ? poolData.oracle : params.pool),
+                to: toAddress(params.pool),
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: toAddress(params.pool),
+                to: senderAccountAddress,
+                opcode: pool_1.Pool.Op.ExecuteAction,
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: toAddress(params.pool),
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                queryId,
+                description: "Withdrawing jetton from the pool",
+                from: poolJettonWalletAddress,
+                to: recipeintJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ];
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            if (poolData.oracle && oracleParams) {
+                const matchedTx1 = await this.findAndCallback(toAddress(params.pool), steps[1], matchedTx0.lt.toString(), callbackFn);
+            }
+            const matchedTx2 = await this.findAndCallback(toAddress(senderAccountAddress), steps[2], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(toAddress(params.sender), steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(toAddress(recipeintJettonWalletAddress), steps[4], matchedTx3.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-withdraw",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async borrow(sender, params) {
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const senderAccount = this.open(account_1.Account.createFromAddress(senderAccountAddress));
+        const accountData = await senderAccount.getAccountData();
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        const assets = [
+            ...new Set([...account_1.Account.haveAssets(accountData), toString(params.asset)]),
+        ];
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .endCell();
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Borrow, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, !!oracleParams, poolData.minimumGasFee);
+        await pool.sendBorrow(sender, gas, {
+            asset: toAddress(params.asset),
+            isShare: params.isShare,
+            amount: params.amount,
+            recipient: toAddress(params.recipient),
+            response: toAddress(params.response),
+            jettonForwardTonAmount,
+            jettonForwardPayload,
+            oracleParams: oracleParams,
+        });
+    }
+    async borrowAndWaitTx(sender, params, callbackFn) {
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const senderAccount = this.open(account_1.Account.createFromAddress(senderAccountAddress));
+        const accountData = await senderAccount.getAccountData();
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const recipeintJettonWalletAddress = await this.getJettonWalletAddress(toString(params.recipient), toString(params.asset));
+        const userAssets = [
+            ...new Set([...account_1.Account.haveAssets(accountData), toString(params.asset)]),
+        ];
+        let { assets, vaultAssets } = await this.separateAssets(userAssets, poolData.oracleConfig);
+        const vaultPositions = await this.getParsedVaults(vaultAssets);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        let requestFactorialPoolsCell = exposurePools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(exposurePools.map((pool) => ton_1.Address.parse(pool)))
+            : null;
+        let requestFactorialVaultsCell = vaultAssets.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaultAssets.map((vault) => ton_1.Address.parse(vault)))
+            : null;
+        let requestFactorialCell = (0, ton_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const opts = {
+            asset: toAddress(params.asset),
+            isShare: params.isShare,
+            amount: params.amount,
+            recipient: toAddress(params.recipient),
+            response: toAddress(params.response),
+            jettonForwardTonAmount,
+            jettonForwardPayload,
+            oracleParams: oracleParams,
+        };
+        const body = pool_1.Pool.createWithdrawMsgBody(opts);
+        const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(params.sender), body);
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Borrow, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, !!oracleParams, poolData.minimumGasFee);
+        await pool.sendBorrow(sender, gas, {
+            ...opts,
+            queryId,
+        });
+        const steps = [
+            {
+                queryId,
+                description: "Sending the tx",
+                from: toAddress(params.sender),
+                to: toAddress(params.pool),
+                opcode: pool_1.Pool.Op.Borrow,
+            },
+            {
+                queryId,
+                description: "Calculating oracle data",
+                from: toAddress(poolData.oracle ? poolData.oracle : params.pool),
+                to: toAddress(params.pool),
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: toAddress(params.pool),
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: toAddress(params.pool),
+                to: senderAccountAddress,
+                opcode: pool_1.Pool.Op.ProcessBorrowActionResult,
+            },
+            {
+                queryId,
+                description: "Withdrawing jetton from the pool",
+                from: poolJettonWalletAddress,
+                to: recipeintJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ];
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            if (poolData.oracle && oracleParams) {
+                const matchedTx1 = await this.findAndCallback(toAddress(params.pool), steps[1], matchedTx0.lt.toString(), callbackFn);
+            }
+            const matchedTx2 = await this.findAndCallback(toAddress(params.sender), steps[2], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(toAddress(senderAccountAddress), steps[3], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(toAddress(recipeintJettonWalletAddress), steps[4], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-borrow",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async findBorrowTx(queryId, params, callbackFn) {
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const senderAccount = this.open(account_1.Account.createFromAddress(senderAccountAddress));
+        const accountData = await senderAccount.getAccountData();
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const recipeintJettonWalletAddress = await this.getJettonWalletAddress(toString(params.recipient), toString(params.asset));
+        const assets = [
+            ...new Set([...account_1.Account.haveAssets(accountData), toString(params.asset)]),
+        ];
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .endCell();
+        const steps = [
+            {
+                queryId,
+                description: "Sending the tx",
+                from: toAddress(params.sender),
+                to: toAddress(params.pool),
+                opcode: pool_1.Pool.Op.Borrow,
+            },
+            {
+                queryId,
+                description: "Calculating oracle data",
+                from: toAddress(poolData.oracle ? poolData.oracle : params.pool),
+                to: toAddress(params.pool),
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: toAddress(params.pool),
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: toAddress(params.pool),
+                to: senderAccountAddress,
+                opcode: pool_1.Pool.Op.ProcessBorrowActionResult,
+            },
+            {
+                queryId,
+                description: "Withdrawing jetton from the pool",
+                from: poolJettonWalletAddress,
+                to: recipeintJettonWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ];
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            if (poolData.oracle && oracleParams) {
+                const matchedTx1 = await this.findAndCallback(toAddress(params.pool), steps[1], matchedTx0.lt.toString(), callbackFn);
+            }
+            const matchedTx2 = await this.findAndCallback(toAddress(params.sender), steps[2], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(toAddress(senderAccountAddress), steps[3], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(toAddress(recipeintJettonWalletAddress), steps[4], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-borrow",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async repay(sender, params) {
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = await pool.getPoolData();
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Repay, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        if (toString(params.asset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            await poolWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                recipient: toAddress(params.pool),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+                forwardPayload: pool_1.Pool.createRepayPayload({
+                    asset: toAddress(params.asset),
+                    recipient: toAddress(params.recipient),
+                    response: toAddress(params.response),
+                    jettonForwardTonAmount,
+                    jettonForwardPayload,
+                }),
+            });
+        }
+        else {
+            const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.asset));
+            const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                recipient: toAddress(params.pool),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+                forwardPayload: pool_1.Pool.createRepayPayload({
+                    asset: toAddress(params.asset),
+                    recipient: toAddress(params.recipient),
+                    response: toAddress(params.response),
+                    jettonForwardTonAmount,
+                    jettonForwardPayload,
+                }),
+            });
+        }
+    }
+    async repayAndWaitTx(sender, params, callbackFn) {
+        const isWTON = toString(params.asset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.asset));
+        const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const poolData = await pool.getPoolData();
+        const recipientAccountAddress = await this.getAccountAddress(toString(params.recipient), toString(params.pool));
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Repay, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        const opts = {
+            recipient: toAddress(params.pool),
+            response: toAddress(params.response),
+            amount: params.amount,
+            forwardTonAmount: gas,
+            forwardPayload: pool_1.Pool.createRepayPayload({
+                asset: toAddress(params.asset),
+                recipient: toAddress(params.recipient),
+                response: toAddress(params.response),
+                jettonForwardTonAmount,
+                jettonForwardPayload,
+            }),
+        };
+        const body = senderJettonWallet.createTransferBody(opts);
+        const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(params.sender), body);
+        const steps = [];
+        if (toString(params.asset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            await poolWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                queryId: queryId,
+                ...opts,
+            });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Sending the tx",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+                {
+                    queryId,
+                    description: "Repaying jetton to the pool",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                ...opts,
+                queryId,
+            });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Sending the tx",
+                    from: toAddress(params.sender),
+                    to: senderJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+                },
+                {
+                    queryId,
+                    description: "Repaying jetton to the pool",
+                    from: senderJettonWalletAddress,
+                    to: poolJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+                },
+            ]);
+        }
+        steps.push(...[
+            {
+                queryId,
+                description: "Pool notification",
+                from: poolJettonWalletAddress,
+                to: pool.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: pool.address,
+                to: recipientAccountAddress,
+                opcode: pool_1.Pool.Op.ExecuteAction,
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: pool.address,
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(poolJettonWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(pool.address, steps[2], matchedTx1.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(recipientAccountAddress, steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(toAddress(params.sender), steps[4], matchedTx3.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-repay",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async findRepayTx(queryId, params, callbackFn) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.asset));
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+        const recipientAccountAddress = await this.getAccountAddress(toString(params.recipient), toString(params.pool));
+        const steps = [];
+        if (toString(params.asset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.asset));
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Sending the tx",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+                {
+                    queryId,
+                    description: "Repaying jetton to the pool",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Sending the tx",
+                    from: toAddress(params.sender),
+                    to: senderJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+                },
+                {
+                    queryId,
+                    description: "Repaying jetton to the pool",
+                    from: senderJettonWalletAddress,
+                    to: poolJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+                },
+            ]);
+        }
+        steps.push(...[
+            {
+                queryId,
+                description: "Pool notification",
+                from: poolJettonWalletAddress,
+                to: pool.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                queryId,
+                description: "Updating the account",
+                from: pool.address,
+                to: recipientAccountAddress,
+                opcode: pool_1.Pool.Op.ExecuteAction,
+            },
+            {
+                queryId,
+                description: "Action notification",
+                from: pool.address,
+                to: toAddress(params.sender),
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(poolJettonWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(pool.address, steps[2], matchedTx1.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(recipientAccountAddress, steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(toAddress(params.sender), steps[4], matchedTx3.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-repay",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async liquidateSimulate(params) {
+        const isWTON = toString(params.repayAsset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const borrowerAccountAddress = await this.getAccountAddress(toString(params.borrower), toString(params.pool));
+        const borrowerAccount = this.open(account_1.Account.createFromAddress(toAddress(borrowerAccountAddress)));
+        const accountData = await borrowerAccount.getAccountData();
+        const assets = [...new Set([...account_1.Account.haveAssets(accountData)])];
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .endCell();
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Liquidate, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        if (toString(params.repayAsset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.repayAsset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            // await poolWTONWallet.sendExternalTransfer(sender, WTONWallet.Gas.ExternalTransfer, {
+            //   recipient: toAddress(params.pool),
+            //   response: toAddress(params.response),
+            //   amount: params.amount,
+            //   forwardTonAmount: gas,
+            //   forwardPayload: Pool.createLiquidatePayload({
+            //     repayAsset: toAddress(params.repayAsset),
+            //     seizeAsset: toAddress(params.seizeAsset),
+            //     borrower: toAddress(params.borrower),
+            //     response: toAddress(params.response),
+            //     jettonForwardTonAmount,
+            //     jettonForwardPayload,
+            //     oracleParams,
+            //   }),
+            // });
+        }
+        else {
+            const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.repayAsset));
+            const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+            // await senderJettonWallet.sendTransfer(sender, gas + JettonWallet.Gas.Transfer, {
+            //   recipient: toAddress(params.pool),
+            //   response: toAddress(params.response),
+            //   amount: params.amount,
+            //   forwardTonAmount: gas,
+            //   forwardPayload: Pool.createLiquidatePayload({
+            //     repayAsset: toAddress(params.repayAsset),
+            //     seizeAsset: toAddress(params.seizeAsset),
+            //     borrower: toAddress(params.borrower),
+            //     response: toAddress(params.response),
+            //     jettonForwardTonAmount,
+            //     jettonForwardPayload,
+            //     oracleParams,
+            //   }),
+            // });
+        }
+    }
+    async liquidateAndWaitTxSimulate(queryId, params, callbackFn) {
+        const isWTON = toString(params.repayAsset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.repayAsset));
+        const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.repayAsset));
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const borrowerAccountAddress = await this.getAccountAddress(toString(params.borrower), toString(params.pool));
+        const borrowerAccount = this.open(account_1.Account.createFromAddress(toAddress(borrowerAccountAddress)));
+        const accountData = await borrowerAccount.getAccountData();
+        const assets = [...new Set([...account_1.Account.haveAssets(accountData)])];
+        const poolData = (await pool.getPoolData());
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .endCell();
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Liquidate, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        const opts = {
+            recipient: toAddress(params.pool),
+            response: toAddress(params.response),
+            amount: params.amount,
+            forwardTonAmount: gas,
+            forwardPayload: pool_1.Pool.createLiquidatePayload({
+                repayAsset: toAddress(params.repayAsset),
+                seizeAsset: toAddress(params.seizeAsset),
+                borrower: toAddress(params.borrower),
+                response: toAddress(params.response),
+                jettonForwardTonAmount,
+                jettonForwardPayload,
+                oracleParams,
+            }),
+        };
+        const body = senderJettonWallet.createTransferBody(opts);
+        const steps = [];
+        if (toString(params.repayAsset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.repayAsset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            // await poolWTONWallet.sendExternalTransfer(sender, WTONWallet.Gas.ExternalTransfer, {
+            //   queryId: queryId,
+            //   ...opts,
+            // });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "tx send",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+                {
+                    queryId,
+                    description: "send wton transfer to pool",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            // await senderJettonWallet.sendTransfer(sender, gas + JettonWallet.Gas.Transfer, {
+            //   ...opts,
+            //   queryId,
+            // });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "tx send",
+                    from: toAddress(params.sender),
+                    to: senderJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+                },
+                {
+                    queryId,
+                    description: "send jetton transfer to pool",
+                    from: senderJettonWalletAddress,
+                    to: poolJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+                },
+            ]);
+        }
+        steps.push(...[
+            {
+                queryId,
+                description: "pool notification",
+                from: poolJettonWalletAddress,
+                to: pool.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                queryId,
+                description: "unlock & update account",
+                from: pool.address,
+                to: borrowerAccountAddress,
+                opcode: pool_1.Pool.Op.ExecuteAction,
+            },
+            {
+                queryId,
+                description: "send seize collateral token",
+                from: pool.address,
+                to: senderAccountAddress,
+            },
+            {
+                queryId,
+                description: "action notification",
+                from: pool.address,
+                to: toAddress(params.sender),
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(poolJettonWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(pool.address, steps[2], matchedTx1.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(borrowerAccountAddress, steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(senderAccountAddress, steps[4], matchedTx3.lt.toString(), callbackFn);
+            const matchedTx5 = await this.findAndCallback(toAddress(params.sender), steps[5], matchedTx4.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async liquidate(sender, params) {
+        const isWTON = toString(params.repayAsset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const borrowerAccountAddress = await this.getAccountAddress(toString(params.borrower), toString(params.pool));
+        const borrowerAccount = this.open(account_1.Account.createFromAddress(toAddress(borrowerAccountAddress)));
+        const accountData = await borrowerAccount.getAccountData();
+        const assets = [...new Set([...account_1.Account.haveAssets(accountData)])];
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolData = (await pool.getPoolData());
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .endCell();
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Liquidate, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        if (toString(params.repayAsset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.repayAsset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            await poolWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                recipient: toAddress(params.pool),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+                forwardPayload: pool_1.Pool.createLiquidatePayload({
+                    repayAsset: toAddress(params.repayAsset),
+                    seizeAsset: toAddress(params.seizeAsset),
+                    borrower: toAddress(params.borrower),
+                    response: toAddress(params.response),
+                    jettonForwardTonAmount,
+                    jettonForwardPayload,
+                    oracleParams,
+                }),
+            });
+        }
+        else {
+            const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.repayAsset));
+            const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                recipient: toAddress(params.pool),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+                forwardPayload: pool_1.Pool.createLiquidatePayload({
+                    repayAsset: toAddress(params.repayAsset),
+                    seizeAsset: toAddress(params.seizeAsset),
+                    borrower: toAddress(params.borrower),
+                    response: toAddress(params.response),
+                    jettonForwardTonAmount,
+                    jettonForwardPayload,
+                    oracleParams,
+                }),
+            });
+        }
+    }
+    async liquidateAndWaitTx(sender, params, callbackFn) {
+        const isWTON = toString(params.repayAsset) == this.contracts.WTON;
+        const jettonForwardTonAmount = isWTON ? (0, ton_1.toNano)(0.02) : 0n;
+        const jettonForwardPayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null;
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.repayAsset));
+        const senderJettonWallet = this.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(params.pool)));
+        const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.repayAsset));
+        const senderAccountAddress = await this.getAccountAddress(toString(params.sender), toString(params.pool));
+        const borrowerAccountAddress = await this.getAccountAddress(toString(params.borrower), toString(params.pool));
+        const borrowerAccount = this.open(account_1.Account.createFromAddress(toAddress(borrowerAccountAddress)));
+        const poolData = (await pool.getPoolData());
+        const accountData = await borrowerAccount.getAccountData();
+        const userAssets = [...new Set([...account_1.Account.haveAssets(accountData)])];
+        let { assets, vaultAssets } = await this.separateAssets(userAssets, poolData.oracleConfig);
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.oracleConfig);
+        const vaultPositions = await this.getParsedVaults(vaultAssets);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        let requestFactorialPoolsCell = exposurePools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(exposurePools.map((pool) => ton_1.Address.parse(pool)))
+            : null;
+        let requestFactorialVaultsCell = vaultAssets.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaultAssets.map((vault) => ton_1.Address.parse(vault)))
+            : null;
+        let requestFactorialCell = (0, ton_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Liquidate, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+        const opts = {
+            recipient: toAddress(params.pool),
+            response: toAddress(params.response),
+            amount: params.amount,
+            forwardTonAmount: gas,
+            forwardPayload: pool_1.Pool.createLiquidatePayload({
+                repayAsset: toAddress(params.repayAsset),
+                seizeAsset: toAddress(params.seizeAsset),
+                borrower: toAddress(params.borrower),
+                response: toAddress(params.response),
+                jettonForwardTonAmount,
+                jettonForwardPayload,
+                oracleParams,
+            }),
+        };
+        const body = senderJettonWallet.createTransferBody(opts);
+        const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(params.sender), body);
+        const steps = [];
+        if (toString(params.repayAsset) == this.contracts.WTON) {
+            const poolWTONWalletAddress = await this.getJettonWalletAddress(toString(params.pool), toString(params.repayAsset));
+            const poolWTONWallet = this.open(jetton_wallet_2.WTONWallet.createFromAddress(poolWTONWalletAddress));
+            await poolWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                queryId: queryId,
+                ...opts,
+            });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "tx send",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+                {
+                    queryId,
+                    description: "send wton transfer to pool",
+                    from: toAddress(params.sender),
+                    to: poolWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                ...opts,
+                queryId,
+            });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "tx send",
+                    from: toAddress(params.sender),
+                    to: senderJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+                },
+                {
+                    queryId,
+                    description: "send jetton transfer to pool",
+                    from: senderJettonWalletAddress,
+                    to: poolJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+                },
+            ]);
+        }
+        steps.push(...[
+            {
+                queryId,
+                description: "pool notification",
+                from: poolJettonWalletAddress,
+                to: pool.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                queryId,
+                description: "unlock & update account",
+                from: pool.address,
+                to: borrowerAccountAddress,
+                opcode: pool_1.Pool.Op.ExecuteAction,
+            },
+            {
+                queryId,
+                description: "send seize collateral token",
+                from: pool.address,
+                to: senderAccountAddress,
+            },
+            {
+                queryId,
+                description: "action notification",
+                from: pool.address,
+                to: toAddress(params.sender),
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.sender), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(poolJettonWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(pool.address, steps[2], matchedTx1.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(borrowerAccountAddress, steps[3], matchedTx2.lt.toString(), callbackFn);
+            const matchedTx4 = await this.findAndCallback(senderAccountAddress, steps[4], matchedTx3.lt.toString(), callbackFn);
+            const matchedTx5 = await this.findAndCallback(toAddress(params.sender), steps[5], matchedTx4.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "pool-liquidate",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    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(ton_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(ton_1.Address.parse(data.sourceAddress.toString()))
+                            .get("get_reserves", []),
+                        this.client
+                            .provider(ton_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(ton_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(ton_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(ton_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(ton_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(ton_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, poolData) {
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.oracleConfig);
+        const redstonePrices = await readonlyCachedRedstone_1.ReadonlyCachedRedstone.getPrices(result.redstoneAssetNames);
+        const prices = {};
+        const onchainData = {};
+        redstonePrices.forEach((item) => {
+            try {
+                const rainfo = poolData.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 };
+    }
+    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;
+    }
+    decomposeAccountStatus(accountStatus, prices, onchainData) {
+        const accumStatus = {};
+        let userAssets = Object.values(accountStatus);
+        while (userAssets.length !== 0) {
+            const restUserAssets = [];
+            for (let i = 0; i < userAssets.length; i++) {
+                const state = userAssets[i];
+                if (state.supply > 0n || state.borrow > 0n) {
+                    accumStatus[userAssets[i].address.toString()] ??= {
+                        supply: 0n,
+                        borrow: 0n,
+                    };
+                    if (state.supply > 0n) {
+                        accumStatus[userAssets[i].address.toString()].supply +=
+                            state.supply;
+                    }
+                    if (state.borrow > 0n) {
+                        accumStatus[userAssets[i].address.toString()].borrow +=
+                            state.borrow;
+                    }
+                    const onchainDataInfo = onchainData[state.address.toString()];
+                    if (!onchainDataInfo && !prices[state.address.toString()]) {
+                        throw "not found onchain data info2";
+                    }
+                    if (onchainDataInfo) {
+                        if (onchainDataInfo.assetType === type_1.AssetType.SingleAsset &&
+                            onchainDataInfo.underlyingReserve &&
+                            onchainDataInfo.totalSupply) {
+                            const underlyingSupply = (state.supply * onchainDataInfo.underlyingReserve) /
+                                onchainDataInfo.totalSupply;
+                            const underlyingBorrow = (state.borrow * onchainDataInfo.underlyingReserve) /
+                                onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlyingAddress,
+                                supply: underlyingSupply,
+                                borrow: underlyingBorrow,
+                            });
+                        }
+                        else if (onchainDataInfo.assetType === type_1.AssetType.MultiAsset &&
+                            onchainDataInfo.underlying0Reserve &&
+                            onchainDataInfo.underlying1Reserve &&
+                            onchainDataInfo.totalSupply) {
+                            const underlying0Supply = (state.supply * onchainDataInfo.underlying0Reserve) /
+                                onchainDataInfo.totalSupply;
+                            const underlying0Borrow = (state.borrow * onchainDataInfo.underlying0Reserve) /
+                                onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlying0Address,
+                                supply: underlying0Supply,
+                                borrow: underlying0Borrow,
+                            });
+                            const underlying1Supply = (state.supply * onchainDataInfo.underlying1Reserve) /
+                                onchainDataInfo.totalSupply;
+                            const underlying1Borrow = (state.borrow * onchainDataInfo.underlying1Reserve) /
+                                onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlying1Address,
+                                supply: underlying1Supply,
+                                borrow: underlying1Borrow,
+                            });
+                        }
+                    }
+                    else if (prices[state.address.toString()]?.type === type_1.AssetType.VaultAsset) {
+                        const priceData = prices[state.address.toString()];
+                        const decomposed = priceData.additionalData.decomposed;
+                        const totalSupply = priceData.additionalData.totalSupply;
+                        for (const asset of Object.keys(decomposed)) {
+                            const underlyingSupply = (state.supply * decomposed[asset].supply) / totalSupply +
+                                (state.borrow * decomposed[asset].borrow) / totalSupply;
+                            const underlyingBorrow = (state.supply * decomposed[asset].borrow) / totalSupply +
+                                (state.borrow * decomposed[asset].supply) / totalSupply;
+                            restUserAssets.push({
+                                address: ton_1.Address.parse(asset),
+                                supply: underlyingSupply,
+                                borrow: underlyingBorrow,
+                            });
+                        }
+                    }
+                }
+            }
+            userAssets = restUserAssets;
+        }
+        return accumStatus;
+    }
+    calculateRisk(decomposedAccountStatus, prices, poolData) {
+        let collateral = 0n;
+        let debt = 0n;
+        let risk = 0n;
+        Object.entries(decomposedAccountStatus).forEach(([asset, status]) => {
+            const price = prices[asset];
+            const suppliedValue = (BigInt(status.supply) * price.price) / BigInt(1e8);
+            const borrowedValue = (BigInt(status.borrow) * price.price) / BigInt(1e8);
+            const isCollateral = poolData.assets[asset].isCollateral;
+            if (price.type === type_1.AssetType.Native) {
+                if (isCollateral) {
+                    collateral += suppliedValue;
+                }
+                debt += borrowedValue;
+            }
+            if (isCollateral) {
+                const delta = suppliedValue > borrowedValue
+                    ? suppliedValue - borrowedValue
+                    : borrowedValue - suppliedValue;
+                risk += (delta * poolData.assets[asset].riskFactor) / BigInt(1e4);
+            }
+            else {
+                risk +=
+                    (borrowedValue * poolData.assets[asset].riskFactor) / BigInt(1e4);
+            }
+        });
+        if (collateral === 0n && debt === 0n) {
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral,
+                debt,
+                risk,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const netValue = collateral - debt;
+        if (netValue <= 0n) {
+            return {
+                result: false,
+                healthy: false,
+                unhealthy: true,
+                collateral,
+                debt,
+                risk,
+                riskRatio: 2n ** 128n - 1n,
+                leverageRatio: 2n ** 128n - 1n,
+            };
+        }
+        const leverageRatio = (collateral * BigInt(1e4)) / netValue;
+        const riskRatio = (risk * BigInt(1e4)) / netValue;
+        const unhealthy = poolData.liquidateLeverageRatio === 0n
+            ? riskRatio > poolData.liquidateVarRatio
+            : leverageRatio > poolData.liquidateLeverageRatio ||
+                riskRatio > poolData.liquidateVarRatio;
+        return {
+            result: !unhealthy,
+            healthy: !unhealthy,
+            unhealthy: unhealthy,
+            collateral,
+            debt,
+            risk,
+            riskRatio,
+            leverageRatio,
+        };
+    }
+    async getOracleRequestParams(assets, oracleConfig) {
+        return redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, oracleConfig);
+    }
+    async isHealthy(poolAddress, ownerAddress, delta) {
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const borrowerAccountAddress = await this.getAccountAddress(toString(ownerAddress), toString(poolAddress));
+        const borrowerAccount = this.open(account_1.Account.createFromAddress(toAddress(borrowerAccountAddress)));
+        // const poolData = await pool.getPoolData() as any;
+        const poolData = pool_1.Pool.simulateAccrueInterest(await pool.getPoolData());
+        let accountData = null;
+        try {
+            accountData = account_1.Account.convertShareToAmount(await borrowerAccount.getAccountData(), poolData);
+            if (delta) {
+                accountData = account_1.Account.applyDelta(accountData, delta);
+            }
+        }
+        catch (e) {
+            console.log(e);
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral: 0n,
+                debt: 0n,
+                risk: 0n,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const __assets = account_1.Account.haveAssets(accountData);
+        if (__assets.length === 0) {
+            return {
+                result: true,
+                healthy: true,
+                unhealthy: false,
+                collateral: 0n,
+                debt: 0n,
+                risk: 0n,
+                riskRatio: 0n,
+                leverageRatio: 0n,
+            };
+        }
+        const oracleConfig = poolData.oracleConfig;
+        let { assets, vaultAssets } = await this.separateAssets(Object.keys(poolData.assets), oracleConfig);
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
+        const onchainData2 = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        const assetPrices = this.calculatePrices(redstonePrices, onchainData);
+        const vaultPositions = await this.getParsedVaults([...vaultAssets]);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const exposurePoolsData = {};
+        for (let exposurePool of exposurePools) {
+            const pool = this.open(pool_1.Pool.createFromAddress(toAddress(exposurePool)));
+            const poolData = await pool.getPoolData();
+            exposurePoolsData[exposurePool] = poolData;
+        }
+        const vaultPrices = await this.calculateVaultPrices(assetPrices, exposurePoolsData, vaultPositions);
+        const prices = {
+            ...assetPrices,
+            ...vaultPrices,
+        };
+        const decomposedAccountStatus = this.decomposeAccountStatus(accountData.status, prices, onchainData);
+        return this.calculateRisk(decomposedAccountStatus, prices, poolData);
+    }
+    isHealthyV2(_poolData, _accountData, prices) {
+        const poolData = pool_1.Pool.simulateAccrueInterest(_poolData);
+        const decomposedAccountStatus = this.decomposeAccountStatus(_accountData, prices, poolData.oracleConfig.assetOnchainDataInfo);
+        return this.calculateRisk(decomposedAccountStatus, prices, poolData);
+    }
+    // async getPrices(poolAddress: Address | string) {
+    //   const pool = this.open(Pool.createFromAddress(toAddress(poolAddress)));
+    //   const poolData = (await pool.getPoolData()) as any;
+    //   const assets = Object.keys(poolData.assets);
+    //   const { redstonePrices, onchainData: od } = await this.getRedstonePrices(
+    //     assets,
+    //     poolData
+    //   );
+    //   const onchainData2 = await this.updateOnchainData(
+    //     poolData.oracleConfig.assetOnchainDataInfo
+    //   );
+    //   const onchainData = { ...od, ...onchainData2 };
+    //   const prices = this.calculatePrices(redstonePrices, onchainData);
+    //   return prices;
+    // }
+    async getPrices(poolAddress) {
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const poolData = await pool.getPoolData();
+        const _assets = Object.keys(poolData.assets);
+        const oracleConfig = poolData.oracleConfig;
+        let { assets, vaultAssets } = await this.separateAssets(_assets, oracleConfig);
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
+        const onchainData2 = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        const vaultPositions = await this.getParsedVaults([...vaultAssets]);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const exposurePoolsData = {};
+        for (let exposurePool of exposurePools) {
+            const pool = this.open(pool_1.Pool.createFromAddress(toAddress(exposurePool)));
+            const poolData = await pool.getPoolData();
+            exposurePoolsData[exposurePool] = poolData;
+        }
+        const vaultPrices = await this.calculateVaultPrices(prices, exposurePoolsData, vaultPositions);
+        return {
+            ...prices,
+            ...vaultPrices,
+        };
+    }
+    async getPricesV2(poolAddress) {
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const poolData = await pool.getPoolData();
+        const _assets = Object.keys(poolData.assets);
+        const oracleConfig = poolData.oracleConfig;
+        let { assets, vaultAssets } = await this.separateAssets(_assets, oracleConfig);
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
+        const onchainData2 = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        const vaultPositions = await this.getParsedVaults([...vaultAssets]);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const exposurePoolsData = {};
+        for (let exposurePool of exposurePools) {
+            const pool = this.open(pool_1.Pool.createFromAddress(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 = ton_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 = share_vault_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;
+    }
+    async calculateMaxBorrowableAmount({ borrowerAddress, poolAddress, tokenAddress, BUFFER = 100n, }) {
+        if (!poolAddress || !borrowerAddress)
+            throw new Error("Pool address or borrower address is required");
+        const poolContract = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const pool = pool_1.Pool.simulateAccrueInterest(await poolContract.getPoolData());
+        const accountContract = this.open(account_1.Account.createFromAddress(await poolContract.getAccountAddress(borrowerAddress)));
+        const accountState = account_1.Account.convertShareToAmount(await accountContract.getAccountData(), pool);
+        const cash = pool.assets[tokenAddress].cash;
+        const { onchainData: od } = await this.getRedstonePrices([tokenAddress], pool);
+        const pricesData = await this.getPricesV2(poolAddress.toString());
+        const onchainData2 = await this.updateOnchainData(pool.oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        // @ts-ignore
+        pool.oracleConfig.assetOnchainDataInfo = onchainData;
+        const beforeHealth = this.isHealthyV2(pool, accountState.status, pricesData);
+        const riskCalculator = new risk_calculator_1.RiskCalculator(accountState.status, pricesData, onchainData, pool);
+        const deltaSolutionsForTargetRatio = riskCalculator.calculateDeltaForTargetRiskRatio(pool.maxLoanVarRatio - BUFFER, tokenAddress);
+        const deltaSolutionForLeverage = riskCalculator.calculateDeltaForTargetLeverage(pool.maxLoanLeverageRatio - BUFFER, tokenAddress, "borrow");
+        const solutionsForTargetRatio = deltaSolutionsForTargetRatio.map((solution) => (0, utils_1.bigIntMin)([solution.delta, 0n]) * -1n);
+        const hasAnswer = solutionsForTargetRatio.length > 0;
+        const solutionForTargetRatio = hasAnswer
+            ? (0, utils_1.bigIntMin)(solutionsForTargetRatio)
+            : utils_1.MAX256;
+        const solutionForLeverage = deltaSolutionForLeverage.delta >= 0n ? deltaSolutionForLeverage.delta : 0n;
+        const maxBorrowableAmount = (0, utils_1.bigIntMin)([
+            solutionForTargetRatio,
+            solutionForLeverage,
+            cash,
+        ]);
+        let reason;
+        if (maxBorrowableAmount === solutionForTargetRatio) {
+            reason = "RISK_RATIO_CONSTRAINT";
+        }
+        else if (maxBorrowableAmount === solutionForLeverage) {
+            reason = "LEVERAGE_CONSTRAINT";
+        }
+        else if (maxBorrowableAmount === cash) {
+            reason = "POOL_CASH_CONSTRAINT";
+        }
+        else {
+            throw new Error("Unknown reason for max borrowable amount");
+        }
+        const accountState2 = account_1.Account.applyDelta(accountState, {
+            [tokenAddress]: {
+                address: ton_1.Address.parse(tokenAddress),
+                supply: 0n,
+                borrow: maxBorrowableAmount,
+            },
+        });
+        const afterHealth = this.isHealthyV2(pool, accountState2.status, pricesData);
+        return {
+            amount: maxBorrowableAmount,
+            reason,
+            beforeAccountHealth: beforeHealth,
+            afterAccountHealth: afterHealth,
+        };
+    }
+    ;
+    async calculateMaxWithdrawableAmount({ withdrawerAddress, poolAddress, tokenAddress, BUFFER = 100n, }) {
+        if (!poolAddress || !withdrawerAddress)
+            throw new Error("Pool address or withdrawer address is required");
+        const poolContract = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const pool = pool_1.Pool.simulateAccrueInterest(await poolContract.getPoolData());
+        const accountContract = this.open(account_1.Account.createFromAddress(await poolContract.getAccountAddress(withdrawerAddress)));
+        const accountState = account_1.Account.convertShareToAmount(await accountContract.getAccountData(), pool);
+        const cash = pool.assets[tokenAddress]?.cash;
+        const hasNoPosition = Object.values(accountState.status).every((value) => value.borrow === 0n && value.supply === 0n);
+        if (hasNoPosition) {
+            return { amount: 0n, reason: "USER_SUPPLY_CONSTRAINT" };
+        }
+        const hasNoBorrowedAmount = Object.values(accountState.status).every((value) => value.borrow === 0n);
+        if (hasNoBorrowedAmount) {
+            const supplyAmount = accountState.status[tokenAddress]?.supply;
+            if (supplyAmount > cash) {
+                return { amount: cash, reason: "POOL_CASH_CONSTRAINT" };
+            }
+            else {
+                return { amount: supplyAmount, reason: "USER_SUPPLY_CONSTRAINT" };
+            }
+        }
+        const { onchainData: od } = await this.getRedstonePrices([tokenAddress], pool);
+        const pricesData = await this.getPricesV2(poolAddress.toString());
+        const onchainData2 = await this.updateOnchainData(pool.oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        // @ts-ignore
+        pool.oracleConfig.assetOnchainDataInfo = onchainData;
+        const beforeHealth = this.isHealthyV2(pool, accountState.status, pricesData);
+        const riskCalculator = new risk_calculator_1.RiskCalculator(accountState.status, pricesData, onchainData, pool);
+        const deltaSolutionsForTargetRatio = riskCalculator.calculateDeltaForTargetRiskRatio(pool.maxLoanVarRatio - BUFFER, tokenAddress);
+        const deltaSolutionForLeverage = riskCalculator.calculateDeltaForTargetLeverage(pool.maxLoanLeverageRatio - BUFFER, tokenAddress, "supply");
+        const solutionsForTargetRatio = deltaSolutionsForTargetRatio.map((solution) => (0, utils_1.bigIntMin)([solution.delta, 0n]) * -1n);
+        const hasTargetRatioAnswer = solutionsForTargetRatio.length > 0;
+        const solutionForTargetRatio = hasTargetRatioAnswer
+            ? (0, utils_1.bigIntMin)(solutionsForTargetRatio)
+            : utils_1.MAX256;
+        const solutionForLeverage = (0, utils_1.bigIntMin)([deltaSolutionForLeverage.delta, 0n]) * -1n;
+        const userSupplyAmount = accountState.status[tokenAddress]?.supply;
+        const maxWithdrawableAmount = (0, utils_1.bigIntMin)([
+            userSupplyAmount,
+            solutionForTargetRatio,
+            solutionForLeverage,
+            cash ?? 0n,
+        ]);
+        let reason;
+        if (maxWithdrawableAmount === solutionForTargetRatio) {
+            reason = "RISK_RATIO_CONSTRAINT";
+        }
+        else if (maxWithdrawableAmount === solutionForLeverage) {
+            reason = "LEVERAGE_CONSTRAINT";
+        }
+        else if (maxWithdrawableAmount === cash) {
+            reason = "POOL_CASH_CONSTRAINT";
+        }
+        else if (maxWithdrawableAmount === userSupplyAmount) {
+            reason = "USER_SUPPLY_CONSTRAINT";
+        }
+        else {
+            throw new Error("Unknown reason for max withdrawable amount");
+        }
+        const accountState2 = account_1.Account.applyDelta(accountState, {
+            [tokenAddress]: {
+                address: ton_1.Address.parse(tokenAddress),
+                supply: -maxWithdrawableAmount,
+                borrow: 0n,
+            },
+        });
+        const afterHealth = this.isHealthyV2(pool, accountState2.status, pricesData);
+        return {
+            amount: maxWithdrawableAmount,
+            reason,
+            beforeAccountHealth: beforeHealth,
+            afterAccountHealth: afterHealth,
+        };
+    }
+    ;
+    async getPoolData(poolAddress) {
+        if (!(poolAddress instanceof ton_1.Address)) {
+            poolAddress = ton_1.Address.parse(poolAddress);
+        }
+        const pool = this.open(pool_1.Pool.createFromAddress(poolAddress));
+        return await pool.getPoolData();
+    }
+    async getAccountData(poolAddress, userAddress) {
+        if (!(poolAddress instanceof ton_1.Address)) {
+            poolAddress = ton_1.Address.parse(poolAddress);
+        }
+        if (!(userAddress instanceof ton_1.Address)) {
+            userAddress = ton_1.Address.parse(userAddress);
+        }
+        const pool = this.open(pool_1.Pool.createFromAddress(poolAddress));
+        if (!this.accountAddresses[userAddress.toString()]?.[poolAddress.toString()]) {
+            if (!this.accountAddresses[userAddress.toString()]) {
+                this.accountAddresses[userAddress.toString()] = {};
+            }
+            this.accountAddresses[userAddress.toString()][poolAddress.toString()] =
+                await pool.getAccountAddress(userAddress);
+        }
+        const account = this.open(account_1.Account.createFromAddress(this.accountAddresses[userAddress.toString()][poolAddress.toString()]));
+        let accountData;
+        const poolData = await pool.getPoolData();
+        const assets = poolData.assets;
+        const emptyStatus = Object.keys(assets).reduce((acc, asset) => {
+            acc[asset] = {
+                address: ton_1.Address.parse(asset),
+                supply: 0n,
+                borrow: 0n,
+            };
+            return acc;
+        }, {});
+        try {
+            /** When Account is deployed */
+            const accountDataFromOnchain = await account.getAccountData();
+            const parsedAccountData = {
+                ...accountDataFromOnchain,
+                status: { ...emptyStatus, ...accountDataFromOnchain.status },
+            };
+            accountData = parsedAccountData;
+        }
+        catch {
+            /** When Account is not deployed(User never interacted with the pool), "Not Active" thrown */
+            accountData = {
+                address: userAddress,
+                pool: poolAddress,
+                owner: poolData.owner,
+                status: emptyStatus,
+            };
+        }
+        return accountData;
+    }
+    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 getPoolOracleParams(poolAddress, actor, executeAsset) {
+        const pool = this.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const poolData = (await pool.getPoolData());
+        const senderAccountAddress = await this.getAccountAddress(toString(actor), toString(poolAddress));
+        const senderAccount = this.open(account_1.Account.createFromAddress(senderAccountAddress));
+        const accountData = await senderAccount.getAccountData();
+        const userAssets = [
+            ...new Set([...account_1.Account.haveAssets(accountData), toString(executeAsset)]),
+        ];
+        let { assets, vaultAssets } = await this.separateAssets(userAssets, poolData.oracleConfig);
+        const vaultPositions = await this.getParsedVaults(vaultAssets);
+        const exposures = await this.getExposures(vaultPositions);
+        const exposurePools = exposures.pools;
+        assets = [...new Set([...assets, ...exposures.assets])];
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.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 ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        let requestFactorialPoolsCell = exposurePools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(exposurePools.map((pool) => ton_1.Address.parse(pool)))
+            : null;
+        let requestFactorialVaultsCell = vaultAssets.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaultAssets.map((vault) => ton_1.Address.parse(vault)))
+            : null;
+        let requestFactorialCell = (0, ton_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        return oracleParams;
+    }
+}
+exports.PoolV1 = PoolV1;
+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,
+        },
+    };
+};