stackswap-front-api-test-02 0.10.1 → 0.10.2

package/dist/esm/stackswap/manager/farm2.manager.js

@@ -1,625 +0,0 @@
-import { callReadOnlyFunction, contractPrincipalCV, cvToValue, FungibleConditionCode, listCV, standardPrincipalCV, uintCV } from '@stacks/transactions';
-import BigNumber from 'bignumber.js';
-import { openContractCall } from '@stacks/connect';
-import { getPostConditionFromAsset, getReadOptions, getWriteOptions, num2decimal } from "../util";
-import _ from 'lodash';
-export var Mode;
-(function (Mode) {
-    Mode[Mode["WITH_SERVER"] = 0] = "WITH_SERVER";
-    Mode[Mode["ONLY_BLOCKCHAIN"] = 1] = "ONLY_BLOCKCHAIN";
-})(Mode || (Mode = {}));
-export class Farm2Manager {
-    constructor(stackswap) {
-        this.localCache = {};
-        ``;
-        this.stackswap = stackswap;
-    }
-    async getFarmingRound2(bh, farming_contract) {
-        try {
-            const function_option = getReadOptions(this.stackswap, farming_contract, 'getRewardRound', [
-                uintCV(bh)
-            ]);
-            const result_raw = await callReadOnlyFunction(function_option);
-            const result = cvToValue(result_raw);
-            return result.value;
-        }
-        catch (e) {
-            return 0;
-        }
-    }
-    async getFarmingRoundFirstBlock2(cycle, farming_contract) {
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getFirstBlockOfRound', [
-            uintCV(cycle)
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        return result;
-    }
-    async isUserMigratable2(pool_address, farming_contract) {
-        const address = pool_address.split('.');
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'isUserMigratable', [
-            contractPrincipalCV(address[0], address[1]),
-            standardPrincipalCV(this.stackswap.getSenderAddress()),
-        ]);
-        try {
-            const result_raw = await callReadOnlyFunction(function_option);
-            const result = cvToValue(result_raw);
-            return result;
-        }
-        catch (e) {
-            return true;
-        }
-    }
-    getPoolUSDPriceFarm(farm, farm_total, oracle_data) {
-        let tvl = 0;
-        switch (farm.BASE) {
-            case 'STX':
-                if (farm.token_x.symbol === farm.BASE) {
-                    tvl = (new BigNumber(farm.pair.balance_x).multipliedBy(farm_total).dividedBy(farm.pair.share_total).dividedBy(new BigNumber(10 ** 12))).multipliedBy(2).multipliedBy(new BigNumber(oracle_data.oracle_stx)).toNumber();
-                }
-                else {
-                    tvl = (new BigNumber(farm.pair.balance_y).multipliedBy(farm_total).dividedBy(farm.pair.share_total).dividedBy(new BigNumber(10 ** 12))).multipliedBy(2).multipliedBy(new BigNumber(oracle_data.oracle_stx)).toNumber();
-                }
-                break;
-            case 'STSW':
-                if (farm.token_x.symbol === farm.BASE) {
-                    tvl = (new BigNumber(farm.pair.balance_x).multipliedBy(farm_total).dividedBy(farm.pair.share_total).dividedBy(new BigNumber(10 ** 12))).multipliedBy(2).multipliedBy(new BigNumber(oracle_data.oracle_stsw)).toNumber();
-                }
-                else {
-                    tvl = (new BigNumber(farm.pair.balance_y).multipliedBy(farm_total).dividedBy(farm.pair.share_total).dividedBy(new BigNumber(10 ** 12))).multipliedBy(2).multipliedBy(new BigNumber(oracle_data.oracle_stsw)).toNumber();
-                }
-                break;
-            case 'lBTC':
-                if (farm.token_x.symbol === farm.BASE) {
-                    tvl = (new BigNumber(farm.pair.balance_x).multipliedBy(farm_total).dividedBy(farm.pair.share_total).dividedBy(new BigNumber(10 ** 14))).multipliedBy(2).multipliedBy(new BigNumber(oracle_data.oracle_lbtc)).toNumber();
-                }
-                else {
-                    tvl = (new BigNumber(farm.pair.balance_y).multipliedBy(farm_total).dividedBy(farm.pair.share_total).dividedBy(new BigNumber(10 ** 14))).multipliedBy(2).multipliedBy(new BigNumber(oracle_data.oracle_lbtc)).toNumber();
-                }
-                break;
-            default:
-                tvl = 0;
-        }
-        return tvl;
-    }
-    async getFarmingStakerStatus2(pool_address, cur_round, farming_contract) {
-        const address = pool_address.split('.');
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getLPUserData', [
-            contractPrincipalCV(address[0], address[1]),
-            standardPrincipalCV(this.stackswap.getSenderAddress()),
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        try {
-            const pooledToken = result.value.amountLP.value;
-            const unclaimedList = [];
-            const stakedList = [];
-            for (const unclaimedElement of result.value.unclaimedList.value) {
-                if (unclaimedElement.value < cur_round) {
-                    unclaimedList.push(unclaimedElement.value);
-                }
-                stakedList.push(unclaimedElement.value);
-            }
-            return { pooledToken, unclaimedList, stakedList };
-        }
-        catch (e) {
-            return { pooledToken: 0, unclaimedList: [], stakedList: [] };
-        }
-    }
-    async getFarmingTotalStatusCycle2(cycle, farming_contract) {
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getTotalRoundDataOrDefault', [
-            uintCV(cycle),
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        try {
-            return {
-                reward: result.reward.value,
-                value: result.value.value
-            };
-        }
-        catch (e) {
-            return {
-                reward: 0,
-                value: 0
-            };
-        }
-    }
-    async getFarmingTotalPoolStatus2(pool_address, farming_contract) {
-        const address = pool_address.split('.');
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getLPTotalData', [
-            contractPrincipalCV(address[0], address[1]),
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        try {
-            return { amountLP: result.value.amountLP.value, weight: result.value.weight.value };
-        }
-        catch (e) {
-            return { amountLP: '0', weight: '1' };
-        }
-    }
-    async getFarmingTotalPoolStatusCycle2(pool_address, cycle, farming_contract) {
-        const address = pool_address.split('.');
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getLPRoundData', [
-            contractPrincipalCV(address[0], address[1]),
-            uintCV(cycle),
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        try {
-            return result.value;
-        }
-        catch (e) {
-            return {
-                value: 0,
-                weight: 0,
-                amountLP: 0,
-                price: 0
-            };
-        }
-    }
-    async getFarmingTotalValue2(pool_address, farming_contract) {
-        try {
-            const address = pool_address.split('.');
-            const function_option = getReadOptions(this.stackswap, farming_contract, 'getLPTotalData', [
-                contractPrincipalCV(address[0], address[1]),
-            ]);
-            const result_raw = await callReadOnlyFunction(function_option);
-            const result = cvToValue(result_raw);
-            return result.value;
-        }
-        catch (e) {
-            return 0;
-        }
-    }
-    async getFarmingUserRewardPerCycle2(pool_address, cycle, farming_contract) {
-        const address = pool_address.split('.');
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getFarmingReward', [
-            contractPrincipalCV(address[0], address[1]),
-            standardPrincipalCV(this.stackswap.getSenderAddress()),
-            uintCV(cycle),
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        return result;
-    }
-    async getFarmingUserRewardList2(pool_address, unclaimed_list, farming_contract) {
-        const address = pool_address.split('.');
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getFarmingRewardFromList', [
-            standardPrincipalCV(this.stackswap.getSenderAddress()),
-            contractPrincipalCV(address[0], address[1]),
-            listCV(unclaimed_list),
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        return result;
-    }
-    async getFarmingRewardInfo2(pool_address, round, farming_contract) {
-        const address = pool_address.split('.');
-        const function_option = getReadOptions(this.stackswap, farming_contract, 'getLPUserRoundData', [
-            contractPrincipalCV(address[0], address[1]),
-            standardPrincipalCV(this.stackswap.getSenderAddress()),
-            uintCV(round),
-        ]);
-        const result_raw = await callReadOnlyFunction(function_option);
-        const result = cvToValue(result_raw);
-        return result.value.returnLP.value;
-    }
-    async getLPUserRoundData(pool_address, round, farming_contract) {
-        try {
-            const address = pool_address.split('.');
-            const function_option = getReadOptions(this.stackswap, farming_contract, 'getLPUserRoundData', [
-                contractPrincipalCV(address[0], address[1]),
-                standardPrincipalCV(this.stackswap.getSenderAddress()),
-                uintCV(round),
-            ]);
-            const result_raw = await callReadOnlyFunction(function_option);
-            const result = cvToValue(result_raw);
-            return result.value;
-        }
-        catch (e) {
-            return {
-                amountLP: {
-                    value: '0'
-                },
-                returnLP: {
-                    value: '0'
-                }
-            };
-        }
-    }
-    async migrateToVersion2(pool_address, farming_contract, callback) {
-        const address = pool_address.split('.');
-        const function_option = getWriteOptions(this.stackswap, farming_contract, 'migrateFromVersion1', [
-            contractPrincipalCV(address[0], address[1]),
-        ], [], callback);
-        await openContractCall(function_option);
-    }
-    async stakeFarmingContract2(pool_address, amountTokens, lockPeriod, callback, farming_contract) {
-        const address = pool_address.split('.');
-        const amount = new BigNumber(amountTokens).multipliedBy(10 ** 6).toFixed(0).toString();
-        const function_option = getWriteOptions(this.stackswap, farming_contract, 'stakeTokens', [
-            uintCV(amount),
-            contractPrincipalCV(address[0], address[1]),
-            uintCV(lockPeriod),
-            contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), this.stackswap.config.CONTRACT_NAME_ORACLE())
-        ], [await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), pool_address, amount, FungibleConditionCode.Equal)], callback);
-        await openContractCall(function_option);
-    }
-    async getFarmBalance2(token, farming_contract) {
-        const pair_details_options = getReadOptions(this.stackswap, token.addr, 'get-balance', [contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), farming_contract)]);
-        try {
-            const result = await callReadOnlyFunction(pair_details_options);
-            return cvToValue(result).value;
-        }
-        catch (e) {
-            return 0;
-        }
-    }
-    async claimFarmingContract2(pool_address, cycle, amount_STSW, amount_LP, callback, farming_contract) {
-        const address = pool_address.split('.');
-        const post_condition = [];
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + farming_contract, this.stackswap.config.BASE_STSW_DATA().addr, amount_STSW, FungibleConditionCode.Equal));
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + farming_contract, pool_address, amount_LP, FungibleConditionCode.Equal));
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_REWARD_BALANCER(), this.stackswap.config.BASE_STSW_DATA().addr, 0, FungibleConditionCode.GreaterEqual));
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_REWARD_BALANCER(), this.stackswap.config.BASE_LBTC_DATA().addr, 0, FungibleConditionCode.GreaterEqual));
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STSW_LBTC_LP(), this.stackswap.config.BASE_STSW_DATA().addr, 0, FungibleConditionCode.GreaterEqual));
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STSW_LBTC_LP(), this.stackswap.config.BASE_LBTC_DATA().addr, 0, FungibleConditionCode.GreaterEqual));
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), this.stackswap.config.BASE_STSW_DATA().addr, amount_STSW, FungibleConditionCode.Equal));
-        let farm_type = 0;
-        switch (farming_contract) {
-            case this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_1():
-                farm_type = 1;
-                break;
-            case this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_2():
-                farm_type = 2;
-                break;
-            case this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_5():
-                farm_type = 3;
-                break;
-        }
-        const function_option = getWriteOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_REWARD_BALANCER(), 'CLAIM_FROM_FARM', [
-            uintCV(farm_type),
-            uintCV(cycle),
-            contractPrincipalCV(address[0], address[1]),
-            contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), this.stackswap.config.CONTRACT_NAME_ORACLE())
-        ], post_condition, callback);
-        await openContractCall(function_option);
-    }
-    async unstakeFarmingContract2(pool_address, cycle, amount_LP, callback, farming_contract) {
-        const address = pool_address.split('.');
-        const post_condition = [];
-        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + farming_contract, pool_address, amount_LP, FungibleConditionCode.Equal));
-        const function_option = getWriteOptions(this.stackswap, farming_contract, 'unstakeLP', [
-            uintCV(cycle),
-            contractPrincipalCV(address[0], address[1]),
-        ], post_condition, callback);
-        await openContractCall(function_option);
-    }
-    async getCurrentFarmingRound2(farming_contract) {
-        const bh = await this.stackswap.getCurrentBlocks();
-        return await this.getFarmingRound2(Number(bh.tenure_block_height), farming_contract);
-    }
-    async getRewardBalanceFromFarming2(pool_addr, unclaimed_list, farming_contract) {
-        const num_list = [];
-        for (const unclaimed of unclaimed_list) {
-            num_list.push(uintCV(unclaimed));
-        }
-        let reward_num = new BigNumber(0);
-        try {
-            for (let i = 0; i < num_list.length; i += 4) {
-                const result = await this.getFarmingUserRewardList2(pool_addr, num_list.slice(i, i + 4 < num_list.length ? i + 4 : num_list.length), farming_contract);
-                reward_num = reward_num.plus(new BigNumber(result.rewardSum.value));
-            }
-            return num2decimal(reward_num.toString(), 6);
-        }
-        catch (e) {
-            return num2decimal(reward_num.toString(), 6);
-        }
-    }
-    getFarmingAPR(tvl, stsw_price, reward, weight) {
-        if (!tvl || new BigNumber(tvl) <= new BigNumber(0)) {
-            const temp = new BigNumber(reward).dividedBy(10 ** 12).multipliedBy(5200).multipliedBy(stsw_price);
-            return temp.toFixed(3).toString();
-        }
-        else {
-            const tvl_bn = new BigNumber(tvl).multipliedBy(10 ** 12);
-            const reward_usd = new BigNumber(reward).multipliedBy(stsw_price);
-            const new_reward = reward_usd.div(tvl_bn);
-            const new_reward_apr = new_reward.multipliedBy(5200).multipliedBy(weight);
-            return new_reward_apr.toFixed(3).toString();
-        }
-    }
-    async getFarmDataFromData(data, type, callback) {
-        const oracle_stsw = (await this.stackswap.lbtcManager.getPrice('STSW'))['last-price'].value;
-        const oracle_stx = (await this.stackswap.lbtcManager.getPrice('STX'))['last-price'].value;
-        const oracle_lbtc = (await this.stackswap.lbtcManager.getPrice('lBTC'))['last-price'].value;
-        const bh = await this.stackswap.getCurrentBlocks();
-        return await this.getEachFarmData(data, bh.tenure_block_height, { oracle_stsw, oracle_lbtc, oracle_stx }, type, callback);
-    }
-    checkAndSetFarmAPR(farms, farm_length, oracle_data) {
-        if (farms.length === farm_length) {
-            const tvls = { 'group1': '0', 'group2': '0', 'group5': '0' };
-            for (const farm_temp of farms) {
-                switch (farm_temp.farm_group) {
-                    case 1:
-                        tvls.group1 = new BigNumber(tvls.group1).plus(new BigNumber(this.getPoolUSDPriceFarm(farm_temp, farm_temp.farm_total_v2, oracle_data)).multipliedBy(farm_temp.weight)).toString();
-                        break;
-                    case 2:
-                        tvls.group2 = new BigNumber(tvls.group2).plus(new BigNumber(this.getPoolUSDPriceFarm(farm_temp, farm_temp.farm_total_v2, oracle_data)).multipliedBy(farm_temp.weight)).toString();
-                        break;
-                    case 5:
-                        tvls.group5 = new BigNumber(tvls.group5).plus(new BigNumber(this.getPoolUSDPriceFarm(farm_temp, farm_temp.farm_total_v2, oracle_data)).multipliedBy(farm_temp.weight)).toString();
-                        break;
-                }
-            }
-            for (const farm_temp of farms) {
-                switch (farm_temp.farm_group) {
-                    case 1:
-                        farm_temp.APR = this.getFarmingAPR(tvls.group1, oracle_data.oracle_stsw, farm_temp.reward, farm_temp.weight);
-                        break;
-                    case 2:
-                        farm_temp.APR = this.getFarmingAPR(tvls.group2, oracle_data.oracle_stsw, farm_temp.reward, farm_temp.weight);
-                        break;
-                    case 5:
-                        farm_temp.APR = this.getFarmingAPR(tvls.group5, oracle_data.oracle_stsw, farm_temp.reward, farm_temp.weight);
-                        break;
-                }
-            }
-        }
-        return farms;
-    }
-    checkAndSetFarmAPR_Dash(farms, farm_length, oracle_data) {
-        if (farms.length === farm_length) {
-            const tvls = { 'group1': '0', 'group2': '0', 'group5': '0' };
-            for (const farm_temp of farms) {
-                switch (farm_temp.farm_group) {
-                    case 1:
-                        tvls.group1 = new BigNumber(tvls.group1).plus(new BigNumber(this.getPoolUSDPriceFarm(farm_temp, farm_temp.total_locked_lp, oracle_data)).multipliedBy(farm_temp.weight)).toString();
-                        break;
-                    case 2:
-                        tvls.group2 = new BigNumber(tvls.group2).plus(new BigNumber(this.getPoolUSDPriceFarm(farm_temp, farm_temp.total_locked_lp, oracle_data)).multipliedBy(farm_temp.weight)).toString();
-                        break;
-                    case 5:
-                        tvls.group5 = new BigNumber(tvls.group5).plus(new BigNumber(this.getPoolUSDPriceFarm(farm_temp, farm_temp.total_locked_lp, oracle_data)).multipliedBy(farm_temp.weight)).toString();
-                        break;
-                }
-                farm_temp.value_per_1LP = new BigNumber(this.getPoolUSDPriceFarm(farm_temp, 1000000, oracle_data)).multipliedBy(farm_temp.weight).toString();
-            }
-            for (const farm_temp of farms) {
-                switch (farm_temp.farm_group) {
-                    case 1:
-                        farm_temp.APR = this.getFarmingAPR(tvls.group1, oracle_data.oracle_stsw, farm_temp.reward, farm_temp.weight);
-                        farm_temp.group_value = tvls.group1;
-                        break;
-                    case 2:
-                        farm_temp.APR = this.getFarmingAPR(tvls.group2, oracle_data.oracle_stsw, farm_temp.reward, farm_temp.weight);
-                        farm_temp.group_value = tvls.group2;
-                        break;
-                    case 5:
-                        farm_temp.APR = this.getFarmingAPR(tvls.group5, oracle_data.oracle_stsw, farm_temp.reward, farm_temp.weight);
-                        farm_temp.group_value = tvls.group5;
-                        break;
-                }
-            }
-        }
-        return farms;
-    }
-    async getEachFarmData(data, bh, oracle_data, type, callback) {
-        const tvl_apr = new BigNumber(0);
-        const farms = [];
-        const farm_length = data.length;
-        for (let i = 0; i < data.length; i++) {
-            let farming_contract = '';
-            if (data[i].farm_group === 1) {
-                farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_1();
-            }
-            else if (data[i].farm_group === 2) {
-                farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_2();
-            }
-            else if (data[i].farm_group === 5) {
-                farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_5();
-            }
-            const farm_round = await this.getCurrentFarmingRound2(farming_contract);
-            this.getFarmData(data[i], farm_round, bh, tvl_apr, farming_contract, oracle_data, type).then((value) => {
-                value.farm_group = data[i].farm_group;
-                value.farm_contract = farming_contract;
-                farms.push(value);
-                this.checkAndSetFarmAPR(farms, farm_length, oracle_data);
-                callback({ farms, farm_round, oracle_data });
-            });
-        }
-    }
-    async getEachFarmDataSerial(data, bh, oracle_data, type) {
-        const tvl_apr = new BigNumber(0);
-        const farms = [];
-        const farm_length = data.length;
-        const farm_round = await this.getCurrentFarmingRound2(this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_1());
-        for (let i = 0; i < data.length; i++) {
-            let farming_contract = '';
-            if (data[i].farm_group === 1) {
-                farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_1();
-            }
-            else if (data[i].farm_group === 2) {
-                farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_2();
-            }
-            else if (data[i].farm_group === 5) {
-                farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_5();
-            }
-            const value = await this.getFarmData(data[i], farm_round, bh, tvl_apr, farming_contract, oracle_data, type);
-            value.farm_group = data[i].farm_group;
-            value.farm_contract = farming_contract;
-            farms.push(value);
-        }
-        this.checkAndSetFarmAPR(farms, farm_length, oracle_data);
-        return { farms, farm_round, oracle_data };
-    }
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    async getEachFarmDataSerialDash(data, bh, oracle_data, type, amount, delayTime = 0) {
-        const farms = [];
-        const farm_length = data.length;
-        for (let i = 0; i < amount; i++) {
-            farms.push([]);
-        }
-        const farm_round = await this.getCurrentFarmingRound2(this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_1());
-        for (let farm_round_iter = Number(farm_round); farm_round_iter < Number(farm_round) + amount; farm_round_iter++) {
-            for (let i = 0; i < data.length; i++) {
-                const farm_data = _.cloneDeep(data[i]);
-                let farming_contract = '';
-                if (farm_data.farm_group === 1) {
-                    farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_1();
-                }
-                else if (farm_data.farm_group === 2) {
-                    farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_2();
-                }
-                else if (farm_data.farm_group === 5) {
-                    farming_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING2_5();
-                }
-                const value = await this.getFarmDataMinimal(farm_data, farm_round_iter, bh, farming_contract, oracle_data, type);
-                value.farm_group = farm_data.farm_group;
-                value.farm_contract = farming_contract;
-                farms[farm_round_iter - Number(farm_round)].push(value);
-                await this.delay(delayTime);
-            }
-            this.checkAndSetFarmAPR_Dash(farms[farm_round_iter - Number(farm_round)], farm_length, oracle_data);
-        }
-        return { farms, farm_round, oracle_data };
-    }
-    async getFarmData(farm, farm_round, block_height, tvl_apr, farming_contract, oracle_data, type) {
-        farm.valid = false;
-        farm.cur_round = farm_round;
-        switch (type) {
-            case Mode.ONLY_BLOCKCHAIN:
-                farm.pair = (await this.stackswap.poolManager.getPairDataFromContract(farm.token_x, farm.token_y));
-                break;
-            case Mode.WITH_SERVER:
-                farm.pair = (await this.stackswap.swapManager.findRouterAll(farm.token_x, farm.token_y, Number(block_height))).pair;
-                break;
-        }
-        farm.pair.price = (farm.pair.balance_y / (10 ** farm.token_y.decimal)) / (farm.pair.balance_x / (10 ** farm.token_x.decimal));
-        const farm_total_v2 = await this.getFarmBalance2(farm.pair.token_lp, farming_contract);
-        const farm_total_v1 = await this.stackswap.farmManager.getFarmBalance(farm.pair.token_lp);
-        farm.TVL = this.getPoolUSDPriceFarm(farm, new BigNumber(farm_total_v1).plus(farm_total_v2).toString(), oracle_data);
-        farm.total_locked_lp = new BigNumber(farm_total_v1).plus(farm_total_v2).toString();
-        farm.farm_total_v2 = (await this.getFarmingTotalPoolStatusCycle2(farm.pair.token_lp.addr, farm_round, farming_contract)).amountLP.value;
-        const farm_temp_total_data = await this.getFarmingTotalStatusCycle2(farm_round, farming_contract);
-        farm.reward = farm_temp_total_data.reward;
-        const lpTotalData = await this.getFarmingTotalPoolStatus2(farm.pair.token_lp.addr, farming_contract);
-        farm.weight = lpTotalData.weight;
-        tvl_apr = tvl_apr.plus(new BigNumber(this.getPoolUSDPriceFarm(farm, farm.total_locked_lp, oracle_data)).multipliedBy(farm.weight));
-        farm.valid = true;
-        return farm;
-    }
-    async getFarmDataMinimal(farm, farm_round, block_height, farming_contract, oracle_data, type) {
-        farm.valid = false;
-        farm.cur_round = farm_round;
-        if (this.localCache[`${farm.token_swapr}|FarmPairData`] == null ||
-            Number(this.localCache[`${farm.token_swapr}|FarmPairData`].block_height) < Number(block_height)) {
-            switch (type) {
-                case Mode.ONLY_BLOCKCHAIN:
-                    farm.pair = (await this.stackswap.poolManager.getPairDataFromContract(farm.token_x, farm.token_y));
-                    break;
-                case Mode.WITH_SERVER:
-                    farm.pair = (await this.stackswap.swapManager.findRouterAll(farm.token_x, farm.token_y, Number(block_height))).pair;
-                    break;
-            }
-            this.localCache[`${farm.token_swapr}|FarmPairData`] = {
-                block_height: block_height,
-                data: farm.pair,
-            };
-        }
-        else {
-            farm.pair = this.localCache[`${farm.token_swapr}|FarmPairData`].data;
-        }
-        farm.pair.price = (farm.pair.balance_y / (10 ** farm.token_y.decimal)) / (farm.pair.balance_x / (10 ** farm.token_x.decimal));
-        const temp_farm_round_data = await this.getFarmingTotalPoolStatusCycle2(farm.pair.token_lp.addr, farm_round, farming_contract);
-        farm.total_locked_lp = temp_farm_round_data.amountLP.value;
-        farm.TVL = this.getPoolUSDPriceFarm(farm, farm.total_locked_lp, oracle_data);
-        if (this.localCache[`${farm.farm_group}|FarmReward`] == null ||
-            Number(this.localCache[`${farm.farm_group}|FarmReward`].block_height) < Number(block_height)) {
-            const farm_temp_total_data = await this.getFarmingTotalStatusCycle2(farm_round, farming_contract);
-            farm.reward = farm_temp_total_data.reward;
-            this.localCache[`${farm.farm_group}|FarmReward`] = {
-                block_height: block_height,
-                data: farm_temp_total_data.reward,
-            };
-        }
-        else {
-            farm.reward = this.localCache[`${farm.farm_group}|FarmReward`].data;
-        }
-        let lpTotalData = null;
-        if (this.localCache[`${farm.token_swapr}|'FarmTotalPool`] == null ||
-            Number(this.localCache[`${farm.token_swapr}|'FarmTotalPool`].block_height) < Number(block_height)) {
-            lpTotalData = await this.getFarmingTotalPoolStatus2(farm.pair.token_lp.addr, farming_contract);
-            this.localCache[`${farm.token_swapr}|'FarmTotalPool`] = {
-                block_height: block_height,
-                data: lpTotalData,
-            };
-        }
-        else {
-            lpTotalData = this.localCache[`${farm.token_swapr}|'FarmTotalPool`].data;
-        }
-        farm.weight = lpTotalData.weight;
-        farm.valid = true;
-        return farm;
-    }
-    async getFarmUserData(farm, farm_round, farming_contract, oracle_data, callback) {
-        farm.isMigratable = await this.isUserMigratable2(farm.pair.token_lp.addr, farming_contract);
-        this.getFarmingStakerStatus2(farm.pair.token_lp.addr, Number(farm_round), farming_contract).then((status_v2) => {
-            if (!farm.isMigratable) {
-                this.stackswap.farmManager.getFarmingStakerStatus(farm.pair.token_lp.addr, Number(farm_round)).then((status_v1) => {
-                    farm.claimable_list = status_v2.unclaimedList.concat(status_v1.unclaimedList);
-                    farm.pooled_stsw = new BigNumber(status_v2.pooledToken).plus(status_v1.pooledToken).toString();
-                    farm.stakedList = status_v2.stakedList;
-                    farm.user_TVL = this.getPoolUSDPriceFarm(farm, farm.pooled_stsw, oracle_data);
-                    this.getRewardBalanceFromFarming2(farm.pair.token_lp.addr, status_v2.unclaimedList, farming_contract).then(reward_v2 => {
-                        this.stackswap.farmManager.getRewardBalanceFromFarming(farm.pair.token_lp.addr, status_v1.unclaimedList).then(reward_v1 => {
-                            farm.total_reward = new BigNumber(reward_v2).plus(reward_v1).toString();
-                            callback(farm);
-                        });
-                    });
-                });
-            }
-            else {
-                farm.claimable_list = status_v2.unclaimedList;
-                farm.pooled_stsw = status_v2.pooledToken;
-                farm.stakedList = status_v2.stakedList;
-                farm.user_TVL = this.getPoolUSDPriceFarm(farm, farm.pooled_stsw, oracle_data);
-                this.getRewardBalanceFromFarming2(farm.token_swapr, status_v2.unclaimedList, farming_contract).then(reward => {
-                    farm.total_reward = reward;
-                    callback(farm);
-                });
-            }
-        });
-    }
-    async getFarmUserData2(farm, farm_round, farming_contract, oracle_data, callback) {
-        farm.isMigratable = await this.isUserMigratable2(farm.pair.token_lp.addr, farming_contract);
-        this.getFarmingStakerStatus2(farm.pair.token_lp.addr, Number(farm_round), farming_contract).then((status_v2) => {
-            this.stackswap.farmManager.getFarmingStakerStatus(farm.pair.token_lp.addr, Number(farm_round)).then((status_v1) => {
-                farm.claimable_list = status_v2.unclaimedList.concat(status_v1.unclaimedList);
-                farm.pooled_lp_v1 = status_v1.pooledToken;
-                farm.pooled_lp_v2 = status_v2.pooledToken;
-                const temp_list = [];
-                for (const item of status_v1.stakedList) {
-                    if (item < farm_round && item > this.stackswap.config.FARM_V1_END_CYCLE()) {
-                        temp_list.push(item);
-                    }
-                }
-                farm.unstaked_v1 = temp_list;
-                farm.pooled_stsw = new BigNumber(status_v2.pooledToken).plus(status_v1.pooledToken).toString();
-                farm.stakedList = status_v2.stakedList;
-                farm.user_TVL = this.getPoolUSDPriceFarm(farm, farm.pooled_stsw, oracle_data);
-                this.getRewardBalanceFromFarming2(farm.pair.token_lp.addr, status_v2.unclaimedList, farming_contract).then(reward_v2 => {
-                    this.stackswap.farmManager.getRewardBalanceFromFarming(farm.pair.token_lp.addr, status_v1.unclaimedList).then(reward_v1 => {
-                        farm.total_reward = new BigNumber(reward_v2).plus(reward_v1).toString();
-                        callback(farm);
-                    });
-                });
-            });
-        });
-    }
-}
-//# sourceMappingURL=farm2.manager.js.map