@affluent-org/sdk 0.0.4 → 0.0.6

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

@@ -8,10 +8,10 @@ exports.getRFQAuction = getRFQAuction;
 exports.isVaultAsset = isVaultAsset;
 exports.splitPureAndVaultAsset = splitPureAndVaultAsset;
 exports.getPoolDataForStrategyVault = getPoolDataForStrategyVault;
-exports.getPoolPositionsForStrategyVault = getPoolPositionsForStrategyVault;
 exports.getValuationContext = getValuationContext;
 exports.getPrice = getPrice;
 exports.getUnderlyingPrices = getUnderlyingPrices;
+exports.getNativeAmountDecomposedContext = getNativeAmountDecomposedContext;
 const core_1 = require("@ton/core");
 const utils_1 = require("../../contracts/common/utils");
 const jetton_wallet_1 = require("../../contracts/jetton/jetton-wallet");
@@ -19,6 +19,7 @@ const rfq_auction_1 = require("../../contracts/rfq/rfq_auction");
 const strategy_vault_1 = require("../../contracts/vault/strategy-vault");
 const composite_oracle_1 = require("../composite-oracle");
 const pool_1 = require("../../contracts/core/pool");
+const transform_1 = require("../../common/transform");
 function getVault(ctx, strategyVaultAddress) {
     return ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(strategyVaultAddress));
 }
@@ -75,57 +76,44 @@ async function getPoolDataForStrategyVault(ctx, strategyVaultAddress) {
     const poolDataEntries = await Promise.all(poolDataEntriesPromises);
     return Object.fromEntries(poolDataEntries);
 }
