@affluent-org/sdk 0.0.1

package/dist/utils/parser.js

@@ -0,0 +1,580 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseActionNotification = parseActionNotification;
+exports.parseJettonTransfer = parseJettonTransfer;
+exports.parseJettonInternalTransfer = parseJettonInternalTransfer;
+exports.parseProvideAggregatedPool = parseProvideAggregatedPool;
+exports.parseExcesses = parseExcesses;
+exports.parseTx = parseTx;
+const core_1 = require("@ton/core");
+const pool_1 = require("../contracts/core/pool");
+const serializer_1 = require("../contracts/core/pool/serializer");
+const jetton_wallet_1 = require("../contracts/jetton/jetton-wallet");
+const share_vault_1 = require("../contracts/vault/share-vault");
+const redstone_onchain_oracle_1 = require("../contracts/oracle/redstone-onchain-oracle");
+const parser_1 = require("../contracts/oracle/parser");
+const LFStonfiJettonWallet_1 = require("../contracts/liquid_token/stonfi/LFStonfiJettonWallet");
+const strategy_vault_1 = require("../contracts/vault/strategy-vault");
+const rfq_auction_1 = require("../contracts/rfq/rfq_auction");
+const jetton_wallet_2 = require("../contracts/wton/jetton-wallet");
+function parseActionNotification(cell) {
+    const ds = cell.beginParse();
+    const opCode = ds.loadUint(32);
+    if (opCode !== pool_1.Pool.Op.ActionNotification)
+        return null;
+    const queryId = ds.loadUintBig(64);
+    const actionOpCode = ds.loadUint(32);
+    const errorCode = ds.loadUint(16);
+    if (errorCode === 0) {
+        if (actionOpCode === pool_1.Pool.Op.Supply) {
+            return (0, serializer_1.parseSuccessActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.Withdraw) {
+            return (0, serializer_1.parseSuccessActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.Borrow) {
+            return (0, serializer_1.parseSuccessActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.Repay) {
+            return (0, serializer_1.parseSuccessRepayActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.Liquidate) {
+            return (0, serializer_1.parseSuccessLiquidationActionNotificationMsgBody)(cell);
+        }
+    }
+    else {
+        if (actionOpCode === jetton_wallet_1.JettonWallet.Op.TransferNotification) {
+            ds.loadCoins();
+            ds.loadAddress();
+            const forwardDS = ds.loadRef().beginParse();
+            forwardDS.loadAddress();
+            const subOp = forwardDS.loadUint(32);
+            if (subOp === pool_1.Pool.Op.Supply) {
+                return (0, serializer_1.parseFailTransferInActionNotificationMsgBody)(cell);
+            }
+            else if (subOp === pool_1.Pool.Op.Repay) {
+                return (0, serializer_1.parseFailTransferInActionNotificationMsgBody)(cell);
+            }
+            else if (subOp === pool_1.Pool.Op.Liquidate) {
+                return (0, serializer_1.parseFailLiquidateActionNotificationMsgBody)(cell);
+            }
+        }
+        else if (actionOpCode === pool_1.Pool.Op.withdraw) {
+            return (0, serializer_1.parseFailTransferOutActionNotificationMsgBody)(cell);
+        }
+        else if (actionOpCode === pool_1.Pool.Op.borrow) {
+            return (0, serializer_1.parseFailTransferOutActionNotificationMsgBody)(cell);
+        }
+    }
+    return null;
+}
+function parseJettonTransfer(cell) {
+    const ds = cell.beginParse();
+    const opcode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const amount = ds.loadCoins();
+    const recipient = ds.loadAddress();
+    const response = ds.loadMaybeAddress();
+    ds.loadBit();
+    const forwardTonAmount = ds.loadCoins();
+    const forwardPayload = ds;
+    return {
+        type: "JettonWallet.Op.Transfer",
+        opcode,
+        queryId,
+        amount,
+        recipient,
+        response,
+        forwardTonAmount,
+        forwardPayload,
+    };
+}
+function parseJettonInternalTransfer(cell) {
+    const ds = cell.beginParse();
+    const opcode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const amount = ds.loadCoins();
+    const fromAddress = ds.loadMaybeAddress();
+    const response = ds.loadMaybeAddress();
+    const forwardTonAmount = ds.loadCoins();
+    const forwardPayload = ds;
+    return {
+        type: "JettonWallet.Op.InternalTransfer",
+        opcode,
+        queryId,
+        amount,
+        fromAddress,
+        response,
+        forwardTonAmount,
+        forwardPayload,
+    };
+}
+function parseProvideAggregatedPool(cell) {
+    const ds = cell.beginParse();
+    const opcode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    const pools = ds.loadDict(core_1.Dictionary.Keys.Address(), core_1.Dictionary.Values.Bool()).keys();
+    const forwardPayload = ds;
+    return {
+        type: "ShareVault.Op.ProvideAggregatedPool",
+        opcode,
+        queryId,
+        pools,
+        forwardPayload,
+    };
+}
+function parseExcesses(cell) {
+    const ds = cell.beginParse();
+    const opcode = ds.loadUint(32);
+    const queryId = ds.loadUintBig(64);
+    return {
+        type: "JettonWallet.Op.Excesses",
+        opcode,
+        queryId,
+    };
+}
+function parseTx(cell) {
+    try {
+        const ds = cell.beginParse();
+        const opCode = ds.loadUint(32);
+        const queryId = ds.loadUintBig(64);
+        if (opCode === jetton_wallet_1.JettonWallet.Op.Transfer) {
+            return parseJettonTransfer(cell);
+        }
+        else if (opCode === jetton_wallet_1.JettonWallet.Op.InternalTransfer) {
+            return parseJettonInternalTransfer(cell);
+        }
+        else if (opCode === share_vault_1.ShareVault.Op.ProvideAggregatedPool) {
+            return parseProvideAggregatedPool(cell);
+        }
+        else if (opCode === jetton_wallet_1.JettonWallet.Op.Excesses) {
+            return parseExcesses(cell);
+        }
+        else if (opCode === pool_1.Pool.Op.Withdraw || opCode === pool_1.Pool.Op.Borrow) {
+            return (0, serializer_1.parseTransferOutMsgBody)(cell);
+        }
+        else if (opCode === share_vault_1.ShareVault.Op.TakeAggregatedPool) {
+            const aggregatorIndex = ds.loadCoins();
+            const aggregatedDict = ds.loadMaybeRef();
+            const actorAddress = ds.loadAddress();
+            const actionOp = ds.loadUint(32);
+            const amount = ds.loadCoins();
+            const createTime = ds.loadUint(40);
+            return {
+                aggregatorIndex,
+                aggregatedDict,
+                actionOp,
+                actorAddress,
+                amount,
+                createTime,
+            };
+        }
+        else if (opCode === redstone_onchain_oracle_1.RedstoneOnchainOracle.Op.TakeOraclePrice) {
+            const DictioryValueOraclePrice = {
+                serialize: (src, builder) => { },
+                parse: (src) => {
+                    const price = src.loadCoins();
+                    const assetType = src.loadUint(8);
+                    // const totalSupplyShare = src.loadCoins();
+                    // const totalBorrowShare = src.loadCoins();
+                    // const isCollateral = src.loadBoolean();
+                    // const riskFactor = src.loadUint(14);
+                    // const liquidationIncentiveRate = src.loadUint(14);
+                    return {
+                        price,
+                        assetType,
+                    };
+                },
+            };
+            const _dict = ds.loadRef();
+            const dict = _dict.beginParse().loadDictDirect(core_1.Dictionary.Keys.Address(), DictioryValueOraclePrice);
+            return {
+                dict,
+            };
+            // const aggregatorIndex = ds.loadCoins();
+            // const aggregatedDict = ds.loadMaybeRef();
+            // const actorAddress = ds.loadAddress();
+            // const actionOp = ds.loadUint(32);
+            // const amount = ds.loadCoins();
+            // const createTime = ds.loadUint(40);
+            // return {
+            //   aggregatorIndex,
+            //   aggregatedDict,
+            //   actionOp,
+            //   actorAddress,
+            //   amount,
+            //   createTime
+            // };
+        }
+        else if (opCode === redstone_onchain_oracle_1.RedstoneOnchainOracle.Op.ProvideOraclePrice) {
+            const DictioryValueOraclePrice = {
+                serialize: (src, builder) => { },
+                parse: (src) => {
+                    const price = src.loadCoins();
+                    const assetType = src.loadUint(8);
+                    // const totalSupplyShare = src.loadCoins();
+                    // const totalBorrowShare = src.loadCoins();
+                    // const isCollateral = src.loadBoolean();
+                    // const riskFactor = src.loadUint(14);
+                    // const liquidationIncentiveRate = src.loadUint(14);
+                    return {
+                        price,
+                        assetType,
+                    };
+                },
+            };
+            const oracleCs = ds.loadRef().beginParse();
+            const oracleConfigCell = oracleCs.loadRef();
+            const oracleParamsCell = oracleCs.loadRef();
+            // console.log(parseOracleConfig(oracleConfigCell));
+            // console.log(parseOracleParams(oracleParamsCell));
+            // // console.log(oracleParamsCs.toString())
+            // // const feedIdAssetDict = oracleConfigCs.loadDict();
+            // oracleConfigCs.loadBit();
+            // const signer_count_threshold = oracleConfigCs.loadCoins();
+            // const signers = oracleConfigCs.loadRef();
+            // // const assetInfoDict =
+            // oracleConfigCs.loadBit();
+            // // console.log(signer_count_threshold);
+            // const dataFeed = oracleParamsCs.loadRef();
+            // const redstone_payload = oracleParamsCs.loadRef();
+            // const request_asset = oracleParamsCs.loadRef();
+            // console.log({
+            //   dataFeed,
+            //   redstone_payload,
+            //   request_asset
+            // });
+            // const aggregatorIndex = ds.loadCoins();
+            // const aggregatedDict = ds.loadMaybeRef();
+            // const actorAddress = ds.loadAddress();
+            // const actionOp = ds.loadUint(32);
+            // const amount = ds.loadCoins();
+            // const createTime = ds.loadUint(40);
+            // return {
+            //   aggregatorIndex,
+            //   aggregatedDict,
+            //   actionOp,
+            //   actorAddress,
+            //   amount,
+            //   createTime
+            // };
+        }
+        else if (opCode === pool_1.Pool.Op.ExecuteAction) {
+            try {
+                const summarizedData = ds.loadRef();
+                const sdata = summarizedData.beginParse();
+                const version = sdata.loadUint(16);
+                const maxLoanLeverageRatio = sdata.loadUint(20);
+                const maxLoanVarRatio = sdata.loadUint(14);
+                const maxLiquidateLeverageRatio = sdata.loadUint(20);
+                const maxLiquidateVarRatio = sdata.loadUint(14);
+                const minLiquidateCloseRatio = sdata.loadUint(14);
+                const maxLiquidateCloseRatio = sdata.loadUint(14);
+                const _dict = sdata.loadDict(core_1.Dictionary.Keys.Address(), DictioryValueSummarizedAsset);
+                const assets = _dict.keys().reduce((acc, cur) => {
+                    acc[cur.toString()] = _dict.get(cur);
+                    return acc;
+                }, {});
+                const oracle = {};
+                if (ds.remainingRefs > 0) {
+                    const DictioryValueOraclePrice = {
+                        serialize: (src, builder) => { },
+                        parse: (src) => {
+                            const price = src.loadCoins();
+                            const assetType = src.loadUint(8);
+                            return { price };
+                        },
+                    };
+                    const _oracle = ds.loadRef().beginParse().loadDictDirect(core_1.Dictionary.Keys.Address(), DictioryValueOraclePrice);
+                    _oracle.keys().forEach((key) => {
+                        oracle[key.toString()] = _oracle.get(key);
+                    });
+                }
+                console.log(oracle);
+                const opcode = ds.loadUint(32);
+                // console.log(_dict);
+                // Supply: 0x480074d8,
+                // Withdraw: 0xcb03bfaf,
+                // Borrow: 0xcfc248e4,
+                // Repay: 0xee555a2c,
+                // Liquidate: 0xcc52bae3,
+                if (opcode === pool_1.Pool.Op.Borrow || opcode === pool_1.Pool.Op.Withdraw || opCode === pool_1.Pool.Op.Liquidate) {
+                    const DictioryValueOraclePrice = {
+                        serialize: (src, builder) => { },
+                        parse: (src) => {
+                            const price = src.loadCoins();
+                            // const assetType = src.loadUint(8);
+                            return { price };
+                        },
+                    };
+                    // const oracleData = ds.loadRef().beginParse().loadDictDirect(Dictionary.Keys.Address(), DictioryValueOraclePrice);
+                }
+                return {
+                    type: "Pool.Op.ExecuteActionToAccount",
+                    version: version,
+                    maxLoanLeverageRatio,
+                    maxLoanVarRatio,
+                    maxLiquidateLeverageRatio,
+                    maxLiquidateVarRatio,
+                    minLiquidateCloseRatio,
+                    maxLiquidateCloseRatio,
+                    assets: assets,
+                    oracle,
+                };
+            }
+            catch (e) {
+                return null;
+            }
+        }
+        else if (opCode === LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.Farm) {
+            const amount = ds.loadCoins();
+            const responseAddress = ds.loadAddress();
+            const forwardTonAmount = ds.loadCoins();
+            return {
+                type: "LFStonfiJettonWallet.Op.Farm",
+                opcode: opCode,
+                queryId,
+                amount,
+                responseAddress,
+                forwardTonAmount,
+            };
+        }
+        else if (opCode === pool_1.Pool.Op.UpdateAccountStatus) {
+        }
+        else if (opCode === strategy_vault_1.StrategyVault.Op.SetAssetConfig) {
+            const assetAddress = ds.loadAddress();
+            const isWhitelisted = ds.loadBoolean();
+            const isDepositable = ds.loadBoolean();
+            const isWithdrawable = ds.loadBoolean();
+            const exposureCap = ds.loadUint(14);
+            return {
+                type: "StrategyVault.Op.SetAssetConfig",
+                opcode: opCode,
+                queryId,
+                assetAddress,
+                isWhitelisted,
+                isDepositable,
+                isWithdrawable,
+                exposureCap,
+            };
+        }
+        else if (opCode === strategy_vault_1.StrategyVault.Op.ExecuteStrategy) {
+            const subOp = ds.loadUint(32);
+            if (subOp === strategy_vault_1.StrategyVault.Op.CreateRFQ) {
+                const oracleParams = ds.loadMaybeRef();
+                const rfqIndex = ds.loadCoins();
+                const sellAsset = ds.loadAddress();
+                const buyAsset = ds.loadAddress();
+                const sellAssetAmount = ds.loadCoins();
+                const minBuyAssetAmount = ds.loadCoins();
+                const maxBuyAssetAmount = ds.loadCoins();
+                const additionalDataCS = ds.loadRef().beginParse();
+                const sellAssetRFQWallet = additionalDataCS.loadAddress();
+                const buyAssetRFQWallet = additionalDataCS.loadAddress();
+                const period = additionalDataCS.loadUint(40);
+                const allowSellerCancel = additionalDataCS.loadBoolean();
+                const allowBidderCancel = additionalDataCS.loadBoolean();
+                const isAmountBid = additionalDataCS.loadBoolean();
+                const rfqId = ds.loadUint(14);
+                return {
+                    type: "StrategyVault.Op.CancelRFQ",
+                    opcode: opCode,
+                    queryId,
+                    oracleParams,
+                    rfqIndex,
+                    sellAsset,
+                    buyAsset,
+                    sellAssetAmount,
+                    minBuyAssetAmount,
+                    maxBuyAssetAmount,
+                    sellAssetRFQWallet,
+                    buyAssetRFQWallet,
+                    period,
+                    allowSellerCancel,
+                    allowBidderCancel,
+                    isAmountBid,
+                    rfqId,
+                };
+            }
+        }
+        else if (opCode === strategy_vault_1.StrategyVault.Op.ProvideAggregatedData) {
+            const assetData = ds.loadMaybeRef();
+            const poolData = ds.loadMaybeRef();
+            const vaultData = ds.loadMaybeRef();
+            const subOp = ds.loadUint(32);
+            if (subOp === strategy_vault_1.StrategyVault.Op.Deposit) {
+                const assetAddress = ds.loadAddress();
+                const fromAddress = ds.loadAddress();
+                const amount = ds.loadCoins();
+                const forwardTonAmount = ds.loadCoins();
+                const forwardPayload = ds.loadMaybeRef();
+                return {
+                    type: "StrategyVault.Op.TakeAggregatedData",
+                    opcode: opCode,
+                    queryId,
+                    assetData,
+                    poolData,
+                    vaultData,
+                    subOp: {
+                        subOpType: "StrategyVault.Op.Deposit",
+                        assetAddress,
+                        fromAddress,
+                        amount,
+                        forwardTonAmount,
+                        forwardPayload,
+                    },
+                };
+            }
+        }
+        else if (opCode === strategy_vault_1.StrategyVault.Op.TakeAggregatedData) {
+            const aggregatorIndex = ds.loadCoins();
+            const assetData = ds.loadMaybeRef();
+            const poolData = ds.loadMaybeRef();
+            const vaultData = ds.loadMaybeRef();
+            const subOp = ds.loadUint(32);
+            if (subOp === strategy_vault_1.StrategyVault.Op.Deposit) {
+                const assetAddress = ds.loadAddress();
+                const fromAddress = ds.loadAddress();
+                const amount = ds.loadCoins();
+                const forwardTonAmount = ds.loadCoins();
+                const forwardPayload = ds.loadMaybeRef();
+                return {
+                    type: "StrategyVault.Op.TakeAggregatedData",
+                    opcode: opCode,
+                    queryId,
+                    assetData,
+                    poolData,
+                    vaultData,
+                    subOp: {
+                        subOpType: "StrategyVault.Op.Deposit",
+                        assetAddress,
+                        fromAddress,
+                        amount,
+                        forwardTonAmount,
+                        forwardPayload,
+                    },
+                };
+            }
+            else if (subOp === strategy_vault_1.StrategyVault.Op.Withdraw) {
+                const assetAddress = ds.loadAddress();
+                const toAddress = ds.loadAddress();
+                const amount = ds.loadCoins();
+                const forwardTonAmount = ds.loadCoins();
+                const forwardPayload = ds.loadMaybeRef();
+                return {
+                    type: "StrategyVault.Op.TakeAggregatedData",
+                    opcode: opCode,
+                    queryId,
+                    aggregatorIndex,
+                    assetData,
+                    poolData,
+                    vaultData,
+                    subOp: {
+                        subOpType: "StrategyVault.Op.Withdraw",
+                        assetAddress,
+                        toAddress,
+                        amount,
+                        forwardTonAmount,
+                        forwardPayload,
+                    },
+                };
+            }
+        }
+        else if (opCode === rfq_auction_1.RFQAuction.Op.Settle) {
+            const oracleParams = ds.loadMaybeRef();
+            return {
+                type: "RFQAuction.Op.Settle",
+                opcode: opCode,
+                queryId,
+                oracleParams: oracleParams && (0, parser_1.parseOracleParams)(oracleParams),
+            };
+        }
+        else if (opCode === jetton_wallet_2.WTONWallet.Op.ExternalTransfer) {
+            const amount = ds.loadCoins();
+            const recipient = ds.loadAddress();
+            const forwardTonAmount = ds.loadCoins();
+            const forwardPayload = ds.loadMaybeRef();
+            let subMessage = {};
+            if (forwardPayload) {
+                const forwardPayloadCs = forwardPayload.beginParse();
+                const forwardPayloadOp = forwardPayloadCs.loadUint(32);
+                if (forwardPayloadOp === strategy_vault_1.StrategyVault.Op.Deposit) {
+                    // console.log(forwardPayloadOp);
+                    subMessage.subOp = "StrategyVault.Op.Deposit";
+                }
+                else if (forwardPayloadOp === strategy_vault_1.StrategyVault.Op.Withdraw) {
+                    // subMessage = parseTakeAggregatedPool(forwardPayload);
+                }
+            }
+            return {
+                type: "WTONWallet.Op.ExternalTransfer",
+                opcode: opCode,
+                queryId,
+                amount,
+                recipient,
+                forwardTonAmount,
+                forwardPayloadParsed: subMessage,
+            };
+        }
+        else if (opCode === jetton_wallet_1.JettonWallet.Op.BurnNotification) {
+            const amount = ds.loadCoins();
+            const fromAddress = ds.loadAddress();
+            const response = ds.loadAddress();
+            const additionalData = ds.loadRef().beginParse();
+            const subOp = additionalData.loadUint(32);
+            if (subOp === strategy_vault_1.StrategyVault.Op.Withdraw) {
+                const assetAddress = additionalData.loadAddress();
+                const oracleParams = additionalData.loadMaybeRef()?.hash();
+                const forwardTonAmount = additionalData.loadCoins();
+                const forwardPayload = additionalData.loadMaybeRef()?.hash();
+                return {
+                    type: "JettonWallet.Op.Burn(StrategyVault.Op.Withdraw)",
+                    opcode: opCode,
+                    queryId,
+                    fromAddress,
+                    amount,
+                    assetAddress,
+                    oracleParams,
+                    forwardTonAmount,
+                    forwardPayload,
+                    subOp: {
+                        subOpType: "StrategyVault.Op.Withdraw",
+                    },
+                };
+            }
+            const forwardTonAmount = ds.loadCoins();
+            const forwardPayload = ds.loadMaybeRef();
+            return {
+                type: "JettonWallet.Op.Burn",
+                opcode: opCode,
+                queryId,
+                amount,
+                forwardTonAmount,
+            };
+        }
+    }
+    catch (e) {
+        return null;
+    }
+}
+const DictioryValueSummarizedAsset = {
+    serialize: (src, builder) => { },
+    parse: (src) => {
+        const totalSupplyAmount = src.loadCoins();
+        const totalBorrowAmount = src.loadCoins();
+        const totalSupplyShare = src.loadCoins();
+        const totalBorrowShare = src.loadCoins();
+        const isCollateral = src.loadBoolean();
+        const riskFactor = src.loadUint(14);
+        const liquidationIncentiveRate = src.loadUint(14);
+        return {
+            totalSupplyAmount,
+            totalBorrowAmount,
+            totalSupplyShare,
+            totalBorrowShare,
+            isCollateral,
+            riskFactor,
+            liquidationIncentiveRate,
+        };
+    },
+};

package/dist/utils/pending-tracker/index.d.ts

@@ -0,0 +1,14 @@
+import { InternalMessageInput } from "../../lib/send-msg";
+import { TrackableSender, SendResult } from "./type";
+export * from "./type";
+export * from "./v3-client";
+export { createTrackableSender, createTrackableSenderFromMnemonic, TrackableSenderConfig, } from "./trackable-sender";
+/**
+ * Send a message using TrackableSender and return tracking info (extMsgHash)
+ *
+ * Use ToncenterV3Client.waitForTrace(extMsgHash) to wait for completion.
+ */
+export declare function sendMsgTracked<T>(sender: TrackableSender, msg: Promise<{
+    opts: T;
+    input: InternalMessageInput;
+}>): Promise<T & SendResult>;

package/dist/utils/pending-tracker/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrackableSenderFromMnemonic = exports.createTrackableSender = void 0;
+exports.sendMsgTracked = sendMsgTracked;
+const core_1 = require("@ton/core");
+__exportStar(require("./type"), exports);
+__exportStar(require("./v3-client"), exports);
+var trackable_sender_1 = require("./trackable-sender");
+Object.defineProperty(exports, "createTrackableSender", { enumerable: true, get: function () { return trackable_sender_1.createTrackableSender; } });
+Object.defineProperty(exports, "createTrackableSenderFromMnemonic", { enumerable: true, get: function () { return trackable_sender_1.createTrackableSenderFromMnemonic; } });
+/**
+ * Send a message using TrackableSender and return tracking info (extMsgHash)
+ *
+ * Use ToncenterV3Client.waitForTrace(extMsgHash) to wait for completion.
+ */
+async function sendMsgTracked(sender, msg) {
+    const { opts, input } = await msg;
+    const result = await sender.send({ ...input, sendMode: core_1.SendMode.PAY_GAS_SEPARATELY });
+    return { ...opts, ...result };
+}

package/dist/utils/pending-tracker/trackable-sender.d.ts

@@ -0,0 +1,16 @@
+import { TonClient, WalletContractV5R1 } from "@ton/ton";
+import { KeyPair } from "@ton/crypto";
+import { TrackableSender } from "./type";
+export interface TrackableSenderConfig {
+    client: TonClient;
+    wallet: WalletContractV5R1;
+    keyPair: KeyPair;
+}
+/**
+ * Create a TrackableSender from wallet contract and key pair
+ */
+export declare function createTrackableSender(config: TrackableSenderConfig): TrackableSender;
+/**
+ * Create a TrackableSender from mnemonic
+ */
+export declare function createTrackableSenderFromMnemonic(client: TonClient, mnemonic: string[], workchain?: number): Promise<TrackableSender>;