@affluent-org/sdk 0.0.1

package/dist/services/strategy-vault/manager/index.js

@@ -0,0 +1,475 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSupplyToFactorialMsg = createSupplyToFactorialMsg;
+exports.createBorrowFromFactorialMsg = createBorrowFromFactorialMsg;
+exports.createRepayToFactorialMsg = createRepayToFactorialMsg;
+exports.createWithdrawFromFactorialMsg = createWithdrawFromFactorialMsg;
+exports.createLiquidateToFactorialMsg = createLiquidateToFactorialMsg;
+exports.createDepositToVaultMsg = createDepositToVaultMsg;
+exports.createWithdrawFromVaultMsg = createWithdrawFromVaultMsg;
+exports.createDepositToVaultQueueMsg = createDepositToVaultQueueMsg;
+exports.createWithdrawFromVaultQueueMsg = createWithdrawFromVaultQueueMsg;
+exports.createDepositToVaultQueueCancelMsg = createDepositToVaultQueueCancelMsg;
+exports.createWithdrawFromVaultQueueCancelMsg = createWithdrawFromVaultQueueCancelMsg;
+exports.createAmountRFQMsg = createAmountRFQMsg;
+exports.createSlippageRFQMsg = createSlippageRFQMsg;
+exports.createCancelRFQMsg = createCancelRFQMsg;
+exports.sendUnwrapWTON = sendUnwrapWTON;
+exports.createConfirmQueueMsg = createConfirmQueueMsg;
+exports.createExecuteDepositQueueMsg = createExecuteDepositQueueMsg;
+exports.createExecuteWithdrawQueueMsg = createExecuteWithdrawQueueMsg;
+const core_1 = require("@ton/core");
+const utils_1 = require("../../../contracts/common/utils");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+const pool_1 = require("../../../contracts/core/pool");
+const strategy_vault_1 = require("../../../contracts/vault/strategy-vault");
+const codec_1 = require("../../../contracts/vault/strategy-vault/codec");
+const share_vault_1 = require("../../../contracts/vault/share-vault");
+const oracle_1 = require("../oracle");
+const share_vault_2 = require("../../share-vault");
+const computation_1 = require("../../../contracts/vault/strategy-vault/computation");
+const query_1 = require("../query");
+const oracle_2 = require("../oracle");
+__exportStar(require("./types"), exports);
+// ============================================================
+// Factorial Pool Operations
+// ============================================================
+async function createSupplyToFactorialMsg(ctx, sender, params, value) {
+    const strategyVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+    const vaultData = await strategyVault.getVaultData();
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const to = strategyVault.address;
+    const resolvedValue = value ??
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferIn] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+            (0, core_1.toNano)(0.1);
+    const body = strategy_vault_1.StrategyVault.createSupplyToFactorialMsgBody(poolAddress, assetAddress, params.assetAmount, sender.address, params.queryId);
+    return {
+        opts: { strategyVault, vaultData, poolAddress, assetAddress },
+        input: { to, value: resolvedValue, body },
+    };
+}
+async function createBorrowFromFactorialMsg(ctx, sender, params, value) {
+    const strategyVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+    const oracleLibs = new oracle_1.OracleHelper(ctx);
+    const vaultData = await strategyVault.getVaultData();
+    const { oracleParams: oraclePayload } = await oracleLibs.getOracleParamsForStrategyVaultV2(vaultData, [
+        params.assetAddress.toString(),
+        ...Object.keys(vaultData.assets),
+    ]);
+    const oracleCalculateGas = BigInt(Object.keys(vaultData.assets).length + Object.keys(vaultData.factorialPools).length) * (0, core_1.toNano)(0.05);
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const to = strategyVault.address;
+    const resolvedValue = value ??
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferOut] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+            oracleCalculateGas +
+            (0, core_1.toNano)(0.1);
+    const body = strategy_vault_1.StrategyVault.createBorrowFromFactorialMsgBody(oraclePayload, poolAddress, assetAddress, params.assetAmount, params.isShare, sender.address, params.queryId);
+    return {
+        opts: { strategyVault, vaultData, oraclePayload, oracleCalculateGas, poolAddress, assetAddress },
+        input: { to, value: resolvedValue, body },
+    };
+}
+async function createRepayToFactorialMsg(ctx, sender, params, value) {
+    const strategyVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+    const vaultData = await strategyVault.getVaultData();
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const to = strategyVault.address;
+    const resolvedValue = value ??
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferIn] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+            (0, core_1.toNano)(0.1);
+    const body = strategy_vault_1.StrategyVault.createRepayToFactorialMsgBody(poolAddress, assetAddress, params.assetAmount, sender.address, params.queryId);
+    return {
+        opts: { strategyVault, vaultData, poolAddress, assetAddress },
+        input: { to, value: resolvedValue, body },
+    };
+}
+async function createWithdrawFromFactorialMsg(ctx, sender, params, value) {
+    const strategyVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+    const pool = ctx.getByContract(pool_1.Pool, params.poolAddress);
+    const oracleLibs = new oracle_1.OracleHelper(ctx);
+    const vaultData = await strategyVault.getVaultData();
+    const poolData = await pool.getPoolData();
+    const poolOraclePayload = await oracleLibs.getOracleParamsForPool(poolData, [params.assetAddress.toString()]);
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const to = strategyVault.address;
+    const resolvedValue = value ??
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialTransferOut] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+            (0, core_1.toNano)(0.1);
+    const body = strategy_vault_1.StrategyVault.createWithdrawFromFactorialMsgBody(poolOraclePayload, poolAddress, assetAddress, params.assetAmount, params.isShare, sender.address, params.queryId);
+    return {
+        opts: { strategyVault, pool, vaultData, poolData, poolOraclePayload, poolAddress, assetAddress },
+        input: { to, value: resolvedValue, body },
+    };
+}
+async function createLiquidateToFactorialMsg(ctx, sender, params, value) {
+    const strategyVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+    const vaultData = await strategyVault.getVaultData();
+    const oraclePayload = await (0, oracle_2.getOracleParams)(ctx, strategyVault.address);
+    const oracleCalculateGas = BigInt(Object.keys(vaultData.assets).length + Object.keys(vaultData.factorialPools).length) * (0, core_1.toNano)(0.05);
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const borrowerAddress = (0, utils_1.toAddress)(params.borrowerAddress);
+    const repayAssetAddress = (0, utils_1.toAddress)(params.repayAssetAddress);
+    const seizeAssetAddress = (0, utils_1.toAddress)(params.seizeAssetAddress);
+    const to = strategyVault.address;
+    const resolvedValue = value ??
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.FactorialLiquidate] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+            oracleCalculateGas +
+            (0, core_1.toNano)(0.1);
+    const body = strategy_vault_1.StrategyVault.createLiquidateToFactorialMsgBody(oraclePayload, poolAddress, borrowerAddress, repayAssetAddress, seizeAssetAddress, params.repayAmount, sender.address, params.queryId);
+    return {
+        opts: { strategyVault, vaultData, oraclePayload, oracleCalculateGas, poolAddress, borrowerAddress, repayAssetAddress, seizeAssetAddress },
+        input: { to, value: resolvedValue, body },
+    };
+}
+// ============================================================
+// Vault-to-Vault Operations
+// ============================================================
+async function createDepositToVaultMsg(ctx, sender, params) {
+    const oracle = new oracle_1.OracleHelper(ctx);
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const strategyVaultData = await strategyVault.getVaultData();
+    const targetVaultType = await ctx.getAssetType(params.depositToVault);
+    const strategyResponseGas = strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.IncreaseBalance] +
+        strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ActionNotification];
+    const bucket = (0, oracle_1.createOracleExposures)();
+    let targetVaultOracleParams;
+    let forwardTonAmount = 0n;
+    if (targetVaultType.type === "share-vault") {
+        const depositToVault = ctx.getByContract(share_vault_1.ShareVault, params.depositToVault);
+        const shareVaultData = await depositToVault.getVaultData();
+        const shareVaultSupplyGas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.Supply, share_vault_1.ShareVault.Gas.baseFee, Object.keys(shareVaultData.whitelistedPools).length, shareVaultData.minimumGasFee);
+        forwardTonAmount = shareVaultSupplyGas + strategyResponseGas;
+    }
+    else if (targetVaultType.type === "strategy-vault") {
+        const depositToVault = (0, query_1.getVault)(ctx, params.depositToVault);
+        const depositToVaultData = await depositToVault.getVaultData();
+        const targetVaultOracleInfo = await oracle.getOracleParamsForStrategyVault(depositToVault.address, depositToVaultData, bucket);
+        targetVaultOracleParams = targetVaultOracleInfo.oracleParams;
+        const targetDepositGas = depositToVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Deposit];
+        forwardTonAmount = (0, core_1.toNano)(bucket.totalSize() * 0.05) + targetDepositGas + strategyResponseGas;
+    }
+    else {
+        throw new Error("Invalid target vault type");
+    }
+    const { oracleParams } = await oracle.getOracleParamsForStrategyVault(strategyVault.address, strategyVaultData, bucket);
+    const vaultStrategyGas = (0, core_1.toNano)(bucket.totalSize() * 0.05) +
+        strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.VaultInteraction];
+    const sendValue = params.value ?? vaultStrategyGas + forwardTonAmount + (0, core_1.toNano)(0.1);
+    const to = strategyVault.address;
+    const body = strategy_vault_1.StrategyVault.createDepositToVaultMsgBody({
+        oracleParams,
+        vaultInteractParams: {
+            vaultAddress: (0, utils_1.toAddress)(params.depositToVault),
+            assetAddress: (0, utils_1.toAddress)(params.assetAddress),
+            assetAmount: params.amount,
+            forwardTonAmount,
+        },
+        targetVaultOracleParams,
+        queryId: params.queryId,
+    });
+    return {
+        opts: { strategyVault, strategyVaultData, targetVaultType, oracleParams, targetVaultOracleParams, forwardTonAmount, vaultStrategyGas },
+        input: { to, value: sendValue, body },
+    };
+}
+async function createWithdrawFromVaultMsg(ctx, sender, params) {
+    const oracle = new oracle_1.OracleHelper(ctx);
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const strategyVaultData = await strategyVault.getVaultData();
+    const targetVaultType = await ctx.getAssetType(params.withdrawFromVault);
+    const strategyResponseGas = strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.IncreaseBalance] +
+        2n * strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ActionNotification];
+    const bucket = (0, oracle_1.createOracleExposures)();
+    let targetVaultOracleParams;
+    let forwardTonAmount = 0n;
+    if (targetVaultType.type === "share-vault") {
+        const withdrawFromVault = ctx.getByContract(share_vault_1.ShareVault, params.withdrawFromVault);
+        const shareVaultData = await withdrawFromVault.getVaultData();
+        const { count } = await new share_vault_2.ShareVaultServiceV1(ctx).estimateWithdrawLiquidityFulfillmentPoolCount(shareVaultData, params.withdrawAmount);
+        const targetWithdrawGas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.Withdraw, share_vault_1.ShareVault.Gas.baseFee, count, shareVaultData.minimumGasFee);
+        forwardTonAmount = targetWithdrawGas + strategyResponseGas + (0, core_1.toNano)(0.1);
+    }
+    else if (targetVaultType.type === "strategy-vault") {
+        const withdrawFromVault = (0, query_1.getVault)(ctx, params.withdrawFromVault);
+        const withdrawFromVaultData = await withdrawFromVault.getVaultData();
+        const targetVaultOracleInfo = await oracle.getOracleParamsForStrategyVault(withdrawFromVault.address, withdrawFromVaultData, bucket);
+        targetVaultOracleParams = targetVaultOracleInfo.oracleParams;
+        const targetWithdrawGas = withdrawFromVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Withdraw];
+        forwardTonAmount = (0, core_1.toNano)(bucket.totalSize() * 0.05) + targetWithdrawGas + strategyResponseGas;
+    }
+    else {
+        throw new Error("Invalid target vault type");
+    }
+    const { oracleParams } = await oracle.getOracleParamsForStrategyVault(strategyVault.address, strategyVaultData, bucket);
+    const vaultStrategyGas = (0, core_1.toNano)(bucket.totalSize() * 0.05) +
+        strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.VaultInteraction];
+    const sendValue = params.value ?? vaultStrategyGas + forwardTonAmount + (0, core_1.toNano)(0.1);
+    const to = strategyVault.address;
+    const body = (0, codec_1.createWithdrawFromVaultMsgBody)({
+        oracleParams,
+        vaultInteractParams: {
+            targetVaultAddress: (0, utils_1.toAddress)(params.withdrawFromVault),
+            targetVaultAmount: params.withdrawAmount,
+            assetAddress: (0, utils_1.toAddress)(params.assetAddress),
+            forwardTonAmount,
+        },
+        targetVaultOracleParams,
+        queryId: params.queryId,
+    });
+    return {
+        opts: { strategyVault, strategyVaultData, targetVaultType, oracleParams, targetVaultOracleParams, forwardTonAmount, vaultStrategyGas },
+        input: { to, value: sendValue, body },
+    };
+}
+async function createDepositToVaultQueueMsg(ctx, sender, params) {
+    const oracle = new oracle_1.OracleHelper(ctx);
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const strategyVaultData = await strategyVault.getVaultData();
+    const targetVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.depositToVaultQueue);
+    const targetVaultData = await targetVault.getVaultData();
+    const { oracleParams, bucket } = await oracle.getOracleParamsForStrategyVault(strategyVault.address, strategyVaultData);
+    const vaultStrategyGas = (0, core_1.toNano)(bucket.totalSize() * 0.05) +
+        strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.JettonTransfer] +
+        strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.VaultInteraction];
+    const forwardTonAmount = strategy_vault_1.StrategyVault.calcQueueResistGas(targetVaultData, {
+        actionForwardTonAmount: strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ActionNotification],
+        jettonForwardTonAmount: strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.IncreaseBalance],
+    });
+    const sendValue = params.value ?? vaultStrategyGas + forwardTonAmount + (0, core_1.toNano)(0.1);
+    const to = strategyVault.address;
+    const body = (0, codec_1.createDepositToVaultQueueMsgBody)({
+        oracleParams,
+        vaultQueueInteractParams: {
+            vaultAddress: (0, utils_1.toAddress)(params.depositToVaultQueue),
+            assetAddress: (0, utils_1.toAddress)(params.assetAddress),
+            assetAmount: params.amount,
+        },
+        queryId: params.queryId,
+    });
+    return {
+        opts: { strategyVault, strategyVaultData, targetVault, targetVaultData, oracleParams, vaultStrategyGas, forwardTonAmount },
+        input: { to, value: sendValue, body },
+    };
+}
+async function createWithdrawFromVaultQueueMsg(ctx, sender, params) {
+    const oracle = new oracle_1.OracleHelper(ctx);
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const strategyVaultData = await strategyVault.getVaultData();
+    const targetVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.withdrawFromVaultQueue);
+    const targetVaultData = await targetVault.getVaultData();
+    const { oracleParams, bucket } = await oracle.getOracleParamsForStrategyVault(strategyVault.address, strategyVaultData);
+    const vaultStrategyGas = (0, core_1.toNano)(bucket.totalSize() * 0.05) +
+        strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.JettonTransfer] +
+        strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.VaultInteraction];
+    const forwardTonAmount = strategy_vault_1.StrategyVault.calcQueueResistGas(targetVaultData, {
+        actionForwardTonAmount: strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ActionNotification],
+        jettonForwardTonAmount: strategyVaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.IncreaseBalance],
+    });
+    const sendValue = params.value ?? vaultStrategyGas + forwardTonAmount + (0, core_1.toNano)(0.1);
+    const to = strategyVault.address;
+    const body = (0, codec_1.createWithdrawFromVaultQueueMsgBody)({
+        oracleParams,
+        vaultQueueInteractParams: {
+            targetVaultAddress: (0, utils_1.toAddress)(params.withdrawFromVaultQueue),
+            targetVaultAmount: params.amount,
+            assetAddress: (0, utils_1.toAddress)(params.assetAddress),
+        },
+        queryId: params.queryId,
+    });
+    return {
+        opts: { strategyVault, strategyVaultData, targetVault, targetVaultData, oracleParams, vaultStrategyGas, forwardTonAmount },
+        input: { to, value: sendValue, body },
+    };
+}
+async function createDepositToVaultQueueCancelMsg(ctx, sender, params) {
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const sendValue = params.value ?? (0, core_1.toNano)(0.1);
+    const to = strategyVault.address;
+    const body = (0, codec_1.createCancelDepositToVaultQueueMsgBody)((0, utils_1.toAddress)(params.depositToVaultQueue), (0, utils_1.toAddress)(params.assetAddress), params.queryId);
+    return {
+        opts: { strategyVault },
+        input: { to, value: sendValue, body },
+    };
+}
+async function createWithdrawFromVaultQueueCancelMsg(ctx, sender, params) {
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const sendValue = params.value ?? (0, core_1.toNano)(0.1);
+    const to = strategyVault.address;
+    const body = (0, codec_1.createCancelWithdrawFromVaultQueueMsgBody)((0, utils_1.toAddress)(params.withdrawFromVaultQueue), (0, utils_1.toAddress)(params.assetAddress), params.queryId);
+    return {
+        opts: { strategyVault },
+        input: { to, value: sendValue, body },
+    };
+}
+// ============================================================
+// RFQ Operations
+// ============================================================
+async function createAmountRFQMsg(ctx, sender, params, value) {
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const vaultData = await strategyVault.getVaultData();
+    const rfqIndex = vaultData.rfqIndex;
+    const rfqAuctionAddress = await strategyVault.getRFQAddress(rfqIndex);
+    const sellAssetAddress = (0, utils_1.toAddress)(params.sellAssetAddress);
+    const buyAssetAddress = (0, utils_1.toAddress)(params.buyAssetAddress);
+    const sellAssetRFQWallet = await ctx.getByContract(jetton_minter_1.JettonMinter, sellAssetAddress).getWalletAddress(rfqAuctionAddress);
+    const buyAssetRFQWallet = await ctx.getByContract(jetton_minter_1.JettonMinter, buyAssetAddress).getWalletAddress(rfqAuctionAddress);
+    const oracleLibs = new oracle_1.OracleHelper(ctx);
+    const { oracleParams, bucket } = await oracleLibs.getOracleParamsForStrategyVaultV2(vaultData, [
+        ...Object.keys(vaultData.assets),
+    ]);
+    const oracleCalculateGas = BigInt(bucket.assets.size + bucket.pools.size + bucket.vaults.size) * (0, core_1.toNano)(0.05);
+    const to = strategyVault.address;
+    const resolvedValue = value ??
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.CreateRFQ] +
+            oracleCalculateGas +
+            (0, core_1.toNano)(0.1);
+    const body = strategy_vault_1.StrategyVault.createCreateRFQMsgBody(rfqIndex, sellAssetAddress, buyAssetAddress, params.sellAssetAmount, params.minBuyAssetAmount, params.maxBuyAssetAmount, sellAssetRFQWallet, buyAssetRFQWallet, oracleParams, params.period, params.allowSellerCancel, params.allowBidderCancel, true, // isAmountBid
+    params.queryId);
+    return {
+        opts: { strategyVault, vaultData, rfqIndex, rfqAuctionAddress, sellAssetAddress, buyAssetAddress, sellAssetRFQWallet, buyAssetRFQWallet, oracleParams, oracleCalculateGas },
+        input: { to, value: resolvedValue, body },
+    };
+}
+async function createSlippageRFQMsg(ctx, sender, params, value) {
+    const strategyVault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const vaultData = await strategyVault.getVaultData();
+    const rfqIndex = vaultData.rfqIndex;
+    const rfqAuctionAddress = await strategyVault.getRFQAddress(rfqIndex);
+    const sellAssetAddress = (0, utils_1.toAddress)(params.sellAssetAddress);
+    const buyAssetAddress = (0, utils_1.toAddress)(params.buyAssetAddress);
+    const sellAssetRFQWallet = await ctx.getByContract(jetton_minter_1.JettonMinter, sellAssetAddress).getWalletAddress(rfqAuctionAddress);
+    const buyAssetRFQWallet = await ctx.getByContract(jetton_minter_1.JettonMinter, buyAssetAddress).getWalletAddress(rfqAuctionAddress);
+    const oracleLibs = new oracle_1.OracleHelper(ctx);
+    const { oracleParams, bucket } = await oracleLibs.getOracleParamsForStrategyVaultV2(vaultData, [
+        ...Object.keys(vaultData.assets),
+    ]);
+    const oracleCalculateGas = BigInt(bucket.assets.size + bucket.pools.size + bucket.vaults.size) * (0, core_1.toNano)(0.05);
+    const slippageBoundConfig = (0, computation_1.toSlippageConfig)(params.slippageBound);
+    const to = strategyVault.address;
+    const resolvedValue = value ??
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.ExecuteStrategy] +
+            vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.CreateRFQ] +
+            oracleCalculateGas +
+            (0, core_1.toNano)(0.1);
+    const body = strategy_vault_1.StrategyVault.createCreateRFQMsgBody(rfqIndex, sellAssetAddress, buyAssetAddress, params.sellAssetAmount, slippageBoundConfig.min, slippageBoundConfig.max, sellAssetRFQWallet, buyAssetRFQWallet, oracleParams, params.period, params.allowSellerCancel, params.allowBidderCancel, false, // isAmountBid
+    params.queryId);
+    return {
+        opts: { strategyVault, vaultData, rfqIndex, rfqAuctionAddress, sellAssetAddress, buyAssetAddress, sellAssetRFQWallet, buyAssetRFQWallet, oracleParams, oracleCalculateGas, slippageBoundConfig },
+        input: { to, value: resolvedValue, body },
+    };
+}
+async function createCancelRFQMsg(ctx, sender, params, value) {
+    const strategyVault = ctx.getByContract(strategy_vault_1.StrategyVault, params.strategyVaultAddress);
+    const to = strategyVault.address;
+    const resolvedValue = value ?? (0, core_1.toNano)(0.05);
+    const body = strategy_vault_1.StrategyVault.createCancelRFQMsgBody(params.rfqIndex, params.queryID);
+    return {
+        opts: { strategyVault },
+        input: { to, value: resolvedValue, body },
+    };
+}
+async function sendUnwrapWTON(ctx, sender, params, value) {
+    if (!ctx.isWTON(params.wtonAddress)) {
+        throw new Error("WTON address is not valid");
+    }
+    const senderAddress = (0, utils_1.toAddress)(params.senderAddress);
+    const wtonAddress = (0, utils_1.toAddress)(params.wtonAddress);
+}
+// ============================================================
+// Queue Confirm/Execute Operations
+// ============================================================
+async function createConfirmQueueMsg(ctx, sender, params) {
+    const vault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const vaultData = await vault.getVaultData();
+    const gasConfig = vaultData.gasConfig;
+    const oracle = new oracle_1.OracleHelper(ctx);
+    const oracleParams = params.oracleParams ??
+        (await oracle.getOracleParamsForStrategyVaultV2(vaultData, [...Object.keys(vaultData.assets)])).oracleParams;
+    const depositAssets = params.depositAssets ??
+        Object.entries(vaultData.depositQueueManager.pendingAssetQueue)
+            .filter(([key, value]) => {
+            return value.sum > 0n && !vaultData.depositQueueManager.confirmedAssetQueue[key];
+        })
+            .map(([key]) => (0, utils_1.toAddress)(key));
+    const withdrawAssets = params.withdrawAssets ??
+        Object.entries(vaultData.withdrawQueueManager.pendingAssetQueue)
+            .filter(([key, value]) => {
+            return value.sum > 0n && !vaultData.withdrawQueueManager.confirmedAssetQueue[key];
+        })
+            .map(([key]) => (0, utils_1.toAddress)(key));
+    const depositLogicGas = depositAssets.length
+        ? gasConfig[strategy_vault_1.StrategyVault.GasKey.Deposit] +
+            gasConfig[strategy_vault_1.StrategyVault.GasKey.DepositLogic] * BigInt(depositAssets.length)
+        : 0n;
+    const withdrawLogicGas = withdrawAssets.length
+        ? gasConfig[strategy_vault_1.StrategyVault.GasKey.Withdraw] +
+            gasConfig[strategy_vault_1.StrategyVault.GasKey.WithdrawLogic] * BigInt(withdrawAssets.length)
+        : 0n;
+    const estimateGas = withdrawLogicGas + depositLogicGas + (0, core_1.toNano)(0.05);
+    const to = (0, utils_1.toAddress)(params.strategyVaultAddress);
+    const value = params.value ?? estimateGas + (0, core_1.toNano)(0.05);
+    const queryId = params.queryId ?? 0n;
+    return {
+        opts: { vault, vaultData, to, value, depositAssets, withdrawAssets, oracleParams, queryId },
+        input: {
+            to,
+            value,
+            body: strategy_vault_1.StrategyVault.createConfirmQueueBody({ depositAssets, withdrawAssets, oracleParams, queryId }),
+        },
+    };
+}
+async function createExecuteDepositQueueMsg(ctx, sender, params) {
+    params.count ??= 50n;
+    const to = (0, utils_1.toAddress)(params.strategyVaultAddress);
+    const value = params.value ?? (0, core_1.toNano)(0.05);
+    const asset = (0, utils_1.toAddress)(params.assetAddress);
+    const count = params.count;
+    const queryId = params.queryId ?? 0n;
+    return {
+        opts: { to, value, asset, count, queryId },
+        input: {
+            to,
+            value,
+            body: strategy_vault_1.StrategyVault.createExecuteDepositQueueBody({ asset, count, queryId }),
+        },
+    };
+}
+async function createExecuteWithdrawQueueMsg(ctx, sender, params) {
+    const to = (0, utils_1.toAddress)(params.strategyVaultAddress);
+    const value = params.value ?? (0, core_1.toNano)(0.05);
+    const asset = (0, utils_1.toAddress)(params.assetAddress);
+    const count = params.count ?? 50n;
+    const queryId = params.queryId ?? 0n;
+    return {
+        opts: { to, value, asset, count, queryId },
+        input: {
+            to,
+            value,
+            body: strategy_vault_1.StrategyVault.createExecuteWithdrawQueueBody({ asset, count, queryId }),
+        },
+    };
+}

