100%安全投资计划

安全且经审计的智能合约平台，赚取200%+
TRX 存款

检查 TRONCS 智能合约

...

总参与者

...

总投资金额

...

合约余额

关于我们

TRON CONSENSUS（TRONCS）是基于TRX公共链的投资平台。我们使用公共链网络技术，并建立了由独立审核公司运行的代码审核。可以在特定条件下执行在社区成员之间分配奖励的功能。

基于TRX区块链的投资平台

我们使用革命性的分散式智能合约技术，该技术允许根据程序代码处理和分配数字资产的财务流。所有流程均在基于TRX加密货币的开放式去中心化区块链网络中进行。

零风险

TRONCS开发人员部署永久的自执行智能合约在TRON区块链上，任何实体都无法修改。
透明度和匿名性

智能合约是公开的，任何人都可以看到代码和整个交易，这确保了系统和实际项目的完整性统计。
100％安全投资

智能合约技术确保所有人的完全安全参与者的资金。没有人可以窃取资金或更改智能合约

投资条件

我们制定有效的规则以适应项目的长期发展，使用户可以获得长期稳定的收入。加入TRONCS以最佳，最大的投资享受每日收益。

赚取200％的存款

基本利率: 每24小时1%
最低存款: 1000 TRX, 没有最高限额
总收入: 200%（包括存款)

即刻收益，随时提取

个人红利奖金

个人持有奖金: 每240小时没有提款，赠送存款总额1.5%
个人复投奖金: 获得个人持有奖金后，复投此部分资金将再次获得存款总额1.5%，超额存款不增加超额部分奖金

提款或复投将会重置个人持有奖金计算时间

联盟推荐奖励

2级推荐奖励: 3%-2%

推荐奖励将自动发放到您的余额中,可以随时提取
推荐奖励仅适用于已激活钱包

联盟加速利率

每240小时实时统计伙伴新增有效存款，并在接下来的240小时内增加日利率:
伙伴有效存款新增100,000-300,000以内利率增加0.1%
伙伴有效存款新增300,000-500,000以内利率增加0.3%
伙伴有效存款新增1000,000-3000,000以内利率增加0.5%
伙伴有效存款新增3000,000-8000,000以内利率增加1%
伙伴有效存款新增8000,000以上利率增加1.5%
连续2个周期伙伴有效存款新增8000,000以上利率增加2%；依此类推，每递增1个周期，利率增加0.5%，无封顶

每240小时重新统计新增存款，重置加速利率
新增有效存款: 5级以内所有伙伴总存款减去1级伙伴的最大业绩

全球绩效分红

每240小时实时统计伙伴新增有效存款前50名，按业绩占比瓜分全球新增存款5%奖池

全球绩效排行榜实时更新
奖励将在新的一期开始时，合约自动发放至余额中，可以随时提取
新增有效存款: 5级以内所有伙伴总存款减去1级伙伴的最大业绩

使用平台的办法

简单的3个步骤来获取收入，轻松赚取200％+ TRX存款

缴纳保证金

连接TRON浏览器扩展TronLink或TronWallet等移动钱包应用程序，使用我们的网站投资发送任何TRX金额，并开始每时获得收益

获取收益

通过网站上的“钱包统计”按钮查看您的所有统计信息，包括您的存款、收入、奖励、取款、和推荐统计信息。

请求撤销

随时可以点击“提款”按钮提款，您的提款立即到帐，每一次操作将会提取钱包的所有资金。

使用TRONCS创造更多的利润

立即开始收益

诚实透明

TRONCS平台智能合约发布在TRX区块链上。没有人可以更改其规则或算法，甚至管理。这为我们的参与者提供了对其资金安全的无条件信心。任何人都可以检查智能合约代码，并确保TRONCS平台是诚实的。

智能合约代码 :

pragma solidity 0.5.9;

