@affluent-org/sdk 0.0.4 → 0.0.6

package/dist/services/rfq-auction/user/trace.d.ts

@@ -0,0 +1,53 @@
+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 RFQAuctionAddresses = {
+    actor: Address;
+    actorBidAssetWallet: Address;
+    rfqAuction: Address;
+    rfqAuctionBidAssetWallet: Address;
+};
+export declare function getRFQAuctionAddresses(client: TonClient, params: {
+    actor: Address;
+    bidAsset: Address;
+    rfqAuction: Address;
+}): Promise<RFQAuctionAddresses>;
+export type RFQAuctionBidTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    bidAsset: Address;
+    rfqAuction: Address;
+    isWTON: boolean;
+};
+export declare class RFQAuctionBidTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: RFQAuctionBidTracerParams): Promise<RFQAuctionBidTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: RFQAuctionAddresses;
+    });
+}
+export type RFQAuctionCancelBidTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    bidAsset: Address;
+    rfqAuction: Address;
+    isWTON: boolean;
+};
+export declare class RFQAuctionCancelBidTracer extends TracerBase<"cancel"> {
+    static create(params: RFQAuctionCancelBidTracerParams): Promise<RFQAuctionCancelBidTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: RFQAuctionAddresses;
+    });
+}

package/dist/services/rfq-auction/user/trace.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQAuctionCancelBidTracer = exports.RFQAuctionBidTracer = void 0;
+exports.getRFQAuctionAddresses = getRFQAuctionAddresses;
+const trace_action_1 = require("../../../common/trace-action");
+const rfq_auction_1 = require("../../../contracts/rfq/rfq_auction");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+async function getRFQAuctionAddresses(client, params) {
+    const { actor, bidAsset, rfqAuction } = params;
+    const _bidAsset = client.open(jetton_minter_1.JettonMinter.createFromAddress(bidAsset));
+    return {
+        actor,
+        actorBidAssetWallet: await _bidAsset.getWalletAddress(actor),
+        rfqAuction,
+        rfqAuctionBidAssetWallet: await _bidAsset.getWalletAddress(rfqAuction),
+    };
+}
+class RFQAuctionBidTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, bidAsset, rfqAuction, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getRFQAuctionAddresses(ctx.client, { actor, bidAsset, rfqAuction });
+        return new RFQAuctionBidTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const type = isWTON ? "wton" : "jetton";
+        const steps = [
+            ...(0, trace_action_1.createJettonSendSteps)({
+                isWTON,
+                actor: addresses.actor,
+                actorWallet: addresses.actorBidAssetWallet,
+                targetWallet: addresses.rfqAuctionBidAssetWallet,
+                target: addresses.rfqAuction,
+                description: "Transferring Bid Asset",
+            }),
+        ];
+        super(toncenterClient, extHash, type, queryId, steps);
+    }
+}
+exports.RFQAuctionBidTracer = RFQAuctionBidTracer;
+class RFQAuctionCancelBidTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, bidAsset, rfqAuction, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getRFQAuctionAddresses(ctx.client, { actor, bidAsset, rfqAuction });
+        return new RFQAuctionCancelBidTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const steps = [
+            {
+                op: rfq_auction_1.RFQAuction.Op.CancelBid,
+                from: addresses.actor,
+                to: addresses.rfqAuction,
+                description: "Cancelling Bid",
+            },
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON,
+                sourceWallet: addresses.rfqAuctionBidAssetWallet,
+                actorWallet: addresses.actorBidAssetWallet,
+                description: "Refunding Bid Asset",
+            }),
+        ];
+        super(toncenterClient, extHash, "cancel", queryId, steps);
+    }
+}
+exports.RFQAuctionCancelBidTracer = RFQAuctionCancelBidTracer;

package/dist/services/rfq-batch/index.d.ts

@@ -1,11 +1,13 @@
 import { AffluentContext } from "../../context";
 import { AddressInput } from "../../contracts/common/type";
 import { AddressSender, MultiSender } from "../../types/sender";
+import { RFQBatchAddOrderTracer, RFQBatchCancelOrderTracer } from "./user/trace";
 import * as query from "./query";
 import * as oracle from "./oracle";
 import * as user from "./user";
 export { sendMsg } from "../../lib/send-msg";
 export * from "./user/types";
