@affluent-org/sdk 0.0.4 → 0.0.6

package/dist/services/pool/index.d.ts

@@ -9,9 +9,11 @@ import * as query from "./query";
 import * as oracle from "./oracle";
 import * as owner from "./owner";
 import * as user from "./user";
+import { PoolSupplyTracer, PoolWithdrawTracer, PoolBorrowTracer, PoolRepayTracer } from "./user/trace";
 export { sendMsg } from "../../lib/send-msg";
 export * from "./owner/types";
 export * from "./user/types";
+export * from "./user/trace";
 export * from "./computation";
 export { computation, query, oracle, owner, user };
 export declare class PoolServiceV1 {
@@ -32,63 +34,12 @@ export declare class PoolServiceV1 {
     static convertShareToAmount(accountData: AccountState, poolData: PoolState): AccountState;
     static haveBorrow(accountData: AccountState): boolean;
     static haveAssets(accountData: AccountState): string[];
-    sendSetOwner(sender: AddressSender, params: owner.SetOwnerParams, value?: bigint): Promise<{
-        newOwner: Address;
-        queryID: number | undefined;
-    }>;
-    sendSetIrmConfig(sender: AddressSender, params: owner.SetIrmConfigParams, value?: bigint): Promise<{
-        asset: Address;
-        irmConfig: import("@ton/core").Cell;
-        queryId: number | undefined;
-    }>;
-    sendSetFeeConfigurer(sender: AddressSender, params: owner.SetFeeConfigurerParams, value?: bigint): Promise<{
-        feeConfigurer: Address;
-        queryId: number | undefined;
-    }>;
-    sendSupply(sender: AddressSender, params: user.SupplyParams, value?: bigint): Promise<{
-        recipient: Address;
-        amount: bigint;
-        response: Address;
-        forwardTonAmount: bigint;
-        forwardPayload: import("@ton/core").Cell;
-        queryId: bigint | undefined;
-    }>;
-    sendWithdraw(sender: AddressSender, params: user.WithdrawParams, value?: bigint): Promise<{
-        asset: Address;
-        isShare: boolean;
-        amount: bigint;
-        recipient: Address;
-        response: Address;
-        jettonForwardTonAmount: bigint;
-        jettonForwardPayload: import("@ton/core").Cell | null;
-        oracleParams: import("@ton/core").Cell | null;
-        queryId: bigint | undefined;
-    }>;
-    sendBorrow(sender: AddressSender, params: user.BorrowParams, value?: bigint): Promise<{
-        asset: Address;
-        isShare: boolean;
-        amount: bigint;
-        recipient: Address;
-        response: Address;
-        jettonForwardTonAmount: bigint;
-        jettonForwardPayload: import("@ton/core").Cell | null;
-        oracleParams: import("@ton/core").Cell | null;
-        queryId: bigint | undefined;
-    }>;
-    sendRepay(sender: AddressSender, params: user.RepayParams, value?: bigint): Promise<{
-        recipient: Address;
-        amount: bigint;
-        response: Address;
-        forwardTonAmount: bigint;
-        forwardPayload: import("@ton/core").Cell;
-        queryId: bigint | undefined;
-    }>;
-    sendLiquidate(sender: AddressSender, params: user.LiquidateParams, value?: bigint): Promise<{
-        recipient: Address;
-        amount: bigint;
-        response: Address;
-        forwardTonAmount: bigint;
-        forwardPayload: import("@ton/core").Cell;
-        queryId: bigint | undefined;
-    }>;
+    sendSetOwner(sender: AddressSender, params: owner.SetOwnerParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendSetIrmConfig(sender: AddressSender, params: owner.SetIrmConfigParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendSetFeeConfigurer(sender: AddressSender, params: owner.SetFeeConfigurerParams, value?: bigint): Promise<import("../..").SimpleTracer>;
+    sendSupply(sender: AddressSender, params: user.SupplyParams, value?: bigint): Promise<PoolSupplyTracer>;
+    sendWithdraw(sender: AddressSender, params: user.WithdrawParams, value?: bigint): Promise<PoolWithdrawTracer>;
+    sendBorrow(sender: AddressSender, params: user.BorrowParams, value?: bigint): Promise<PoolBorrowTracer>;
+    sendRepay(sender: AddressSender, params: user.RepayParams, value?: bigint): Promise<PoolRepayTracer>;
+    sendLiquidate(sender: AddressSender, params: user.LiquidateParams, value?: bigint): Promise<import("../..").SimpleTracer>;
 }

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,75 @@ class PoolServiceV1 {
     // Owner
     // ============================================================
     async sendSetOwner(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetOwnerMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetOwnerMsg(this.ctx, params, value));
     }
     async sendSetIrmConfig(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetIrmConfigMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetIrmConfigMsg(this.ctx, params, value));
     }
     async sendSetFeeConfigurer(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, owner.createSetFeeConfigurerMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await owner.createSetFeeConfigurerMsg(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 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);
+        return 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),
+        });
     }
     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);
+        return 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),
+        });
     }
     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);
+        return 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),
+        });
     }
     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);
+        return 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),
+        });
     }
     async sendLiquidate(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createLiquidateMsg(this.ctx, sender, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await user.createLiquidateMsg(this.ctx, sender, params, value));
     }
 }
 exports.PoolServiceV1 = PoolServiceV1;

package/dist/services/pool/oracle.d.ts

@@ -2,12 +2,12 @@ import { Cell } from "@ton/core";
 import { AffluentContext } from "../../context";
 import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { PoolState } from "../../contracts/core/pool/type";
-import { VaultPositions } from "../composite-oracle/types";
+import { IVaultStateContext } from "../../common/types";
 /**
  * Build oracle params Cell from pre-fetched vault positions
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions): Promise<Cell>;
+export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>): Promise<Cell>;
 /**
  * Get oracle params for a pool operation
  * Fetches account data and builds oracle params

package/dist/services/pool/query.d.ts

@@ -5,7 +5,7 @@ import { Pool } from "../../contracts/core/pool";
 import { PoolState } from "../../contracts/core/pool/type";
 import { Account } from "../../contracts/core/account";
 import { AccountState, AccountAssetState } from "../../contracts/core/account/type";
-import { VaultCompositions, Prices } from "../composite-oracle/types";
+import { VaultCompositions, Prices } from "../../common/types";
 import { HealthResult, MaxBorrowableResult, MaxWithdrawableResult } from "./computation";
 /**
  * Get Pool contract instance

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,58 @@ 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);
+        return 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),
+        });
     }
     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);
+        return 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),
+        });
     }
     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);
+        return 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),
+        });
     }
+    // ============================================================
+    // Market Maker
+    // ============================================================
     async sendSettle(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createSettleMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await user.createSettleMsg(this.ctx, params, value));
     }
     async sendClearBids(sender, params, value) {
-        return (0, send_msg_1.sendMsg)(sender, user.createClearBidsMsg(this.ctx, params, value));
+        return (0, send_msg_1.sendMsgAndWaitTxSimple)(this.ctx, sender, await user.createClearBidsMsg(this.ctx, params, value));
     }
 }
 exports.RFQAuctionServiceV1 = RFQAuctionServiceV1;

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

@@ -2,13 +2,13 @@ import { Cell } from "@ton/core";
 import { AffluentContext } from "../../context";
 import { AddressInput, AddressLike } from "../../contracts/common/type";
 import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
-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 data
  * Pure computation - no network calls
  */
-export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions): Promise<Cell>;
+export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: Record<string, IVaultStateContext>): Promise<Cell>;
 /**
  * Get oracle params for RFQ auction settlement
  */

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(),
         },
     };