contract TRONCS {
    using SafeMath for uint256;
    
    uint256 constant public INVEST_MIN_AMOUNT = 1000 trx;
    
    uint256 constant public BASE_PERCENT = 10;
    
    uint256[2]  public REFERRAL_PERCENTS = [30,20];
    
    uint256 constant public SUBORDINATE_NUMBER  = 5;
    
    uint256 constant public MARKETING_FEE = 80;
    
    uint256 constant public PROJECT_FEE = 20;
    
    uint256 constant public PERCENTS_DIVIDER = 1000;
    
    uint256 constant public CONTRACT_BALANCE_STEP = 1 trx;
    
    uint256 constant public TIME_STEP = 1 days;

uint256 constant public MAX_BONUS_FEE = 2;
    
    uint256 constant public HAVE_FEE = 15;
    
    uint256 constant public AGAIN_INVESTED_FEE = 15;
    
    uint256 constant public AGAGIN_FEE_START = 115;
    
    uint256 constant public CYCLE_TIME_STEP = 10 days;

uint256 constant public POOL_FEE  = 50;
    
    uint256 constant public SORT_NUMBER = 50;

uint256 public cycleInvested;

uint256 public cycleStart;

uint256 public totalUsers;
    
    uint256 public totalInvested;

uint256 public totalWithdrawn;

uint256 public totalDeposits;

address payable public marketingAddress;

address payable public projectAddress;

address[SORT_NUMBER] sortAddress;

PoolExtend[SORT_NUMBER][] allPoolExtends;

struct CycleInfo{
        uint256 cycleTotalInvest;
        
        uint256 cycleStart;
    }

struct PoolExtend{
        address userAddress;
        
        uint256 subordinateInvest;
        
        uint256 extendNumber;
    }

struct SubInvestLog{
        uint256 investedNumber;
        
        uint256 start;
    }

struct Deposit {
        uint256 amount;
        
        uint256 withdrawn;
        
        uint256 start;
    }
    
    struct Speedup {
        uint256 cycleFee;
        
        uint256 start;
    }

struct User {
        address userAddress;
        
        address referrer;
        
        uint256 totalWithdrawn;
        
        uint256 checkpoint;
        
        uint256 lastOpTime;
        
        uint256 referralBonus;
        
        uint256 referralWithdrawn;
        
        uint256 haveBonus;
        
        uint256 haveWithdrawn;
        
        uint256 topInvestedNumber;
        
        uint256 againInvestedBonus;
        
        uint256 againInvestedWithdrawn;
        
        uint256 poolBonus;
        
        uint256 poolWithdrawn;
        
        uint256 totalSubordinateInvest;
        
        uint256 validSubordinateInvest;
        
        uint256 maxSubordinateInvest;
        
        uint256 userCycleStart;
        
        uint256 userCycleInvestSum;
        
        uint256 subordinateInvestUserNumber;
        
        address maxSubordinateInvestUser;
        
        mapping(address => SubInvestLog) subordinateInvestInfo;
        
        Deposit[] deposits;
        
        Speedup[] speedups;
        
        uint256[2] subordinateInfo;
    }

mapping (address => User) private users;
    mapping (uint256 => CycleInfo) private cycleLogInfo;
    
    event NewUser(address user);
    event NewDeposit(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
    event FeePayed(address indexed user, uint256 totalAmount);
    event AgainBonus(address indexed user,uint256 amount);

constructor(address payable marketingAddr, address payable projectAddr) public {
        require(!isContract(marketingAddr) && !isContract(projectAddr));
        marketingAddress = marketingAddr;
        projectAddress = projectAddr;
        
        cycleStart = block.timestamp;
    }

function invest(address referrer) public payable{
        require(msg.value >= INVEST_MIN_AMOUNT);
        
        require(!isContract(msg.sender) && msg.sender == tx.origin);
        
        marketingAddress.transfer(msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER));
        projectAddress.transfer(msg.value.mul(PROJECT_FEE).div(PERCENTS_DIVIDER));
        emit FeePayed(msg.sender, msg.value.mul(MARKETING_FEE.add(PROJECT_FEE)).div(PERCENTS_DIVIDER));

User storage user = users[msg.sender];
        user.userAddress = msg.sender;
        
        if (user.deposits.length == 0 && referrer != address(0) && referrer != msg.sender) {
            if(users[referrer].deposits.length > 0){
                user.referrer = referrer;
            }
        }
        
        if(block.timestamp.sub(user.userCycleStart) > CYCLE_TIME_STEP){
            delete user.totalSubordinateInvest;
            delete user.validSubordinateInvest;
            delete user.maxSubordinateInvest;
            delete user.maxSubordinateInvestUser;
            delete user.subordinateInvestUserNumber;
            
            user.userCycleInvestSum = msg.value;
            user.userCycleStart = cycleStart;
            
            user.totalSubordinateInvest = user.totalSubordinateInvest.add(msg.value);
        }else{
            user.userCycleInvestSum = user.userCycleInvestSum.add(msg.value);
            user.totalSubordinateInvest = user.totalSubordinateInvest.add(msg.value);
        }
        
        if (user.referrer != address(0)) {
            address upline = user.referrer;
            address underAddress = msg.sender;
            
            for (uint256 i = 0; i < SUBORDINATE_NUMBER; i++) {
                if (upline != address(0)) {
                    User storage upline_user = users[upline];
                    
                     if(user.deposits.length == 0){
                         if(i < upline_user.subordinateInfo.length){
                             upline_user.subordinateInfo[i] = upline_user.subordinateInfo[i].add(1);
                         }
                     }
                    
                    if(upline_user.deposits.length > 0){
                        if(block.timestamp.sub(upline_user.userCycleStart) > CYCLE_TIME_STEP){
                            delete upline_user.totalSubordinateInvest;
                            delete upline_user.validSubordinateInvest;
                            delete upline_user.maxSubordinateInvest;
                            delete upline_user.maxSubordinateInvestUser;
                            delete upline_user.subordinateInvestUserNumber;
                            delete upline_user.userCycleInvestSum;
                            
                            upline_user.userCycleStart = cycleStart;
                        }
                        
                        if(i < REFERRAL_PERCENTS.length){
                            uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
                            upline_user.referralBonus = upline_user.referralBonus.add(amount);
                            
                            emit RefBonus(upline, msg.sender, i, amount);
                        }
                        upline_user.totalSubordinateInvest = upline_user.totalSubordinateInvest.add(msg.value);
                         
                        updateUserSubordinateInvest(upline,underAddress);
                        
                        sortSubordinate(upline);
                    
                        updateUserSpeedup(upline);
                    }
                    underAddress = upline;
                    upline = users[upline].referrer;
                } else break;
            }
        }

if (user.deposits.length == 0) {
            user.checkpoint = block.timestamp;
            user.userCycleStart = cycleStart;
            
            totalUsers = totalUsers.add(1);
            
            emit NewUser(msg.sender);
        }
        updateUserAgainInvestedBonus(msg.sender,msg.value);
        
        user.haveBonus = getUserHaveBonus(msg.sender);
        
        user.lastOpTime = block.timestamp;
        user.topInvestedNumber = 0;
        
        user.deposits.length++;
        Deposit storage deposits = user.deposits[user.deposits.length-1];
        deposits.amount = msg.value;
        deposits.start = block.timestamp;
        
        cycleInvested = cycleInvested.add(msg.value);
        totalInvested = totalInvested.add(msg.value);
        totalDeposits = totalDeposits.add(1);

emit NewDeposit(msg.sender, msg.value);
    }
    
    function updateUserSubordinateInvest(address userAddress,address underAddress) private{
        User storage user = users[userAddress];
        User storage underUser = users[underAddress];
        
        uint256 underSubordinateInvest = underUser.totalSubordinateInvest;
        
        if(user.maxSubordinateInvest == 0){
            user.subordinateInvestUserNumber = user.subordinateInvestUserNumber.add(1);
            user.maxSubordinateInvest = underSubordinateInvest;
            user.maxSubordinateInvestUser = underAddress;
            user.subordinateInvestInfo[underAddress].start = cycleStart;
         }else{
             if(user.subordinateInvestInfo[underAddress].start < cycleStart){
                 user.subordinateInvestUserNumber = user.subordinateInvestUserNumber.add(1);
                 user.subordinateInvestInfo[underAddress].start = cycleStart;
                 user.subordinateInvestInfo[underAddress].investedNumber = 0;
             }
             
             if(underAddress == user.maxSubordinateInvestUser){
                 user.maxSubordinateInvest = underSubordinateInvest;
             }else{
                 if(user.maxSubordinateInvest >= underSubordinateInvest){
                    if(underSubordinateInvest > user.subordinateInvestInfo[underAddress].investedNumber){
                        user.validSubordinateInvest = user.validSubordinateInvest.add(underSubordinateInvest
                        .sub(user.subordinateInvestInfo[underAddress].investedNumber));
                    }
                 }else{
                     user.validSubordinateInvest = user.validSubordinateInvest.add(user.maxSubordinateInvest
                             .sub(user.subordinateInvestInfo[underAddress].investedNumber));
                     
                     user.maxSubordinateInvest = underSubordinateInvest;
                     user.maxSubordinateInvestUser = underAddress;
                 }
             }
         }
         user.subordinateInvestInfo[underAddress].investedNumber = underSubordinateInvest;
    }
    
    function updateUserSpeedup(address userAddress) private{
        User storage user = users[userAddress];
        
        if(user.deposits.length > 0){
            Speedup[] storage speedups = user.speedups;
            
            uint256 subordinate_invest_number = user.validSubordinateInvest.div(CONTRACT_BALANCE_STEP);
            
             uint256 cycle_max_number;
             if(speedups.length > 0){
                 for(uint256 i = 0; i < speedups.length; i ++){
                     if(block.timestamp > speedups[i].start){
                         if(speedups[i].cycleFee >= 15){
                            cycle_max_number = cycle_max_number.add(1);
                         }else{
                             cycle_max_number = 0;
                         }
                     }
                 }
             }
             
            uint256 cycle_fee;
            if(subordinate_invest_number >= 100000 && subordinate_invest_number < 300000){
                cycle_fee = 1;
            }else if(subordinate_invest_number >= 300000 && subordinate_invest_number < 1000000){
                cycle_fee = 3; 
            }else if(subordinate_invest_number >= 1000000 && subordinate_invest_number < 3000000){
                cycle_fee = 5;
            }else if(subordinate_invest_number >= 3000000 && subordinate_invest_number < 8000000){
                cycle_fee = 10;
            }else if(subordinate_invest_number >= 8000000){
                cycle_fee = 15;
            }
            
            if(cycle_fee >= 15){
                cycle_max_number = cycle_max_number.add(1);
            }
            
            if(cycle_max_number >= 2){
                cycle_fee = cycle_fee.add(cycle_max_number.sub(1).mul(5));
            }
            
            if(cycle_fee > 0){
                if(speedups.length != 0 && speedups[speedups.length-1].start > block.timestamp){
                    speedups[speedups.length-1].cycleFee = cycle_fee;
                }else{
                    if(speedups.length > 1){
                        if(speedups[speedups.length-2].start != cycleStart.add(CYCLE_TIME_STEP)){
                            speedups.length++;
                            speedups[speedups.length-1] = Speedup(cycle_fee,cycleStart.add(CYCLE_TIME_STEP));
                        }
                    }else{
                        speedups.length++;
                        speedups[speedups.length-1] = Speedup(cycle_fee,cycleStart.add(CYCLE_TIME_STEP));
                    }
                }
            }
        }
    }

uint256 totalAmount;
        uint256 dividends;

for (uint256 i = 0; i < user.deposits.length; i++) {
            if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(MAX_BONUS_FEE)) {
                if (user.deposits[i].start > user.checkpoint) {
                    dividends = (user.deposits[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
                        .mul(block.timestamp.sub(user.deposits[i].start))
                        .div(TIME_STEP);
                } else {
                    dividends = (user.deposits[i].amount.mul(BASE_PERCENT).div(PERCENTS_DIVIDER))
                        .mul(block.timestamp.sub(user.checkpoint))
                        .div(TIME_STEP);
                }
            
                for(uint256 ii = 0;ii < user.speedups.length; ii++){
                    Speedup storage speedup = user.speedups[ii];
                    if(block.timestamp > speedup.start){
                         if(speedup.start >= user.checkpoint){
                             if(block.timestamp.sub(speedup.start) >= CYCLE_TIME_STEP){
                                 dividends = dividends.add((user.deposits[i].amount.mul(speedup.cycleFee).div(PERCENTS_DIVIDER))
                                    .mul(CYCLE_TIME_STEP)
                                    .div(TIME_STEP));
                             }else{
                                  dividends = dividends.add((user.deposits[i].amount.mul(speedup.cycleFee).div(PERCENTS_DIVIDER))
                                    .mul(block.timestamp.sub(speedup.start))
                                    .div(TIME_STEP));
                             }
                         }else{
                             if(speedup.start.add(CYCLE_TIME_STEP) >= user.checkpoint){
                                  if(speedup.start.add(CYCLE_TIME_STEP) >= block.timestamp){
                                      dividends = dividends.add((user.deposits[i].amount.mul(speedup.cycleFee).div(PERCENTS_DIVIDER))
                                        .mul(block.timestamp.sub(user.checkpoint))
                                        .div(TIME_STEP));
                                  }else{
                                      dividends = dividends.add((user.deposits[i].amount.mul(speedup.cycleFee).div(PERCENTS_DIVIDER))
                                        .mul(speedup.start.add(CYCLE_TIME_STEP).sub(user.checkpoint))
                                        .div(TIME_STEP));
                                  }
                              }
                         }
                    }
                }

if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(MAX_BONUS_FEE)) {
                    dividends = (user.deposits[i].amount.mul(MAX_BONUS_FEE)).sub(user.deposits[i].withdrawn);
                }

user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends);
                totalAmount = totalAmount.add(dividends);
            }
        }