package/dist/services/strategy-vault/manager/types.d.ts

@@ -0,0 +1,144 @@
+import { Address, Cell } from "@ton/core";
+import { AddressInput, AddressLike } from "../../../contracts/common/type";
+import { SippageBoundInput } from "../../../contracts/vault/strategy-vault/computation";
+export type SupplyToFactorialParams = {
+    strategyVaultAddress: AddressInput;
+    poolAddress: AddressLike;
+    assetAddress: AddressLike;
+    assetAmount: bigint;
+    queryId?: number;
+};
+export type BorrowFromFactorialParams = {
+    strategyVaultAddress: AddressInput;
+    poolAddress: AddressLike;
+    assetAddress: AddressLike;
+    assetAmount: bigint;
+    isShare: boolean;
+    queryId?: number;
+};
+export type RepayToFactorialParams = {
+    strategyVaultAddress: AddressInput;
+    poolAddress: AddressLike;
+    assetAddress: AddressLike;
+    assetAmount: bigint;
+    queryId?: number;
+};
+export type WithdrawFromFactorialParams = {
+    strategyVaultAddress: AddressInput;
+    poolAddress: AddressLike;
+    assetAddress: AddressLike;
+    assetAmount: bigint;
+    isShare: boolean;
+    queryId?: number;
+};
+export type LiquidateToFactorialParams = {
+    strategyVaultAddress: AddressInput;
+    poolAddress: AddressLike;
+    borrowerAddress: AddressLike;
+    repayAssetAddress: AddressLike;
+    seizeAssetAddress: AddressLike;
+    repayAmount: bigint;
+    queryId?: number;
+};
+export type DepositToVaultParams = {
+    strategyVaultAddress: AddressInput;
+    depositToVault: AddressInput;
+    assetAddress: AddressInput;
+    amount: bigint;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type WithdrawFromVaultParams = {
+    strategyVaultAddress: AddressInput;
+    withdrawFromVault: AddressInput;
+    withdrawAmount: bigint;
+    assetAddress: AddressInput;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type DepositToVaultQueueParams = {
+    strategyVaultAddress: AddressInput;
+    depositToVaultQueue: AddressInput;
+    assetAddress: AddressInput;
+    amount: bigint;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type WithdrawFromVaultQueueParams = {
+    strategyVaultAddress: AddressInput;
+    withdrawFromVaultQueue: AddressInput;
+    assetAddress: AddressInput;
+    amount: bigint;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type DepositToVaultQueueCancelParams = {
+    strategyVaultAddress: AddressInput;
+    depositToVaultQueue: AddressInput;
+    assetAddress: AddressInput;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type WithdrawFromVaultQueueCancelParams = {
+    strategyVaultAddress: AddressInput;
+    withdrawFromVaultQueue: AddressInput;
+    assetAddress: AddressInput;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type CreateAmountRFQParams = {
+    strategyVaultAddress: AddressInput;
+    sellAssetAddress: AddressLike;
+    buyAssetAddress: AddressLike;
+    sellAssetAmount: bigint;
+    minBuyAssetAmount: bigint;
+    maxBuyAssetAmount: bigint;
+    period: number;
+    allowSellerCancel: boolean;
+    allowBidderCancel: boolean;
+    queryId?: number;
+};
+export type CreateSlippageRFQParams = {
+    strategyVaultAddress: AddressInput;
+    sellAssetAddress: AddressLike;
+    buyAssetAddress: AddressLike;
+    sellAssetAmount: bigint;
+    slippageBound: SippageBoundInput;
+    period: number;
+    allowSellerCancel: boolean;
+    allowBidderCancel: boolean;
+    queryId?: number;
+};
+export type CancelRFQParams = {
+    strategyVaultAddress: AddressInput;
+    rfqIndex: bigint;
+    queryID?: number;
+};
+export type UnwrapWTONParams = {
+    senderAddress: AddressLike;
+    wtonAddress: AddressLike;
+    amount: bigint;
+    queryId?: number;
+};
+export type SendConfirmQueueParams = {
+    strategyVaultAddress: AddressInput;
+    depositAssets?: Address[];
+    withdrawAssets?: Address[];
+    oracleParams?: Cell;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type ExecuteDepositQueueParams = {
+    strategyVaultAddress: AddressInput;
+    assetAddress: AddressLike;
+    count?: bigint;
+    value?: bigint;
+    queryId?: bigint;
+};
+export type ExecuteWithdrawQueueParams = {
+    strategyVaultAddress: AddressInput;
+    assetAddress: AddressLike;
+    count?: bigint;
+    value?: bigint;
+    queryId?: bigint;
+};

package/dist/services/strategy-vault/manager/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });