系统语言

English

한국어

日本語

中 文

加入

XYC

您的XYC钱包:

XYC余额:--

  • +500 XYC
  • +1K XYC
  • +10K XYC
  • +50K XYC
  • +100K XYC
  • +500K XYC
撤销
加入

合约数据

  • 智能合约地址

    --

  • 合约存款总数

    -- XYC

  • 智能合约结余

    -- XYC

  • 全球会员总数

    -- 

  • 会员提币总数

    -- 

  • 竞赛总奖金 所有玩家投资数量的2.4%累计作为竞赛总奖金,并将其中的20%奖励给直推好友投资数量最大的前4名玩家,每24小时累计并结算一次

    -- 

  • 竞赛奖励倒计时

    --

个人数据

  • 你的合约地址

  • 你的上级

    --

  • 直推人数

    --

  • 团队人数

  • 300%回报计算

    -- XYC

  • 300%回报状态 当你提币数量达到你投资数量的300%时,状态将会变成已完成;此时你需要通过重新投资来继续获得收益,且投资金额需大于前一次投资金额

    --

  • 直推奖励 每直推一位好友,你将立即收到好友投资数量的10%作为奖励

    -- XYC

  • 竞赛排名 所有玩家投资数量的2.4%累计作为竞赛总奖金,并将其中的20%奖励给直推好友投资数量最大的前4名玩家,每24小时累计并结算一次

    20+

  • 团队收益奖励 每直推一位好友,团队收益奖励激活一层,最多20层

    -- XYC

  • 竞赛奖金

    -- XYC

  • 基础收益率(日)

    --

  • 已提币总数

    -- XYC

  • 未提币总数 提现没有审核,你可以随时随地发起链上申请,每次提现需扣除10%XYC,扣除的XYC进入销毁账号等待被永久销毁

    -- XYC

提币
邀请链接

推广竞赛

  • 地址
  • XYC
  • 奖金

关于合约

智能合约代码

pragma solidity ^0.5.10;

contract IToken{

function balanceOf(address account) external view returns (uint256);

function transfer(address recipient, uint256 amount) external returns (bool);

function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

}

contract XYCChain{

using SafeMath for uint256;

IToken token;

struct Deposit {

uint256 amount;

uint256 withdrawn;

uint256 start;

}

struct User {

Deposit[] deposits;

uint256 checkpoint;

address upline;

uint256 bonus;

uint256 referrals;

uint256 totalStructure;

uint256 poolBonus;

uint256 directBonus;

uint256 partnerBonus;

uint256 partnerBonusTotal;

uint256 partnerAmount;

uint256 partnerWithdrawn;

uint256 performance;

uint256 partnerCheckpoint;

uint256 userTotalWithdraw;

uint256 depositsSum;

bool isPartner;

}

address owner;

uint256 internal decimal = 10 ** 6;

uint256 internal MIN_INVESTMENT = 500 * decimal;

uint256 internal MAX_INVESTMENT = 500000 * decimal;

uint256 constant public BASE_PERCENT = 10;

uint256 constant public DIRECT_BONUS_PERCENT = 100;

uint256 constant public ADMIN_FEE_PERCENT = 40;

uint256 constant public REWARD_PERCENT = 24;

uint256[] public REFERRAL_PERCENTS = [300,300,300,100,100,100,100,80,80,80,80,50,50,50,50,10,10,10,10,10];

uint256 constant public WITHDRAWN_FEE = 100;

uint256 constant public PERCENTS_DIVIDER = 1000;

uint256 public CONTRACT_BALANCE_STEP = 9000000 * decimal;

uint256 public CONTRACT_BALANCE_STEP_SECOND = 5000000 * decimal;

uint256 constant public TIME_STEP = 1 days;

uint8 constant public DIRECT_TOP = 20;

uint256 public totalUsers;

uint256 public totalInvested;

uint256 public totalWithdrawn;

uint256 public totalDeposits;

address private adminAddr;

address private feeAddr;

address private tokenAddr;

mapping (address => User) internal users;

uint8[] public pool_bonuses;

uint40 public pool_last_draw = uint40(block.timestamp);

uint256 public pool_cycle;

uint256 public pool_balance;

uint256 public pool_balance_total;

mapping(uint256 => mapping(address => uint256)) public pool_users_refs_deposits_sum;

mapping(uint8 => address) public pool_top;

address[] public bigPartnerAddr;

address[] public smallPartnerAddr;

address[] public superPartnerAddr;

uint256 public partnerPoolBalance;

uint40 public partnerLastBonus = uint40(block.timestamp);

uint40 public partnerLastAssessment = uint40(block.timestamp);

bool isOpen = true;

event NewUser(address user);

event RefBonus(address up,address _addr,uint256 bonus);

event NewDeposit(address indexed user,address indexed upline, uint256 amount);

event Withdrawn(address indexed user, uint256 amount);

event RefBonus(address indexed upline, address indexed referral, uint256 indexed level, uint256 amount);

event FeePayed(address indexed user, uint256 totalAmount);

event PoolPayout(address indexed addr, uint256 amount);

constructor(IToken _token,address _tokenAddr,address _adminAddr,address _feeAddr) public payable{

owner = msg.sender;

adminAddr =_adminAddr;

feeAddr =_feeAddr;

tokenAddr = _tokenAddr;

token = _token;

pool_bonuses.push(40);

pool_bonuses.push(30);

pool_bonuses.push(20);

pool_bonuses.push(10);

}

function() external payable{}

function userInfo(address addr) external view returns(address upline,uint[16] memory res){

User memory user = users[addr];

uint256 maxPayOut;

uint256 status;

uint256 lastDeposite;

if(user.deposits.length > 0){

Deposit memory deposit = user.deposits[user.deposits.length-1];

maxPayOut = deposit.amount.mul(3);

lastDeposite = deposit.amount;

if(isActive(addr)){

status = 1;

}else{

status = 2;

}

}

res[0]= user.referrals;

res[1]= user.totalStructure;

res[2]= maxPayOut;

res[3]= status;

res[4]= user.directBonus;

res[5]= uint(getRanking(addr)) ;

res[6]= user.bonus;

res[7]= user.poolBonus;

res[8]= getUserPercentRate();

res[9]= BASE_PERCENT;

res[10]= user.depositsSum;

res[11]= user.userTotalWithdraw;

res[12]= user.performance;

res[13]= uint(user.checkpoint);

res[14]= userUnWithdraw(addr);

res[15]= lastDeposite;

return (user.upline,res);

}

function getRanking(address addr) public view returns(uint8){

for(uint8 i=0;i

if(addr != address(0) && addr == pool_top[i]){

return i+1;

}

}

return 0;

}

function conctractInfo() external view returns(uint[7] memory res){

res[0]=totalInvested;

res[1]=totalWithdrawn;

res[2]=token.balanceOf(address(this));

res[3]=totalUsers;

res[4]=pool_balance;

res[5]=uint(pool_last_draw);

res[6]=totalDeposits;

return res;

}

function bytesToAddress(bytes memory bys) public pure returns (address addr) {

assembly {

addr := mload(add(bys,20))

}

}

function onTokenTransfer(address _sender, uint _amount, bytes calldata _data) external returns (bool){

require(!isContract(_sender),'error contract address');

require(msg.sender != address(0) && msg.sender == tokenAddr,'can not be call');

address _upline = bytesToAddress(_data);

invest(_sender,_upline,_amount);

return true;

}

function invest(address _sender,address _upline,uint256 amount) private {

require(isOpen,'invest is not open');

require(amount >= MIN_INVESTMENT,'The investment amount is wrong');

require(amount <= MAX_INVESTMENT,'The investment amount is wrong');

if(totalInvested < (1e7 * decimal)){

require(amount <= (1e4 * decimal) ,'The investment amount must be less than 10,000');

}

if(totalInvested >=(1e7 * decimal) && totalInvested< (2e7 * decimal)){

require(amount <= (5e4 * decimal) ,'The investment amount must be less than 50,000');

}

require(!isActive(_sender),'Deposit already exists');

User storage user = users[_sender];

if(user.deposits.length>0){

Deposit memory d = user.deposits[user.deposits.length-1];

require(amount >d.amount ,'The investment amount must be greater than the last time');

}

uint256 adminFee = amount.mul(ADMIN_FEE_PERCENT).div(PERCENTS_DIVIDER);

token.transfer(adminAddr, adminFee);

if (user.upline == address(0) && users[_upline].deposits.length > 0 && _upline != _sender) {

user.upline = _upline;

}

address up = user.upline;

if (user.upline != address(0)) {

users[up].directBonus += (amount.mul(DIRECT_BONUS_PERCENT).div(PERCENTS_DIVIDER));

}

user.checkpoint = block.timestamp;

if (user.deposits.length == 0) {

totalUsers = totalUsers.add(1);

users[up].referrals++;

for(uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {

if(up == address(0)) break;

users[up].totalStructure++;

up = users[up].upline;

}

emit NewUser(_sender);

}

_caclPerformance(_sender, amount);

user.deposits.push(Deposit(amount, 0, block.timestamp));

user.depositsSum += amount;

totalInvested = totalInvested.add(amount);

totalDeposits ++;

_pollDeposits(_sender, amount);

if(pool_last_draw + TIME_STEP < block.timestamp) {

drawPool();

}

if(partnerLastBonus + (10*60*60) < block.timestamp){

drawPartnerBonus();

}

partnerPoolBalance += (amount * 60/1000);

emit NewDeposit(_sender,user.upline, amount);

}

function _caclPerformance(address _addr, uint256 _amount) private {

address up = users[_addr].upline;

if (up == address(0)) return;

for (uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {

if(up == address(0)) break;

users[up].performance += _amount;

up = users[up].upline;

}

}

function superPartnerAssessment() private{

address addr0 = superPartnerAddr[0];

uint performance0 = users[addr0].performance;

users[addr0].isPartner = true;

for(uint8 i=1;i < superPartnerAddr.length;i++){

address userAddr = superPartnerAddr[i];

users[userAddr].isPartner = true;

uint performance = users[userAddr].performance;

if(performance < performance0){

addr0 = userAddr;

performance0 = performance;

}

}

users[addr0].isPartner = false;

}

function bigPartnerAssessment() private{

address addr0 = bigPartnerAddr[0];

uint performance0 = users[addr0].performance;

users[addr0].isPartner = true;

for(uint8 i=1;i < bigPartnerAddr.length;i++){

address userAddr = bigPartnerAddr[i];

users[userAddr].isPartner = true;

uint performance = users[userAddr].performance;

if(performance < performance0){

addr0 = userAddr;

performance0 = performance;

}

}

users[addr0].isPartner = false;

}

function smallPartnerAssessment() private{

address addr0 = smallPartnerAddr[0];

uint performance0 = users[addr0].performance;

users[addr0].isPartner = true;

for(uint8 i=1;i < smallPartnerAddr.length;i++){

address userAddr = smallPartnerAddr[i];

users[userAddr].isPartner = true;

uint performance = users[userAddr].performance;

if(performance < performance0){

addr0 = userAddr;

performance0 = performance;

}

}

users[addr0].isPartner = false;

}

function drawPartnerBonus() private{

if(partnerLastAssessment + 30 days < block.timestamp){

bigPartnerAssessment();

smallPartnerAssessment();

superPartnerAssessment();

partnerLastAssessment = uint40(block.timestamp);

}

uint256 superTotalPerformance;

uint256 superActuMembers ;

uint256 bigTotalPerformance;

uint256 bigActuMembers ;

uint256 smallTotalPerformance;

uint256 smallActuMembers ;

for(uint8 i=0;i

User storage user = users[superPartnerAddr[i]];

if(user.isPartner){

superTotalPerformance += user.performance;

superActuMembers++;

}

}

for(uint8 i=0;i

User storage user = users[superPartnerAddr[i]];

if(user.isPartner){

uint256 half = partnerPoolBalance*24/100/2;

user.partnerBonus += (half/superActuMembers + half*user.performance/superTotalPerformance);

}

}

for(uint8 i=0;i

User storage user = users[bigPartnerAddr[i]];

if(user.isPartner){

bigTotalPerformance += user.performance;

bigActuMembers++;

}

}

for(uint8 i=0;i

User storage user = users[bigPartnerAddr[i]];

if(user.isPartner){

uint256 half = partnerPoolBalance*33/100/2;

user.partnerBonus += (half/bigActuMembers + half*user.performance/bigTotalPerformance);

}

}

for(uint8 i=0;i

User storage user = users[smallPartnerAddr[i]];

if(user.isPartner){

smallTotalPerformance += user.performance;

smallActuMembers++;

}

}

for(uint8 i=0;i

User storage user = users[smallPartnerAddr[i]];

if(user.isPartner){

uint256 half = partnerPoolBalance*43/100/2;

user.partnerBonus += (half/smallActuMembers + half*user.performance/smallTotalPerformance);

}

}

partnerLastBonus=uint40(block.timestamp);

partnerPoolBalance = 0;

}

function _pollDeposits(address _addr, uint256 _amount) private {

pool_balance += _amount * 24 / 1000;

address upline = users[_addr].upline;

if (upline == address(0)) return;

pool_users_refs_deposits_sum[pool_cycle][upline] += _amount;

for (uint8 i = 0; i < DIRECT_TOP; i++) {

if (pool_top[i] == upline) break;

if (pool_top[i] == address(0)) {

pool_top[i] = upline;

break;

}

if (pool_users_refs_deposits_sum[pool_cycle][upline] > pool_users_refs_deposits_sum[pool_cycle][pool_top[i]]) {

for (uint8 j = i + 1; j < DIRECT_TOP; j++) {

if (pool_top[j] == upline) {

for (uint8 k = j; k <= DIRECT_TOP; k++) {

pool_top[k] = pool_top[k + 1];

}

break;

}

}

for (uint8 j = (DIRECT_TOP - 1); j > i; j--) {

pool_top[j] = pool_top[j - 1];

}

pool_top[i] = upline;

break;

}

}

}

function drawPool() private {

pool_last_draw = uint40(block.timestamp);

pool_cycle++;

uint256 pool_balance_tmp = pool_balance * 200/1000;

for(uint8 i = 0; i < pool_bonuses.length; i++) {

if(pool_top[i] == address(0)) break;

uint256 win = pool_balance_tmp * pool_bonuses[i] / 100;

users[pool_top[i]].poolBonus += win;

pool_balance -= win;

emit PoolPayout(pool_top[i], win);

}

for(uint8 i = 0; i < DIRECT_TOP; i++) {

pool_top[i] = address(0);

}

}

function getPoolTop() external view returns(address[6] memory addr,uint[6] memory performace,uint[6] memory poolBonus){

uint256 draw_amount = pool_balance * 200/1000;

for(uint8 i=0; i< pool_bonuses.length; i++){

if (pool_top[i] == address(0)) break;

addr[i] = pool_top[i];

performace[i] = pool_users_refs_deposits_sum[pool_cycle][pool_top[i]];

poolBonus[i] = draw_amount * pool_bonuses[i] / PERCENTS_DIVIDER;

}

}

function refBonus(address _addr, uint256 _amount) private {

address up = users[_addr].upline;

for(uint8 i = 0; i < REFERRAL_PERCENTS.length; i++) {

if(up == address(0)) break;

if(users[up].referrals >= i + 1) {

uint256 bonus = _amount * REFERRAL_PERCENTS[i] / PERCENTS_DIVIDER;

users[up].bonus += bonus;

emit RefBonus(up, _addr, bonus);

}

up = users[up].upline;

}

}

function withdraw() public returns (bool){

if(pool_last_draw + TIME_STEP < block.timestamp) {

drawPool();

}

if(partnerLastBonus + (10*60*60) < block.timestamp){

drawPartnerBonus();

}

User storage user = users[msg.sender];

require(user.deposits.length>0,'you have not invested');

Deposit storage deposit = user.deposits[user.deposits.length-1];

uint256 maxPayOut = deposit.amount.mul(3);

require( deposit.withdrawn < maxPayOut, "User has no dividends");

uint256 userPercentRate = getUserPercentRate();

uint256 totalAmount;

uint256 dividends = (deposit.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))

.mul(block.timestamp.sub(user.checkpoint))

.div(TIME_STEP);

if((deposit.withdrawn + dividends)>maxPayOut){

dividends = maxPayOut.sub(deposit.withdrawn);

}

if(dividends > 0){

deposit.withdrawn += dividends;

totalAmount += dividends;

refBonus(msg.sender,dividends);

}

if(deposit.withdrawn < maxPayOut && user.directBonus>0){

uint256 directBonus = user.directBonus;

if(deposit.withdrawn + directBonus > maxPayOut){

directBonus = maxPayOut - deposit.withdrawn;

}

user.directBonus -= directBonus;

deposit.withdrawn += directBonus;

totalAmount += directBonus;

}

if(deposit.withdrawn < maxPayOut && user.bonus >0){

uint256 bonus = user.bonus;

if(deposit.withdrawn + bonus >maxPayOut){

bonus = maxPayOut - deposit.withdrawn;

}

user.bonus -= bonus;

deposit.withdrawn += bonus;

totalAmount += bonus;

}

if(deposit.withdrawn < maxPayOut && user.poolBonus >0){

uint256 poolBonus = user.poolBonus;

if(deposit.withdrawn + poolBonus> maxPayOut){

poolBonus = maxPayOut - deposit.withdrawn;

}

user.poolBonus -= poolBonus;

deposit.withdrawn += poolBonus;

totalAmount += poolBonus;

}

uint fee = totalAmount.mul(WITHDRAWN_FEE).div(PERCENTS_DIVIDER);

token.transfer(feeAddr,fee);

if(user.isPartner && user.partnerBonus > 0){

totalAmount += user.partnerBonus;

user.partnerBonusTotal += user.partnerBonus;

user.partnerBonus = 0;

}

uint256 partnerRealese = (user.partnerAmount.mul(userPercentRate).div(PERCENTS_DIVIDER))

.mul(block.timestamp.sub(user.partnerCheckpoint))

.div(TIME_STEP);

if(user.partnerWithdrawn + partnerRealese > user.partnerAmount){

partnerRealese = user.partnerAmount.sub(user.partnerWithdrawn);

}

user.partnerWithdrawn += partnerRealese;

totalAmount = totalAmount.add(partnerRealese);

bool res = token.transfer(msg.sender,totalAmount.sub(fee));

require(res,'withdraw failed');

user.userTotalWithdraw += totalAmount;

totalWithdrawn = totalWithdrawn.add(totalAmount);

user.checkpoint = block.timestamp;

user.partnerCheckpoint = block.timestamp;

emit Withdrawn(msg.sender, totalAmount);

return true;

}

function getUserDividends(address userAddress) public view returns (uint256) {

User storage user = users[userAddress];

Deposit storage deposit = user.deposits[user.deposits.length-1];

uint256 maxPayOut = deposit.amount.mul(3);

uint256 userPercentRate = getUserPercentRate();

uint256 dividends;

//static

dividends = (deposit.amount.mul(userPercentRate).div(PERCENTS_DIVIDER))

.mul(block.timestamp.sub(user.checkpoint))

.div(TIME_STEP);

if((deposit.withdrawn + dividends) > maxPayOut){

dividends = maxPayOut.sub(deposit.withdrawn);

}

return dividends;

}

function getUserCheckpoint(address userAddress) public view returns(uint256) {

return users[userAddress].checkpoint;

}

function getUserUpline(address userAddress) public view returns(address) {

return users[userAddress].upline;

}

function getUserReferralBonus(address userAddress) public view returns(uint256) {

return users[userAddress].bonus;

}

function getUserpoolBonus(address userAddress) public view returns(uint256) {

return users[userAddress].poolBonus;

}

function getUserDirectBonus(address userAddress) public view returns(uint256) {

return users[userAddress].directBonus;

}

function userUnWithdraw(address userAddress) public view returns(uint256 data) {

User storage user = users[userAddress];

if(user.deposits.length==0){

return 0;

}

Deposit storage deposit = user.deposits[user.deposits.length-1];

uint256 maxPayOut = deposit.amount.mul(3);

uint256 dividends = getUserDividends(userAddress);

uint256 referralBonus = getUserReferralBonus(userAddress);

uint256 directBonus = getUserDirectBonus(userAddress);

uint256 poolBonus = getUserpoolBonus(userAddress);

uint256 result = dividends + referralBonus + directBonus + poolBonus ;

if(result + deposit.withdrawn > maxPayOut){

result = maxPayOut.sub(deposit.withdrawn);

}

if(user.isPartner){

result += user.partnerBonus;

}

uint256 partnerRealese = getParterRealease(userAddress);

result += partnerRealese;

return result;

}

function getParterRealease(address addr) private view returns(uint256){

uint256 userPercentRate = getUserPercentRate();

User memory user=users[addr];

uint256 partnerRealese = user.partnerAmount.mul(userPercentRate).div(PERCENTS_DIVIDER)

.mul(block.timestamp.sub(user.partnerCheckpoint))

.div(TIME_STEP);

if(user.partnerWithdrawn + partnerRealese > user.partnerAmount){

partnerRealese = user.partnerAmount.sub(user.partnerWithdrawn);

}

}

function isActive(address userAddress) public view returns (bool) {

User storage user = users[userAddress];

if (user.deposits.length > 0) {

if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(3)) {

return true;

}

}

}

function getUserDepositInfoByIndex(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {

User storage user = users[userAddress];

return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);

}

function getUserTotalInvestAndWithdrawnForDeposits(address userAddress) public view returns(uint8,uint256,uint256) {

User memory user = users[userAddress];

uint256 totalAmountForDeposits;

uint256 totalWithdrawnForDeposits;

for (uint256 i = 0; i < user.deposits.length; i++) {

totalAmountForDeposits = totalAmountForDeposits.add(user.deposits[i].amount);

totalWithdrawnForDeposits = totalWithdrawnForDeposits.add(user.deposits[i].withdrawn);

}

return (uint8(user.deposits.length),totalAmountForDeposits,totalWithdrawnForDeposits);

}

function contractInfo() view external returns (uint256 _totalUsers,uint256 _totalInvested,uint256 _totalWithdrawn,uint256 _totalDeposits,uint256 _pool_last_draw,uint256 _pool_balance,uint256 _pool_balance_total,uint256 _topReffer){

return (totalUsers,totalInvested,totalWithdrawn,totalDeposits,pool_last_draw,pool_balance,pool_balance_total,pool_users_refs_deposits_sum[pool_cycle][pool_top[0]]);

}

function setIsOpen(bool _isOpen) external onlyOwner returns(bool){

isOpen = _isOpen;

return true;

}

function addPartner(address addr,uint8 type_big1small2super3) public onlyOwner returns (bool){

require(users[addr].deposits.length != 0,' this address is not in users');

require((type_big1small2super3==1 || type_big1small2super3==2 || type_big1small2super3==3),'type_big1small2super3 must be 1 or 2 or 3' );

bool isExist =false;

for(uint8 i =0;i

if(superPartnerAddr[i]==addr){

isExist =true;

}

}

for(uint8 i =0;i

if(bigPartnerAddr[i]==addr){

isExist =true;

}

}

for(uint8 i =0;i

if(smallPartnerAddr[i]==addr){

isExist =true;

}

}

require(!isExist,'this address already exists ');

if(type_big1small2super3==1){

bigPartnerAddr.push(addr);

users[addr].partnerAmount = 210000* decimal;

}else if(type_big1small2super3==2){

smallPartnerAddr.push(addr);

users[addr].partnerAmount=70000* decimal;

}else if(type_big1small2super3==3){

superPartnerAddr.push(addr);

users[addr].partnerAmount=630000* decimal;

}

users[addr].isPartner =true;

users[addr].partnerCheckpoint = block.timestamp;

return true;

}

function delPartner(address addr) public onlyOwner returns(bool){

for(uint8 i =0;i

if(superPartnerAddr[i]==addr){

delete superPartnerAddr[i];

for(uint8 j = i; j

superPartnerAddr[j]=superPartnerAddr[j+1];

}

delete superPartnerAddr[superPartnerAddr.length-1];

superPartnerAddr.length--;

users[addr].isPartner=false;

users[addr].partnerAmount=0;

users[addr].partnerWithdrawn = 0;

}

}

for(uint8 i =0;i

if(bigPartnerAddr[i]==addr){

delete bigPartnerAddr[i];

for(uint8 j = i; j

bigPartnerAddr[j]=bigPartnerAddr[j+1];

}

delete bigPartnerAddr[bigPartnerAddr.length-1];

bigPartnerAddr.length--;

users[addr].isPartner=false;

users[addr].partnerAmount=0;

users[addr].partnerWithdrawn = 0;

}

}

for(uint8 i =0;i

if(smallPartnerAddr[i]==addr){

delete smallPartnerAddr[i];

for(uint8 j = i; j

smallPartnerAddr[j]=smallPartnerAddr[j+1];

}

delete smallPartnerAddr[smallPartnerAddr.length-1];

smallPartnerAddr.length--;

users[addr].isPartner=false;

users[addr].partnerAmount=0;

users[addr].partnerWithdrawn = 0;

}

}

}

function isContract(address addr) internal view returns (bool) {

uint size;

assembly { size := extcodesize(addr) }

return size > 0;

}

function getPoolBalance() internal view returns (uint256) {

return totalInvested <= totalWithdrawn?0:totalInvested.sub(totalWithdrawn);

}

function getUserPercentRate() public view returns (uint256) {

uint256 contractBalance = getPoolBalance();

if(contractBalance>(1e7 * decimal) && contractBalance<(5e7 * decimal) ){

uint256 f = contractBalance.sub(1e7 * decimal);

uint256 m = (f+ CONTRACT_BALANCE_STEP -1 )/CONTRACT_BALANCE_STEP;

m = m<=90 ? m :90;

return BASE_PERCENT.add(m);

}

if(contractBalance > (5e7 * decimal) ){

uint256 f = contractBalance.sub(5e7 * decimal);

uint256 m = (f+ CONTRACT_BALANCE_STEP_SECOND -1 )/CONTRACT_BALANCE_STEP_SECOND;

m = m<=90 ? m :90;

return BASE_PERCENT.add(m);

}

return BASE_PERCENT;

}

modifier onlyOwner() {

require(msg.sender == owner);

_;

}

}

library SafeMath {

function add(uint256 a, uint256 b) internal pure returns (uint256) {

uint256 c = a + b;

require(c >= a, "SafeMath: addition overflow");

return c;

}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {

require(b <= a, "SafeMath: subtraction overflow");

uint256 c = a - b;

return c;

}

function mul(uint256 a, uint256 b) internal pure returns (uint256) {

if (a == 0) {

return 0;

}

uint256 c = a * b;

require(c / a == b, "SafeMath: multiplication overflow");

return c;

}

function div(uint256 a, uint256 b) internal pure returns (uint256) {

require(b > 0, "SafeMath: division by zero");

uint256 c = a / b;

return c;

}

function mod(uint256 a, uint256 b) internal pure returns (uint256) {

require(b != 0, "SafeMath: modulo by zero");

return a % b;

}

}

智能合约规则解释

关于安全

区块链技术具有开放、自治、不可篡改等特性,因此所有投资者可以随时随地通过tron浏览器审计财务数据、任何人都没有办法私自篡改任何数据,从而保障规则的公平性和资金的安全性。

关于提币

传统金融领域提现一般都是由中心化的操盘方将您的收益转入到您的账户。去中心化的XYC是将所有的规则都用代码的方式部署到tron公链上,且不可修改。没有操盘方,因此提现是由投资者自行点击页面上的按钮进行提现,随时随地都可以进行。

关于投资

XYC智能合约部署在tron公链上,因此投资需要用tron公链代币XYC进行。每次投入金额需高于500XYC。

关于收益

总收益包括1种静态收益和2种动态收益。

静态:每日基础收益为投资额的1%,当合约池余额达到5000万XYC时候,每增加1000万枚XYC,您每日的基础收益率都会增加0.1%,最多增加至3%;在此基础上,如果您提现时间间隔达到24n小时,则收益率会再增加0.1%n,总收益率最多增加至4%/日。总收益额达到您投资额的3倍时,您需要通过再次投资来继续获得收益。

动态:1、你邀请好友加入,你将获得好友投资数量的10%作为佣金奖励,且可立即提现。

2、您的好友邀请他的好友您还可获得佣金奖励。最多可获得15层之内好友的投资佣金奖励,好友静态提现部分作为奖励基数,每层奖励比例如下:

第1层:30%

第2层:20%

第3~5层:10%

第6~10层:8%

第11~15层:5%

邀请参与的好友越多,您获得的佣金奖励也将越多,且佣金奖励是可立即提现的。

关于合约池

用户投入的XYC会作为合约余额,此余额除按照合约既定规则进行转入转出以外,没有任何人可以人为干预,且任何人均可随时随地查看。既定规则规定:用户投入的XYC数量的90%进入到合约余额,归所有投资者共同所有;5%分配给109名社区自治节点;5%分配给合约研发团队;

如何加入

联系我们

官方的联系方式

Telegram: https://t.me/joinchat/

Biyong: https://t.me/joinchat/

加入社群

Telegram: https://t.me/joinchat/

Biyong: https://t.me/joinchat/

社交网络

Twitter:https://twitter.com/

Copyright © 2020, Created by APACHE FOUNDATION