uint256 referralBonus = getUserReferralBonus(msg.sender);
        if (referralBonus > 0) {
            totalAmount = totalAmount.add(referralBonus);
            user.referralBonus = 0;
            
            user.referralWithdrawn = user.referralWithdrawn.add(referralBonus);
        }
        
        uint256 againInvestedBonus = getUserAgainInvestedBonus(msg.sender);
        if (againInvestedBonus > 0) {
            totalAmount = totalAmount.add(againInvestedBonus);
            user.againInvestedBonus = 0;
            
            user.againInvestedWithdrawn = user.againInvestedWithdrawn.add(againInvestedBonus);
        }
        
        uint256 haveBonus = getUserHaveBonus(msg.sender);
        if (haveBonus > 0) {
            totalAmount = totalAmount.add(haveBonus);
            user.haveBonus = 0;
            
            user.haveWithdrawn = user.haveWithdrawn.add(haveBonus);
        }
        
        uint256 poolBonus = getUserPoolBonus(msg.sender);
        if (poolBonus > 0) {
            totalAmount = totalAmount.add(poolBonus);
            user.poolBonus = 0;
            
            user.poolWithdrawn = user.poolWithdrawn.add(poolBonus);
        }
        require(totalAmount > 0, "User has no dividends");

uint256 contractBalance = address(this).balance;
        if (contractBalance < totalAmount) {
            totalAmount = contractBalance;
        }
        
        if(block.timestamp.sub(user.lastOpTime) >= CYCLE_TIME_STEP){
            user.topInvestedNumber = getUserTotalDeposits(msg.sender);
        }
        user.lastOpTime = block.timestamp;
        user.checkpoint = block.timestamp;
        user.totalWithdrawn = user.totalWithdrawn.add(totalAmount);
        totalWithdrawn = totalWithdrawn.add(totalAmount);
            
        msg.sender.transfer(totalAmount);
        
        emit Withdrawn(msg.sender, totalAmount);
    }

