trc100_propose.sol

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;
import "./interface_slice.sol";
/*
trc100_propose 主分片合约 提案管理部分
*/
contract trc100_propose{
    address public	InitSender;
    address public	trc100_addr;
    address public	slice_addr;
    address public	check_addr;
    uint256    public  pno;
    uint256    limitvote;
    uint256    limitsubmit;
    interface_slice 	slice;

    struct MapPos{
      uint256 pos;
      bool isVaild;
    }
    struct propose{
        uint256     ltype;          //提案类型
        address     submit;         //提出者
        uint256     status;         //状态
        uint256     pno;            //提案号
        uint256     sliceno;        //分片号
        address     contentAddr;    //内容地址    
        bytes32     contentMark;    //内容hash
        uint256     ldays;          //有效天数
        uint256     timeval;        //时间
    }
    struct vote{
        uint256     no;             //提案号
        address[]   pass;           //通过
        address[]   rjuest;         //拒绝
    }
    struct member{
        address     user;
        uint256     amount;
    }
    member[]        users;
    propose[]       history;

    uint256         totalamount;
    uint256         pronums=6;
    propose[6]      curPropose;

    mapping(uint256 => vote)            voteMap;                         //提案投票中
    mapping(address => MapPos)          userMap;                         //投票人管理
    mapping(uint256 => mapping(address => uint256))  voteIndex;          //提案投票中

    
    constructor(){
        InitSender=msg.sender;
        trc100_addr=msg.sender;
        slice_addr=msg.sender;
        check_addr=msg.sender;
        pno=1;
        limitvote=10000;
        limitsubmit=10000;
        totalamount=10000000000;
        for(uint256 i=0;i<6;i++){
            curPropose[i].pno=0;
        }
	}
    function  LimitAvail()public{
        check_addr=trc100_addr;
    }
    function  SetTrc100Addr(address addr,address sliceaddr,uint256 _limitvote,uint256 _limitsubmit)public returns(address){
        if(msg.sender!=trc100_addr)return trc100_addr;
        trc100_addr=addr;
        slice_addr=sliceaddr;
        limitvote=_limitvote;
        limitsubmit=_limitsubmit;
        return trc100_addr;
    }
    function trc100Addr()public view returns (address){
		return trc100_addr;
	}
    function Members()public view returns(member[] memory){
        return users;
    }
    //确认权限
    function confirminfo() public view returns (uint256,uint256){
       return (limitvote,limitsubmit);
    }
    function transType(uint256 _type) private pure returns  (uint256){
        if(_type>5)return 0;
        return _type;
    }
    //查询提案投票信息
    function queryVoteInfo(uint256 _type) public view returns(uint256,uint256,uint256,uint256){
        uint256 no=transType(_type);
        propose storage pro=curPropose[no];

        require(pro.pno>0,"queryVoteInfo access denied");
        vote storage voteitem=voteMap[pro.pno];
        uint256 passnums=0;
        uint256 rejuestnums=0;
        uint256 passamount=0;
        uint256 rejuestamount=0;
        uint256 i=0;
        for (i=0;i<voteitem.pass.length;i++){
            passnums++;
            MapPos storage posstion=userMap[voteitem.pass[i]];
            if(posstion.isVaild){
                passamount+=users[posstion.pos].amount;
            }
        }
        for (i=0;i<voteitem.rjuest.length;i++){
            rejuestnums++;
            MapPos storage posstion=userMap[voteitem.rjuest[i]];
            if(posstion.isVaild){
                rejuestamount+=users[posstion.pos].amount;
            }
        }
        return (passnums,rejuestnums,passamount,rejuestamount);
    }
    //检测提案
    function runcheck(uint256 _type)public payable returns(uint256,uint256,address){
        uint256 no=transType(_type);
        uint256 ndays;
        propose storage pro=curPropose[no];

        if(pro.pno==0){
            return (2,0,trc100_addr);
        }
        if (check_addr==trc100_addr){
            ndays=(block.timestamp-pro.timeval)/(24*3600*1000000000);
            if(ndays<=pro.ldays){
                return (3,ndays,trc100_addr);
            }
        }

        pro.status=CheckPropose(pro.pno);
        if (pro.status==0){
            return (0,0,trc100_addr);
        }
        return (0,1,trc100_addr);
    }
    //删除提案
    function removepropose(address submit,uint256 _type)public  returns(bool){
        uint256 no=transType(_type);
        propose storage pro=curPropose[no];
        require(trc100_addr==msg.sender,"removepropose access1 denied");
        require(pro.pno>0,"removepropose access2 denied"); 
        require(pro.submit==submit,"removepropose access3 denied"); 
        pro.pno=0;
        return true;
    }
    //提交提案
    function submitpropose(address submit,address addr,bytes32 _contentmark,uint256 _days,uint256 _type,uint256 amount)public returns (bool,uint256){
      
        require(trc100_addr==msg.sender,"submitpropose access1 denied");
        require(amount>=limitsubmit,"submitpropose access2 denied");
        require(_days>=3,"submitpropose access3 denied");

        uint256 no=transType(_type);
        propose storage pro=curPropose[no];
        require(pro.pno==0,"submitpropose access6 denied");
        
        MapPos storage posstion=userMap[addr];
        if(posstion.isVaild){
           users[posstion.pos].amount=amount;     
        }else{
            users.push(member(addr,amount));
            userMap[addr].pos=users.length-1;
            userMap[addr].isVaild=true;
        }

        pro.submit=submit;
        pro.contentAddr=addr;
        pro.status=0;
        pro.contentMark=_contentmark;
        pro.ldays=_days;
        pro.ltype=_type;
        pro.pno=pno++;
        pro.timeval=block.timestamp;
        return (true,pro.pno);
	}
	//投票
	function voteing(uint256 _type,uint256 _op,address voter,uint256 amount)public payable returns (bool,uint256){
        require(trc100_addr==msg.sender,"voteing access1 denied");
        require(amount>=limitvote,"voteing access2 denied");

        uint256 no=transType(_type);
        propose storage pro=curPropose[no];

        MapPos storage posstion=userMap[voter];
        if(posstion.isVaild){
           users[posstion.pos].amount=amount;     
        }else{
            users.push(member(voter,amount));
            userMap[voter].pos=users.length-1;
            userMap[voter].isVaild=true;
        }

        vote storage item=voteMap[pro.pno];
        uint n=voteIndex[pro.pno][voter];
        require(n==0,"voteing access3 denied");

        voteIndex[pro.pno][voter]=pro.pno;
        if(_op==1){
            item.pass.push(voter);
        }else{
            item.rjuest.push(voter);
        }
        return (true,0);
    }
	//执行提案
	function runpropose(uint256 _type)public returns(bool success,uint256 result,uint256 _type1,address addr,bytes32 markid){
        require(trc100_addr==msg.sender,"runpropose access denied");
        uint256 no=transType(_type);
        uint i=0;
        uint256 ndays;
        propose storage pro=curPropose[no];

        require(pro.pno>0,"runpropose access2 denied");
        if (check_addr==trc100_addr){
            ndays=(block.timestamp-pro.timeval)/(24*3600*1000000000);
            require(ndays>pro.ldays,"runpropose access3 denied");
        }
        
        pro.status=CheckPropose(pro.pno);

        history.push(pro);
        vote storage voter=voteMap[pro.pno];
        for(i=0;i<voter.pass.length;i++){
            delete voteIndex[pro.pno][voter.pass[i]];
        }
        for(i=0;i<voter.rjuest.length;i++){
            delete voteIndex[pro.pno][voter.rjuest[i]];
        }
        pro.pno=0;
        return (true,pro.status,_type,pro.contentAddr,pro.contentMark);
    }

    /*
        提案生效条件
        1、提案最短时间为三天
        2、满足提案截止时间
        3、同意票的累积权益超过否定票权益数量，而且同意的权益超过平台总量的10%，即视为通过
    */
    function CheckPropose(uint256 _no) private view returns(uint256){
        if(_no>4){return 0;}
        vote storage v=voteMap[_no];
        uint256 passval=0;
        uint256 rejuestval=0;
        uint256 i;
        bool    avail=false;
        MapPos storage posstion;
        for(i=0;i<v.pass.length;i++){
            if(v.pass[i]==InitSender){
                avail=true;
            }
            posstion=userMap[v.pass[i]];
            if(posstion.isVaild){
                passval+=users[posstion.pos].amount;
            }
        }
        for(i=0;i<v.rjuest.length;i++){
            posstion=userMap[v.rjuest[i]];
            if(posstion.isVaild){
                rejuestval+=users[posstion.pos].amount;
            }
        }
        if(rejuestval>=passval){
            return rejuestval;
        }
        if(passval<(totalamount*1/100)){
            return passval;
        }
        //Clear security controls after maturity
        require(avail,"process denied");
        return 0;
    }
    function QueryPropose(uint256 _type,address sender)public view returns(address,uint256,uint256,address,bytes32,uint256,uint256,bool){
        uint256 no=transType(_type);
        require(curPropose[no].pno>0,"access denied");
        
        bool bvote=false;
        if (voteIndex[curPropose[no].pno][sender]>0){
           bvote=true;     
        }
        return (curPropose[no].submit,curPropose[no].status,curPropose[no].pno,curPropose[no].contentAddr,curPropose[no].contentMark,curPropose[no].ldays,curPropose[no].timeval,bvote);
    } 
    //查询历时提案信息
    function QueryProposeInfo(uint256 begin ,uint256 _len)view public returns(uint256 []memory,address[]memory,uint256[]memory,address[]memory){
         uint l=history.length;
        uint end=begin+_len;
        require(l>=begin,"QueryProposeInfo access denied");
        if(end>l){
            end=l;
        }
        uint256[] memory result_type    =new uint256[](end-begin);
        address[] memory result_submit  =new address[](end-begin);
        uint256[] memory result_status  =new uint256[](end-begin);
        address[] memory result_content =new address[](end-begin);
        uint count=0;
        for(uint i=begin;i<end;i++){
            result_type[count]=history[i].ltype;
            result_submit[count]=history[i].submit;
            result_status[count]=history[i].status;
            result_content[count]=history[i].contentAddr;
            count++;
        }
		return (result_type,result_submit,result_status,result_content);
    }
    //查询历时提案总数
    function QuerySize() view public returns(uint256){
        return history.length;
    }
}