100% БЕЗОПАСНЫЙ ИНВЕСТИЦИОННЫЙ ПЛАН

Безопасная и проверенная платформа смарт-контрактов, приносящая 200% + TRX депозиты

Проверить смарт-контракт TRONCS

...

Всего участников

...

Общий депозит

...

Баланс контракта

НАСЧЕТ НАС

TRON CONSENSUS (TRONCS) - инвестиционная платформа, основанная на публичной сети TRX. Мы используем сетевую технологию публичной сети и настраиваем аудит кода, проводимый независимой аудиторской компанией. Функция распределения вознаграждений между членами сообщества может выполняться при определенных условиях.

Инвестиционная платформа на базе блокчейна TRX

Мы используем революционную децентрализованную технологию смарт-контрактов, которая позволяет обрабатывать и распределять финансовые потоки цифровых активов в соответствии с программным кодом. Все процессы выполняются в открытой децентрализованной сети блокчейнов на базе криптовалюты TRX.

НУЛЕВОЙ РИСК

Разработчики TRONCS развертывают постоянный самоисполняющийся смарт-контракт в блокчейне Tron, который не может быть изменен ни одним лицом.
Прозрачность и анонимность

Смарт-контракты являются публичными. Кто угодно может увидеть код и весь сделка. Это обеспечивает целостность системы и реального проекта. статистика.
100% НАДЕЖНЫЕ ИНВЕСТИЦИИ

Технология смарт-контракта обеспечивает полную безопасность всех средства участников. Никто не может украсть деньги или изменить смарт-контракт

УСЛОВИЯ ИНВЕСТИЦИИ

Мы формулируем эффективные правила для адаптации к долгосрочному развитию проекта, чтобы пользователи могли получать долгосрочный стабильный доход. Присоединяйтесь к TRONCS, чтобы получать ежедневную прибыль с лучшими и крупными инвестициями.

Заработай 200% депозита

Базовая процентная ставка: 1% за 24 часа
Минимальный депозит: 1000 TRX, без ограничения
Суммарный доход: 200% (включая депозиты)

Мгновенный доход, вывод в любой момент

Персональный бонус

Индивидуальный бонус за хранение: 1,5% от общей суммы депозита будет предоставлено, если не будет выводиться каждые 240 часов
Индивидуальное реинвестирование: после получения индивидуального бонуса удержания реинвестирование этой части фонда снова приведет к получению общего депозита в размере 1,5%, избыточный депозит не будет увеличивать избыточную часть бонуса.

При выводе или реинвестировании время расчета индивидуальных бонусов будет сброшено.

Партнерское реферальное вознаграждение

Награда за рекомендацию уровня 2: 3%-2%

Реферальные вознаграждения будут автоматически зачислены на ваш баланс и могут быть сняты в любое время
Реферальные вознаграждения применяются только к активированным кошелькам

Ускоренная ставка Союза

Статистика в реальном времени новых эффективных вкладов партнеров каждые 240 часов и повышение дневной процентной ставки на следующие 240 часов:
Эффективные депозиты партнеров увеличиваются в пределах от 100000 до 300000, а затем процентная ставка увеличивается на 0,1%.
Эффективные депозиты партнеров увеличиваются на 300,000 до 1 миллиона ，, а затем процентная ставка увеличивается на 0,3%.
Эффективный депозит партнеров увеличивается с 1 миллиона до 3 миллионов, а затем процентная ставка увеличивается на 0,5%.
Эффективный депозит партнеров увеличивается на 3 миллиона до 8 миллионов, а затем процентная ставка увеличивается на 1%.
Эффективные депозиты партнеров увеличились более чем на 8 миллионов, а затем процентная ставка увеличилась на 1,5%.
За два последовательных цикла эффективные депозиты партнеров увеличились более чем на 8 миллионов, а процентная ставка увеличилась на 2%. И так далее, без потолка, процентная ставка увеличивается на 0,5% за каждый дополнительный период.

Пересчитывать новые депозиты каждые 240 часов и сбрасывать ускоренную ставку
Новые эффективные депозиты: равны общей сумме депозитов всех партнеров на уровне 5 после вычитания максимальной производительности партнеров уровня 1.

Бонус за глобальную производительность

Ранжирование 50 лучших депозитов новых партнеров до уровня 5 за 240-часовой снимок, разделение 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?

КТО УПРАВЛЯЕТ ПЛАТФОРМОЙ?

TRONCS автоматически выполняет транзакции с помощью смарт-контрактов, и никто не может вмешиваться в процесс транзакции

КТО СОЗДАЛ ТРОНКИ?

TRONCS был создан группой энтузиастов криптовалюты, которые принадлежат к сообществу и не имеют каких-либо специальных разрешений.

ЧТО ТАКОЕ ТРОН?

