@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/share-vault.js

@@ -0,0 +1,747 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareVaultV1 = void 0;
+const ton_1 = require("@ton/ton");
+const pool_1 = require("./contracts/core/pool");
+const jetton_minter_1 = require("./contracts/jetton/jetton-minter");
+const jetton_wallet_1 = require("./contracts/jetton/jetton-wallet");
+const tracker_1 = require("./utils/tracker");
+const share_vault_1 = require("./contracts/vault/share-vault");
+const query_id_generactor_1 = require("./utils/tracker/query-id-generactor");
+const parser_1 = require("./utils/parser");
+const jetton_wallet_2 = require("./contracts/wton/jetton-wallet");
+const jetton_minter_2 = require("./contracts/wton/jetton-minter");
+const service_1 = require("./common/service");
+const TIMEOUT_SEC = 2 * 60 * 1000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const toAddress = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value;
+    }
+    return ton_1.Address.parse(value);
+};
+const toString = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value.toString();
+    }
+    return value;
+};
+class ShareVaultV1 extends service_1.ServiceBaseV1 {
+    // user -> asset -> wallet
+    walletAddresses = {};
+    async getJettonWalletAddress(owner, jetton) {
+        if (!this.walletAddresses[owner]) {
+            this.walletAddresses[owner] = {};
+        }
+        if (!this.walletAddresses[owner][jetton]) {
+            const jettonMinter = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(jetton)));
+            this.walletAddresses[owner][jetton] = await jettonMinter.getWalletAddress(toAddress(owner));
+        }
+        return this.walletAddresses[owner][jetton];
+    }
+    async findTx(action, callbackFn) {
+        if (action.type == "vault-supply") {
+            return this.findSupplyTx(BigInt(action.queryId), action.params, callbackFn);
+        }
+        else if (action.type == "vault-withdraw") {
+            return this.findWithdrawTx(BigInt(action.queryId), action.params, callbackFn);
+        }
+    }
+    async supply(sender, params) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.Supply, share_vault_1.ShareVault.Gas.baseFee, Object.keys(vaultData.whitelistedPools).length, vaultData.minimumGasFee);
+        if (toString(vaultData.asset) == this.contracts.WTON) {
+            const vaultWTONWalletAddress = await this.getJettonWalletAddress(toString(params.vault), toString(vaultData.asset));
+            const vaultWTONWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromAddress(vaultWTONWalletAddress));
+            await vaultWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                recipient: toAddress(params.vault),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+                forwardPayload: (0, ton_1.beginCell)().storeUint(0, 32).endCell(),
+            });
+        }
+        else {
+            const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(vaultData.asset));
+            const senderJettonWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                recipient: toAddress(params.vault),
+                response: toAddress(params.response),
+                amount: params.amount,
+                forwardTonAmount: gas,
+            });
+        }
+    }
+    async supplyAndWaitTx(sender, params, callbackFn) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.Supply, share_vault_1.ShareVault.Gas.baseFee, Object.keys(vaultData.whitelistedPools).length, vaultData.minimumGasFee);
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(vaultData.asset));
+        const senderJettonWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+        const senderVaultWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.vault));
+        const opt = {
+            recipient: toAddress(params.vault),
+            response: toAddress(params.response),
+            amount: params.amount,
+            forwardTonAmount: gas,
+        };
+        const body = senderJettonWallet.createTransferBody(opt);
+        const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(params.sender), body);
+        const steps = [];
+        if (toString(vaultData.asset) == this.contracts.WTON) {
+            const vaultWTONWalletAddress = await this.getJettonWalletAddress(toString(params.vault), toString(vaultData.asset));
+            const vaultWTONWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromAddress(vaultWTONWalletAddress));
+            await vaultWTONWallet.sendExternalTransfer(sender, jetton_wallet_2.WTONWallet.Gas.ExternalTransfer, {
+                ...opt,
+                queryId: queryId,
+            });
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Starting the tx",
+                    from: toAddress(params.sender),
+                    to: vaultWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            await senderJettonWallet.sendTransfer(sender, gas + jetton_wallet_1.JettonWallet.Gas.Transfer, {
+                ...opt,
+                queryId: queryId,
+            });
+            steps.push(...[
+                {
+                    description: "Starting the tx",
+                    from: toAddress(params.sender),
+                    to: senderJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+                    queryId: queryId,
+                },
+            ]);
+        }
+        steps.push(...[
+            {
+                description: "Sending the token to the vault",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                description: "Aggregating pools",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: share_vault_1.ShareVault.Op.TakeAggregatedPool,
+            },
+            {
+                description: "Sending asset to the pool",
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                description: "Action notification",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                description: "Minting the vault share token",
+                from: toAddress(params.vault),
+                to: toAddress(senderVaultWalletAddress),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx1 = await (0, tracker_1.findTx)(this.client, toAddress(params.sender), "0", steps[0]);
+            steps[0].matchedTx = matchedTx1;
+            if (callbackFn)
+                callbackFn(steps[0]);
+            const matchedTx2 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx1.lt.toString(), steps[1]);
+            steps[1].matchedTx = matchedTx2;
+            if (callbackFn)
+                callbackFn(steps[1]);
+            let poolAddress;
+            if (matchedTx2.outMessages[0]?.parsedBody?.type ===
+                "ShareVault.Op.ProvideAggregatedPool") {
+                const matchedTx3 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), steps[2]);
+                steps[2].matchedTx = matchedTx3;
+                if (callbackFn)
+                    callbackFn(steps[2]);
+                if (matchedTx3.outMessages[0]?.parsedBody?.type ===
+                    "JettonWallet.Op.Transfer") {
+                    poolAddress = matchedTx3.outMessages[0]?.parsedBody.recipient;
+                }
+            }
+            else if (matchedTx2.outMessages[0]?.parsedBody?.type ===
+                "JettonWallet.Op.Transfer") {
+                poolAddress = matchedTx2.outMessages[0]?.parsedBody.recipient;
+            }
+            if (poolAddress) {
+                const matchedTx4 = await (0, tracker_1.findTx)(this.client, toAddress(poolAddress), matchedTx2.lt.toString(), steps[3]);
+                steps[3].matchedTx = matchedTx4;
+                if (callbackFn)
+                    callbackFn(steps[3]);
+                const matchedTx5 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx4.lt.toString(), steps[4]);
+                steps[4].matchedTx = matchedTx5;
+                if (matchedTx5.inMessage?.body) {
+                    steps[4].actionNotificationResult = (0, parser_1.parseActionNotification)(matchedTx5.inMessage?.body);
+                }
+                if (callbackFn)
+                    callbackFn(steps[4]);
+            }
+            const matchedTx6 = await (0, tracker_1.findTx)(this.client, toAddress(senderVaultWalletAddress), matchedTx2.lt.toString(), steps[5]);
+            steps[5].matchedTx = matchedTx6;
+            if (callbackFn)
+                callbackFn(steps[5]);
+        })();
+        return {
+            action: {
+                type: "vault-supply",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async findSupplyTx(queryId, params, callbackFn) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(vaultData.asset));
+        const senderVaultWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.vault));
+        const steps = [];
+        if (toString(vaultData.asset) == this.contracts.WTON) {
+            const vaultWTONWalletAddress = await this.getJettonWalletAddress(toString(params.vault), toString(vaultData.asset));
+            const vaultWTONWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromAddress(vaultWTONWalletAddress));
+            steps.push(...[
+                {
+                    queryId,
+                    description: "Starting the tx",
+                    from: toAddress(params.sender),
+                    to: vaultWTONWalletAddress,
+                    opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+                },
+            ]);
+        }
+        else {
+            steps.push(...[
+                {
+                    description: "Starting the tx",
+                    from: toAddress(params.sender),
+                    to: senderJettonWalletAddress,
+                    opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+                    queryId: queryId,
+                },
+            ]);
+        }
+        steps.push(...[
+            {
+                description: "Sending the token to the vault",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                description: "Aggregating pools",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: share_vault_1.ShareVault.Op.TakeAggregatedPool,
+            },
+            {
+                description: "Sending asset to the pool",
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                description: "Action notification",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                description: "Minting the vault share token",
+                from: toAddress(params.vault),
+                to: toAddress(senderVaultWalletAddress),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx1 = await (0, tracker_1.findTx)(this.client, toAddress(params.sender), "0", steps[0]);
+            steps[0].matchedTx = matchedTx1;
+            if (callbackFn)
+                callbackFn(steps[0]);
+            const matchedTx2 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx1.lt.toString(), steps[1]);
+            steps[1].matchedTx = matchedTx2;
+            if (callbackFn)
+                callbackFn(steps[1]);
+            let poolAddress;
+            if (matchedTx2.outMessages[0]?.parsedBody?.type ===
+                "ShareVault.Op.ProvideAggregatedPool") {
+                const matchedTx3 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), steps[2]);
+                steps[2].matchedTx = matchedTx3;
+                if (callbackFn)
+                    callbackFn(steps[2]);
+                if (matchedTx3.outMessages[0]?.parsedBody?.type ===
+                    "JettonWallet.Op.Transfer") {
+                    poolAddress = matchedTx3.outMessages[0]?.parsedBody.recipient;
+                }
+            }
+            else if (matchedTx2.outMessages[0]?.parsedBody?.type ===
+                "JettonWallet.Op.Transfer") {
+                poolAddress = matchedTx2.outMessages[0]?.parsedBody.recipient;
+            }
+            if (poolAddress) {
+                const matchedTx4 = await (0, tracker_1.findTx)(this.client, toAddress(poolAddress), matchedTx2.lt.toString(), steps[3]);
+                steps[3].matchedTx = matchedTx4;
+                if (callbackFn)
+                    callbackFn(steps[3]);
+                const matchedTx5 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx4.lt.toString(), steps[4]);
+                steps[4].matchedTx = matchedTx5;
+                if (matchedTx5.inMessage?.body) {
+                    steps[4].actionNotificationResult = (0, parser_1.parseActionNotification)(matchedTx5.inMessage?.body);
+                }
+                if (callbackFn)
+                    callbackFn(steps[4]);
+            }
+            const matchedTx6 = await (0, tracker_1.findTx)(this.client, toAddress(senderVaultWalletAddress), matchedTx2.lt.toString(), steps[5]);
+            steps[5].matchedTx = matchedTx6;
+            if (callbackFn)
+                callbackFn(steps[5]);
+        })();
+        return {
+            action: {
+                type: "vault-supply",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async withdraw(sender, params) {
+        const senderVaultWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.vault));
+        const senderVaultWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderVaultWalletAddress));
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const { count } = await this.estimateWithdrawLiquidityFulfillmentPoolCount(vaultData, params.amount);
+        const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.Withdraw, share_vault_1.ShareVault.Gas.baseFee, count, vaultData.minimumGasFee) + (0, ton_1.toNano)(0.1); // TODO: re-mapping withdraw gas fee
+        await senderVaultWallet.sendBurn(sender, gas, {
+            response: toAddress(params.response),
+            amount: params.amount,
+        });
+    }
+    async withdrawAndWaitTx(sender, params, callbackFn) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const asset = vaultData.asset;
+        const vaultJettonWalletAddress = await this.getJettonWalletAddress(toString(params.vault), toString(vaultData.asset));
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(vaultData.asset));
+        const senderJettonWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+        const senderVaultWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.vault));
+        const senderVaultWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderVaultWalletAddress));
+        const { count } = await this.estimateWithdrawLiquidityFulfillmentPoolCount(vaultData, params.amount);
+        const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.Withdraw, share_vault_1.ShareVault.Gas.baseFee, count, vaultData.minimumGasFee) + (0, ton_1.toNano)(0.1); // TODO: re-mapping withdraw gas fee
+        const opt = { response: toAddress(params.response), amount: params.amount };
+        // const queryId = 16131232817234889649n;
+        const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(params.sender), jetton_wallet_1.JettonWallet.getBurnMsgBody(opt));
+        await senderVaultWallet.sendBurn(sender, gas, {
+            ...opt,
+            queryId: queryId,
+        });
+        const steps = [
+            {
+                description: "Staring the tx",
+                from: toAddress(params.sender),
+                to: senderVaultWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.Burn,
+                queryId: queryId,
+            },
+            {
+                description: "Burning the vault share token",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.BurnNotification,
+            },
+            {
+                description: "Aggregating pools",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: share_vault_1.ShareVault.Op.TakeAggregatedPool,
+            },
+            {
+                description: "Withdrawing from the pool",
+                from: toAddress(params.vault),
+                queryId: queryId,
+                opcode: pool_1.Pool.Op.Withdraw,
+            },
+            {
+                description: "Action notification",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                description: "Receiving the token from the vault",
+                from: toAddress(vaultJettonWalletAddress),
+                to: toAddress(senderJettonWalletAddress),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ];
+        (async () => {
+            const matchedTx0 = await (0, tracker_1.findTx)(this.client, senderVaultWalletAddress, "0", steps[0]);
+            steps[0].matchedTx = matchedTx0;
+            if (callbackFn)
+                callbackFn(steps[0]);
+            const matchedTx1 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx0.lt.toString(), steps[1]);
+            steps[1].matchedTx = matchedTx1;
+            if (callbackFn)
+                callbackFn(steps[1]);
+            const transferMessage = matchedTx1.outMessages.find((item) => item?.parsedBody?.type === "JettonWallet.Op.Transfer");
+            const poolAggregateMessage = matchedTx1.outMessages.find((item) => item?.parsedBody?.type === "ShareVault.Op.ProvideAggregatedPool");
+            if (transferMessage && !poolAggregateMessage) {
+                const matchedTx5 = await (0, tracker_1.findTx)(this.client, toAddress(senderJettonWalletAddress), matchedTx1.lt.toString(), steps[5]);
+                steps[5].matchedTx = matchedTx5;
+                if (callbackFn)
+                    callbackFn(steps[5]);
+                return;
+            }
+            if (poolAggregateMessage) {
+                const matchedTx2 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx1.lt.toString(), steps[2]);
+                steps[2].matchedTx = matchedTx2;
+                if (callbackFn)
+                    callbackFn(steps[2]);
+                const transferMessage = matchedTx2.outMessages.find((item) => item?.parsedBody?.type === "JettonWallet.Op.Transfer");
+                const withdrawMessage = matchedTx2.outMessages.find((item) => item?.parsedBody?.type === "Pool.Op.TransferOut");
+                if (transferMessage && !withdrawMessage) {
+                    const matchedTx5 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), steps[5]);
+                    steps[5].matchedTx = matchedTx5;
+                    if (callbackFn)
+                        callbackFn(steps[5]);
+                    return;
+                }
+                const poolAddresses = matchedTx2.outMessages
+                    .filter((item) => item?.parsedBody?.type === "Pool.Op.TransferOut")
+                    .map((item) => item?.dst)
+                    .filter((item) => !!item);
+                const matchedTxs3 = [];
+                for (let poolAddress of poolAddresses) {
+                    const matchedTx = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), { ...steps[3], to: poolAddress });
+                    matchedTxs3.push(matchedTx);
+                }
+                steps[3].matchedTx = matchedTxs3;
+                if (callbackFn)
+                    callbackFn(steps[3]);
+                const matchedTxs4 = [];
+                for (let poolAddress of poolAddresses) {
+                    const matchedTx = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), { ...steps[4], from: poolAddress });
+                    matchedTxs4.push(matchedTx);
+                }
+                steps[4].matchedTx = matchedTxs4;
+                if (callbackFn)
+                    callbackFn(steps[4]);
+                const matchedTxs5 = [];
+                for (let poolAddress of poolAddresses) {
+                    const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(poolAddress), toString(vaultData.asset));
+                    const matchedTx = await (0, tracker_1.findTx)(this.client, poolJettonWalletAddress, matchedTx2.lt.toString(), { ...steps[5], from: poolJettonWalletAddress });
+                    matchedTxs5.push(matchedTx);
+                }
+                steps[5].matchedTx = matchedTxs5;
+                if (callbackFn)
+                    callbackFn(steps[5]);
+            }
+        })();
+        return {
+            action: {
+                type: "vault-withdraw",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async findWithdrawTx(queryId, params, callbackFn) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const vaultJettonWalletAddress = await this.getJettonWalletAddress(toString(params.vault), toString(vaultData.asset));
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(vaultData.asset));
+        const senderVaultWalletAddress = await this.getJettonWalletAddress(toString(params.sender), toString(params.vault));
+        // const queryId = 16131232817234889649n;
+        const steps = [
+            {
+                description: "Staring the tx",
+                from: toAddress(params.sender),
+                to: senderVaultWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.Burn,
+                queryId: queryId,
+            },
+            {
+                description: "Burning the vault share token",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.BurnNotification,
+            },
+            {
+                description: "Aggregating pools",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: share_vault_1.ShareVault.Op.TakeAggregatedPool,
+            },
+            {
+                description: "Withdrawing from the pool",
+                from: toAddress(params.vault),
+                queryId: queryId,
+                opcode: pool_1.Pool.Op.Withdraw,
+            },
+            {
+                description: "Action notification",
+                to: toAddress(params.vault),
+                queryId: queryId,
+                opcode: pool_1.Pool.Op.ActionNotification,
+            },
+            {
+                description: "Receiving the token from the vault",
+                from: toAddress(vaultJettonWalletAddress),
+                to: toAddress(senderJettonWalletAddress),
+                queryId: queryId,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ];
+        (async () => {
+            const matchedTx0 = await (0, tracker_1.findTx)(this.client, senderVaultWalletAddress, "0", steps[0]);
+            steps[0].matchedTx = matchedTx0;
+            if (callbackFn)
+                callbackFn(steps[0]);
+            const matchedTx1 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx0.lt.toString(), steps[1]);
+            steps[1].matchedTx = matchedTx1;
+            if (callbackFn)
+                callbackFn(steps[1]);
+            const transferMessage = matchedTx1.outMessages.find((item) => item?.parsedBody?.type === "JettonWallet.Op.Transfer");
+            const poolAggregateMessage = matchedTx1.outMessages.find((item) => item?.parsedBody?.type === "ShareVault.Op.ProvideAggregatedPool");
+            if (transferMessage && !poolAggregateMessage) {
+                const matchedTx5 = await (0, tracker_1.findTx)(this.client, toAddress(senderJettonWalletAddress), matchedTx1.lt.toString(), steps[5]);
+                steps[5].matchedTx = matchedTx5;
+                if (callbackFn)
+                    callbackFn(steps[5]);
+                return;
+            }
+            if (poolAggregateMessage) {
+                const matchedTx2 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx1.lt.toString(), steps[2]);
+                steps[2].matchedTx = matchedTx2;
+                if (callbackFn)
+                    callbackFn(steps[2]);
+                const transferMessage = matchedTx2.outMessages.find((item) => item?.parsedBody?.type === "JettonWallet.Op.Transfer");
+                const withdrawMessage = matchedTx2.outMessages.find((item) => item?.parsedBody?.type === "Pool.Op.TransferOut");
+                if (transferMessage && !withdrawMessage) {
+                    const matchedTx5 = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), steps[5]);
+                    steps[5].matchedTx = matchedTx5;
+                    if (callbackFn)
+                        callbackFn(steps[5]);
+                    return;
+                }
+                const poolAddresses = matchedTx2.outMessages
+                    .filter((item) => item?.parsedBody?.type === "Pool.Op.TransferOut")
+                    .map((item) => item?.dst)
+                    .filter((item) => !!item);
+                const matchedTxs3 = [];
+                for (let poolAddress of poolAddresses) {
+                    const matchedTx = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), { ...steps[3], to: poolAddress });
+                    matchedTxs3.push(matchedTx);
+                }
+                steps[3].matchedTx = matchedTxs3;
+                if (callbackFn)
+                    callbackFn(steps[3]);
+                const matchedTxs4 = [];
+                for (let poolAddress of poolAddresses) {
+                    const matchedTx = await (0, tracker_1.findTx)(this.client, toAddress(params.vault), matchedTx2.lt.toString(), { ...steps[4], from: poolAddress });
+                    matchedTxs4.push(matchedTx);
+                }
+                steps[4].matchedTx = matchedTxs4;
+                if (callbackFn)
+                    callbackFn(steps[4]);
+                const matchedTxs5 = [];
+                for (let poolAddress of poolAddresses) {
+                    const poolJettonWalletAddress = await this.getJettonWalletAddress(toString(poolAddress), toString(vaultData.asset));
+                    const matchedTx = await (0, tracker_1.findTx)(this.client, poolJettonWalletAddress, matchedTx2.lt.toString(), { ...steps[5], from: poolJettonWalletAddress });
+                    matchedTxs5.push(matchedTx);
+                }
+                steps[5].matchedTx = matchedTxs5;
+                if (callbackFn)
+                    callbackFn(steps[5]);
+            }
+        })();
+        return {
+            action: {
+                type: "vault-withdraw",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async supplyToPool(sender, params) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.supplyToPool, share_vault_1.ShareVault.Gas.baseFee, Object.keys(vaultData.whitelistedPools).length, vaultData.minimumGasFee);
+        await shareVault.sendSupplyToPool(sender, gas, {
+            pool: toAddress(params.pool),
+            amount: params.amount,
+        });
+    }
+    async withdrawFromPool(sender, params) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        console.log("shareVault", shareVault);
+        const vaultData = await shareVault.getVaultData();
+        console.log("vaultData", vaultData);
+        const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.withdrawFromPool, share_vault_1.ShareVault.Gas.baseFee, Object.keys(vaultData.whitelistedPools).length, vaultData.minimumGasFee);
+        console.log("gas", gas);
+        await shareVault.sendWithdrawFromPool(sender, gas, {
+            pool: toAddress(params.pool),
+            isShare: params.isShare,
+            amount: params.amount,
+        });
+    }
+    async withdrawFromPoolSimulate(sender, params) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        const vaultData = await shareVault.getVaultData();
+        const gas = share_vault_1.ShareVault.calculateGasFee(share_vault_1.ShareVault.Op.withdrawFromPool, share_vault_1.ShareVault.Gas.baseFee, Object.keys(vaultData.whitelistedPools).length, vaultData.minimumGasFee);
+        console.log("vaultData", vaultData);
+        console.log("gas", gas);
+        // await shareVault.sendWithdrawFromPool(sender, gas, {
+        //   pool: toAddress(params.pool),
+        //   isShare: params.isShare,
+        //   amount: params.amount,
+        // });
+    }
+    async setTargetWeight(sender, params) {
+        const shareVault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(params.vault)));
+        await shareVault.sendSetTargetWeight(sender, (0, ton_1.toNano)(0.006), {
+            pool: toAddress(params.pool),
+            targetWeight: params.targetWeight,
+        });
+    }
+    async getVaultData(vaultAddress) {
+        const vault = this.client.open(share_vault_1.ShareVault.createFromAddress(toAddress(vaultAddress)));
+        return await vault.getVaultData();
+    }
+    async getPoolCashAmounts(vaultData) {
+        const poolCashAmounts = {};
+        const poolAddresses = Object.keys(vaultData.whitelistedPools);
+        await Promise.all(poolAddresses.map(async (poolAddress) => {
+            const pool = this.getByContract(pool_1.Pool, poolAddress);
+            const poolCash = await pool.getPoolData();
+            poolCashAmounts[poolAddress] =
+                poolCash.assets[vaultData.asset.toString()].cash;
+        }));
+        return poolCashAmounts;
+    }
+    async getPoolInfoForShareVault(vaultData) {
+        const poolInfoForShareVault = {};
+        await Promise.all(Object.entries(vaultData.whitelistedPools).map(async ([poolAddress, whitelistedPool]) => {
+            const pool = this.getByContract(pool_1.Pool, poolAddress);
+            const poolData = await pool.getPoolData();
+            const poolAssetInfo = poolData.assets[vaultData.asset.toString()];
+            poolInfoForShareVault[poolAddress] = {
+                cash: poolData.assets[vaultData.asset.toString()].cash,
+                totalSupplyAmount: poolAssetInfo.totalSupplyAmount,
+                totalSupplyShare: poolAssetInfo.totalSupplyShare,
+                vaultSupplyAmount: (poolAssetInfo.totalSupplyAmount * whitelistedPool.supply) /
+                    poolAssetInfo.totalSupplyShare,
+            };
+        }));
+        return poolInfoForShareVault;
+    }
+    async estimateWithdrawLiquidityFulfillmentPoolCount(vaultData, requst_vault_shares) {
+        const poolInfoForShareVault = await this.getPoolInfoForShareVault(vaultData);
+        const totalAssetAmount = vaultData.cash +
+            Object.values(poolInfoForShareVault).reduce((acc, pool) => acc + pool.vaultSupplyAmount, 0n);
+        const sortedPools = this.getPoolTupleSortedByTargetWeight(vaultData.whitelistedPools, totalAssetAmount, vaultData.totalTargetWeight, poolInfoForShareVault);
+        let restAmount = (requst_vault_shares * totalAssetAmount) / vaultData.totalSupply;
+        let count = 0;
+        for (const pool of sortedPools) {
+            const withdrawFulfillAmount = pool.availableAmount < restAmount ? pool.availableAmount : restAmount;
+            if (withdrawFulfillAmount !== 0n) {
+                restAmount -= withdrawFulfillAmount;
+                count++;
+                if (restAmount === 0n) {
+                    break;
+                }
+            }
+        }
+        count += 1; // TODO: refine gas estimation - temporary add buffer, needs accurate calculation later
+        return { count, sortedPools };
+    }
+    getPoolTupleSortedByTargetWeight(whitelistedPools, totalAssetAmount, totalTargetWeight, poolInfoForShareVault) {
+        const DECIMALS_OF_WEIGHT = 10000n;
+        const poolTuples = [];
+        for (const [poolAddress, pool] of Object.entries(whitelistedPools)) {
+            if (pool.supply > 0n) {
+                const poolCash = poolInfoForShareVault[poolAddress].cash || 0n;
+                const supplyAmount = (poolInfoForShareVault[poolAddress].totalSupplyAmount * pool.supply) /
+                    poolInfoForShareVault[poolAddress].totalSupplyShare;
+                const availableAmount = poolCash > supplyAmount ? supplyAmount : poolCash;
+                if (pool.targetWeight === 0n) {
+                    // target weight가 0인 경우
+                    if (poolCash > 0n && pool.supply > 0n) {
+                        poolTuples.push({
+                            targetWeightRatio: -1, // 특별한 값으로 마킹
+                            poolAddress,
+                            availableAmount,
+                            pool,
+                        });
+                    }
+                }
+                else {
+                    // target weight가 있는 경우
+                    const suppliedWeight = (DECIMALS_OF_WEIGHT * pool.supply) / totalAssetAmount;
+                    const targetWeight = (DECIMALS_OF_WEIGHT * pool.targetWeight) / totalTargetWeight;
+                    const targetWeightRatio = Number((suppliedWeight * DECIMALS_OF_WEIGHT) / targetWeight) /
+                        Number(DECIMALS_OF_WEIGHT);
+                    poolTuples.push({
+                        targetWeightRatio,
+                        poolAddress,
+                        availableAmount,
+                        pool,
+                    });
+                }
+            }
+        }
+        // Sort: items with targetWeightRatio -1 come first, others in descending order
+        return poolTuples.sort((a, b) => {
+            if (a.targetWeightRatio === -1 && b.targetWeightRatio === -1)
+                return 0;
+            if (a.targetWeightRatio === -1)
+                return -1;
+            if (b.targetWeightRatio === -1)
+                return 1;
+            return b.targetWeightRatio - a.targetWeightRatio;
+        });
+    }
+    WTON = {
+        unwrap: async (sender, params) => {
+            const walletAddress = await this.getJettonWalletAddress(toString(params.sender), this.contracts.WTON);
+            const wtonWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromAddress(walletAddress));
+            await wtonWallet.sendBurn(sender, (0, ton_1.toNano)(0.05), {
+                amount: params.amount,
+                response: toAddress(params.recipient),
+            });
+        },
+        wrap: async (sender, params) => {
+            const walletAddress = await this.getJettonWalletAddress(toString(params.recipient), this.contracts.WTON);
+            const wtonWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromAddress(walletAddress));
+            const wtonWalletState = await wtonWallet.getState();
+            wtonWalletState.state.type === "active";
+            if (wtonWalletState.state.type === "active") {
+                await wtonWallet.sendMint(sender, (0, ton_1.toNano)(0.05) + params.amount);
+            }
+            else {
+                const wton = this.client.open(jetton_minter_2.WTONMinter.createFromAddress(ton_1.Address.parse(this.contracts.WTON)));
+                await wton.sendMint(sender, (0, ton_1.toNano)(0.05) + params.amount, {
+                    recipient: toAddress(params.recipient),
+                });
+            }
+        },
+    };
+}
+exports.ShareVaultV1 = ShareVaultV1;