@affluent-org/sdk 0.0.5 → 0.0.7

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

@@ -36,7 +36,7 @@ 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.StrategyVaultV1 = exports.user = exports.manager = exports.owner = exports.createQueryId = exports.sendMsg = void 0;
+exports.StrategyVaultServiceV1 = exports.user = exports.manager = exports.owner = exports.createQueryId = exports.sendMsg = void 0;
 const context_1 = require("../../context");
 const send_msg_1 = require("../../lib/send-msg");
 const composite_oracle_1 = require("../composite-oracle");
@@ -49,6 +49,7 @@ exports.manager = manager;
 const user = __importStar(require("./user"));
 exports.user = user;
 const utils_1 = require("../../contracts/common/utils");
+const trace_1 = require("./user/trace");
 var send_msg_2 = require("../../lib/send-msg");
 Object.defineProperty(exports, "sendMsg", { enumerable: true, get: function () { return send_msg_2.sendMsg; } });
 var computation_1 = require("../../contracts/vault/strategy-vault/computation");
@@ -56,7 +57,8 @@ Object.defineProperty(exports, "createQueryId", { enumerable: true, get: functio
 __exportStar(require("./owner/types"), exports);
 __exportStar(require("./manager/types"), exports);
 __exportStar(require("./user/types"), exports);
-class StrategyVaultV1 {
+__exportStar(require("./user/trace"), exports);
+class StrategyVaultServiceV1 {
     ctx;
     constructor(ctx = context_1.AffluentContext.getInstance()) {
         this.ctx = ctx;
@@ -107,163 +109,322 @@ class StrategyVaultV1 {
     // Owner
     // ============================================================
     async sendSetOwner(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetOwnerMsg(this.ctx, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetOwnerMsg(this.ctx, params));
+        await trace.wait();
+        return trace;
     }
     async sendSetGuardianAddress(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetGuardianAddressMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetGuardianAddressMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetManager(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetManagerMsg(this.ctx, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetManagerMsg(this.ctx, params));
+        await trace.wait();
+        return trace;
     }
     async sendSetPrivateVault(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetPrivateVaultMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetPrivateVaultMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetWhitelistedMinters(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetWhitelistedMintersMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetWhitelistedMintersMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetMaxLeverageRatio(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetMaxLeverageRatioMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetMaxLeverageRatioMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendExecuteOwnerAction(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createExecuteOwnerActionMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createExecuteOwnerActionMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendRevertOwnerAction(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createRevertOwnerActionMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createRevertOwnerActionMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetTimelock(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetTimelockMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetTimelockMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetManagementFeeRecipientAddress(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetManagementFeeRecipientAddressMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetManagementFeeRecipientAddressMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetProtocolFeeRatePerYear(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetProtocolFeeRatePerYearMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetProtocolFeeRatePerYearMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetProtocolFeeManagerAddress(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetProtocolFeeManagerAddressMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetProtocolFeeManagerAddressMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetFactorialPoolConfig(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetFactorialPoolConfigMsg(this.ctx, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetFactorialPoolConfigMsg(this.ctx, params));
+        await trace.wait();
+        return trace;
     }
     async sendSetAssetConfig(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetAssetConfigMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetAssetConfigMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetRFQConfig(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetRFQConfigMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetRFQConfigMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetManagementFeeRatePerYear(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetManagementFeeRatePerYearMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetManagementFeeRatePerYearMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetDepositCloseTimestamp(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetDepositCloseTimestampMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetDepositCloseTimestampMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetWithdrawOpenTimestamp(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetWithdrawOpenTimestampMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetWithdrawOpenTimestampMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetGasConfig(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetGasConfigMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetGasConfigMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetOracleConfig(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetOracleConfigMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetOracleConfigMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetWalletCode(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetWalletCodeMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetWalletCodeMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetDataAggregatorCode(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetDataAggregatorCodeMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetDataAggregatorCodeMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetRFQCode(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetRFQCodeMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetRFQCodeMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetContent(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetContentMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetContentMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendUpgradeCode(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createUpgradeCodeMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createUpgradeCodeMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendCollectProtocolFee(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createCollectProtocolFeeMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createCollectProtocolFeeMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendClaimManagementFee(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createClaimManagementFeeMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createClaimManagementFeeMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     // ============================================================
     // Manager
     // ============================================================
     async sendSupplyToFactorial(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createSupplyToFactorialMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createSupplyToFactorialMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendBorrowFromFactorial(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createBorrowFromFactorialMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createBorrowFromFactorialMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendRepayToFactorial(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createRepayToFactorialMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createRepayToFactorialMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendWithdrawFromFactorial(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createWithdrawFromFactorialMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createWithdrawFromFactorialMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendLiquidateToFactorial(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createLiquidateToFactorialMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createLiquidateToFactorialMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendDepositToVault(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createDepositToVaultMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createDepositToVaultMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendWithdrawFromVault(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createWithdrawFromVaultMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createWithdrawFromVaultMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendDepositToVaultQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createDepositToVaultQueueMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createDepositToVaultQueueMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendWithdrawFromVaultQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createWithdrawFromVaultQueueMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createWithdrawFromVaultQueueMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendDepositToVaultQueueCancel(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createDepositToVaultQueueCancelMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createDepositToVaultQueueCancelMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendWithdrawFromVaultQueueCancel(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createWithdrawFromVaultQueueCancelMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createWithdrawFromVaultQueueCancelMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendCreateAmountRFQ(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createAmountRFQMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createAmountRFQMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendCreateSlippageRFQ(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createSlippageRFQMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createSlippageRFQMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendCancelRFQ(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createCancelRFQMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createCancelRFQMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendUnwrapWTON(sender, params, value) {
         return manager.sendUnwrapWTON(this.ctx, sender, params, value);
     }
     async sendConfirmQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createConfirmQueueMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createConfirmQueueMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendExecuteDepositQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createExecuteDepositQueueMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createExecuteDepositQueueMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     async sendExecuteWithdrawQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createExecuteWithdrawQueueMsg(this.ctx, sender, params));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createExecuteWithdrawQueueMsg(this.ctx, sender, params));
+        await trace.wait();
+        return trace;
     }
     // ============================================================
     // User
     // ============================================================
     async sendDepositAsset(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createDepositAssetMsg(this.ctx, sender, params, value));
+        const msg = await user.createDepositAssetMsg(this.ctx, sender, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const asset = (0, utils_1.toAddress)(params.assetAddress);
+        const trace = await trace_1.StrategyVaultDepositTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset,
+            vault: (0, utils_1.toAddress)(params.strategyVaultAddress),
+            isWTON: this.ctx.isWTON(asset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendBurnVaultAsset(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createBurnVaultAssetMsg(this.ctx, sender, params, value));
+        const msg = await user.createBurnVaultAssetMsg(this.ctx, sender, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const trace = await trace_1.StrategyVaultWithdrawTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            withdrawAsset: (0, utils_1.toAddress)(params.withdrawAssetAddress),
+            vault: (0, utils_1.toAddress)(params.strategyVaultAddress),
+            isWTON: this.ctx.isWTON((0, utils_1.toAddress)(params.withdrawAssetAddress)),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendDepositQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, user.createDepositQueueMsg(this.ctx, sender, params));
+        const msg = await user.createDepositQueueMsg(this.ctx, sender, params);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const asset = (0, utils_1.toAddress)(params.assetAddress);
+        const trace = await trace_1.StrategyVaultDepositQueueTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset,
+            vault: (0, utils_1.toAddress)(params.strategyVaultAddress),
+            isWTON: this.ctx.isWTON(asset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendWithdrawQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, user.createWithdrawQueueMsg(this.ctx, sender, params));
+        const msg = await user.createWithdrawQueueMsg(this.ctx, sender, params);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const trace = await trace_1.StrategyVaultWithdrawQueueTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            vault: (0, utils_1.toAddress)(params.strategyVaultAddress),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendCancelDepositQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, user.createCancelDepositQueueMsg(this.ctx, params));
+        const msg = await user.createCancelDepositQueueMsg(this.ctx, params);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const asset = (0, utils_1.toAddress)(params.assetAddress);
+        const trace = await trace_1.StrategyVaultCancelDepositQueueTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset,
+            vault: (0, utils_1.toAddress)(params.strategyVaultAddress),
+            isWTON: this.ctx.isWTON(asset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendCancelWithdrawQueue(sender, params) {
-        return (0, send_msg_1.sendMsg)(sender, user.createCancelWithdrawQueueMsg(this.ctx, params));
+        const msg = await user.createCancelWithdrawQueueMsg(this.ctx, params);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const trace = await trace_1.StrategyVaultCancelWithdrawQueueTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            vault: (0, utils_1.toAddress)(params.strategyVaultAddress),
+        });
+        await trace.wait();
+        return trace;
     }
     async getValuationContext(vaultAddress) {
         return query.getValuationContext(this.ctx, (0, utils_1.toAddress)(vaultAddress));
@@ -278,4 +439,4 @@ class StrategyVaultV1 {
         return query.getNativeAmountDecomposedContext(this.ctx, vaultAddress);
     }
 }
-exports.StrategyVaultV1 = StrategyVaultV1;
+exports.StrategyVaultServiceV1 = StrategyVaultServiceV1;

package/dist/services/strategy-vault/oracle.js

@@ -114,6 +114,7 @@ class OracleHelper {
         const oracleConfig = vaultData.oracleConfig;
         const allAssets = [...Object.keys(vaultData.assets), ...additionalAssets];
         const { vaultAssets } = (0, computation_1.separateAssets)(allAssets, oracleConfig);
+        vaultAssets.push(vaultData.address.toString()); // include self
         // Fetch
         const vaultPositions = await this.fetcher.fetchVaultPositions(vaultAssets);
         // Compute

package/dist/services/strategy-vault/owner/index.d.ts

@@ -1,7 +1,7 @@
 import { Dictionary } from "@ton/core";
 import { AffluentContext } from "../../../context";
 import { StrategyVault } from "../../../contracts/vault/strategy-vault";
-import { SetOwnerParams, SetGuardianAddressParams, SetManagerParams, SetPrivateVaultParams, SetWhitelistedMintersParams, SetMaxLeverageRatioParams, ExecuteOwnerActionParams, RevertOwnerActionParams, SetTimelockParams, SetManagementFeeRecipientAddressParams, SetProtocolFeeRatePerYearParams, SetProtocolFeeManagerAddressParams, SetFactorialPoolConfigParams, SetAssetConfigParams, SetRFQConfigParams, SetManagementFeeRatePerYearParams, SetDepositCloseTimestampParams, SetWithdrawOpenTimestampParams, SetGasConfigParams, SetOracleConfigParams, SetWalletCodeParams, SetDataAggregatorCodeParams, SetRFQCodeParams, SetContentParams, UpgradeCodeParams, CollectProtocolFeeParams, ClaimManagementFeeParams } from "./types";
+import { SetOwnerParams, SetGuardianAddressParams, SetManagerParams, SetPrivateVaultParams, SetWhitelistedMintersParams, SetMaxLeverageRatioParams, ExecuteOwnerActionParams, RevertOwnerActionParams, SetTimelockParams, SetManagementFeeRecipientAddressParams, SetProtocolFeeRatePerYearParams, SetProtocolFeeManagerAddressParams, SetFactorialPoolConfigParams, SetAssetConfigV2Params, SetRFQConfigParams, SetManagementFeeRatePerYearParams, SetDepositCloseTimestampParams, SetWithdrawOpenTimestampParams, SetGasConfigParams, SetOracleConfigParams, SetWalletCodeParams, SetDataAggregatorCodeParams, SetRFQCodeParams, SetContentParams, UpgradeCodeParams, CollectProtocolFeeParams, ClaimManagementFeeParams } from "./types";
 export * from "./types";
 export declare function createSetOwnerMsg(ctx: AffluentContext, params: SetOwnerParams): Promise<{
     opts: {
@@ -135,7 +135,7 @@ export declare function createSetFactorialPoolConfigMsg(ctx: AffluentContext, pa
         body: import("@ton/core").Cell;
     };
 }>;
-export declare function createSetAssetConfigMsg(ctx: AffluentContext, params: SetAssetConfigParams, value?: bigint): Promise<{
+export declare function createSetAssetConfigMsg(ctx: AffluentContext, params: SetAssetConfigV2Params, value?: bigint): Promise<{
     opts: {
         vault: import("@ton/core").OpenedContract<StrategyVault>;
     };

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

@@ -192,7 +192,7 @@ async function createSetAssetConfigMsg(ctx, params, value) {
     const vault = ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(params.strategyVaultAddress));
     const to = vault.address;
     const resolvedValue = value ?? (0, core_1.toNano)(0.02);
-    const body = strategy_vault_1.StrategyVault.createSetAssetConfigMsgBody((0, utils_1.toAddress)(params.assetAddress), params.isWhitelisted, params.isDepositable, params.isWithdrawable, params.exposureCap, params.queryId);
+    const body = strategy_vault_1.StrategyVault.createSetAssetConfigV2MsgBody((0, utils_1.toAddress)(params.assetAddress), params.isWhitelisted, params.isDepositable, params.isWithdrawable, params.isDepositQueueActivated, params.isWithdrawQueueActivated, params.exposureCap, params.queryId);
     return {
         opts: { vault },
         input: { to, value: resolvedValue, body },

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

@@ -78,6 +78,10 @@ export type SetAssetConfigParams = {
     exposureCap: number;
     queryId?: number;
 };
+export type SetAssetConfigV2Params = SetAssetConfigParams & {
+    isDepositQueueActivated: boolean;
+    isWithdrawQueueActivated: boolean;
+};
 export type SetRFQConfigParams = {
     strategyVaultAddress: AddressInput;
     priceDeviationTolerance: bigint;

package/dist/services/strategy-vault/query.js

@@ -88,7 +88,7 @@ async function getValuationContext(ctx, vaultAddress) {
     const amountContext = vaultStateContext.toAmountContext(poolContexts);
     const valueContext = amountContext.toValueContext(priceInfo.allPrices);
     const nativeValueDecomposedContext = transform_1.VaultNativeValueDecomposedContext.fromValueContext(valueContext, priceInfo.allPrices);
-    const nativeAmountDecomposedContext = transform_1.VaultNativeAmountDecomposedContext.fromDecomposedValueContext(nativeValueDecomposedContext, priceInfo.allPrices);
+    const nativeAmountDecomposedContext = transform_1.VaultNativeAmountDecomposedContext.fromAmountContext(amountContext, priceInfo.allPrices);
     return {
         vaultStateContext,
         amountContext,

package/dist/services/strategy-vault/user/trace.d.ts

@@ -0,0 +1,156 @@
+import { Address, Cell } from "@ton/core";
+import { TracerBase } from "../../../common/trace-action";
+import { MessageHash } from "../../../utils/external-message-hash";
+import { TonClient } from "@ton/ton";
+import { AffluentContext } from "../../../context";
+import { ToncenterV3Client } from "../../../utils/pending-tracker/v3-client";
+export type StrategyVaultDepositAddresses = {
+    actor: Address;
+    actorAssetWallet: Address;
+    actorVaultWallet: Address;
+    vault: Address;
+    vaultAssetWallet: Address;
+};
+export type StrategyVaultWithdrawAddresses = {
+    actor: Address;
+    actorVaultWallet: Address;
+    actorWithdrawAssetWallet: Address;
+    vault: Address;
+    vaultWithdrawAssetWallet: Address;
+};
+export declare function getDepositAddresses(client: TonClient, params: {
+    actor: Address;
+    asset: Address;
+    vault: Address;
+}): Promise<StrategyVaultDepositAddresses>;
+export declare function getWithdrawAddresses(client: TonClient, params: {
+    actor: Address;
+    withdrawAsset: Address;
+    vault: Address;
+}): Promise<StrategyVaultWithdrawAddresses>;
+export type StrategyVaultDepositTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class StrategyVaultDepositTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: StrategyVaultDepositTracerParams): Promise<StrategyVaultDepositTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: StrategyVaultDepositAddresses;
+    });
+}
+export type StrategyVaultWithdrawTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    withdrawAsset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class StrategyVaultWithdrawTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: StrategyVaultWithdrawTracerParams): Promise<StrategyVaultWithdrawTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: StrategyVaultWithdrawAddresses;
+    });
+}
+export type StrategyVaultDepositQueueTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class StrategyVaultDepositQueueTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: StrategyVaultDepositQueueTracerParams): Promise<StrategyVaultDepositQueueTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: StrategyVaultDepositAddresses;
+    });
+}
+export type StrategyVaultWithdrawQueueTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    vault: Address;
+};
+export declare class StrategyVaultWithdrawQueueTracer extends TracerBase<"jetton"> {
+    static create(params: StrategyVaultWithdrawQueueTracerParams): Promise<StrategyVaultWithdrawQueueTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: {
+            actor: Address;
+            actorVaultWallet: Address;
+            vault: Address;
+        };
+    });
+}
+export type StrategyVaultCancelDepositQueueAddresses = {
+    actor: Address;
+    actorAssetWallet: Address;
+    vault: Address;
+    vaultAssetWallet: Address;
+};
+export declare function getCancelDepositQueueAddresses(client: TonClient, params: {
+    actor: Address;
+    asset: Address;
+    vault: Address;
+}): Promise<StrategyVaultCancelDepositQueueAddresses>;
+export type StrategyVaultCancelDepositQueueTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class StrategyVaultCancelDepositQueueTracer extends TracerBase<"cancel"> {
+    static create(params: StrategyVaultCancelDepositQueueTracerParams): Promise<StrategyVaultCancelDepositQueueTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: StrategyVaultCancelDepositQueueAddresses;
+    });
+}
+export type StrategyVaultCancelWithdrawQueueAddresses = {
+    actor: Address;
+    actorVaultWallet: Address;
+    vault: Address;
+};
+export declare function getCancelWithdrawQueueAddresses(client: TonClient, params: {
+    actor: Address;
+    vault: Address;
+}): Promise<StrategyVaultCancelWithdrawQueueAddresses>;
+export type StrategyVaultCancelWithdrawQueueTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    vault: Address;
+};
+export declare class StrategyVaultCancelWithdrawQueueTracer extends TracerBase<"cancel"> {
+    static create(params: StrategyVaultCancelWithdrawQueueTracerParams): Promise<StrategyVaultCancelWithdrawQueueTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: StrategyVaultCancelWithdrawQueueAddresses;
+    });
+}