@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/poolCacheV1.js

@@ -0,0 +1,1841 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolCacheV1 = 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 service_1 = require("./common/service");
+const jetton_minter_2 = require("./contracts/wton/jetton-minter");
+const readonlyCachedRedstone_1 = require("./utils/oracle/redstone/readonlyCachedRedstone");
+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 PoolCacheV1 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();
+        // async calculateGasFee(actionOp: number, baseFee: bigint, forwardFee: bigint, forwardTonAmount: bigint, useInternalOracle: boolean, useOracle: boolean, gas: PoolGasFee) {
+        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], matchedTx3.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 getPricesV2(poolAddress) {
+        const pool = this.client.open(pool_1.Pool.createFromAddress(toAddress(poolAddress)));
+        const poolData = await pool.getPoolData();
+        const _assets = Object.keys(poolData.assets);
+        const oracleConfig = poolData.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);
+            }
+        }
+        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);
+        return {
+            ...prices,
+            ...vaultAssets.reduce((acc, asset) => {
+                acc[asset] = { type: 10, price: BigInt(1e8) };
+                return acc;
+            }, {})
+        };
+    }
+    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 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 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, {
+            ...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], matchedTx3.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 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 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 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 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 vault = this.open(StormVault.createFromAddress(data.sourceAddress));
+                    const { lpRate } = await vault.getVaultRate();
+                    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) {
+                    if (!accumStatus[userAssets[i].address.toString()])
+                        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,
+                            });
+                        }
+                    }
+                }
+            }
+            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) {
+        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);
+            // accountData.status["EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs"].borrow += 4637173n;
+        }
+        catch (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 result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(assets, poolData.oracleConfig);
+        const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
+        const onchainData2 = await this.updateOnchainData(poolData.oracleConfig.assetOnchainDataInfo);
+        const onchainData = { ...od, ...onchainData2 };
+        Object.keys(onchainData).forEach((key) => {
+            if (!result.requestAssets.map((item) => item.toString()).includes(key) &&
+                !result.redstoneAssets.map((item) => item.toString()).includes(key)) {
+                delete onchainData[key];
+            }
+        });
+        const prices = this.calculatePrices(redstonePrices, onchainData);
+        const decomposedAccountStatus = this.decomposeAccountStatus(accountData.status, prices, onchainData);
+        return this.calculateRisk(decomposedAccountStatus, prices, poolData);
+    }
+    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 { 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 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;
+    }
+}
+exports.PoolCacheV1 = PoolCacheV1;
+class StormVault {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new StormVault(address);
+    }
+    async getVaultRate(provider) {
+        const { stack } = await provider.get("get_vault_data", []);
+        const jettonWalletAddress = stack.readAddress();
+        const lpRate = stack.readBigNumber();
+        const lpTotalSupply = stack.readBigNumber();
+        const freeBalance = stack.readBigNumber();
+        const lockedBalance = stack.readBigNumber();
+        const withdrawLockedBalance = stack.readBigNumber();
+        const stakersBalance = stack.readBigNumber();
+        const executorsBalance = stack.readBigNumber();
+        return {
+            jettonWalletAddress,
+            lpRate,
+            lpTotalSupply,
+            freeBalance,
+            lockedBalance,
+            withdrawLockedBalance,
+            stakersBalance,
+        };
+    }
+}