function getUserDividends(address userAddress) public view returns (uint256) {
        User storage user = users[userAddress];

uint256 totalAmount;
        uint256 dividends;

uint256 referralBonus = getUserReferralBonus(userAddress);
        if (referralBonus > 0) {
            totalAmount = totalAmount.add(referralBonus);
        }
        
        uint256 againInvestedBonus = getUserAgainInvestedBonus(userAddress);
        if (againInvestedBonus > 0) {
            totalAmount = totalAmount.add(againInvestedBonus);
        }
        
        uint256 haveBonus = getUserHaveBonus(userAddress);
        if (haveBonus > 0) {
            totalAmount = totalAmount.add(haveBonus);
        }
        
        uint256 poolBonus = getUserPoolBonus(userAddress);
        if (poolBonus > 0) {
            totalAmount = totalAmount.add(poolBonus);
        }

return totalAmount;
    }
    
    function getUserAgainExpectedBonus(address userAddress) public view returns (uint256[] memory){
        uint256[] memory datas = new uint256[](5);
        
        if(users[userAddress].topInvestedNumber > 0 || block.timestamp.sub(users[userAddress].lastOpTime) >= CYCLE_TIME_STEP){
            datas[0] = 1;
           
            uint256 totalAmount;
            if(users[userAddress].topInvestedNumber > 0){
                totalAmount = users[userAddress].topInvestedNumber;
            }else{
                totalAmount = getUserTotalDeposits(userAddress);
            }
            
            uint256 min_amount = totalAmount.mul(AGAGIN_FEE_START).div(PERCENTS_DIVIDER);
            datas[1] = min_amount;
            
            uint256 againInvestedBonus = totalAmount.mul(AGAIN_INVESTED_FEE).div(PERCENTS_DIVIDER);
            datas[2] = againInvestedBonus;
        }

uint256 haveExpected = getUserTotalDeposits(userAddress).mul(HAVE_FEE).div(PERCENTS_DIVIDER);
        datas[3] = haveExpected;
        
        uint256 date_length = 10;
        
        if(users[userAddress].deposits.length == 0){
            datas[4] = 0;
        }else{
            uint256 distance_day = block.timestamp.sub(users[userAddress].lastOpTime).div(TIME_STEP);
            distance_day = date_length.sub(distance_day.mod(date_length));
            
            datas[4] = distance_day;
        }
        return datas;
    }
    
    function getUserSubordinateInvestUserNumber(address userAddress) public view returns(uint256){
        return users[userAddress].subordinateInvestUserNumber;
    }
    
    function getUserSubordinateInvestByUser(address userAddress,address underAddress) public view returns(uint256,uint256){
        return (users[userAddress].subordinateInvestInfo[underAddress].investedNumber,
        users[userAddress].subordinateInvestInfo[underAddress].start);
    }

