stackswap-front-api-test-02 1.0.115 → 1.0.118

package/src/stackswap/manager/groupfarm.manager.ts

@@ -0,0 +1,307 @@
+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";
+
+export enum Mode {
+    WITH_SERVER,
+    ONLY_BLOCKCHAIN
+}
+
+export class GroupFarmManager {
+    stackswap: StackswapAPI;
+
+    constructor(stackswap: StackswapAPI) {``
+        this.stackswap = stackswap;
+    }
+
+    async getAllDatas(farming_contract: string) {
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getAllDatas', [
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // console.log('getFarmingUserRewardTotal', result);
+        return result;
+    }
+
+    async getFarmingRound(bh: number, farming_contract: string) {
+        try {
+            const function_option = getReadOptions(this.stackswap, farming_contract, 'getRewardRound', [
+                uintCV(bh)
+            ]);
+            const result_raw = await callReadOnlyFunction(function_option);
+            const result = cvToValue(result_raw);
+            // console.log('farming round', result);
+            return result.value;
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    async getCurrentFarmingRound2(farming_contract: string) {
+        const bh = await this.stackswap.getCurrentBlock();
+        return await this.getFarmingRound(Number(bh), farming_contract);
+    }
+
+
+    async getFarmingRoundFirstBlock(cycle: number, farming_contract: string) {
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getFirstBlockOfRound', [
+            uintCV(cycle)
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // console.log(result);
+        return result;
+    }
+
+
+    async getFarmingStakerStatus(stakingToken: string, cur_round: number, farming_contract: string) {
+        const address = stakingToken.split('.');
+        console.log('getFarmingStakerStatus', farming_contract);
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getUserData', [
+            contractPrincipalCV(address[0], address[1]),
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        try {
+            console.log('getFarmingStakerStatus', result);
+            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);
+                    // 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 getTotalData(stakingToken: string, farming_contract: string) {
+        const address = stakingToken.split('.');
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getTotalData', [
+            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 result.value;
+            // return {amountLP: result.value.amountLP.value, weight: '3'};
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    async getRoundData(stakingToken: string, cycle: number, farming_contract: string) {
+        const address = stakingToken.split('.');
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getRoundData', [
+            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 new result.value;
+        } catch (e) {
+            return '0';
+        }
+    }
+
+    async getUserData(stakingToken: string, farming_contract: string) {
+        try {
+            const address = stakingToken.split('.');
+            const function_option = getReadOptions(this.stackswap, farming_contract, 'getUserData', [
+                contractPrincipalCV(address[0], address[1]),
+                standardPrincipalCV(this.stackswap.getSenderAddress()),
+            ]);
+            const result_raw = await callReadOnlyFunction(function_option);
+            const result = cvToValue(result_raw);
+            // console.log('get_farming_total',result.value);
+            return result.value;
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    async getUserNFTData( farming_contract: string) {
+        try {
+            const function_option = getReadOptions(this.stackswap, farming_contract, 'getUserNFTData', [
+                standardPrincipalCV(this.stackswap.getSenderAddress()),
+            ]);
+            const result_raw = await callReadOnlyFunction(function_option);
+            const result = cvToValue(result_raw);
+            // console.log('get_farming_total',result.value);
+            return result.value;
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    async getUserRoundData(stakingToken: string, cycle: number, farming_contract: string) {
+        const address = stakingToken.split('.');
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getUserRoundData', [
+            contractPrincipalCV(address[0], address[1]),
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+            uintCV(cycle),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // console.log('reward', result);
+        return result;
+    }
+
+    async getFarmingReward(stakingToken: string, round: number | bigint, farming_contract: string) {
+        const address = stakingToken.split('.');
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getFarmingReward', [
+            contractPrincipalCV(address[0], address[1]),
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+            uintCV(round),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // console.log('getFarmingUserRewardTotal', result);
+        return result;
+    }
+
+    async getNFTFarmingReward(farming_contract: string) {
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getNFTFarmingReward', [
+            standardPrincipalCV(this.stackswap.getSenderAddress()),
+        ]);
+        const result_raw = await callReadOnlyFunction(function_option);
+        const result = cvToValue(result_raw);
+        // console.log('getFarmingUserRewardTotal', result);
+        return result;
+    }
+
+    async getFarmingUserRewardList2(stakingToken: string, unclaimed_list: any, farming_contract: string) {
+        const address = stakingToken.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);
+        // console.log('getFarmingUserRewardTotal', result);
+        return result;
+    }
+
+    async getFarmBalance(token: any, farming_contract: string) {
+        // console.log("getBalance", token)
+        const pair_details_options: any = 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 stakeTokens(stakingToken: string, amountTokens: string, lockPeriod: number, callback: any, farming_contract: string) {
+        const address = stakingToken.split('.');
+        // console.log(amountTokens);
+        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)
+        ], [await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), stakingToken, amount, FungibleConditionCode.Equal)], callback);
+        await openContractCall(function_option);
+    }
+
+
+
+    async claimStakingReward(stakingToken: string, cycle: number, amount_STSW: string, amount_LP: string, rewardToken1: string, rewardToken2: string, rewardToken3: string, rewardToken4: string, rewardList: any, callback: any, farming_contract: string) {
+        const address = stakingToken.split('.');
+        const post_condition = [];
+        post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, this.stackswap.config.BASE_STSW_DATA().addr, amount_STSW, FungibleConditionCode.Equal));
+        post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, stakingToken, amount_LP, FungibleConditionCode.Equal));
+        const function_option = getWriteOptions(this.stackswap, farming_contract, 'claimStakingReward', [
+            uintCV(cycle),
+            contractPrincipalCV(address[0], address[1]),
+            parseAddressToCV(rewardToken1),
+            parseAddressToCV(rewardToken2),
+            parseAddressToCV(rewardToken3),
+            parseAddressToCV(rewardToken4),
+        ], post_condition, callback, true); //TODO post condition
+        console.log(rewardList);
+        await openContractCall(function_option);
+    }
+
+    async stakeNFTs(goldList: number[], silverList: number[], callback: any, farming_contract: string) {
+        // console.log(amountTokens);
+        const gold_list = [];
+        const silver_list = [];
+        for (const gold of goldList) {
+            gold_list.push(uintCV(gold))
+        }
+        for (const silver of silverList) {
+            silver_list.push(uintCV(silver))
+        }
+        const function_option = getWriteOptions(this.stackswap, farming_contract, 'stakeTokens', [
+                listCV(gold_list),
+                listCV(silver_list)
+            ], [], callback, true); //TODO post Condition
+        await openContractCall(function_option);
+    }
+
+
+    async claimNFTStakingReward(  rewardToken1: string, rewardToken2: string, rewardToken3: string, rewardToken4: string, rewardList: any, reclaimList: string[], callback: any, farming_contract: string) {
+        const post_condition: any = [];
+        const function_option = getWriteOptions(this.stackswap, farming_contract, 'claimNFTStakingReward', [
+            parseAddressToCV(rewardToken1),
+            parseAddressToCV(rewardToken2),
+            parseAddressToCV(rewardToken3),
+            parseAddressToCV(rewardToken4),
+        ], post_condition, callback, true); //TODO post condition
+        console.log(rewardList, reclaimList);
+        await openContractCall(function_option);
+    }
+
+
+    async getRewardBalanceFromFarming2(pool_addr: string, unclaimed_list: any, farming_contract: string) {
+        // 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, farming_contract)
+        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), farming_contract);
+                const result = await this.getFarmingUserRewardList2(pool_addr, num_list.slice(i, i + 4 < num_list.length ? i + 4 : num_list.length), farming_contract);
+                // rewardSum.value;
+                console.log('temp result', result.rewardSum.value);
+                reward_num = reward_num.plus(new BigNumber(result.rewardSum.value));
+            }
+            return num2decimal(reward_num.toString(), 6);
+        } catch (e) {
+            // console.log(e);
+            return num2decimal(reward_num.toString(), 6);
+        }
+    }
+
+
+
+}

