@affluent-org/sdk 0.0.5 → 0.0.7

package/dist/services/pool/index.js

@@ -38,6 +38,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PoolServiceV1 = exports.user = exports.owner = exports.oracle = exports.query = exports.computation = 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 computation = __importStar(require("./computation"));
 exports.computation = computation;
@@ -49,11 +50,13 @@ const owner = __importStar(require("./owner"));
 exports.owner = owner;
 const user = __importStar(require("./user"));
 exports.user = user;
+const trace_1 = require("./user/trace");
 // Re-exports
 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("./user/types"), exports);
+__exportStar(require("./user/trace"), exports);
 __exportStar(require("./computation"), exports); // Types and pure computation functions
 class PoolServiceV1 {
     ctx;
@@ -109,31 +112,91 @@ class PoolServiceV1 {
     // Owner
     // ============================================================
     async sendSetOwner(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetOwnerMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetOwnerMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetIrmConfig(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetIrmConfigMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetIrmConfigMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendSetFeeConfigurer(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetFeeConfigurerMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetFeeConfigurerMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     // ============================================================
     // User
     // ============================================================
     async sendSupply(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createSupplyMsg(this.ctx, sender, params, value));
+        const msg = await user.createSupplyMsg(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.PoolSupplyTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset,
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            isWTON: this.ctx.isWTON(asset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendWithdraw(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createWithdrawMsg(this.ctx, sender, params, value));
+        const msg = await user.createWithdrawMsg(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.PoolWithdrawTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset,
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            isWTON: this.ctx.isWTON(asset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendBorrow(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createBorrowMsg(this.ctx, sender, params, value));
+        const msg = await user.createBorrowMsg(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.PoolBorrowTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset,
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            isWTON: this.ctx.isWTON(asset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendRepay(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createRepayMsg(this.ctx, sender, params, value));
+        const msg = await user.createRepayMsg(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.PoolRepayTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            asset,
+            pool: (0, utils_1.toAddress)(params.poolAddress),
+            isWTON: this.ctx.isWTON(asset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendLiquidate(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createLiquidateMsg(this.ctx, sender, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await user.createLiquidateMsg(this.ctx, sender, params, value));
+        await trace.wait();
+        return trace;
     }
 }
 exports.PoolServiceV1 = PoolServiceV1;

package/dist/services/pool/query.js

@@ -107,7 +107,7 @@ async function getPricesAndCompositions(ctx, poolAddress) {
         vaultPositions,
         poolInfos,
     });
-    const vaultCompositions = Object.fromEntries(Object.entries(result.vaultPrices).map(([k, v]) => [k, v.additionalData]));
+    const vaultCompositions = Object.fromEntries(Object.entries(result.vaultPrices).map(([asset, priceData]) => [asset, priceData.additionalData]));
     return { prices: result.allPrices, vaultCompositions };
 }
 /**

package/dist/services/pool/user/trace.d.ts

@@ -0,0 +1,90 @@
+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 PoolAddresses = {
+    actor: Address;
+    actorAssetWallet: Address;
+    account: Address;
+    pool: Address;
+    poolAssetWallet: Address;
+};
+export declare function getPoolAddresses(client: TonClient, params: {
+    actor: Address;
+    asset: Address;
+    pool: Address;
+}): Promise<PoolAddresses>;
+export type PoolSupplyTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    pool: Address;
+    isWTON: boolean;
+};
+export declare class PoolSupplyTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: PoolSupplyTracerParams): Promise<PoolSupplyTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: PoolAddresses;
+    });
+}
+export type PoolWithdrawTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    pool: Address;
+    isWTON: boolean;
+};
+export declare class PoolWithdrawTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: PoolWithdrawTracerParams): Promise<PoolWithdrawTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: PoolAddresses;
+    });
+}
+export type PoolBorrowTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    pool: Address;
+    isWTON: boolean;
+};
+export declare class PoolBorrowTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: PoolBorrowTracerParams): Promise<PoolBorrowTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: PoolAddresses;
+    });
+}
+export type PoolRepayTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    pool: Address;
+    isWTON: boolean;
+};
+export declare class PoolRepayTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: PoolRepayTracerParams): Promise<PoolRepayTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: PoolAddresses;
+    });
+}

package/dist/services/pool/user/trace.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolRepayTracer = exports.PoolBorrowTracer = exports.PoolWithdrawTracer = exports.PoolSupplyTracer = void 0;
+exports.getPoolAddresses = getPoolAddresses;
+const trace_action_1 = require("../../../common/trace-action");
+const jetton_wallet_1 = require("../../../contracts/jetton/jetton-wallet");
+const pool_1 = require("../../../contracts/core/pool");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+async function getPoolAddresses(client, params) {
+    const { actor, asset, pool } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    const _pool = client.open(pool_1.Pool.createFromAddress(pool));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        account: await _pool.getAccountAddress(actor),
+        pool,
+        poolAssetWallet: await _asset.getWalletAddress(pool),
+    };
+}
+class PoolSupplyTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, pool, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getPoolAddresses(ctx.client, { actor, asset, pool });
+        return new PoolSupplyTracer(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.poolAssetWallet,
+                target: addresses.pool,
+                description: "Supplying Tokens",
+            }),
+            {
+                op: pool_1.Pool.Op.UpdateAccountStatus,
+                from: addresses.pool,
+                to: addresses.account,
+                description: "Updating Account Status",
+            },
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.Transfer,
+            from: addresses.pool,
+            to: addresses.poolAssetWallet,
+            description: "Refunding Tokens",
+        };
+        super(toncenterClient, extHash, type, queryId, steps, failStep);
+    }
+}
+exports.PoolSupplyTracer = PoolSupplyTracer;
+class PoolWithdrawTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, pool, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getPoolAddresses(ctx.client, { actor, asset, pool });
+        return new PoolWithdrawTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const type = isWTON ? "wton" : "jetton";
+        const steps = [
+            {
+                op: pool_1.Pool.Op.Withdraw,
+                from: addresses.actor,
+                to: addresses.pool,
+                description: "Requesting Withdrawal",
+            },
+            {
+                op: pool_1.Pool.Op.ExecuteAction,
+                from: addresses.pool,
+                to: addresses.account,
+                description: "Checking Account Health",
+            },
+            {
+                op: pool_1.Pool.Op.ExecuteAction,
+                from: addresses.account,
+                to: addresses.pool,
+                description: "Checking Account Health",
+            },
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON,
+                sourceWallet: addresses.poolAssetWallet,
+                actorWallet: addresses.actorAssetWallet,
+                actor: addresses.actor,
+                description: "Receiving Asset",
+            }),
+        ];
+        super(toncenterClient, extHash, type, queryId, steps);
+    }
+}
+exports.PoolWithdrawTracer = PoolWithdrawTracer;
+class PoolBorrowTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, pool, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getPoolAddresses(ctx.client, { actor, asset, pool });
+        return new PoolBorrowTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const type = isWTON ? "wton" : "jetton";
+        const steps = [
+            {
+                op: pool_1.Pool.Op.Borrow,
+                from: addresses.actor,
+                to: addresses.pool,
+                description: "Requesting Borrow",
+            },
+            {
+                op: pool_1.Pool.Op.ExecuteAction,
+                from: addresses.pool,
+                to: addresses.account,
+                description: "Checking Account Health",
+            },
+            {
+                op: pool_1.Pool.Op.ExecuteAction,
+                from: addresses.account,
+                to: addresses.pool,
+                description: "Checking Account Health",
+            },
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON,
+                sourceWallet: addresses.poolAssetWallet,
+                actorWallet: addresses.actorAssetWallet,
+                actor: addresses.actor,
+                description: "Receiving Borrowed Asset",
+            }),
+        ];
+        super(toncenterClient, extHash, type, queryId, steps);
+    }
+}
+exports.PoolBorrowTracer = PoolBorrowTracer;
+class PoolRepayTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, pool, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getPoolAddresses(ctx.client, { actor, asset, pool });
+        return new PoolRepayTracer(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.poolAssetWallet,
+                target: addresses.pool,
+                description: "Repaying Tokens",
+            }),
+            {
+                op: pool_1.Pool.Op.ExecuteAction,
+                from: addresses.pool,
+                to: addresses.account,
+                description: "Updating Account Health",
+            },
+        ];
+        super(toncenterClient, extHash, type, queryId, steps);
+    }
+}
+exports.PoolRepayTracer = PoolRepayTracer;

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

@@ -3,11 +3,13 @@ import { AffluentContext } from "../../context";
 import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
 import { AddressSender } from "../../types/sender";
+import { RFQAuctionBidTracer, RFQAuctionCancelBidTracer } 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 RFQAuctionServiceV1 {
     private ctx;
@@ -55,27 +57,9 @@ export declare class RFQAuctionServiceV1 {
     }>;
     getOracleParams(rfqAuctionAddress: AddressInput): Promise<Cell>;
     getOracleParamsForVault(vaultAddress: AddressLike, additionalAssets?: AddressLike[], vaultData?: StrategyVaultState): Promise<Cell>;
-    sendAmountBid(sender: AddressSender, params: user.AmountBidParams, value?: bigint): Promise<{
-        recipient: import("@ton/core").Address;
-        response: import("@ton/core").Address;
-        amount: bigint;
-        forwardTonAmount: bigint;
-        forwardPayload: Cell;
-        queryId: bigint | undefined;
-    }>;
-    sendSlippageBid(sender: AddressSender, params: user.SlippageBidParams, value?: bigint): Promise<{
-        recipient: import("@ton/core").Address;
-        response: import("@ton/core").Address;
-        amount: bigint;
-        forwardTonAmount: bigint;
-        forwardPayload: Cell;
-        queryId: bigint | undefined;
-    }>;
-    sendCancelBid(sender: AddressSender, params: user.CancelBidParams, value?: bigint): Promise<{}>;
-    sendSettle(sender: AddressSender, params: user.SettleParams, value?: bigint): Promise<{
-        oracleParams: Cell;
-    }>;
-    sendClearBids(sender: AddressSender, params: user.ClearBidsParams, value?: bigint): Promise<{
-        clearCount: number;
-    }>;
+    sendAmountBid(sender: AddressSender, params: user.AmountBidParams, value?: bigint): Promise<RFQAuctionBidTracer>;
+    sendSlippageBid(sender: AddressSender, params: user.SlippageBidParams, value?: bigint): Promise<RFQAuctionBidTracer>;
+    sendCancelBid(sender: AddressSender, params: user.CancelBidParams, value?: bigint): Promise<RFQAuctionCancelBidTracer>;
+    sendSettle(sender: AddressSender, params: user.SettleParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendClearBids(sender: AddressSender, params: user.ClearBidsParams, value?: bigint): Promise<import("../..").SimpleTracer>;
 }

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

@@ -39,6 +39,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RFQAuctionServiceV1 = exports.user = exports.oracle = exports.query = exports.sendMsg = void 0;
 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"));
@@ -48,6 +50,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 RFQAuctionServiceV1 {
     ctx;
     constructor(ctx = context_1.AffluentContext.getInstance()) {
@@ -72,22 +75,68 @@ class RFQAuctionServiceV1 {
         return oracle.getOracleParamsForVault(this.ctx, vaultAddress, additionalAssets, vaultData);
     }
     // ============================================================
-    // User Operations
+    // User
     // ============================================================
     async sendAmountBid(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createAmountBidMsg(this.ctx, sender, params, value));
+        const msg = await user.createAmountBidMsg(this.ctx, sender, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const bidAsset = (0, utils_1.toAddress)(params.bidAsset);
+        const trace = await trace_1.RFQAuctionBidTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            bidAsset,
+            rfqAuction: (0, utils_1.toAddress)(params.rfqAuctionAddress),
+            isWTON: this.ctx.isWTON(bidAsset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendSlippageBid(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createSlippageBidMsg(this.ctx, sender, params, value));
+        const msg = await user.createSlippageBidMsg(this.ctx, sender, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const bidAsset = (0, utils_1.toAddress)(params.bidAsset);
+        const trace = await trace_1.RFQAuctionBidTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            bidAsset,
+            rfqAuction: (0, utils_1.toAddress)(params.rfqAuctionAddress),
+            isWTON: this.ctx.isWTON(bidAsset),
+        });
+        await trace.wait();
+        return trace;
     }
     async sendCancelBid(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createCancelBidMsg(this.ctx, params, value));
+        const rfqData = await this.getRFQData(params.rfqAuctionAddress);
+        const msg = await user.createCancelBidMsg(this.ctx, params, value);
+        const result = await (0, send_msg_1.sendMsgAndWaitTx)(this.ctx, sender, msg);
+        const trace = await trace_1.RFQAuctionCancelBidTracer.create({
+            ctx: this.ctx,
+            msgBody: msg.input.body,
+            extHash: await result.getExternalHash(),
+            actor: sender.address,
+            bidAsset: rfqData.buyAssetAddress,
+            rfqAuction: (0, utils_1.toAddress)(params.rfqAuctionAddress),
+            isWTON: this.ctx.isWTON(rfqData.buyAssetAddress),
+        });
+        await trace.wait();
+        return trace;
     }
+    // ============================================================
+    // Market Maker
+    // ============================================================
     async sendSettle(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createSettleMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await user.createSettleMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
     async sendClearBids(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createClearBidsMsg(this.ctx, params, value));
+        const trace = await (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await user.createClearBidsMsg(this.ctx, params, value));
+        await trace.wait();
+        return trace;
     }
 }
 exports.RFQAuctionServiceV1 = RFQAuctionServiceV1;

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

@@ -192,7 +192,7 @@ async function createSettleMsg(ctx, params, value) {
             body: (0, core_1.beginCell)()
                 .storeUint(rfq_auction_1.RFQAuction.Op.Settle, 32)
                 .storeUint(params.queryId ?? 0, 64)
-                .storeRef(oracleParams)
+                .storeMaybeRef(oracleParams)
                 .endCell(),
         },
     };

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;