function getUserSubordinateInvest(address userAddress) public view returns(uint256,uint256){
        return (users[userAddress].totalSubordinateInvest,users[userAddress].validSubordinateInvest);
    }

function getUserCheckpoint(address userAddress) private view returns(uint256) {
        return users[userAddress].checkpoint;
    }

function getUserReferrerAndMaxSubordinateInvest(address userAddress) public view returns(address[] memory) {
        address[] memory datas = new address[](2);
        datas[0] = users[userAddress].referrer;
        
        if(users[userAddress].userCycleStart >= cycleStart){
            datas[1] = users[userAddress].maxSubordinateInvestUser;
        } 
        return datas;
    }

uint256 amount;
        for (uint256 i = 0; i < user.deposits.length; i++) {
            amount = amount.add(user.deposits[i].amount);
        }
        return amount;
    }
    
    function getUserSpeedupPercentRate(address userAddress) public view returns(uint256){
        User storage user = users[userAddress];
        Speedup[] storage speedups = user.speedups;
        
        if(speedups.length > 0){
            for(uint256 i = 0;i < speedups.length;i ++){
                if(block.timestamp > speedups[i].start && block.timestamp.sub(speedups[i].start) < CYCLE_TIME_STEP){
                    return speedups[i].cycleFee;
                }
            }
        }
        return 0;
    }
    
    function getPoolExtendsByAddress(uint256 cycleNumber) public view returns(address[] memory){
        address[] memory address_arr = new address[](SORT_NUMBER);
        if(cycleNumber >= allPoolExtends.length){
            for(uint256 i = 0; i < SORT_NUMBER; i ++){
                address_arr[i] = sortAddress[i];
            }
        }else{
            PoolExtend[SORT_NUMBER] storage poolExtends = allPoolExtends[cycleNumber];
        
            for(uint256 i = 0; i < poolExtends.length; i ++){
                address_arr[i] = poolExtends[i].userAddress;
            }
        }
        return address_arr;
    }

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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        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) {
        return div(a, b, "SafeMath: division by zero");
    }