package/src/stackswap/manager/launchpad.manager.ts

@@ -2,12 +2,12 @@ import {
   getAmountStringWithDecimal,
   getAmountWithDecimalString,
   getPostConditionFromAsset, getReadOptions,
-  getWriteOptions
+  getWriteOptions, parseAddressToCV
 } from "../util";
 import {
   callReadOnlyFunction, contractPrincipalCV,
   cvToValue,
-  FungibleConditionCode,
+  FungibleConditionCode, listCV,
   stringAsciiCV,
   stringUtf8CV,
   uintCV
@@ -77,6 +77,17 @@ export class LaunchpadManager {
     }
   }
 
+  async geTemplatetFarmList() {
+    const pair_details_options : any = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_ONE_STEP_GROUP_FARM(), 'get-group-farm-list', []);
+    try {
+      const result = cvToValue(await callReadOnlyFunction(pair_details_options)).value;
+
+      return result[this.getRandomIntNum(0, result.length-1)].value;
+    } catch (e) {
+      return('');
+    }
+  }
+
   async mintSIPContractCall(soft_token: string, liquidity_token: string, data : any, callback: any = null) {
     const token_y_addr = soft_token.split('.');
     const pair_addr = liquidity_token.split('.');
@@ -261,4 +272,36 @@ export class LaunchpadManager {
       ], post_condition, callback);
     openContractCall(options);
   }