-async function getPoolPositionsForStrategyVault(ctx, strategyVaultAddress) {
-    const strategyVault = getVault(ctx, strategyVaultAddress);
-    const vaultData = await strategyVault.getVaultData();
-    const poolInfo = {};
-    const poolDatas = await getPoolDataForStrategyVault(ctx, strategyVaultAddress);
-    for (const [poolAddress, poolPosition] of Object.entries(vaultData.factorialPools)) {
-        const poolData = poolDatas[poolAddress];
-        const position = {};
-        for (const [assetAddress, assetPosition] of Object.entries(poolPosition)) {
-            const amountPosition = (0, pool_1.positionShareToAmount)(assetPosition, poolData.assets[assetAddress]);
-            position[assetAddress] = {
-                supplyShare: assetPosition.supply,
-                supplyAmount: amountPosition.supply,
-                borrowShare: assetPosition.borrow,
-                borrowAmount: amountPosition.borrow,
-            };
-        }
-        poolInfo[poolAddress] = position;
-    }
-    return poolInfo;
-}
-async function getValuationContext(ctx, strategyVaultAddress) {
+async function getValuationContext(ctx, vaultAddress) {
     const compositeOracle = new composite_oracle_1.CompositeOracleV1(ctx);
-    const vaultData = await getVaultData(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
-    const { allPrices: priceInfo } = await compositeOracle.getVaultPriceWithDetails((0, utils_1.toAddress)(strategyVaultAddress));
-    const vaultPrice = priceInfo[(0, utils_1.toAddress)(strategyVaultAddress).toString()].price;
-    if (!vaultPrice)
-        throw new Error("Vault price not found");
-    const poolPositions = await getPoolPositionsForStrategyVault(ctx, strategyVaultAddress);
+    const vault = ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+    const vaultData = await vault.getVaultData();
+    const priceInfo = await compositeOracle.getVaultPriceWithDetails(vaultAddress, vaultData);
+    const poolPositions = await getPoolDataForStrategyVault(ctx, vaultAddress);
+    const poolContexts = {};
+    Object.entries(poolPositions).forEach(([poolAddress, poolState]) => poolContexts[poolAddress] = transform_1.PoolContext.fromPoolState(poolState));
+    const vaultStateContext = transform_1.VaultStateContext.fromStrategyVaultState(vaultData);
+    const amountContext = vaultStateContext.toAmountContext(poolContexts);
+    const valueContext = amountContext.toValueContext(priceInfo.allPrices);
+    const nativeValueDecomposedContext = transform_1.VaultNativeValueDecomposedContext.fromValueContext(valueContext, priceInfo.allPrices);
+    const nativeAmountDecomposedContext = transform_1.VaultNativeAmountDecomposedContext.fromAmountContext(amountContext, priceInfo.allPrices);
     return {
-        storage: vaultData,
-        totalSupply: vaultData.totalSupply,
-        reserves: Object.fromEntries(Object.entries(vaultData.assets)
-            .map(([assetAddress, assetData]) => [assetAddress, assetData.cash])),
-        poolPositions,
-        price: vaultPrice,
+        vaultStateContext,
+        amountContext,
+        valueContext,
+        nativeValueDecomposedContext,
+        nativeAmountDecomposedContext,
         priceInfo,
     };
 }
 async function getPrice(ctx, strategyVaultAddress) {
-    const valuationCtx = await getValuationContext(ctx, strategyVaultAddress);
-    return valuationCtx.price;
+    const valuationCtx = await getValuationContext(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
+    return valuationCtx.priceInfo.price;
 }
 async function getUnderlyingPrices(ctx, strategyVaultAddress) {
-    const valuationCtx = await getValuationContext(ctx, strategyVaultAddress);
-    const underlyingPriceEntries = Object.keys(valuationCtx.storage.assets)
+    const valuationCtx = await getValuationContext(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
+    const underlyingPriceEntries = Object.keys(valuationCtx.vaultStateContext.assets)
         .map(assetAddress => {
-        const priceData = valuationCtx.priceInfo[assetAddress];
+        const priceData = valuationCtx.priceInfo.allPrices[assetAddress];
         if (!priceData)
             throw new Error(`Price data not found for asset ${assetAddress}`);
         return [assetAddress, priceData.price];
     });
     return Object.fromEntries(underlyingPriceEntries);
 }
+async function getNativeAmountDecomposedContext(ctx, strategyVaultAddress) {
+    const valuationCtx = await getValuationContext(ctx, (0, utils_1.toAddress)(strategyVaultAddress));
+    return valuationCtx.nativeAmountDecomposedContext;
+}

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

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

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyVaultCancelWithdrawQueueTracer = exports.StrategyVaultCancelDepositQueueTracer = exports.StrategyVaultWithdrawQueueTracer = exports.StrategyVaultDepositQueueTracer = exports.StrategyVaultWithdrawTracer = exports.StrategyVaultDepositTracer = void 0;
+exports.getDepositAddresses = getDepositAddresses;
+exports.getWithdrawAddresses = getWithdrawAddresses;
+exports.getCancelDepositQueueAddresses = getCancelDepositQueueAddresses;
+exports.getCancelWithdrawQueueAddresses = getCancelWithdrawQueueAddresses;
+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 strategy_vault_1 = require("../../../contracts/vault/strategy-vault");
+async function getDepositAddresses(client, params) {
+    const { actor, asset, vault } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    const _vault = client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        vault,
+        vaultAssetWallet: await _asset.getWalletAddress(vault),
+    };
+}
+async function getWithdrawAddresses(client, params) {
+    const { actor, withdrawAsset, vault } = params;
+    const _withdrawAsset = client.open(jetton_minter_1.JettonMinter.createFromAddress(withdrawAsset));
+    const _vault = client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+    return {
+        actor,
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        actorWithdrawAssetWallet: await _withdrawAsset.getWalletAddress(actor),
+        vault,
+        vaultWithdrawAssetWallet: await _withdrawAsset.getWalletAddress(vault),
+    };
+}
+class StrategyVaultDepositTracer 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 getDepositAddresses(ctx.client, { actor, asset, vault });
+        return new StrategyVaultDepositTracer(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.StrategyVaultDepositTracer = StrategyVaultDepositTracer;
+class StrategyVaultWithdrawTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, withdrawAsset, vault, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getWithdrawAddresses(ctx.client, { actor, withdrawAsset, vault });
+        return new StrategyVaultWithdrawTracer(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.vaultWithdrawAssetWallet,
+                actorWallet: addresses.actorWithdrawAssetWallet,
+                actor: addresses.actor,
+                description: "Receiving Withdraw Asset",
+            }),
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            from: addresses.vaultWithdrawAssetWallet,
+            to: addresses.actorWithdrawAssetWallet,
+            description: "Refunding Withdraw Asset",
+        };
+        super(toncenterClient, extHash, type, queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultWithdrawTracer = StrategyVaultWithdrawTracer;
+class StrategyVaultDepositQueueTracer 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 getDepositAddresses(ctx.client, { actor, asset, vault });
+        return new StrategyVaultDepositQueueTracer(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",
+            }),
+            {
+                op: strategy_vault_1.StrategyVault.Op.Excesses,
+                from: addresses.vault,
+                to: addresses.actor,
+                description: "Queue Registered Excesses",
+            },
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.Transfer,
+            from: addresses.vault,
+            to: addresses.vaultAssetWallet,
+            description: "Refunding Tokens",
+        };
+        super(toncenterClient, extHash, type, queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultDepositQueueTracer = StrategyVaultDepositQueueTracer;
+class StrategyVaultWithdrawQueueTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, vault } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const _vault = ctx.client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+        const actorVaultWallet = await _vault.getWalletAddress(actor);
+        return new StrategyVaultWithdrawQueueTracer(ctx.toncenterClient, {
+            queryId,
+            extHash,
+            addresses: { actor, actorVaultWallet, vault },
+        });
+    }
+    constructor(toncenterClient, params) {
+        const { queryId, extHash, addresses } = params;
+        const steps = [
+            ...(0, trace_action_1.createBurnSteps)({
+                actor: addresses.actor,
+                actorWallet: addresses.actorVaultWallet,
+                minter: addresses.vault,
+                description: "Burning Vault Tokens",
+            }),
+            {
+                op: strategy_vault_1.StrategyVault.Op.Excesses,
+                from: addresses.vault,
+                to: addresses.actor,
+                description: "Queue Registered Excesses",
+            },
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            from: addresses.vault,
+            to: addresses.actorVaultWallet,
+            description: "Refunding Vault Tokens",
+        };
+        super(toncenterClient, extHash, "jetton", queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultWithdrawQueueTracer = StrategyVaultWithdrawQueueTracer;
+async function getCancelDepositQueueAddresses(client, params) {
+    const { actor, asset, vault } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        vault,
+        vaultAssetWallet: await _asset.getWalletAddress(vault),
+    };
+}
+class StrategyVaultCancelDepositQueueTracer 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 getCancelDepositQueueAddresses(ctx.client, { actor, asset, vault });
+        return new StrategyVaultCancelDepositQueueTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const steps = [
+            {
+                op: strategy_vault_1.StrategyVault.Op.CancelDepositQueue,
+                from: addresses.actor,
+                to: addresses.vault,
+                description: "Cancelling Deposit Queue",
+            },
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON,
+                sourceWallet: addresses.vaultAssetWallet,
+                actorWallet: addresses.actorAssetWallet,
+                actor: addresses.actor,
+                description: "Refunding Tokens",
+            }),
+        ];
+        const failStep = {
+            op: 0xffffffff,
+            from: addresses.vault,
+            to: addresses.actor,
+            description: "Bounced",
+        };
+        super(toncenterClient, extHash, "cancel", queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultCancelDepositQueueTracer = StrategyVaultCancelDepositQueueTracer;
+async function getCancelWithdrawQueueAddresses(client, params) {
+    const { actor, vault } = params;
+    const _vault = client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+    return {
+        actor,
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        vault,
+    };
+}
+class StrategyVaultCancelWithdrawQueueTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, vault } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getCancelWithdrawQueueAddresses(ctx.client, { actor, vault });
+        return new StrategyVaultCancelWithdrawQueueTracer(ctx.toncenterClient, { queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { queryId, extHash, addresses } = params;
+        const steps = [
+            {
+                op: strategy_vault_1.StrategyVault.Op.CancelWithdrawQueue,
+                from: addresses.actor,
+                to: addresses.vault,
+                description: "Cancelling Withdraw Queue",
+            },
+            ...(0, trace_action_1.createMintSteps)({
+                minter: addresses.vault,
+                actorWallet: addresses.actorVaultWallet,
+                description: "Refunding Vault Tokens",
+            }),
+        ];
+        const failStep = {
+            op: 0xffffffff,
+            from: addresses.vault,
+            to: addresses.actor,
+            description: "Bounced",
+        };
+        super(toncenterClient, extHash, "cancel", queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultCancelWithdrawQueueTracer = StrategyVaultCancelWithdrawQueueTracer;