stackswap-front-api-test-02 1.0.117 → 1.0.120

package/src/index.ts

@@ -17,6 +17,7 @@ import {StakingManager} from "./stackswap/manager/staking.manager";
 import {SwapManager} from "./stackswap/manager/swap.manager";
 import {AppConfig, showConnect, UserSession} from "@stacks/connect";
 import {LBTCStakingManager} from "./stackswap/manager/lbtcstaking.manager";
+import {GroupFarmManager} from "./stackswap/manager/groupfarm.manager";
 
 export interface StackswapAPI {
   config : StackswapConfig;
@@ -27,6 +28,7 @@ export interface StackswapAPI {
   tokenManager: TokenManager;
   farmManager: FarmManager;
   farm2Manager: Farm2Manager;
+  groupFarmManager: GroupFarmManager;
   governanceManager: GovernanceManager;
   launchpadManager: LaunchpadManager;
   lbtcManager: LbtcManager;
@@ -68,6 +70,7 @@ export class StackswapMainnetAPI implements StackswapAPI{
   poxlManager: PoxlManager;
   stakingManager: StakingManager;
   swapManager: SwapManager;
+  groupFarmManager: GroupFarmManager;
 
   constructor(farm_end_cycle: string = '') {
     this.config = new StackswapMainetConfig(farm_end_cycle)
@@ -90,6 +93,7 @@ export class StackswapMainnetAPI implements StackswapAPI{
     this.stakingManager = new StakingManager(this);
     this.swapManager = new SwapManager(this);
     this.lbtcStakingManager = new LBTCStakingManager(this);
+    this.groupFarmManager = new GroupFarmManager(this);
   }
 
   getSenderAddress() : string {
@@ -186,6 +190,7 @@ export class StackswapMainnetAPI implements StackswapAPI{
       return false;
     }
   }
+
 }
 
 export class StackswapDevnetAPI extends StackswapMainnetAPI {

package/src/stackswap/config.ts

@@ -12,6 +12,7 @@ export interface StackswapConfig {
   CONTRACT_NAME_STACKSWAP_SWAP: () => string;
   CONTRACT_NAME_STACKSWAP_ONE_STEP_MINT: () => string;
   CONTRACT_NAME_STACKSWAP_ONE_STEP_MINT_CITY: () => string;
+  CONTRACT_NAME_STACKSWAP_ONE_STEP_GROUP_FARM: () => string;
   CONTRACT_NAME_STACKSWAP_DAO: () => string;
   CONTRACT_NAME_STACKSWAP_GOVERNANCE: () => string;
   CONTRACT_NAME_STACKSWAP_STACKING: () => string;
@@ -45,6 +46,7 @@ export interface StackswapConfig {
   NEWYORK_DATA: () => any;
   BASE_STSW_DATA: () => any;
   BASE_vSTSW_DATA: () => any;
+  BASE_NULL_TOKEN_DATA: () => any;
   BASE_LBTC_DATA: () => any;
   STX_STSW_LP: () => string;
   STSW_LBTC_LP: () => string;
@@ -231,6 +233,9 @@ export class StackswapMainetConfig implements StackswapConfig {
   BASE_LBTC_DATA(): any {
     return JSON.parse('{"name":"Lucid Bitcoin","decimal":8,"icon":"https://app.stackswap.org/icon/lbtc.svg","addr":"SP1Z92MPDQEWZXW36VX71Q25HKF5K2EPCJ304F275.lbtc-token-v1c","symbol":"lBTC"}');
   }
+  BASE_NULL_TOKEN_DATA(): any {
+    return JSON.parse('{"name":"NULL","decimal":6,"icon":"","addr":"SP1Z92MPDQEWZXW36VX71Q25HKF5K2EPCJ304F275.null-token-v1a","symbol":"NULL"}');
+  }
   STX_STSW_LP(): string {
     return 'SP1Z92MPDQEWZXW36VX71Q25HKF5K2EPCJ304F275.liquidity-token-stx-stsw';
   }
@@ -238,6 +243,10 @@ export class StackswapMainetConfig implements StackswapConfig {
     return 'SP1Z92MPDQEWZXW36VX71Q25HKF5K2EPCJ304F275.liquidity-token-v5krqbd8nh6';
   }
 
+  CONTRACT_NAME_STACKSWAP_ONE_STEP_GROUP_FARM(): string {
+    return "stackswap-one-step-group-farm-v1a";
+  }
+
 }
 export class StackswapDevnetConfig extends StackswapMainetConfig {
 
@@ -299,6 +308,10 @@ export class StackswapDevnetConfig extends StackswapMainetConfig {
     return JSON.parse('{"name":"Lucid Bitcoin","decimal":8,"icon":"https://app.stackswap.org/icon/lbtc.svg","addr":"ST2REHHS5J3CERCRBEPMGH7921Q6PYKAADT7JP2VB.lbtc-token-v1c","symbol":"lBTC"}');
   }
 
+  BASE_NULL_TOKEN_DATA(): any {
+    return JSON.parse('{"name":"NULL","decimal":6,"icon":"","addr":"ST2REHHS5J3CERCRBEPMGH7921Q6PYKAADT7JP2VB.null-token-v1a","symbol":"NULL"}');
+  }
+
   STX_STSW_LP(): string {
     return 'ST2REHHS5J3CERCRBEPMGH7921Q6PYKAADT7JP2VB.liquidity-token-stx-stsw';
   }

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 getTemplatetFarmList() {
+    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 createGroupContractCall(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_GROUP_FARM(),
+      '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/token.manager.ts

@@ -20,6 +20,7 @@ export enum BaseToken {
   STSW,
   vSTSW,
   lBTC,
+  NULL,
 }
 
 export class Token {
@@ -63,6 +64,8 @@ export class Token {
         return Token.parseTokenFromJson(stackswap.config.BASE_vSTSW_DATA());
       case BaseToken.lBTC:
         return Token.parseTokenFromJson(stackswap.config.BASE_LBTC_DATA());
+      case BaseToken.NULL:
+        return Token.parseTokenFromJson(stackswap.config.BASE_NULL_TOKEN_DATA());
     }
   }
 }