TRON (TRX) - одна из ведущих мировых криптовалют. Протокол TRON, основанный в 2017 году, является одной из крупнейших в мире операционных систем децентрализованных приложений с блокчейном, со зрелым сообществом разработчиков для поддержки разработки настраиваемых смарт-контрактов, Вся бизнес-логика и информация о финансовых данных размещены на высоте блока TRON и не могут быть изменены. Этой платформой пользуется большое количество криптовалютных компаний.

ЧТО ТАКОЕ УМНЫЙ КОНТРАКТ? В ЧЕМ ЕГО ПРЕИМУЩЕСТВА?

Смарт-контракт - это алгоритм в криптовалюте блокчейн. TRON - наша предпочтительная платформа для создания смарт-контрактов. Смарт-контракты позволяют проводить надежные транзакции без участия третьей стороны и гарантируют, что весь процесс транзакции открыт и прозрачен.

КАКОЙ КОШЕЛЕК СЛЕДУЕТ ИСПОЛЬЗОВАТЬ?

TRONCS применяется ко всем зашифрованным кошелькам. Мы рекомендуем следующие:
-Приложение TRON Wallet для мобильных устройств (смартфонов, планшетов) https://tronwallet.me
-Tronlink, расширение браузера для компьютеров и ноутбуков https://www.tronlink.org/

ЧТО МНЕ НУЖНО СДЕЛАТЬ, ЧТОБЫ ПРИСОЕДИНИТЬСЯ К СООБЩЕСТВУ?

Установите зашифрованный кошелек и Telegram на свое устройство (смартфон, планшет, компьютер) и присоединитесь к официальному сообществу через ссылку сообщества на нашей домашней странице.

ГДЕ Я МОГУ ПОЛУЧИТЬ БОЛЬШЕ ИНФОРМАЦИИ О TRONCS?

Подпишитесь на проверенный канал TRONCS в Telegram, чтобы сообщать о любых проблемах Отправьте его нашим участникам, и они будут рады поделиться своим опытом.
Присоединяйтесь к странице чата в Telegram
https://t.me/troncs

КАКОВЫ РИСКИ?

На платформе TRONCS нет риска. Платформа основана на работе смарт-контракта в системе блокчейн, а код смарт-контракта написан в публичной цепочке. Все переводы поступают непосредственно в ваш личный кошелек, здесь нет скрытых комиссий и не используются сторонние ресурсы, что гарантирует, что все заработанные вами деньги принадлежат только вам, а средства из кошелька могут быть сняты в любое время.

СДЕЛАТЬ НОВЫЙ ДЕПОЗИТ

ВАЖНЫЙ! Не забывайте про плату за блокчейн! У вас должно быть на 30-50 TRX больше на вашем кошельке, иначе ваша транзакция выйдет из состояния энергопотребления!

Минимальная сумма депозита: 1000 TRX (без максимальных ограничений)

Мы работаем только с

Криптовалюта TRON (TRX)

Заработок поступает на баланс вашего кошелька каждый момент, вы можете вывести его в любой момент

100% БЕЗОПАСНЫЙ ИНВЕСТИЦИОННЫЙ ПЛАН

...

Всего участников

...

Общий депозит

...

Баланс контракта

НАСЧЕТ НАС

Инвестиционная платформа на базе блокчейна TRX

НУЛЕВОЙ РИСК

Прозрачность и анонимность

100% НАДЕЖНЫЕ ИНВЕСТИЦИИ

УСЛОВИЯ ИНВЕСТИЦИИ

Вознаграждение по контракту

Персональный бонус

Реферальный план

Accelerated Rate

Глобальная производительность

Заработай 200% депозита

Персональный бонус

Партнерское реферальное вознаграждение

Ускоренная ставка Союза

Бонус за глобальную производительность

КАК ЭТО РАБОТАЕТ

Сделать депозит

Получайте заработок

Запрос на вывод

Использование TRONCS для получения более прибыльного дохода

ЧЕСТНЫЙ И ПРОЗРАЧНЫЙ

Аудиторская организация

ЧАСТО ЗАПРОСИЛИ

ЧТО ТАКОЕ TRONCS?

КТО УПРАВЛЯЕТ ПЛАТФОРМОЙ?

КТО СОЗДАЛ ТРОНКИ?

ЧТО ТАКОЕ ТРОН?

ЧТО ТАКОЕ УМНЫЙ КОНТРАКТ? В ЧЕМ ЕГО ПРЕИМУЩЕСТВА?

КАКОЙ КОШЕЛЕК СЛЕДУЕТ ИСПОЛЬЗОВАТЬ?

ЧТО МНЕ НУЖНО СДЕЛАТЬ, ЧТОБЫ ПРИСОЕДИНИТЬСЯ К СООБЩЕСТВУ?

ГДЕ Я МОГУ ПОЛУЧИТЬ БОЛЬШЕ ИНФОРМАЦИИ О TRONCS?

КАКОВЫ РИСКИ?

СДЕЛАТЬ НОВЫЙ ДЕПОЗИТ

Статистика кошелька