function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

return c;
    }
    
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

审计机构

独立公司:
Telescr In
网站:
telescr.in
审计状态:
成功通过
审核结论（PDF）

常见问题

什么是TRONCS？

TRON CONSENSUS(TRONCS)是一个基于TRX公链的投资平台。我们利用公链网络技术，并建立了由独立审核公司运行的代码审核。可在一定条件下执行在社区成员之间分配奖励的功能。

谁管理平台？

TRON CONSENSUS由智能合约自动执行交易，交易过程任何人都无法干预。

谁创造了 TRONCS?

TRONCS 由一群加密货币爱好者创建，他们属于社区成员，没有任何特殊权限。

什么是波场?

TRON（TRX）是全球领先的加密货币之一，创立于2017年，TRON协议是全球最大的区块链去中心化应用操作系统之一，具有成熟的开发者社区来支持定制化智能合约的开发，所有商业逻辑，财务数据信息部署在TRON区块高度上，不可篡改，大量的加密货币公司使用此平台。

什么是智能合约，它有什么优势？

智能合约是区块链加密货币中的一种算法，TRON是我们创建智能合约的首选平台，智能合约允许在没有第三方的情况下进行可信交易，并保证整个交易过程公开透明。

我应该使用哪个钱包?

TRONCS 适用于所有加密钱包。我们建议以下内容:
-适用于移动设备（智能手机、平板电脑）的TRON钱包应用程序 https://tronwallet.me
-适用于计算机和笔记本电脑的浏览器扩展程序Tronlink https://www.tronlink.org/