+
+  async mintGroupContractCall(data : any, callback: any = null) {
+    // const token_y_addr = city_token.split('.');
+    // const pair_addr = liquidity_token.split('.');
+    const post_condition: any = [];
+    // post_condition.push(await getPostConditionFromAsset(this.stackswap,this.stackswap.getSenderAddress(), this.stackswap.config.BASE_STSW_DATA().addr, getAmountWithDecimalString(data.initial_amount_x, 6), FungibleConditionCode.Equal));
+    // post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), city_token, 0, FungibleConditionCode.GreaterEqual));
+    const options = getWriteOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_ONE_STEP_MINT_CITY(),
+      'create-pair-new-city-token-with-stsw',
+      [
+        parseAddressToCV(data.templateFarm),
+        stringAsciiCV( data.name),
+        stringUtf8CV( data.uri),
+        parseAddressToCV(data.project_token),
+        parseAddressToCV(data.project_lp_token),
+        uintCV(data.lp_lock_amount),
+        parseAddressToCV(data.reward_token_1_in),
+        parseAddressToCV(data.reward_token_2_in),
+        parseAddressToCV(data.reward_token_3_in),
+        parseAddressToCV(data.reward_token_4_in),
+        listCV([uintCV(data.reward1List[0]),uintCV(data.reward1List[1]),uintCV(data.reward1List[2]),uintCV(data.reward1List[3]),]),
+        listCV([uintCV(data.reward2List[0]),uintCV(data.reward2List[1]),uintCV(data.reward2List[2]),uintCV(data.reward2List[3]),]),
+        listCV([uintCV(data.reward3List[0]),uintCV(data.reward3List[1]),uintCV(data.reward3List[2]),uintCV(data.reward3List[3]),]),
+        uintCV(data.first_farming_block_in),
+        uintCV(data.reward_round_length_in),
+        uintCV(data.max_farming_rounds_in),
+        uintCV(data.nft_end_block_in),
+        uintCV(data.nft_count_limit_in),
+        uintCV(data.nft_count_takes_in),
+      ], post_condition, callback,true);
+    openContractCall(options);
+  }
 }

package/src/stackswap/manager/lbtcstaking.manager.ts

@@ -256,7 +256,7 @@ export class LBTCStakingManager {
 
     const tvl_lbtc = await this.stackswap.tokenManager.getBalanceOf(Token.getBaseTokens(this.stackswap, BaseToken.lBTC), this.stackswap.config.STACKSWAP_ADDRESS()+'.'+this.stackswap.config.CONTRACT_NAME_STACKSWAP_LBTC_STACKING());
 
-    const apr_bn = new BigNumber(1).dividedBy(new BigNumber(tvl_apr).plus(1)).multipliedBy(round_reward).multipliedBy(10**4).multipliedBy(oracle_stsw).dividedBy(oracle_lbtc);
+    const apr_bn = new BigNumber(round_reward).multipliedBy(10**4).multipliedBy(oracle_stsw).dividedBy(new BigNumber(tvl_apr).plus(1)).dividedBy(oracle_lbtc);
     const max_apr = numFormat_(apr_bn.multipliedBy(8).toString(),3);
     const min_apr = numFormat_(apr_bn.toString(),3);
     const tvl_usd = numFormat_(new BigNumber(tvl_lbtc).multipliedBy(oracle_lbtc).div(10**8).toString(),2);