@affluent-org/sdk 0.0.5 → 0.0.6

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/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,62 +33,16 @@ 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<{
         vaultStateContext: import("../../common/transform").VaultStateContext;
         amountContext: import("../../common/transform").VaultAmountContext;

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.js

@@ -129,7 +129,7 @@ async function getValuationContext(ctx, vaultAddress) {
     Object.entries(poolPositions).forEach(([poolAddress, poolState]) => poolContexts[poolAddress] = transform_1.PoolContext.fromPoolState(poolState));
     const vaultStateContext = transform_1.VaultStateContext.fromShareVaultState(vaultData);
     const amountContext = vaultStateContext.toAmountContext(poolContexts);
-    const netAmount = amountContext.net()[vaultData.asset.toString()].net();
+    const netAmount = amountContext.decompose()[vaultData.asset.toString()].net();
     return {
         vaultStateContext,
         amountContext,

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

@@ -0,0 +1,54 @@
+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 ShareVaultAddresses = {
+    actor: Address;
+    actorAssetWallet: Address;
+    actorVaultWallet: Address;
+    vault: Address;
+    vaultAssetWallet: Address;
+};
+export declare function getShareVaultAddresses(client: TonClient, params: {
+    actor: Address;
+    asset: Address;
+    vault: Address;
+}): Promise<ShareVaultAddresses>;
+export type ShareVaultSupplyTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class ShareVaultSupplyTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: ShareVaultSupplyTracerParams): Promise<ShareVaultSupplyTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: ShareVaultAddresses;
+    });
+}
+export type ShareVaultWithdrawTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class ShareVaultWithdrawTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: ShareVaultWithdrawTracerParams): Promise<ShareVaultWithdrawTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: ShareVaultAddresses;
+    });
+}

package/dist/services/share-vault/user/trace.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareVaultWithdrawTracer = exports.ShareVaultSupplyTracer = void 0;
+exports.getShareVaultAddresses = getShareVaultAddresses;
+const trace_action_1 = require("../../../common/trace-action");
+const jetton_wallet_1 = require("../../../contracts/jetton/jetton-wallet");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+const share_vault_1 = require("../../../contracts/vault/share-vault");
+async function getShareVaultAddresses(client, params) {
+    const { actor, asset, vault } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    const _vault = client.open(share_vault_1.ShareVault.createFromAddress(vault));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        vault,
+        vaultAssetWallet: await _asset.getWalletAddress(vault),
+    };
+}
+class ShareVaultSupplyTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, vault, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getShareVaultAddresses(ctx.client, { actor, asset, vault });
+        return new ShareVaultSupplyTracer(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.actorAssetWallet,
+                targetWallet: addresses.vaultAssetWallet,
+                target: addresses.vault,
+                description: "Transferring Tokens",
+            }),
+            ...(0, trace_action_1.createMintSteps)({
+                minter: addresses.vault,
+                actorWallet: addresses.actorVaultWallet,
+                description: "Receiving Vault Tokens",
+            }),
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            from: addresses.vaultAssetWallet,
+            to: addresses.actorAssetWallet,
+            description: "Refunding Tokens",
+        };
+        super(toncenterClient, extHash, type, queryId, steps, failStep);
+    }
+}
+exports.ShareVaultSupplyTracer = ShareVaultSupplyTracer;
+class ShareVaultWithdrawTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, vault, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getShareVaultAddresses(ctx.client, { actor, asset, vault });
+        return new ShareVaultWithdrawTracer(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.createBurnSteps)({
+                actor: addresses.actor,
+                actorWallet: addresses.actorVaultWallet,
+                minter: addresses.vault,
+                description: "Burning Vault Tokens",
+            }),
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON,
+                sourceWallet: addresses.vaultAssetWallet,
+                actorWallet: addresses.actorAssetWallet,
+                actor: addresses.actor,
+                description: "Receiving Asset",
+            }),
+        ];
+        super(toncenterClient, extHash, type, queryId, steps);
+    }
+}
+exports.ShareVaultWithdrawTracer = ShareVaultWithdrawTracer;