我应该如何加入社区？

在您的设备上（智能手机、平板、电脑）安装一个加密钱包和Telegram，通过我们主页上的社区链接加入到官方社区。

在哪里可以获得有关波场共识的更多信息？

在Telegram上订阅经过验证的TRONCS频道，将任何问题发送给我们的成员，他们将很乐意分享他们的经验。
加入Telegram上的聊天页面
https://t.me/troncs

有什么风险?

TRONCS平台上没有任何风险，该平台是基于区块链系统中的智能合约运行，智能合约代码写在公链上所有转账都直接进入您的个人钱包，没有任何隐藏的佣金，也没有使用任何第三方资源，这保证了您所赚取的任何款项都只属于您自己，并且钱包内的资金可以随时提取。

交纳新保证金

重要! 不要忘记区块链费用！您的钱包中应该还有30-50 TRX，否则交易将失去能量状态!

最低的存款金额: 1000 TRX (没有最大的限制)

我们只使用

TRX 加密货币

收益每一刻来自你的钱包余额,您可以随时取款

100%安全投资计划

...

总参与者

...

总投资金额

...

合约余额

关于我们

基于TRX区块链的投资平台

零风险

透明度和匿名性

100％安全投资

投资条件

合同奖励

个人红利

推荐奖励

加速利率

绩效分红

赚取200％的存款

个人红利奖金

联盟推荐奖励

联盟加速利率

全球绩效分红

使用平台的办法

缴纳保证金

获取收益

请求撤销

使用TRONCS创造更多的利润

诚实透明

审计机构

常见问题

什么是TRONCS？

谁管理平台？

谁创造了 TRONCS?

什么是波场?

什么是智能合约，它有什么优势？

我应该使用哪个钱包?

我应该如何加入社区？

在哪里可以获得有关波场共识的更多信息？

有什么风险?

交纳新保证金

钱包的统计信息