stackswap-front-api-test-02 0.10.1

package/src/stackswap/manager/governance.manager.ts

@@ -0,0 +1,112 @@
+import {
+  callReadOnlyFunction,
+  cvToValue,
+  FungibleConditionCode, listCV,
+  standardPrincipalCV,
+  uintCV
+} from "@stacks/transactions";
+import {openContractCall} from "@stacks/connect";
+import BigNumber from "bignumber.js";
+import {getPostConditionFromAsset, getReadOptions, getWriteOptions} from "../util";
+import {StackswapAPI} from "../../index";
+
+export class GovernanceManager {
+  stackswap: StackswapAPI;
+
+  constructor(stackswap: StackswapAPI) {
+    this.stackswap = stackswap;
+  }
+
+
+  async getProposalsList(){
+    let res_list:any = [];
+
+    for (const governance of this.stackswap.config.CONTRACT_NAME_STACKSWAP_GOVERNANCE_LIST()) {
+      let args = [];
+      if (governance.version == 2){
+        const arg2 = []
+        for(let i = 0; i < 30; i ++){
+          arg2.push(uintCV(i))
+        }
+        args.push(listCV(arg2))
+      }
+      const function_option : any = getReadOptions(this.stackswap, governance.name,'get-proposals',args);
+      const result_raw = await callReadOnlyFunction(function_option);
+
+      const result = cvToValue(result_raw);
+
+      // tslint:disable-next-line:prefer-const
+      result.value.forEach((element:any) =>{
+        if(Number(element.value['end-block-height']) != 0)
+          element.value['contract-name'] = governance.name
+          res_list.push(element.value);
+      });
+    }
+
+    return res_list;
+  }
+
+  async getNumVoting(proposal_id:number, governance_name: string = this.stackswap.config.CONTRACT_NAME_STACKSWAP_GOVERNANCE()) {
+    const function_option : any = getReadOptions(
+      this.stackswap,
+      governance_name,
+      'get-votes-by-member-by-id',
+      [
+        uintCV(proposal_id),
+        standardPrincipalCV(this.stackswap.getSenderAddress())
+      ]);
+    const result_raw = await callReadOnlyFunction(function_option);
+    const result = cvToValue(result_raw);
+    // // // console.log("TTT", cvToValue(result_raw))
+    return [result['vote-count'].value, result.returned.value];
+  }
+
+
+  async txWithdrawVoting(proposal_id:number, _amount: string, callback: any = null, governance_name: string = this.stackswap.config.CONTRACT_NAME_STACKSWAP_GOVERNANCE()) {
+    const post_condition = [];
+    post_condition.push(await getPostConditionFromAsset(this.stackswap, this.stackswap.config.STACKSWAP_ADDRESS()+'.'+this.stackswap.config.CONTRACT_NAME_STACKSWAP_GOVERNANCE(), this.stackswap.config.BASE_vSTSW_DATA().addr, _amount, FungibleConditionCode.Equal));
+
+    const function_option : any = getWriteOptions(
+      this.stackswap,
+      governance_name,
+      'return-votes-to-member',
+      [
+        uintCV(proposal_id),
+        standardPrincipalCV(this.stackswap.getSenderAddress())
+      ], post_condition, callback);
+    await openContractCall(function_option);
+    // // console.log("TTT", cvToValue(result_raw))
+  }
+
+
+  async txVote(proposal_id:number, vote_mode:string, vote_amount:any, callback: any = null, governance_name: string = this.stackswap.config.CONTRACT_NAME_STACKSWAP_GOVERNANCE()){
+    // // console.log("TT", typeof(vote_mode), vote_mode)
+    // // console.log("TT", typeof(vote_amount), vote_amount)
+    // // console.log("TT", typeof(BASE_vSTSW_DATA().decimal), BASE_vSTSW_DATA().decimal)
+
+    const vote_amount_bn = new BigNumber(10 ** 6).multipliedBy(parseFloat(vote_amount)).toFixed(0).toString();
+    // // console.log("TT", typeof(vote_amount_bn), vote_amount_bn)
+
+    const post_condition = [await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), this.stackswap.config.BASE_vSTSW_DATA().addr, vote_amount_bn, FungibleConditionCode.Equal)];
+
+    let function_option = null;
+    if(vote_mode==='For'){
+      function_option =  getWriteOptions(
+        this.stackswap,
+        governance_name,
+        'vote-for',[
+          uintCV(proposal_id), uintCV(vote_amount_bn)],
+        post_condition, callback);
+    }else if (vote_mode === 'Against'){
+      function_option =  getWriteOptions(
+        this.stackswap,
+        governance_name,
+        'vote-against',[
+          uintCV(proposal_id), uintCV(vote_amount_bn)],
+        post_condition, callback);
+    }
+    if(function_option !=null){
+      await openContractCall(function_option);
+    }
+  }
+}

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