+export * from "./user/trace";
 export { query, oracle, user };
 export declare class RFQBatchServiceV1 {
     private ctx;
@@ -48,14 +50,8 @@ export declare class RFQBatchServiceV1 {
         oracleParams: import("@ton/core").Cell;
         bucket: oracle.OracleExposures;
     }>;
-    sendAddOrder(sender: AddressSender, params: user.AddOrderParams, value?: bigint): Promise<{
-        recipient: import("@ton/core").Address;
-        response: import("@ton/core").Address;
-        amount: bigint;
-        forwardTonAmount: bigint;
-        forwardPayload: import("@ton/core").Cell;
-        queryId: bigint | undefined;
-    }>;
+    sendAddOrder(sender: AddressSender, params: user.AddOrderParams, value?: bigint): Promise<RFQBatchAddOrderTracer>;
+    sendCancelOrder(sender: AddressSender, params: user.CancelOrderParams, value?: bigint): Promise<RFQBatchCancelOrderTracer>;
     sendSettle(sender: AddressSender, params: user.SettleParams, value?: bigint): Promise<{
         recipient: import("@ton/core").Address;
         response: import("@ton/core").Address;
@@ -63,16 +59,23 @@ export declare class RFQBatchServiceV1 {
         forwardTonAmount: bigint;
         forwardPayload: import("@ton/core").Cell;
         queryId: bigint | undefined;
+    } & {
+        seqno: number;
     }>;
-    sendLock(sender: AddressSender, params: user.LockParams, value?: bigint): Promise<{}>;
-    sendCancelOrder(sender: AddressSender, params: user.CancelOrderParams, value?: bigint): Promise<{
-        assetIdx: 0 | 1;
+    sendLock(sender: AddressSender, params: user.LockParams, value?: bigint): Promise<{
+        seqno: number;
     }>;
     sendPayout(sender: AddressSender, params: user.PayoutParams, value?: bigint): Promise<{
         assetIdx: 0 | 1;
         count: number;
+    } & {
+        seqno: number;
+    }>;
+    sendReopen(sender: AddressSender, params: user.ReopenParams, value?: bigint): Promise<{
+        seqno: number;
+    }>;
+    sendCollectFee(sender: AddressSender, params: user.CollectFeeParams, value?: bigint): Promise<{
+        seqno: number;
     }>;
-    sendReopen(sender: AddressSender, params: user.ReopenParams, value?: bigint): Promise<{}>;
-    sendCollectFee(sender: AddressSender, params: user.CollectFeeParams, value?: bigint): Promise<{}>;
     sendBatchPayout(sender: MultiSender, params: user.BatchPayoutParams, value?: bigint): Promise<void>;
 }

package/dist/services/rfq-batch/index.js

@@ -40,6 +40,8 @@ exports.RFQBatchServiceV1 = exports.user = exports.oracle = exports.query = expo
 const core_1 = require("@ton/core");
 const context_1 = require("../../context");
 const send_msg_1 = require("../../lib/send-msg");
+const utils_1 = require("../../contracts/common/utils");
+const trace_1 = require("./user/trace");
 const query = __importStar(require("./query"));
 exports.query = query;
 const oracle = __importStar(require("./oracle"));
@@ -49,6 +51,7 @@ exports.user = user;
 var send_msg_2 = require("../../lib/send-msg");
 Object.defineProperty(exports, "sendMsg", { enumerable: true, get: function () { return send_msg_2.sendMsg; } });
 __exportStar(require("./user/types"), exports);
+__exportStar(require("./user/trace"), exports);
 class RFQBatchServiceV1 {
     ctx;
     constructor(ctx = context_1.AffluentContext.getInstance()) {
@@ -73,28 +76,49 @@ class RFQBatchServiceV1 {
         return oracle.getOracleParams(this.ctx, rfqBatchAddress);
     }
     // ============================================================
-    // User Operations
+    // User
     // ============================================================
     async sendAddOrder(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createAddOrderMsg(this.ctx, sender, params, value));
+        const msg = await user.createAddOrderMsg(this.ctx, sender, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        return trace_1.RFQBatchAddOrderTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset: (0, utils_1.toAddress)(params.assetAddress),
+            rfqBatch: (0, utils_1.toAddress)(params.rfqBatchAddress),
+        });
     }
+    async sendCancelOrder(sender, params, value) {
+        const msg = await user.createCancelOrderMsg(this.ctx, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        return trace_1.RFQBatchCancelOrderTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset: (0, utils_1.toAddress)(params.assetAddress),
+            rfqBatch: (0, utils_1.toAddress)(params.rfqBatchAddress),
+        });
+    }
+    // ============================================================
+    // Market Maker
+    // ============================================================
     async sendSettle(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createSettleMsg(this.ctx, sender, params, value));
+        return (0, send_msg_1.sendMsg)(sender, await user.createSettleMsg(this.ctx, sender, params, value));
     }
     async sendLock(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createLockMsg(this.ctx, params, value));
