@affluent-org/sdk 0.0.2 → 0.0.4

package/dist/periphery.js

@@ -0,0 +1,1087 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeripheryV1 = void 0;
+const ton_1 = require("@ton/ton");
+const contracts_1 = require("./constants/contracts");
+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 query_id_generactor_1 = require("./utils/tracker/query-id-generactor");
+const parser_1 = require("./utils/parser");
+const minter_1 = require("./contracts/liquid_token/dedust/minter");
+const LFStonfiJettonWallet_1 = require("./contracts/liquid_token/stonfi/LFStonfiJettonWallet");
+const wallet_1 = require("./contracts/liquid_token/dedust/wallet");
+const LFStonfiJettonMinter_1 = require("./contracts/liquid_token/stonfi/LFStonfiJettonMinter");
+const account_1 = require("./contracts/core/account");
+const client_for_parameter_1 = require("./utils/client-for-parameter");
+const Account_compiled_json_1 = __importDefault(require("./build/Account.compiled.json"));
+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;
+};
+const generateRandomQueryId = (senderAddress) => {
+    const randomCell = (0, ton_1.beginCell)()
+        .storeCoins(Date.now())
+        .storeCoins(Math.floor(Math.random() * 1000000000000))
+        .endCell();
+    const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(senderAddress), randomCell);
+    return queryId;
+};
+class PeripheryV1 {
+    client;
+    contracts;
+    // user -> asset -> wallet
+    walletAddresses = {};
+    constructor(client, network, custom_contracts) {
+        this.client = client;
+        if (network === "custom" && !custom_contracts)
+            throw "should provide custom contracts";
+        this.contracts =
+            network === "mainnet"
+                ? contracts_1.MAINNET_CONTRACTS
+                : network === "testnet"
+                    ? contracts_1.TESTNET_CONTRACTS
+                    : custom_contracts;
+    }
+    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 deployWallet(sender, tokenAddress, targetAddress, gas) {
+        const jettonMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(tokenAddress)));
+        await jettonMinter.sendDeployWallet(sender, {
+            recipient: toAddress(targetAddress),
+            value: gas || (0, ton_1.toNano)(0.1),
+        });
+    }
+    async deployWLPWalletAndWaitTx(sender, params, callbackFn) {
+        const jettonMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.tokenAddress)));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await jettonMinter.sendDeployWallet(sender, {
+            queryId,
+            recipient: toAddress(params.targetAddress),
+            value: params.gas || (0, ton_1.toNano)(0.1),
+        });
+        const wlpWalletAddress = await jettonMinter.getWalletAddress(toAddress(params.targetAddress));
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: toAddress(params.tokenAddress),
+                opcode: minter_1.LFDedustJettonMinter.Op.DeployWallet,
+            },
+            {
+                queryId,
+                description: "deploy",
+                from: toAddress(params.tokenAddress),
+                to: toAddress(wlpWalletAddress),
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(wlpWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async initializeLFWallet(sender, lfTokenAddress, targetAddress) {
+        const targetJettonWalletAddress = await this.getJettonWalletAddress(toString(targetAddress), toString(lfTokenAddress));
+        const targetLFJettonWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(targetJettonWalletAddress));
+        const a = await targetLFJettonWallet.sendInitialize(sender, (0, ton_1.toNano)(0.06));
+    }
+    async deployWLPWalletAndWaitTx2(sender, params, callbackFn) {
+        const jettonMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.tokenAddress)));
+        let poolAddress;
+        try {
+            const jettonMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.tokenAddress)));
+            poolAddress = (await jettonMinter.getWLPJettonData()).poolAddress;
+        }
+        catch (e) {
+            const jettonMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.tokenAddress)));
+            poolAddress = (await jettonMinter.getWLPJettonData()).poolAddress;
+        }
+        // console.log("poolAddress", poolAddress);
+        const pool = this.client.open(pool_1.Pool.createFromAddress(poolAddress));
+        const accountAddress = await pool.getAccountAddress(toAddress(params.targetAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        // console.log("deployed?", await this.client.isContractDeployed(accountAddress) ? "true" : "false");
+        if (!(await this.client.isContractDeployed(accountAddress))) {
+            const clientForParameter = new client_for_parameter_1.TonClientForParameter(this.client.parameters);
+            const jettonMinter = clientForParameter.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.tokenAddress)));
+            const deployWalletParams = await jettonMinter.sendDeployWallet(sender, {
+                queryId,
+                recipient: toAddress(params.targetAddress),
+                value: params.gas || (0, ton_1.toNano)(0.1),
+            });
+            const account = clientForParameter.open(account_1.Account.createFromConfig({
+                pool: poolAddress,
+                owner: toAddress(params.targetAddress),
+            }, ton_1.Cell.fromHex(Account_compiled_json_1.default.hex)));
+            const deployAccountParams = await account.sendDeploy(sender, (0, ton_1.toNano)(0.02));
+            // console.log("deployWalletParams  ", deployWalletParams)
+            // console.log("deployAccountParams ", deployAccountParams)
+            if (sender.multiSend) {
+                await sender.multiSend([deployWalletParams, deployAccountParams]);
+            }
+        }
+        else {
+            await jettonMinter.sendDeployWallet(sender, {
+                queryId,
+                recipient: toAddress(params.targetAddress),
+                value: params.gas || (0, ton_1.toNano)(0.1),
+            });
+        }
+        const wlpWalletAddress = await jettonMinter.getWalletAddress(toAddress(params.targetAddress));
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: toAddress(params.tokenAddress),
+                opcode: minter_1.LFDedustJettonMinter.Op.DeployWallet,
+            },
+            {
+                queryId,
+                description: "deploy",
+                from: toAddress(params.tokenAddress),
+                to: toAddress(wlpWalletAddress),
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(wlpWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async seize(sender, senderAddress, lfTokenAddress, targetAddress, responseAddress, amount, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(lfTokenAddress));
+        const senderLFJettonWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(senderJettonWalletAddress));
+        const result = await senderLFJettonWallet.sendSeize(sender, {
+            amount,
+            value: (0, ton_1.toNano)(0.11),
+            targetAddress: toAddress(targetAddress),
+            responseAddress: toAddress(responseAddress),
+        });
+    }
+    async wrapDedustLPAndWaitTx(sender, params, callbackFn) {
+        const dedustWLPMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await dedustWLPMinter.getWLPJettonData();
+        const underlyingAssetAddress = wlpData.assetAddress;
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(underlyingAssetAddress)));
+        const senderWLPWalletAddress = await dedustWLPMinter.getWalletAddress(toAddress(params.senderAddress));
+        const senderLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(params.senderAddress));
+        const wlpLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(senderWLPWalletAddress));
+        const senderLPWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderLPWalletAddress));
+        if (!(await this.client.isContractDeployed(senderWLPWalletAddress))) {
+            throw "not deployed lf wallet";
+        }
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderLPWallet.sendTransfer(sender, params.gas || (0, ton_1.toNano)(0.1), {
+            queryId,
+            recipient: toAddress(senderWLPWalletAddress),
+            response: toAddress(params.senderAddress),
+            amount: params.amount,
+            forwardTonAmount: (0, ton_1.toNano)(0.02),
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderLPWallet.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            },
+            {
+                queryId,
+                description: "mint",
+                from: toAddress(wlpLPWalletAddress),
+                to: senderWLPWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(senderWLPWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async wrapStonfiLPAndWaitTx(sender, params, callbackFn) {
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        // console.log("wlpData", wlpData);
+        const underlyingAssetAddress = wlpData.assetAddress;
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(underlyingAssetAddress)));
+        const senderWLPWalletAddress = await stonfiWLPMinter.getWalletAddress(toAddress(params.senderAddress));
+        const senderLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(params.senderAddress));
+        const wlpLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(senderWLPWalletAddress));
+        const senderLPWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderLPWalletAddress));
+        if (!(await this.client.isContractDeployed(senderWLPWalletAddress))) {
+            throw "not deployed lf wallet";
+        }
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderLPWallet.sendTransfer(sender, params.gas || (0, ton_1.toNano)(0.1), {
+            queryId,
+            recipient: toAddress(senderWLPWalletAddress),
+            response: toAddress(params.senderAddress),
+            amount: params.amount,
+            forwardTonAmount: (0, ton_1.toNano)(0.02),
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderLPWallet.address,
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            },
+            {
+                queryId,
+                description: "mint",
+                from: toAddress(wlpLPWalletAddress),
+                to: senderWLPWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(senderWLPWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async unwrapDedustWLPAndWaitTx(sender, params, callbackFn) {
+        const dedustWLPMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await dedustWLPMinter.getWLPJettonData();
+        const underlyingAssetAddress = wlpData.assetAddress;
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(underlyingAssetAddress)));
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+        const senderWLPWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const wlpWalletData = await senderWLPWallet.getLiquidFarmData();
+        if (wlpWalletData.balance < params.amount) {
+            throw "not enough balance";
+        }
+        if (wlpWalletData.lockedAssetBalance < params.amount) {
+            throw "not enough locked asset balance";
+        }
+        const recipientLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(params.recipientAddress));
+        const wlpLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(senderWLPWalletAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderWLPWallet.sendBurn(sender, {
+            value: params.gas || (0, ton_1.toNano)(0.2),
+            queryId,
+            amount: params.amount,
+            recipientAddress: toAddress(params.recipientAddress),
+            responseAddress: toAddress(params.responseAddress),
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWalletAddress,
+                opcode: wallet_1.LFDedustJettonWallet.Op.Burn,
+            },
+            {
+                queryId,
+                description: "send lp",
+                from: wlpLPWalletAddress,
+                to: recipientLPWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(recipientLPWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async unwrapStonfiWLPAndWaitTx(sender, params, callbackFn) {
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        const underlyingAssetAddress = wlpData.assetAddress;
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(underlyingAssetAddress)));
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const wlpWalletData = await senderWLPWallet.getLiquidFarmData();
+        if (wlpWalletData.balance < params.amount) {
+            throw "not enough balance";
+        }
+        if (wlpWalletData.lockedAssetBalance < params.amount) {
+            throw "not enough locked asset balance";
+        }
+        if (wlpWalletData.lockedAssetCash < params.amount) {
+            throw "not enough locked asset cash";
+        }
+        const recipientLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(params.recipientAddress));
+        const wlpLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(senderWLPWalletAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderWLPWallet.sendBurn(sender, {
+            value: params.gas || (0, ton_1.toNano)(0.2),
+            queryId,
+            amount: params.amount,
+            recipientAddress: toAddress(params.recipientAddress),
+            responseAddress: toAddress(params.responseAddress),
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWalletAddress,
+                opcode: wallet_1.LFDedustJettonWallet.Op.Burn,
+            },
+            {
+                queryId,
+                description: "send lp",
+                from: wlpLPWalletAddress,
+                to: recipientLPWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(recipientLPWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async seizeDedustLPAndWaitTx(sender, params, callbackFn) {
+        const dedustWLPMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await dedustWLPMinter.getWLPJettonData();
+        const underlyingAssetAddress = wlpData.assetAddress;
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+        const targetWLPWalletAddress = await this.getJettonWalletAddress(toString(params.targetAddress), toString(params.wlpTokenAddress));
+        const senderWLPWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const wlpWalletData = await senderWLPWallet.getLiquidFarmData();
+        if (wlpWalletData.balance - wlpWalletData.lockedAssetBalance <
+            params.amount) {
+            throw "not enough balance";
+        }
+        const targetWLPWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(targetWLPWalletAddress));
+        const targetWlpWalletData = await targetWLPWallet.getLiquidFarmData();
+        let balance = targetWlpWalletData.balance;
+        if (targetWlpWalletData.poolAccountAddress &&
+            targetWlpWalletData.connectedWithPoolAccount) {
+            targetWlpWalletData.poolAccountAddress;
+            const targetAccount = this.client.open(account_1.Account.createFromAddress(targetWlpWalletData.poolAccountAddress));
+            const accountData = await targetAccount.getAccountData();
+            if (accountData.status[toString(params.wlpTokenAddress)]) {
+                balance += accountData.status[toString(params.wlpTokenAddress)].supply;
+            }
+        }
+        if (targetWlpWalletData.lockedAssetBalance - balance < params.amount) {
+            throw "not enough liquidity";
+        }
+        const queryId = generateRandomQueryId(params.senderAddress);
+        const result = await senderWLPWallet.sendSeize(sender, {
+            value: (0, ton_1.toNano)(0.11),
+            queryId,
+            targetAddress: toAddress(params.targetAddress),
+            responseAddress: toAddress(params.responseAddress),
+            amount: params.amount,
+        });
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(underlyingAssetAddress));
+        const targetWlpLpWalletAddress = await underlyingAsset.getWalletAddress(targetWLPWalletAddress);
+        const senderLpWalletAddress = await underlyingAsset.getWalletAddress(toAddress(params.senderAddress));
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWallet.address,
+                opcode: wallet_1.LFDedustJettonWallet.Op.Seize,
+            },
+            {
+                queryId,
+                description: "mint",
+                from: toAddress(targetWlpLpWalletAddress),
+                to: senderLpWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(senderLpWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async seizeStonfiLPAndWaitTx(sender, params, callbackFn) {
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        const underlyingAssetAddress = wlpData.assetAddress;
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(underlyingAssetAddress));
+        const senderLpWalletAddress = await underlyingAsset.getWalletAddress(toAddress(params.senderAddress));
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+        const targetWLPWalletAddress = await this.getJettonWalletAddress(toString(params.targetAddress), toString(params.wlpTokenAddress));
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const wlpWalletData = await senderWLPWallet.getLiquidFarmData();
+        if (wlpWalletData.balance - wlpWalletData.lockedAssetBalance <
+            params.amount) {
+            throw "not enough balance";
+        }
+        const targetWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(targetWLPWalletAddress));
+        const targetWlpWalletData = await targetWLPWallet.getLiquidFarmData();
+        if (targetWlpWalletData.lockedAssetCash < params.amount) {
+            throw "not enough balance, try to unfarm & sync";
+        }
+        let balance = targetWlpWalletData.balance;
+        if (targetWlpWalletData.poolAccountAddress &&
+            targetWlpWalletData.connectedWithPoolAccount) {
+            targetWlpWalletData.poolAccountAddress;
+            const targetAccount = this.client.open(account_1.Account.createFromAddress(targetWlpWalletData.poolAccountAddress));
+            const accountData = await targetAccount.getAccountData();
+            if (accountData.status[toString(params.wlpTokenAddress)]) {
+                balance += accountData.status[toString(params.wlpTokenAddress)].supply;
+            }
+        }
+        if (targetWlpWalletData.lockedAssetBalance - balance < params.amount) {
+            throw "not enough liquidity";
+        }
+        const targetWlpLpWalletAddress = await underlyingAsset.getWalletAddress(targetWLPWalletAddress);
+        const targetWlpLpWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(targetWlpLpWalletAddress));
+        const targetWlpLpWalletData = await targetWlpLpWallet.getWalletData();
+        const queryId = generateRandomQueryId(params.senderAddress);
+        const result = await senderWLPWallet.sendSeize(sender, {
+            value: (0, ton_1.toNano)(0.11),
+            queryId,
+            targetAddress: toAddress(params.targetAddress),
+            responseAddress: toAddress(params.responseAddress),
+            amount: params.amount,
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWallet.address,
+                opcode: wallet_1.LFDedustJettonWallet.Op.Seize,
+            },
+            {
+                queryId,
+                description: "mint",
+                from: toAddress(targetWlpLpWalletAddress),
+                to: senderLpWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(senderLpWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async syncStonfiWLPAndWaitTx(sender, params, callbackFn) {
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        const queryId = generateRandomQueryId(params.senderAddress);
+        const targetWLPWalletAddress = await this.getJettonWalletAddress(toString(params.targetAddress), toString(params.wlpTokenAddress));
+        const targetWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(targetWLPWalletAddress));
+        await targetWLPWallet.sendSyncLockedAssetCash(sender, params.gas || (0, ton_1.toNano)(0.16), {
+            queryId,
+        });
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(wlpData.assetAddress)));
+        const targetWlpLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(targetWLPWalletAddress));
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: targetWLPWalletAddress,
+                opcode: LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.SyncLockedAssetCash,
+            },
+            {
+                queryId,
+                description: "sync",
+                from: toAddress(targetWlpLPWalletAddress),
+                to: targetWLPWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(targetWLPWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async isSeizableDedustLP(params) {
+        const dedustWLPMinter = this.client.open(minter_1.LFDedustJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await dedustWLPMinter.getWLPJettonData();
+        if (params.senderAddress) {
+            const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+            const senderWLPWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(senderWLPWalletAddress));
+            const wlpWalletData = await senderWLPWallet.getLiquidFarmData();
+            if (wlpWalletData.balance - wlpWalletData.lockedAssetBalance <
+                params.amount) {
+                return {
+                    seizable: false,
+                    errorType: 1,
+                    message: "not enough seizer's wlp balance",
+                };
+            }
+        }
+        const targetWLPWalletAddress = await this.getJettonWalletAddress(toString(params.targetAddress), toString(params.wlpTokenAddress));
+        const targetWLPWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(targetWLPWalletAddress));
+        const targetWlpWalletData = await targetWLPWallet.getLiquidFarmData();
+        let balance = targetWlpWalletData.balance;
+        if (targetWlpWalletData.poolAccountAddress &&
+            targetWlpWalletData.connectedWithPoolAccount) {
+            targetWlpWalletData.poolAccountAddress;
+            const targetAccount = this.client.open(account_1.Account.createFromAddress(targetWlpWalletData.poolAccountAddress));
+            const accountData = await targetAccount.getAccountData();
+            if (accountData.status[toString(params.wlpTokenAddress)]) {
+                balance += accountData.status[toString(params.wlpTokenAddress)].supply;
+            }
+        }
+        if (targetWlpWalletData.lockedAssetBalance - balance < params.amount) {
+            return {
+                seizable: false,
+                errorType: 2,
+                message: "not enough liquidity",
+                wlpBalance: balance,
+                lockedAssetBalance: targetWlpWalletData.lockedAssetBalance,
+            };
+        }
+        return {
+            seizable: true,
+            wlpBalance: balance,
+            lockedAssetBalance: targetWlpWalletData.lockedAssetBalance,
+            seizableAmount: targetWlpWalletData.lockedAssetBalance - balance,
+        };
+    }
+    async isSeizableStonfiLP(params) {
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        if (params.senderAddress) {
+            const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+            const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+            const wlpWalletData = await senderWLPWallet.getLiquidFarmData();
+            if (wlpWalletData.balance - wlpWalletData.lockedAssetBalance <
+                params.amount) {
+                return {
+                    seizable: false,
+                    errorType: 1,
+                    message: "not enough seizer's wlp balance",
+                    balance: wlpWalletData.balance - wlpWalletData.lockedAssetBalance,
+                };
+            }
+        }
+        const targetWLPWalletAddress = await this.getJettonWalletAddress(toString(params.targetAddress), toString(params.wlpTokenAddress));
+        const targetWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(targetWLPWalletAddress));
+        const targetWlpWalletData = await targetWLPWallet.getLiquidFarmData();
+        let balance = targetWlpWalletData.balance;
+        if (targetWlpWalletData.poolAccountAddress &&
+            targetWlpWalletData.connectedWithPoolAccount) {
+            targetWlpWalletData.poolAccountAddress;
+            const targetAccount = this.client.open(account_1.Account.createFromAddress(targetWlpWalletData.poolAccountAddress));
+            const accountData = await targetAccount.getAccountData();
+            if (accountData.status[toString(params.wlpTokenAddress)]) {
+                balance += accountData.status[toString(params.wlpTokenAddress)].supply;
+            }
+        }
+        if (targetWlpWalletData.lockedAssetBalance - balance < params.amount) {
+            return {
+                seizable: false,
+                errorType: 2,
+                message: "not enough liquidity",
+                wlpBalance: balance,
+                lockedAssetBalance: targetWlpWalletData.lockedAssetBalance,
+            };
+        }
+        if (targetWlpWalletData.lockedAssetCash < params.amount) {
+            const underlyingAssetAddress = wlpData.assetAddress;
+            const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(underlyingAssetAddress));
+            const targetWlpLpWalletAddress = await underlyingAsset.getWalletAddress(targetWLPWalletAddress);
+            const targetWlpLpWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(targetWlpLpWalletAddress));
+            const targetWlpLpWalletData = await targetWlpLpWallet.getWalletData();
+            const result = {
+                seizable: false,
+                errorType: 3,
+                wlpBalance: balance,
+                message: "",
+                lockedAssetBalance: targetWlpWalletData.lockedAssetBalance,
+                lockedAssetCash: targetWlpWalletData.lockedAssetCash,
+            };
+            if (targetWlpWalletData.lockedAssetBalance === targetWlpLpWalletData.balance) {
+                result.message += "not enough locked asset cash, try to sync";
+            }
+            else {
+                result.message += "not enough locked asset cash, try to unfarm";
+                result.nfts = await this.getStonfiWLPFarmedNfts({
+                    wlpTokenAddress: params.wlpTokenAddress,
+                    targetAddress: params.targetAddress,
+                });
+            }
+            return result;
+        }
+        return {
+            seizable: true,
+            wlpBalance: balance,
+            lockedAssetBalance: targetWlpWalletData.lockedAssetBalance,
+            seizableAmount: targetWlpWalletData.lockedAssetBalance - balance,
+        };
+    }
+    async farmStonfiWLPAndWaitTx(sender, params, callbackFn) {
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const farmLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        const result = await senderWLPWallet.sendFarm(sender, params.gas || (0, ton_1.toNano)(0.5), {
+            queryId,
+            amount: params.amount,
+            response: toAddress(params.responseAddress),
+            forwardTonAmount: (0, ton_1.toNano)(0.35),
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWallet.address,
+                opcode: LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.Farm,
+            },
+            {
+                queryId,
+                description: "farm notification",
+                to: wlpData.farmAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+            },
+            {
+                queryId,
+                description: "mint",
+                from: senderWLPWallet.address,
+                to: toAddress(params.senderAddress),
+                opcode: jetton_wallet_1.JettonWallet.Op.Excesses,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(wlpData.farmAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(senderWLPWallet.address, steps[2], matchedTx1.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async unfarmStonfiWLPAndWaitTx(sender, params, callbackFn) {
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        const targetWLPWalletAddress = await this.getJettonWalletAddress(toString(params.targetAddress), toString(params.wlpTokenAddress));
+        const targetWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(targetWLPWalletAddress));
+        const underlyingAsset = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(wlpData.assetAddress)));
+        const wlpLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(targetWLPWalletAddress));
+        const farmLPWalletAddress = await underlyingAsset.getWalletAddress(toAddress(wlpData.farmAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await targetWLPWallet.sendUnfarm(sender, params.gas || (0, ton_1.toNano)(0.42), {
+            queryId,
+            nftAddress: toAddress(params.nftAddress),
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: targetWLPWalletAddress,
+                opcode: LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.Unfarm,
+            },
+            {
+                queryId,
+                description: "unfarm notification",
+                from: toAddress(params.nftAddress),
+                to: wlpData.farmAddress,
+                opcode: 0xa1312496,
+            },
+            {
+                queryId,
+                description: "transfer",
+                from: farmLPWalletAddress,
+                to: wlpLPWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(wlpData.farmAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(wlpLPWalletAddress, steps[2], matchedTx1.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async getStonfiWLPFarmedNfts(params) {
+        throw Error("Not implemented");
+        // const response = await axios.get(`https://626wfskayjpoilzz7czxsfed7q0xiymi.lambda-url.ap-northeast-2.on.aws/?owner=${toString(params.targetAddress)}`);
+        // const targetWLPWalletAddress = await this.getJettonWalletAddress(
+        //   toString(params.targetAddress),
+        //   toString(params.wlpTokenAddress)
+        // );
+        // const lp = response.data.data.find((item: any) => item.lfWalletAddress === toString(targetWLPWalletAddress));
+        // if (!lp) return [];
+        // const nftStatus = await Promise.all(lp.nftItems.map((item: any) => this.getStonfiFarmingData(item)));
+        // const activeNfts = nftStatus.filter(item => item.status === 1);
+        // return activeNfts.map(item => item.address);
+    }
+    async lock(sender, senderAddress, lpTokenAddress, lfTokenAddress, amount, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(lpTokenAddress));
+        const senderJettonWallet = this.client.open(jetton_wallet_1.JettonWallet.createFromAddress(senderJettonWalletAddress));
+        const target = await this.getJettonWalletAddress(toString(senderAddress), toString(lfTokenAddress));
+        await senderJettonWallet.sendTransfer(sender, gas || (0, ton_1.toNano)(0.1), {
+            recipient: toAddress(target),
+            response: toAddress(senderAddress),
+            amount: amount,
+            forwardTonAmount: (0, ton_1.toNano)(0.02),
+        });
+    }
+    async withdrawTons(sender, senderAddress, wlpAddress) {
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(wlpAddress));
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const queryId = generateRandomQueryId(senderAddress);
+        await senderWLPWallet.sendWithdrawTons(sender, (0, ton_1.toNano)(0.1), {
+            queryId,
+        });
+    }
+    async withdrawTonAndWaitTx(sender, params, callbackFn) {
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpAddress));
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderWLPWallet.sendWithdrawTons(sender, (0, ton_1.toNano)(0.1), {
+            queryId,
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWalletAddress,
+                opcode: LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.WithdrawTons,
+            },
+            {
+                queryId,
+                description: "withdraw tons",
+                from: senderWLPWalletAddress,
+                to: toAddress(params.senderAddress),
+                opcode: jetton_wallet_1.JettonWallet.Op.Excesses,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(toAddress(params.senderAddress), steps[1], matchedTx0.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async withdrawJettons(sender, senderAddress, wlpAddress, assetAddress, amount) {
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(wlpAddress));
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const wlpAssetWalletAddress = await this.getJettonWalletAddress(toString(senderWLPWalletAddress), toString(assetAddress));
+        const queryId = generateRandomQueryId(senderAddress);
+        await senderWLPWallet.sendWithdrawJettons(sender, (0, ton_1.toNano)(0.1), {
+            queryId,
+            wallet: toAddress(wlpAssetWalletAddress),
+            amount: amount,
+        });
+    }
+    async withdrawJettonAndWaitTx(sender, params, callbackFn) {
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpAddress));
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const wlpAssetWalletAddress = await this.getJettonWalletAddress(toString(senderWLPWalletAddress), toString(params.assetAddress));
+        const senderAssetWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.assetAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderWLPWallet.sendWithdrawJettons(sender, (0, ton_1.toNano)(0.1), {
+            queryId,
+            wallet: toAddress(wlpAssetWalletAddress),
+            amount: params.amount,
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWalletAddress,
+                opcode: LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.WithdrawJettons,
+            },
+            {
+                queryId,
+                description: "transfer",
+                from: senderWLPWalletAddress,
+                to: wlpAssetWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            },
+            {
+                queryId,
+                description: "internal_transfer",
+                from: wlpAssetWalletAddress,
+                to: senderAssetWalletAddress,
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(wlpAssetWalletAddress, steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(senderAssetWalletAddress, steps[2], matchedTx1.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async getStonfiLFData(lfTokenAddress, targetAddress) {
+        const targetJettonWalletAddress = await this.getJettonWalletAddress(toString(targetAddress), toString(lfTokenAddress));
+        const targetJettonWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(targetJettonWalletAddress));
+        return targetJettonWallet.getLiquidFarmData();
+    }
+    async getDedustLFData(lfTokenAddress, targetAddress) {
+        const targetJettonWalletAddress = await this.getJettonWalletAddress(toString(targetAddress), toString(lfTokenAddress));
+        const targetJettonWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(targetJettonWalletAddress));
+        return targetJettonWallet.getLiquidFarmData();
+    }
+    async dedustUnlock(sender, senderAddress, lfTokenAddress, amount, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(lfTokenAddress));
+        const senderJettonWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(senderJettonWalletAddress));
+        await senderJettonWallet.sendBurn(sender, {
+            amount,
+            value: gas || (0, ton_1.toNano)(0.2),
+            recipientAddress: toAddress(senderAddress),
+            responseAddress: toAddress(senderAddress),
+        });
+    }
+    async stonfiUnlock(sender, senderAddress, lfTokenAddress, amount, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(lfTokenAddress));
+        const senderJettonWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderJettonWalletAddress));
+        await senderJettonWallet.sendBurn(sender, {
+            amount,
+            value: gas || (0, ton_1.toNano)(0.2),
+            recipientAddress: toAddress(senderAddress),
+            responseAddress: toAddress(senderAddress),
+        });
+    }
+    async claimDedustRewardAndWaitTx(sender, params, callbackFn) {
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+        const senderWLPWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderWLPWallet.sendClaimRewards(sender, {
+            queryId,
+            value: params.gas || (0, ton_1.toNano)(0.3),
+            distributorAddress: toAddress(params.distributorAddress),
+            proof: params.proof,
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: toAddress(senderWLPWalletAddress),
+                opcode: wallet_1.LFDedustJettonWallet.Op.ClaimRewards,
+            },
+            {
+                queryId,
+                description: "request claim to distributor",
+                from: toAddress(senderWLPWalletAddress),
+                to: toAddress(params.distributorAddress),
+                opcode: wallet_1.LFDedustJettonWallet.Op.DedustClaim,
+            },
+            {
+                queryId,
+                description: "Check claim eligibility.",
+                to: toAddress(params.distributorAddress),
+                opcode: 0x951c5d6b,
+            },
+        ]);
+        if (params.rewardAssetAddress === "NATIVE") {
+            steps.push({
+                queryId,
+                description: "withdraw",
+                from: toAddress(params.distributorAddress),
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            });
+        }
+        else {
+            const wlpRewardAssetWalletAddress = await this.getJettonWalletAddress(toString(senderWLPWalletAddress), toString(params.rewardAssetAddress));
+            steps.push({
+                queryId,
+                description: "withdraw",
+                to: toAddress(wlpRewardAssetWalletAddress),
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            });
+        }
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(toAddress(params.distributorAddress), steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(toAddress(params.distributorAddress), steps[2], matchedTx1.lt.toString(), callbackFn);
+            if (params.rewardAssetAddress === "NATIVE") {
+                const dedustVaultAddress = matchedTx2.outMessages[0]?.dst;
+                steps[3].to = dedustVaultAddress;
+                const matchedTx3 = await this.findAndCallback(toAddress(dedustVaultAddress), steps[3], matchedTx2.lt.toString(), callbackFn);
+            }
+            else {
+                const wlpRewardAssetWalletAddress = await this.getJettonWalletAddress(toString(senderWLPWalletAddress), toString(params.rewardAssetAddress));
+                const matchedTx3 = await this.findAndCallback(toAddress(wlpRewardAssetWalletAddress), steps[3], matchedTx2.lt.toString(), callbackFn);
+            }
+        })();
+        return steps;
+    }
+    async dedustClaimReward(sender, senderAddress, lfTokenAddress, distributorAddress, proof, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(lfTokenAddress));
+        const senderJettonWallet = this.client.open(wallet_1.LFDedustJettonWallet.createFromAddress(senderJettonWalletAddress));
+        await senderJettonWallet.sendClaimRewards(sender, {
+            value: gas || (0, ton_1.toNano)(0.3),
+            distributorAddress: toAddress(distributorAddress),
+            proof: proof,
+        });
+    }
+    async claimStonfiRewardAndWaitTx(sender, params, callbackFn) {
+        const senderWLPWalletAddress = await this.getJettonWalletAddress(toString(params.senderAddress), toString(params.wlpTokenAddress));
+        const stonfiWLPMinter = this.client.open(LFStonfiJettonMinter_1.LFStonfiJettonMinter.createFromAddress(toAddress(params.wlpTokenAddress)));
+        const wlpData = await stonfiWLPMinter.getWLPJettonData();
+        const senderWLPWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderWLPWalletAddress));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await senderWLPWallet.sendClaimRewards(sender, {
+            queryId,
+            value: params.gas || (0, ton_1.toNano)(0.5),
+            nftAddress: toAddress(params.nftAddress),
+            claimAll: true,
+            poolIndex: 0,
+        });
+        const steps = [];
+        steps.push(...[
+            {
+                queryId,
+                description: "tx send",
+                from: toAddress(params.senderAddress),
+                to: senderWLPWalletAddress,
+                opcode: LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.ClaimRewards,
+            },
+            {
+                queryId,
+                description: "request claim to nft",
+                from: senderWLPWalletAddress,
+                to: toAddress(params.nftAddress),
+                opcode: LFStonfiJettonWallet_1.LFStonfiJettonWallet.Op.ClaimRewards,
+            },
+            {
+                queryId,
+                description: "request claim to farm",
+                from: toAddress(params.nftAddress),
+                to: toAddress(wlpData.farmAddress),
+                opcode: 0x39656584,
+            },
+            {
+                queryId,
+                description: "claim",
+                from: toAddress(senderWLPWalletAddress),
+                to: toAddress(params.senderAddress),
+                opcode: jetton_wallet_1.JettonWallet.Op.Excesses,
+            },
+        ]);
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(toAddress(params.nftAddress), steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(wlpData.farmAddress, steps[2], matchedTx1.lt.toString(), callbackFn);
+            const matchedTx3 = await this.findAndCallback(toAddress(params.senderAddress), steps[3], matchedTx2.lt.toString(), callbackFn);
+        })();
+        return steps;
+    }
+    async stonfiClaimReward(sender, senderAddress, lfTokenAddress, nftAddress, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(lfTokenAddress));
+        const senderJettonWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderJettonWalletAddress));
+        await senderJettonWallet.sendClaimRewards(sender, {
+            value: gas || (0, ton_1.toNano)(0.2),
+            nftAddress: toAddress(nftAddress),
+            claimAll: true,
+            poolIndex: 0,
+        });
+    }
+    async stonfiFarm(sender, senderAddress, lfTokenAddress, amount, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(senderAddress), toString(lfTokenAddress));
+        const senderJettonWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderJettonWalletAddress));
+        await senderJettonWallet.sendFarm(sender, gas || (0, ton_1.toNano)(0.5), {
+            amount,
+            response: toAddress(senderAddress),
+            forwardTonAmount: (0, ton_1.toNano)(0.35),
+        });
+    }
+    async stonfiUnfarm(sender, targetAddress, lfTokenAddress, nftAddress, gas) {
+        const senderJettonWalletAddress = await this.getJettonWalletAddress(toString(targetAddress), toString(lfTokenAddress));
+        const senderJettonWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(senderJettonWalletAddress));
+        await senderJettonWallet.sendUnfarm(sender, gas || (0, ton_1.toNano)(0.4), {
+            nftAddress: toAddress(nftAddress),
+        });
+    }
+    async findAndCallback(target, step, createdLt, callbackFn) {
+        const matchedTx = await (0, tracker_1.findTx)(this.client, toAddress(target), createdLt.toString(), step);
+        step.matchedTx = matchedTx;
+        if (matchedTx.inMessage?.body) {
+            const parsed = (0, parser_1.parseActionNotification)(matchedTx.inMessage.body);
+            if (parsed) {
+                step.actionNotificationResult = parsed;
+            }
+        }
+        if (callbackFn)
+            callbackFn(step);
+        return matchedTx;
+    }
+    async stonfiSync(sender, targetAddress, lfTokenAddress, gas) {
+        const targetJettonWalletAddress = await this.getJettonWalletAddress(toString(targetAddress), toString(lfTokenAddress));
+        const targetJettonWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(targetJettonWalletAddress));
+        await targetJettonWallet.sendSyncLockedAssetCash(sender, gas || (0, ton_1.toNano)(0.16), {});
+    }
+    async connectToPoolAccount(sender, targetAddress, lfTokenAddress, gas) {
+        const targetJettonWalletAddress = await this.getJettonWalletAddress(toString(targetAddress), toString(lfTokenAddress));
+        const targetJettonWallet = this.client.open(LFStonfiJettonWallet_1.LFStonfiJettonWallet.createFromAddress(targetJettonWalletAddress));
+        await targetJettonWallet.sendConnectPoolAccount(sender, gas || (0, ton_1.toNano)(0.03));
+    }
+    async getStonfiFarmingData(nftAddress) {
+        const result = await this.client
+            .provider(toAddress(nftAddress))
+            .get("get_farming_data", []);
+        const status = result.stack.readNumber();
+        const itemIndex = result.stack.readBigNumber();
+        const stakedTokens = result.stack.readBigNumber();
+        const stakedDate = result.stack.readBigNumber();
+        const claimedPerUnitDict = result.stack.readCell();
+        const ownerAddress = result.stack.readAddress();
+        const statusMap = {
+            0: "nft::status::uninitialized",
+            1: "nft::status::active",
+            2: "nft::status::unstaked",
+            3: "nft::status::claiming",
+            4: "nft::status::unstaked_pending",
+        };
+        return {
+            address: nftAddress,
+            status,
+            statusString: statusMap[status],
+            itemIndex,
+            stakedTokens,
+            stakedDate,
+            claimedPerUnitDict,
+            ownerAddress,
+        };
+    }
+}
+exports.PeripheryV1 = PeripheryV1;