stackswap-front-api-test-02 0.10.1

package/src/stackswap/manager/farm3.manager.ts

@@ -0,0 +1,690 @@
+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, parseAddressToCV} from "../util";
+import {StackswapAPI} from "../../index";
+import _ from 'lodash';
+
+export enum Mode {
+    WITH_SERVER,
+    ONLY_BLOCKCHAIN
+}
+
+export class Farm3Manager {
+    stackswap: StackswapAPI;
+
+    constructor(stackswap: StackswapAPI) {``
+        this.stackswap = stackswap;
+    }
+
+    async getFarmingRound3(bh: number) {
+        try {
+            return Math.floor((Number(bh) - 70843) / 504);
+        } catch (e) {
+            return 0;
+        }
+    }
+
+
+    async getCurrentFarmingRound3() {
+        const bh = await this.stackswap.getCurrentBlocks();
+        return await this.getFarmingRound3(Number(bh.tenure_block_height));
+    }
+
+    async getFarmingRoundFirstBlock3(cycle: number) {
+        return 70843 + 504 * Number(cycle);
+    }
+
+    getPoolUSDPriceFarm(farm: any, farm_total: any, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }) {
+        // BigNumber.config({ DECIMAL_PLACES: 6});
+        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;
+    }
+    getStakingAmountAtRound = (round: number, lpUser : any) => {
+        if (round > Number(lpUser.StartRound)) {
+            return lpUser.StakingLockedAmt;
+        }else if (round === Number(lpUser.StartRound)) {
+            return lpUser.StartRoundAmt;
+        }else if (round < Number(lpUser.StartRound)) {
+            return 0;
+        }
+    };
+    async getLPUser(pool_address: string) {
+        const address = pool_address.split('.');
+        // // console.log('getFarmingStakerStatus', farming_contract);
+        const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 'getLPUserOrDefault', [
+            contractPrincipalCV(address[0], address[1]),
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        try {
+            /*
+                ViewAmt: uint,
+                StakingLockedAmt: uint,
+                StartRound: uint,
+                StartRoundAmt: uint,
+                WithdrawEndRound: uint,
+                WithdrawAmt: uint,
+             */
+
+            return {
+                ViewAmt: result.ViewAmt.value,
+                StakingLockedAmt: result.StakingLockedAmt.value,
+                StartRound: result.StartRound.value,
+                StartRoundAmt: result.StartRoundAmt.value};
+        } catch (e) {
+            console.log(e);
+            return {
+                ViewAmt: '0',
+                StakingLockedAmt: '0',
+                StartRound: '0',
+                StartRoundAmt: '0'};
+        }
+    }
+
+    async getFarmingStakerStatus3(pool_address: string, cur_round: number) {
+        const address = pool_address.split('.');
+        // // console.log('getFarmingStakerStatus', farming_contract);
+        const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 'getLPUserOrDefault', [
+            contractPrincipalCV(address[0], address[1]),
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        try {
+            /*
+                ViewAmt: uint,
+                StakingLockedAmt: uint,
+                StartRound: uint,
+                StartRoundAmt: uint,
+                WithdrawEndRound: uint,
+                WithdrawAmt: uint,
+             */
+            // console.log('getFarmingStakerStatus', result);
+            const startRound = Number(result.StartRound.value);
+            const pooledToken = result.ViewAmt.value;
+            // console.log('farmv3 user rounds', startRound, cur_round);
+            const unclaimedList = [];
+            for (let i = startRound; i < cur_round; i++) {
+                unclaimedList.push(i);
+            }
+            //startRound < cur_round ? Array.from(new Array(cur_round - startRound), (i) => i + startRound) : [];
+            const stakedList = unclaimedList;
+            // for (const unclaimedElement of result.value.unclaimedList.value) {
+            //     if (unclaimedElement.value < cur_round) {
+            //         unclaimedList.push(unclaimedElement.value);
+            //         // // console.log('TTT', unclaimedElement.value)
+            //     }
+            //     stakedList.push(unclaimedElement.value);
+            // }
+            // console.log({pooledToken, unclaimedList, stakedList});
+            return {pooledToken, unclaimedList, stakedList};
+        } catch (e) {
+            console.log(e);
+            return {pooledToken: 0, unclaimedList: [], stakedList: []}
+        }
+    }
+
+    async getFarmingTotalStatusCycle3(cycle: number, group: string| number) {
+        // // console.log(cycle);
+        const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 'getGroupHistoryOrDefault', [
+            uintCV(cycle),
+            uintCV(group),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // // console.log('FARMING TOTAL', result);
+        try {
+            return {
+                reward: result.GroupRewardAmt.value,
+                value: result.GroupWeightedTVL.value
+            }
+            // return new BigNumber(result.value.amountUstx.value).multipliedBy(2).toFixed(0).toString();
+        } catch (e) {
+            return {
+                reward: 0,
+                value: 0
+            }
+        }
+    }
+
+    async getFarmingTotalPoolStatus3(pool_address: string) {
+        const address = pool_address.split('.');
+        const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 'getLPOrDefault', [
+            contractPrincipalCV(address[0], address[1]),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // // console.log('lp total data', result);
+        try {
+            return {amountLP: '0', weight: result.CurWeight.value};
+        } catch (e) {
+            return {amountLP: '0', weight: '1'};
+        }
+    }
+
+    async getFarmingTotalPoolStatusCycle3(pool_address: string, cycle: number) {
+        const address = pool_address.split('.');
+        const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 'getLPHistoryOrDefault', [
+            contractPrincipalCV(address[0], address[1]),
+            uintCV(cycle),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // // console.log('lp round data', result);
+        try {
+            return {
+                value: result.WeightedTVL.value,
+                weight: result.Weight.value,
+                amountLP: result.LockedAmt.value,
+                price: result.Price.value
+            };
+        } catch (e) {
+            return {
+                value: 0,
+                weight: 0,
+                amountLP: 0,
+                price: 0
+            };
+        }
+    }
+
+    async getFarmingTotalValue3(group: string) {
+        try {
+            // const address = pool_address.split('.');
+            const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 'getGroupOrDefault', [
+                // contractPrincipalCV(address[0], address[1]),
+                uintCV(group)
+            ]);
+            const result_raw = await callReadOnlyFunction(function_option);
+            const result = cvToValue(result_raw);
+            // // console.log('get_farming_total',result.value);
+            return result.CurRewardAmt.value;
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    async getFarmingUserRewardPerCycle3(pool_address: string, cycle: number) {
+        const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3(), 'getUserStakingRewardAtRound', [
+            parseAddressToCV(pool_address),
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+            uintCV(cycle),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // console.log('reward', result, pool_address, this.stackswap.getSenderAddress(), cycle);
+        return result;
+    }
+
+    async getFarmingUserRewardList3(pool_address: string, unclaimed_list: any) {
+        const address = pool_address.split('.');
+        const function_option = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3(), 'getFarmingRewardFromList', [
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+            contractPrincipalCV(address[0], address[1]),
+            listCV(unclaimed_list),
+        ]);
+        console.log('fkk', {
+            addr: this.stackswap.getSenderAddress(),
+            pool_address,
+            unclaimed_list,
+        })
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        console.log('getFarmingUserRewardTotal', result);
+        return result;
+    }
+
+    async getFarmBalance3(token: any) {
+        // // console.log("getBalance", token)
+        const pair_details_options: any = getReadOptions(this.stackswap, token.addr, 'get-balance',
+          [contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3())]);
+        try {
+            const result = await callReadOnlyFunction(pair_details_options);
+            return cvToValue(result).value;
+        } catch (e) {
+            return 0;
+        }
+    }
+
+
+    async stakeFarmingContract3(pool_address: string, amountTokens: string, amountRewards: string, callback: any) {
+        const address = pool_address.split('.');
+        const post_condition = [];
+        const amount = new BigNumber(amountTokens).multipliedBy(10 ** 6).toFixed(0).toString();
+        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), pool_address, amount, FungibleConditionCode.Equal));
+        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), this.stackswap.config.BASE_STSW_DATA().addr, new BigNumber(amountRewards).multipliedBy(10**6).toFixed(0), FungibleConditionCode.Equal));
+
+        // // console.log(amountTokens);
+        const function_option = getWriteOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3(), 'stake', [
+            contractPrincipalCV(address[0], address[1]),
+            uintCV(amount),
+            contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), this.stackswap.config.CONTRACT_NAME_ORACLE())
+        ], post_condition, callback);
+        await openContractCall(function_option);
+    }
+
+
+    async claimFarmingContract3(pool_address: string, amount_STSW: string, callback: any, mode: boolean = false) {
+        const address = pool_address.split('.');
+        if(mode){
+            const post_condition = [];
+            post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), this.stackswap.config.BASE_STSW_DATA().addr, amount_STSW, FungibleConditionCode.Equal));
+            // post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 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));
+            const function_option = getWriteOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_REWARD_BALANCER(), 'CLAIM_FROM_FARM', [
+                contractPrincipalCV(address[0], address[1]),
+                contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), this.stackswap.config.CONTRACT_NAME_ORACLE())
+            ], post_condition, callback);
+            await openContractCall(function_option);
+        }else {
+            const post_condition = [];
+            post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), this.stackswap.config.BASE_STSW_DATA().addr, new BigNumber(amount_STSW).multipliedBy(10**6).toFixed(0), FungibleConditionCode.Equal));
+            const function_option = getWriteOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3(), 'claimReward', [
+                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 claimFarmingRewardRound(pool_address: string, amount_STSW: string, amount_LP: string, round: number|string, callback: any) {
+    //     const address = pool_address.split('.');
+    //     const post_condition = [];
+    //     post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), this.stackswap.config.BASE_STSW_DATA().addr, amount_STSW, FungibleConditionCode.Equal));
+    //     post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), 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));
+    //     const function_option = getWriteOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_REWARD_BALANCER(), 'CLAIM_FROM_FARM', [
+    //         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 unstakeFarmingContract3(pool_address: string, amount_LP: string, amountRewards: string, callback: any) {
+        const address = pool_address.split('.');
+        const post_condition = [];
+        const newAmount = new BigNumber(amount_LP).multipliedBy(10**6).toFixed();
+        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), pool_address, newAmount, FungibleConditionCode.Equal));
+        post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS() + '.' + this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_DATA_3(), this.stackswap.config.BASE_STSW_DATA().addr, new BigNumber(amountRewards).multipliedBy(10**6).toFixed(0), FungibleConditionCode.Equal));
+        const function_option = getWriteOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3(), 'withdrawDirect', [
+            contractPrincipalCV(address[0], address[1]),
+            uintCV(newAmount),
+            contractPrincipalCV(this.stackswap.config.STACKSWAP_ADDRESS(), this.stackswap.config.CONTRACT_NAME_ORACLE())
+        ], post_condition, callback);
+        await openContractCall(function_option);
+    }
+
+
+    async getRewardBalanceFromFarming3(pool_addr: string, unclaimed_list: any) {
+        // let reward_balance = new BigNumber(0);
+        const num_list = [];
+        for (const unclaimed of unclaimed_list) {
+            num_list.push(uintCV(unclaimed));
+        }
+        let reward_num = new BigNumber(0);
+        // console.log(pool_addr, num_list)
+        try {
+            for (let i = 0; i < num_list.length; i += 4) {
+                // console.log(pool_addr, num_list.slice(i, i + 4 < num_list.length ? i + 4 : num_list.length));
+                const result = await this.getFarmingUserRewardList3(pool_addr, num_list.slice(i, i + 4 < num_list.length ? i + 4 : num_list.length));
+                // rewardSum.value;
+                // console.log('temp result', result);
+                reward_num = reward_num.plus(new BigNumber(result.value.rewardSum.value));
+            }
+            return num2decimal(reward_num.toString(), 6);
+        } catch (e) {
+            console.log(e);
+            return num2decimal(reward_num.toString(), 6);
+        }
+    }
+
+
+    getFarmingAPR(tvl: string, stsw_price: string, reward: string, weight: string) {
+        // // console.log('farmingAPR');
+        // // console.log({tvl, stsw_price, reward, weight})
+        if (!tvl || new BigNumber(tvl) <= new BigNumber(0)) {
+            const temp = new BigNumber(reward).dividedBy(10 ** 12).multipliedBy(10400).multipliedBy(stsw_price);
+            // // console.log('reward_to_stx', temp.toFixed(3).toString());
+            // // console.log(typeof temp);
+            return temp.toFixed(3).toString();
+        } else {
+            // BigNumber.config({DECIMAL_PLACES: 10});
+            const tvl_bn = new BigNumber(tvl).multipliedBy(10 ** 12);
+            // // console.log({tvl_bn: tvl_bn.toString()});
+            const reward_usd = new BigNumber(reward).multipliedBy(stsw_price);
+            // // console.log({reward_stx: reward_usd.toString()});
+            const new_reward = reward_usd.div(tvl_bn);
+            // // console.log({new_reward: new_reward.toString()});
+            const new_reward_apr = new_reward.multipliedBy(10400).multipliedBy(weight);
+            // // console.log({new_reward_apr: new_reward_apr.toString()});
+            return new_reward_apr.toFixed(3).toString();
+        }
+    }
+
+    async getFarmDataFromData(data: any, type: Mode, callback: any) {
+        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 : any, farm_length: number, oracle_data: any){
+        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_v3, 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_v3, 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_v3, oracle_data)).multipliedBy(farm_temp.weight)).toString();
+                        break;
+                }
+            }
+            // // console.log({tvls})
+            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;
+                }
+                // // console.log(farm_temp.APR)
+            }
+        }
+        return farms;
+    }
+
+
+    checkAndSetFarmAPR_Dash(farms : any, farm_length: number, oracle_data: any){
+        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();
+            }
+            // // console.log({tvls})
+            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;
+                }
+                // // console.log(farm_temp.APR)
+            }
+        }
+        return farms;
+    }
+
+    async getEachFarmData(data: any, bh: string, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }, type: Mode, callback: any) {
+
+        const tvl_apr = new BigNumber(0);
+        const farms : any[] = [];
+        const farm_length: number = data.length;
+
+        for (let i = 0; i < data.length; i++) {
+
+            const farm_round = await this.getCurrentFarmingRound3();
+            this.getFarmData(data[i], farm_round, bh, tvl_apr, oracle_data, type).then((value) => {
+                value.farm_group = data[i].farm_group;
+                value.farm_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3();
+                farms.push(value);
+                this.checkAndSetFarmAPR(farms, farm_length, oracle_data);
+
+                // // console.log("let's callback");
+                callback({farms, farm_round, oracle_data});
+            })
+        }
+    }
+    async getEachFarmDataSerial(data: any, bh: string, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }, type: Mode) {
+
+        const tvl_apr = new BigNumber(0);
+        const farms : any[] = [];
+        const farm_length: number = data.length;
+        const farm_round = await this.getCurrentFarmingRound3();
+
+        for (let i = 0; i < data.length; i++) {
+
+            const value = await this.getFarmData(data[i], farm_round, bh, tvl_apr, oracle_data, type);
+            value.farm_group = data[i].farm_group;
+            value.farm_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3();
+            farms.push(value);
+        }
+        this.checkAndSetFarmAPR(farms,farm_length, oracle_data);
+        return {farms, farm_round, oracle_data};
+    }
+
+    delay(ms: number) {
+        return new Promise( resolve => setTimeout(resolve, ms) );
+    }
+
+
+    async getEachFarmDataSerialDash(data: any, bh: string, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }, type: Mode, amount: number, delayTime:number = 0) {
+
+        const farms : any[][] = [];
+        const farm_length: number = data.length;
+        for (let i = 0; i < amount; i++) {
+            farms.push([]);
+        }
+        let farm_round = await this.getCurrentFarmingRound3();
+        if(farm_round < 65) farm_round = 65;
+        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]);
+                const value = await this.getFarmDataMinimal(farm_data, farm_round_iter, bh, oracle_data, type, farm_round);
+                value.farm_group = farm_data.farm_group;
+                value.farm_contract = this.stackswap.config.CONTRACT_NAME_STACKSWAP_FARMING_LOGIC_3();
+
+                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);
+        }
+        // this.checkAndSetFarmAPR(farms,farm_length, oracle_data);
+        return {farms, farm_round, oracle_data};
+    }
+
+    async getFarmData(farm: any, farm_round: any, block_height: string, tvl_apr: BigNumber, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }, type : Mode ) {
+        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.sharetoken = {balance: 0, addr: farm.pair.token_lp.addr};
+        farm.pair.price = (farm.pair.balance_y / (10 ** farm.token_y.decimal)) / (farm.pair.balance_x / (10 ** farm.token_x.decimal));
+        const farm_total_v3 = await this.getFarmBalance3(farm.pair.token_lp);
+
+        farm.TVL = this.getPoolUSDPriceFarm(farm, new BigNumber(farm_total_v3).toString(), oracle_data);
+        farm.total_locked_lp = new BigNumber(farm_total_v3).toString();
+        farm.farm_total_v3 =  (await this.getFarmingTotalPoolStatusCycle3(farm.pair.token_lp.addr, farm_round)).amountLP;
+        const farm_temp_total_data = await this.getFarmingTotalValue3(farm.farm_group);
+        farm.reward = farm_temp_total_data;
+        const lpTotalData = await this.getFarmingTotalPoolStatus3(farm.pair.token_lp.addr);
+        farm.weight = lpTotalData.weight;
+        tvl_apr = tvl_apr.plus(new BigNumber(this.getPoolUSDPriceFarm(farm, farm.total_locked_lp, oracle_data)).multipliedBy(farm.weight));
+        // // console.log(farming_contract, farm.TVL, tvl_apr);
+        farm.valid = true;
+
+        return farm;
+    }
+
+
+    localCache:{[name: string]: {block_height: string, data: any} } = {};
+
+    async getFarmDataMinimal(farm: any, farm_round: any, block_height: string, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }, type : Mode , current_round: number|string|null = null) {
+        farm.valid = false;
+        farm.cur_round = farm_round;
+        if (current_round && Number(current_round) + 1 < Number(farm_round)) farm_round = Number(current_round)+1;
+        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.sharetoken = {balance: 0, addr: farm.pair.token_lp.addr};
+        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.getFarmBalance3(farm.pair.token_lp, farming_contract);
+        // const farm_total_v1 = await this.stackswap.farmManager.getFarmBalance(farm.pair.token_lp);
+        const temp_farm_round_data= await this.getFarmingTotalPoolStatusCycle3(farm.pair.token_lp.addr, farm_round);
+        // // console.log(temp_farm_round_data);
+        farm.total_locked_lp = temp_farm_round_data.amountLP;
+        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.getFarmingTotalValue3(farm.farm_group);
+            farm.reward = farm_temp_total_data;
+            this.localCache[`${farm.farm_group}|FarmReward`] = {
+                block_height : block_height,
+                data : farm_temp_total_data,
+            }
+        }else {
+            farm.reward = this.localCache[`${farm.farm_group}|FarmReward`].data;
+        }
+
+        let lpTotalData : any  = null;
+        if(this.localCache[`${farm.token_swapr}|'FarmTotalPool`]  == null ||
+          Number(this.localCache[`${farm.token_swapr}|'FarmTotalPool`].block_height) < Number(block_height)  ){
+
+            lpTotalData = await this.getFarmingTotalPoolStatus3(farm.pair.token_lp.addr);
+            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; //TODO if weight chanages, use temp_farm_round_Data.weight
+        // tvl_apr = tvl_apr.plus(new BigNumber(this.getPoolUSDPriceFarm(farm, farm.total_locked_lp, oracle_data)).multipliedBy(farm.weight));
+        // // console.log(farming_contract, farm.TVL, tvl_apr);
+        farm.valid = true;
+
+        return farm;
+    }
+
+    async getFarmUserData3(farm: any, farm_round: string, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }, callback: any) {
+        const status_v3 = await this.getFarmingStakerStatus3(farm.pair.token_lp.addr, Number(farm_round));
+        farm.claimable_list = status_v3.unclaimedList;
+        farm.pooled_lp_v3 = status_v3.pooledToken;
+        farm.pooled_stsw = new BigNumber(status_v3.pooledToken).toString();
+        farm.stakedList = status_v3.stakedList;
+        farm.user_TVL = this.getPoolUSDPriceFarm(farm, farm.pooled_stsw, oracle_data);
+        const reward_v2 = await this.getRewardBalanceFromFarming3(farm.pair.token_lp.addr, status_v3.unclaimedList)
+        farm.total_reward = new BigNumber(reward_v2).toString();
+        callback(farm);
+    }
+    async getFarmUserData3_seperate(farm: any, farm_round: string, oracle_data: { oracle_stx: any, oracle_stsw: any, oracle_lbtc: any }, callback: any) {
+        const status_v3 = await this.getFarmingStakerStatus3(farm.pair.token_lp.addr, Number(farm_round));
+        // console.log(status_v3);
+        const pooled_lp_v3 = status_v3.pooledToken;
+        const pooled_lp = new BigNumber(status_v3.pooledToken).toString();
+        const claimable_list= Number(pooled_lp_v3) == 0? [] : status_v3.unclaimedList;
+        const stakedList= Number(pooled_lp_v3) == 0? [] : status_v3.stakedList;
+        const user_TVL = this.getPoolUSDPriceFarm(farm, pooled_lp, oracle_data);
+        const reward_v2 = await this.getRewardBalanceFromFarming3(farm.pair.token_lp.addr, claimable_list)
+        const total_reward = new BigNumber(reward_v2).toString();
+       const userdata = {
+           claimable_list: claimable_list,
+           pooled_lp_v3: pooled_lp_v3,
+           pooled_lp: pooled_lp,
+           stakedList: stakedList,
+           user_TVL: user_TVL,
+           total_reward: total_reward,
+       }
+       // console.log(userdata);
+       if(callback) callback(userdata);
+       return userdata;
+    }
+}