@@ -0,0 +1,474 @@
+import {
+    callReadOnlyFunction,
+    contractPrincipalCV,
+    cvToValue,
+    FungibleConditionCode,
+    listCV, makeContractNonFungiblePostCondition, makeStandardNonFungiblePostCondition,
+    NonFungibleConditionCode,
+    standardPrincipalCV,
+    uintCV,
+} from '@stacks/transactions';
+import BigNumber from 'bignumber.js';
+import {openContractCall} from '@stacks/connect';
+import {
+    getPostConditionFromAsset,
+    getReadOptions,
+    getWriteOptions,
+    parseAddressToCV,
+} from "../util";
+import {StackswapAPI} from "../../index";
+import {BaseToken, Token} from "./token.manager";
+import axios from "axios";
+
+export enum Mode {
+    WITH_SERVER,
+    ONLY_BLOCKCHAIN
+}
+
+export class GroupFarmManager {
+    stackswap: StackswapAPI;
+
+    constructor(stackswap: StackswapAPI) {``
+        this.stackswap = stackswap;
+    }
+
+    async getFarmCounts() {
+        const pair_details_options : any = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_ONE_STEP_GROUP_FARM(), 'get-farm-counts', []);
+        try {
+            const result = cvToValue(await callReadOnlyFunction(pair_details_options)).value;
+            return result;
+        } catch (e) {
+            return('');
+        }
+    }
+
+    async getFarmLists(farmIDs: number[]) {
+        const listTemp = [];
+        for (const farmID of farmIDs) {
+            listTemp.push(uintCV(farmID));
+        }
+        const pair_details_options : any = getReadOptions(this.stackswap, this.stackswap.config.CONTRACT_NAME_STACKSWAP_ONE_STEP_GROUP_FARM(), 'get-farms', [listCV(listTemp)]);
+        try {
+            const result = cvToValue(await callReadOnlyFunction(pair_details_options)).value;
+            // console.log('farmLists', result);
+            return result;
+        } catch (e) {
+            return('');
+        }
+    }
+
+    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 getRewardData(farming_contract: string) {
+        const function_option = getReadOptions(this.stackswap, farming_contract, 'getAllRewardData', [
+        ]);
+        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.getCurrentBlocks();
+        return await this.getFarmingRound(Number(bh.tenure_block_height), 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 {amountToken: {type: 'uint', value: '0'}, unclaimedList: {type: "(list 0 uint)", value: []}}
+        }
+    }
+
+
+    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 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 {amountToken: {type: 'uint', value: '0'}, unclaimedList: {type: "(list 0 uint)", value: []}}
+        }
+    }
+
+    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 {
+                "amountGold": {
+                    "type": "uint",
+                    "value": "0"
+                },
+                "amountInCount": {
+                    "type": "uint",
+                    "value": "0"
+                },
+                "amountSilver": {
+                    "type": "uint",
+                    "value": "0"
+                },
+                "unclaimedList": {
+                    "type": "(list 0 uint)",
+                    "value": [
+                    ]
+                }
+            }
+        }
+    }
+
+    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 | string, 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: Token, amountTokens: string, lockPeriod: number, callback: any, farming_contract: string) {
+        const amount = new BigNumber(amountTokens).multipliedBy(10 ** stakingToken.decimal).toFixed(0).toString();
+        const function_option = getWriteOptions(this.stackswap, farming_contract, 'stakeTokens', [
+            uintCV(amount),
+            parseAddressToCV(stakingToken.addr),
+            uintCV(lockPeriod)
+        ], [await getPostConditionFromAsset(this.stackswap, this.stackswap.getSenderAddress(), stakingToken.addr, amount, FungibleConditionCode.Equal)], callback);
+        await openContractCall(function_option);
+    }
+
+
+
+    async claimStakingReward(stakingToken: string, cycle: number, rewardToken1: string, rewardToken2: string, rewardToken3: string, rewardToken4: string, rewardList: any, callback: any, farming_contract: string) {
+        const address = stakingToken.split('.');
+        const post_condition : any = [];
+        if(stakingToken === rewardToken1){
+            post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, stakingToken, new BigNumber(rewardList.returnToken.value).plus(rewardList.reward1.value).toFixed(0), FungibleConditionCode.Equal));
+        }else{
+            post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, stakingToken, rewardList.returnToken.value, FungibleConditionCode.Equal));
+            post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, rewardToken1, rewardList.reward1.value, FungibleConditionCode.Equal));
+        }
+        if(rewardToken2 !== Token.getBaseTokens(this.stackswap, BaseToken.NULL).addr){
+        post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, rewardToken2, rewardList.reward2.value, FungibleConditionCode.Equal));
+        }
+        if(rewardToken3 !== Token.getBaseTokens(this.stackswap, BaseToken.NULL).addr){
+            post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, rewardToken3, rewardList.reward3.value, FungibleConditionCode.Equal));
+        }
+        if(rewardToken4 !== Token.getBaseTokens(this.stackswap, BaseToken.NULL).addr) {
+            post_condition.push(await getPostConditionFromAsset(this.stackswap, farming_contract, rewardToken4, rewardList.reward4.value, FungibleConditionCode.Equal));
+        }
+
+        //{
+        //     "returnToken": {
+        //         "type": "uint",
+        //         "value": "0"
+        //     },
+        //     "reward1": {
+        //         "type": "uint",
+        //         "value": "104500000"
+        //     },
+        //     "reward2": {
+        //         "type": "uint",
+        //         "value": "10545000"
+        //     },
+        //     "reward3": {
+        //         "type": "uint",
+        //         "value": "105545000"
+        //     },
+        //     "reward4": {
+        //         "type": "uint",
+        //         "value": "0"
+        //     }
+        // }
+        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, false);
+        // console.log(rewardList);
+        await openContractCall(function_option);
+    }
+
+    async getNFTAsset(tokenStr: string){
+        // // console.log(tokenStr);
+        const token_addr = tokenStr.split('.');
+        const url = this.stackswap.config.STACKS_API_URL() + '/v2/contracts/interface/' + token_addr[0] + '/' + token_addr[1];
+        const result = await axios.get(url);
+        if (result.data.non_fungible_tokens.length === 1) {
+            return tokenStr + '::' + result.data.non_fungible_tokens[0].name as any;
+        } else {
+            return tokenStr + '::' + result.data.non_fungible_tokens[0].name as any;
+        }
+    }
+
+    async stakeNFTs(goldList: number[], silverList: number[], callback: any, farming_contract: string) {
+        // // console.log(amountTokens);
+        const gold_list = [];
+        const silver_list = [];
+        const post_condition : any = [];
+        const gold_asset_string = await this.getNFTAsset(this.stackswap.config.STACKSWAP_ADDRESS()+'.'+this.stackswap.config.CONTRACT_NAME_GOLD_PASS());
+        const silver_asset_string = await this.getNFTAsset(this.stackswap.config.STACKSWAP_ADDRESS()+'.'+this.stackswap.config.CONTRACT_NAME_SILVER_PASS());
+        for (const gold of goldList) {
+            gold_list.push(uintCV(gold))
+            post_condition.push(
+              makeStandardNonFungiblePostCondition(this.stackswap.getSenderAddress(), NonFungibleConditionCode.Sends, gold_asset_string, uintCV(gold)),
+            )
+        }
+        for (const silver of silverList) {
+            silver_list.push(uintCV(silver))
+            post_condition.push(
+              makeStandardNonFungiblePostCondition(this.stackswap.getSenderAddress(), NonFungibleConditionCode.Sends, silver_asset_string, uintCV(silver)),
+            )
+        }
+        const function_option = getWriteOptions(this.stackswap, farming_contract, 'stakeNFTs', [
+                listCV(gold_list),
+                listCV(silver_list)
+            ], post_condition, callback, false);
+        await openContractCall(function_option);
+    }
+
+
+    async claimNFTStakingReward(  rewardToken1: string, rewardToken2: string, rewardToken3: string, rewardToken4: string, rewardList: any, callback: any, farming_contract: string) {
+        const post_condition: any = [];
+        const gold_asset_string = await this.getNFTAsset(this.stackswap.config.STACKSWAP_ADDRESS()+'.'+this.stackswap.config.CONTRACT_NAME_GOLD_PASS());
+        for (const gold of rewardList.returnNFTS.value) {
+            // console.log(gold);
+            post_condition.push(
+              makeContractNonFungiblePostCondition(farming_contract.split('.')[0],farming_contract.split('.')[1], NonFungibleConditionCode.Sends, gold_asset_string, uintCV(gold.value)),
+            )
+        }
+        if(rewardToken1 !== Token.getBaseTokens(this.stackswap, BaseToken.NULL).addr){
+            post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, rewardToken1, rewardList.reward1.value, FungibleConditionCode.Equal));
+        } if(rewardToken2 !== Token.getBaseTokens(this.stackswap, BaseToken.NULL).addr){
+            post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, rewardToken2, rewardList.reward2.value, FungibleConditionCode.Equal));
+        } if(rewardToken3 !== Token.getBaseTokens(this.stackswap, BaseToken.NULL).addr){
+            post_condition.push(await getPostConditionFromAsset(this.stackswap,  farming_contract, rewardToken3, rewardList.reward3.value, FungibleConditionCode.Equal));
+        } if(rewardToken4 !== Token.getBaseTokens(this.stackswap, BaseToken.NULL).addr) {
+            post_condition.push(await getPostConditionFromAsset(this.stackswap, farming_contract, rewardToken4, rewardList.reward4.value, FungibleConditionCode.Equal));
+        }
+
+        const function_option = getWriteOptions(this.stackswap, farming_contract, 'claimNFTStakingReward', [
+            parseAddressToCV(rewardToken1),
+            parseAddressToCV(rewardToken2),
+            parseAddressToCV(rewardToken3),
+            parseAddressToCV(rewardToken4),
+        ], post_condition, callback, false);
+        // // console.log(rewardList, reclaimList);
+        await openContractCall(function_option);
+    }
+
+
+    async getRewardBalanceFromFarming(stakingToken: string, unclaimed_list: any, farming_contract: string) {
+        // let reward_balance = new BigNumber(0);
+        const tempRewardDict = {
+            returnToken:{
+                type: "uint",
+                value: '0'
+            }, reward1:{
+                type: "uint",
+                value: '0'
+            }, reward2:{
+                type: "uint",
+                value: '0'
+            }, reward3:{
+                type: "uint",
+                value: '0'
+            }, reward4:{
+                type: "uint",
+                value: '0'
+            }
+        }
+        try {
+            for (const round of unclaimed_list) {
+                const result = await this.getFarmingReward(stakingToken, round, farming_contract);
+                tempRewardDict.returnToken.value =
+                  new BigNumber(tempRewardDict.returnToken.value).plus(result.returnToken.value).toFixed(0);
+                tempRewardDict.reward1.value =
+                  new BigNumber(tempRewardDict.reward1.value).plus(result.reward1.value).toFixed(0);
+                tempRewardDict.reward2.value =
+                  new BigNumber(tempRewardDict.reward2.value).plus(result.reward2.value).toFixed(0);
+                tempRewardDict.reward3.value =
+                  new BigNumber(tempRewardDict.reward3.value).plus(result.reward3.value).toFixed(0);
+                tempRewardDict.reward4.value =
+                  new BigNumber(tempRewardDict.reward4.value).plus(result.reward4.value).toFixed(0);
+            }
+            return tempRewardDict;
+        } catch (e) {
+            // console.log(e);
+            return {
+                returnToken: {
+                    type: "uint",
+                    value: '0'
+                }, reward1: {
+                    type: "uint",
+                    value: '0'
+                }, reward2: {
+                    type: "uint",
+                    value: '0'
+                }, reward3: {
+                    type: "uint",
+                    value: '0'
+                }, reward4: {
+                    type: "uint",
+                    value: '0'
+                }
+            };
+        }
+    }
+
+
+
+}