-    }
-    async sendCancelOrder(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createCancelOrderMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsg)(sender, await user.createLockMsg(this.ctx, params, value));
     }
     async sendPayout(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createPayoutMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsg)(sender, await user.createPayoutMsg(this.ctx, params, value));
     }
     async sendReopen(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createReopenMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsg)(sender, await user.createReopenMsg(this.ctx, params, value));
     }
     async sendCollectFee(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createCollectFeeMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsg)(sender, await user.createCollectFeeMsg(this.ctx, params, value));
     }
     async sendBatchPayout(sender, params, value) {
         const rfqBatchData = await this.getRFQBatchData(params.rfqBatchAddress);

package/dist/services/rfq-batch/oracle.d.ts

@@ -2,13 +2,13 @@ import { Cell } from "@ton/core";
 import { AffluentContext } from "../../context";
 import { AddressInput } from "../../contracts/common/type";
 import { OracleExposures } from "../composite-oracle/computation";
-import { VaultPositions } from "../composite-oracle/types";
+import { IVaultStateContext } from "../../common/types";
 export { OracleExposures, createOracleExposures } from "../composite-oracle/computation";
 /**
  * Build oracle params Cell from pre-fetched vault positions
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsCellFromData(assetAddresses: string[], oracleConfig: any, vaultPositions: VaultPositions): Promise<{
+export declare function buildOracleParamsCellFromData(assetAddresses: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>): Promise<{
     oracleParams: Cell;
     bucket: OracleExposures;
 }>;

package/dist/services/rfq-batch/user/trace.d.ts

@@ -0,0 +1,49 @@
+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 RFQBatchAddresses = {
+    actor: Address;
+    actorAssetWallet: Address;
+    rfqBatch: Address;
+    rfqBatchAssetWallet: Address;
+};
+export declare function getRFQBatchAddresses(client: TonClient, params: {
+    actor: Address;
+    asset: Address;
+    rfqBatch: Address;
+}): Promise<RFQBatchAddresses>;
+export type RFQBatchAddOrderTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    rfqBatch: Address;
+};
+export declare class RFQBatchAddOrderTracer extends TracerBase<"jetton"> {
+    static create(params: RFQBatchAddOrderTracerParams): Promise<RFQBatchAddOrderTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: RFQBatchAddresses;
+    });
+}
+export type RFQBatchCancelOrderTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    rfqBatch: Address;
+};
+export declare class RFQBatchCancelOrderTracer extends TracerBase<"cancel"> {
+    static create(params: RFQBatchCancelOrderTracerParams): Promise<RFQBatchCancelOrderTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: RFQBatchAddresses;
+    });
+}

package/dist/services/rfq-batch/user/trace.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQBatchCancelOrderTracer = exports.RFQBatchAddOrderTracer = void 0;
+exports.getRFQBatchAddresses = getRFQBatchAddresses;
+const trace_action_1 = require("../../../common/trace-action");
+const rfq_batch_1 = require("../../../contracts/rfq/rfq_batch");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+async function getRFQBatchAddresses(client, params) {
+    const { actor, asset, rfqBatch } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        rfqBatch,
+        rfqBatchAssetWallet: await _asset.getWalletAddress(rfqBatch),
+    };
+}
+class RFQBatchAddOrderTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, rfqBatch } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getRFQBatchAddresses(ctx.client, { actor, asset, rfqBatch });
+        return new RFQBatchAddOrderTracer(ctx.toncenterClient, { queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { queryId, extHash, addresses } = params;
+        const steps = [
+            ...(0, trace_action_1.createJettonSendSteps)({
+                isWTON: false,
+                actor: addresses.actor,
+                actorWallet: addresses.actorAssetWallet,
+                targetWallet: addresses.rfqBatchAssetWallet,
+                target: addresses.rfqBatch,
+                description: "Adding Order",
+            }),
+        ];
+        super(toncenterClient, extHash, "jetton", queryId, steps);
+    }
+}
+exports.RFQBatchAddOrderTracer = RFQBatchAddOrderTracer;
+class RFQBatchCancelOrderTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, rfqBatch } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getRFQBatchAddresses(ctx.client, { actor, asset, rfqBatch });
+        return new RFQBatchCancelOrderTracer(ctx.toncenterClient, { queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { queryId, extHash, addresses } = params;
+        const steps = [
+            {
+                op: rfq_batch_1.RFQBatch.Op.CancelOrder,
+                from: addresses.actor,
+                to: addresses.rfqBatch,
+                description: "Cancelling Order",
+            },
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON: false,
+                sourceWallet: addresses.rfqBatchAssetWallet,
+                actorWallet: addresses.actorAssetWallet,
+                description: "Refunding Asset",
+            }),
+        ];
+        super(toncenterClient, extHash, "cancel", queryId, steps);
+    }
+}
+exports.RFQBatchCancelOrderTracer = RFQBatchCancelOrderTracer;

package/dist/services/share-vault/index.d.ts

@@ -7,10 +7,12 @@ import * as query from "./query";
 import * as owner from "./owner";
 import * as manager from "./manager";
 import * as user from "./user";
+import { ShareVaultSupplyTracer, ShareVaultWithdrawTracer } from "./user/trace";
 export { sendMsg } from "../../lib/send-msg";
 export * from "./owner/types";
 export * from "./manager/types";
 export * from "./user/types";
+export * from "./user/trace";
 export { owner, manager, user, query };
 export { PoolInfoForShareVault, PoolTuple } from "./query";
 export declare class ShareVaultServiceV1 {
@@ -31,95 +33,19 @@ export declare class ShareVaultServiceV1 {
         count: number;
         sortedPools: query.PoolTuple[];
     }>;
-    sendSetWhitelistPools(sender: AddressSender, params: owner.SetWhitelistPoolsParams, value?: bigint): Promise<{
-        whitelists: [Address, 0 | 1][];
-        queryID: bigint | undefined;
-    }>;
-    sendSetGasConfig(sender: AddressSender, params: owner.SetGasConfigParams, value?: bigint): Promise<{
-        gasFee: {
-            supply: bigint;
-            withdraw: bigint;
-            factorialSupply: bigint;
-            factorialWithdraw: bigint;
-            mintVaultShareTokens: bigint;
-        };
-        queryID: bigint | undefined;
-    }>;
-    sendChangeManager(sender: AddressSender, params: owner.ChangeManagerParams, value?: bigint): Promise<{
-        manager: Address;
-        queryID: bigint | undefined;
-    }>;
-    sendChangeAdmin(sender: AddressSender, params: owner.ChangeAdminParams, value?: bigint): Promise<{
-        address: Address;
-        queryID: number | undefined;
-    }>;
-    sendUpgradeCode(sender: AddressSender, params: owner.UpgradeCodeParams, value?: bigint): Promise<{
-        newCode: import("@ton/core").Cell;
-        queryID: number | undefined;
-    }>;
-    sendSupplyToPool(sender: AddressSender, params: manager.SupplyToPoolParams, value?: bigint): Promise<{
-        pool: Address;
-        amount: bigint;
-        queryID: number | undefined;
-    }>;
-    sendWithdrawFromPool(sender: AddressSender, params: manager.WithdrawFromPoolParams, value?: bigint): Promise<{
-        pool: Address;
-        amount: bigint;
-        isShare: boolean;
-        queryID: number | undefined;
-    }>;
-    sendSetTargetWeight(sender: AddressSender, params: manager.SetTargetWeightParams, value?: bigint): Promise<{
-        pool: Address;
-        targetWeight: number;
-        queryID: number | undefined;
-    }>;
-    sendSupply(sender: AddressSender, params: user.SupplyParams, value?: bigint): Promise<{
-        recipient: Address;
-        response: Address;
-        amount: bigint;
-        forwardTonAmount: bigint;
-        forwardPayload: import("@ton/core").Cell;
-        queryId: bigint | undefined;
-    }>;
-    sendWithdraw(sender: AddressSender, params: user.WithdrawParams, value?: bigint): Promise<{
-        amount: bigint;
-        response: Address;
-        forwardPayload: import("@ton/core").Cell;
-        queryId: bigint | undefined;
-    }>;
+    sendSetWhitelistPools(sender: AddressSender, params: owner.SetWhitelistPoolsParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendSetGasConfig(sender: AddressSender, params: owner.SetGasConfigParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendChangeManager(sender: AddressSender, params: owner.ChangeManagerParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendChangeAdmin(sender: AddressSender, params: owner.ChangeAdminParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendUpgradeCode(sender: AddressSender, params: owner.UpgradeCodeParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendSupplyToPool(sender: AddressSender, params: manager.SupplyToPoolParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendWithdrawFromPool(sender: AddressSender, params: manager.WithdrawFromPoolParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendSetTargetWeight(sender: AddressSender, params: manager.SetTargetWeightParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendSupply(sender: AddressSender, params: user.SupplyParams, value?: bigint): Promise<ShareVaultSupplyTracer>;
+    sendWithdraw(sender: AddressSender, params: user.WithdrawParams, value?: bigint): Promise<ShareVaultWithdrawTracer>;
     getValuationContext(vaultAddress: AddressInput): Promise<{
-        storage: {
-            totalSupply: bigint;
-            owner: Address | null;
-            manager: Address | null;
-            asset: Address;
-            balance: bigint;
-            cash: bigint;
-            totalTargetWeight: bigint;
-            nextAggregatorIndex: bigint;
-            isWtonVault: boolean;
-            assetWallet: Address | null;
-            whitelistedPools: Record<string, {
-                isWhitelisted: boolean;
-                targetWeight: bigint;
-                supply: bigint;
-            } & {
-                address: Address;
-            }>;
-            minimumGasFee: {
-                supply: bigint;
-                withdraw: bigint;
-                factorialSupply: bigint;
-                factorialWithdraw: bigint;
-                mintVaultShareTokens: bigint;
-            };
-            code: import("@ton/core").Cell;
-            address: Address;
-        };
-        totalSupply: bigint;
-        asset: Address;
-        reserve: bigint;
-        poolPositions: Record<string, query.PoolInfoForShareVault>;
+        vaultStateContext: import("../../common/transform").VaultStateContext;
+        amountContext: import("../../common/transform").VaultAmountContext;
         netAmount: bigint;
         exr: number;
     }>;

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

@@ -38,6 +38,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShareVaultServiceV1 = exports.query = exports.user = exports.manager = exports.owner = exports.sendMsg = void 0;
 const context_1 = require("../../context");
+const utils_1 = require("../../contracts/common/utils");
 const send_msg_1 = require("../../lib/send-msg");
 const query = __importStar(require("./query"));
 exports.query = query;
@@ -48,11 +49,13 @@ const manager = __importStar(require("./manager"));
 exports.manager = manager;
 const user = __importStar(require("./user"));
 exports.user = user;
+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; } });
 __exportStar(require("./owner/types"), exports);
 __exportStar(require("./manager/types"), exports);
 __exportStar(require("./user/types"), exports);
+__exportStar(require("./user/trace"), exports);
 class ShareVaultServiceV1 {
     ctx;
     constructor(ctx = context_1.AffluentContext.getInstance()) {
@@ -92,40 +95,64 @@ class ShareVaultServiceV1 {
     // Owner
     // ============================================================
     async sendSetWhitelistPools(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetWhitelistPoolsMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetWhitelistPoolsMsg(this.ctx, params, value));
     }
     async sendSetGasConfig(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetGasConfigMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetGasConfigMsg(this.ctx, params, value));
     }
     async sendChangeManager(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createChangeManagerMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createChangeManagerMsg(this.ctx, params, value));
     }
     async sendChangeAdmin(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createChangeAdminMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createChangeAdminMsg(this.ctx, params, value));
     }
     async sendUpgradeCode(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createUpgradeCodeMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createUpgradeCodeMsg(this.ctx, params, value));
     }
     // ============================================================
     // Manager
     // ============================================================
     async sendSupplyToPool(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createSupplyToPoolMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createSupplyToPoolMsg(this.ctx, params, value));
     }
     async sendWithdrawFromPool(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createWithdrawFromPoolMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createWithdrawFromPoolMsg(this.ctx, params, value));
     }
     async sendSetTargetWeight(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, manager.createSetTargetWeightMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await manager.createSetTargetWeightMsg(this.ctx, params, value));
     }
     // ============================================================
     // User
     // ============================================================
     async sendSupply(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createSupplyMsg(this.ctx, sender, params, value));
+        const vault = (0, utils_1.toAddress)(params.vaultAddress);
+        const vaultData = await query.getVaultData(this.ctx, vault);
+        const msg = await user.createSupplyMsg(this.ctx, sender, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        return trace_1.ShareVaultSupplyTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset: vaultData.asset,
+            vault,
+            isWTON: this.ctx.isWTON(vaultData.asset),
+        });
     }
     async sendWithdraw(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createWithdrawMsg(this.ctx, sender, params, value));
+        const vault = (0, utils_1.toAddress)(params.vaultAddress);
+        const vaultData = await query.getVaultData(this.ctx, vault);
+        const msg = await user.createWithdrawMsg(this.ctx, sender, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        return trace_1.ShareVaultWithdrawTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset: vaultData.asset,
+            vault,
+            isWTON: this.ctx.isWTON(vaultData.asset),
+        });
     }
     async getValuationContext(vaultAddress) {
         return query.getValuationContext(this.ctx, vaultAddress);

package/dist/services/share-vault/query.d.ts

@@ -4,6 +4,8 @@ import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { ShareVault, ShareVaultState } from "../../contracts/vault/share-vault";
 import { JettonWallet } from "../../contracts/jetton/jetton-wallet";
 import { PoolInfoForShareVault } from "./type";
+import { VaultStateContext } from "../../common/transform";
+import { PoolState } from "../../contracts/core/pool/type";
 export { PoolInfoForShareVault, PoolTuple } from "./type";
 /**
  * Get ShareVault contract instance
@@ -25,39 +27,10 @@ export declare function getVaultWallet(ctx: AffluentContext, vaultAddress: Addre
  * Get pool info for all whitelisted pools
  */
 export declare function getPoolInfoForShareVault(ctx: AffluentContext, vaultData: ShareVaultState): Promise<Record<string, PoolInfoForShareVault>>;
+export declare function getPoolDataForShareVault(ctx: AffluentContext, vaultAddress: AddressInput): Promise<Record<string, PoolState>>;
 export declare function getValuationContext(ctx: AffluentContext, vaultAddress: AddressInput): Promise<{
-    storage: {
-        totalSupply: bigint;
-        owner: Address | null;
-        manager: Address | null;
-        asset: Address;
-        balance: bigint;
-        cash: bigint;
-        totalTargetWeight: bigint;
-        nextAggregatorIndex: bigint;
-        isWtonVault: boolean;
-        assetWallet: Address | null;
-        whitelistedPools: Record<string, {
-            isWhitelisted: boolean;
-            targetWeight: bigint;
-            supply: bigint;
-        } & {
-            address: Address;
-        }>;
-        minimumGasFee: {
-            supply: bigint;
-            withdraw: bigint;
-            factorialSupply: bigint;
-            factorialWithdraw: bigint;
-            mintVaultShareTokens: bigint;
-        };
-        code: import("@ton/core").Cell;
-        address: Address;
-    };
-    totalSupply: bigint;
-    asset: Address;
-    reserve: bigint;
-    poolPositions: Record<string, PoolInfoForShareVault>;
+    vaultStateContext: VaultStateContext;
+    amountContext: import("../../common/transform").VaultAmountContext;
     netAmount: bigint;
     exr: number;
 }>;