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%

추천 보상은 자동으로 잔액에 적립되며 언제든지 인출 할 수 있습니다.
추천 보상은 활성화 된 지갑에만 적용됩니다.

Union Accelerated Rate

240 시간마다 파트너의 새로운 유효 예금에 대한 실시간 통계를 제공하고 다음 240 시간 동안 일일 이자율을 높입니다.
파트너의 유효 예치금은 100,000에서 300,000으로 증가하고 이자율은 0.1 % 인상됩니다.
파트너의 유효 예금은 30 만에서 100만으로 증가하고 이자율은 0.3 % 증가합니다.
파트너의 유효 예치금이 100 만에서 300만으로 증가한 후 이자율이 0.5 % 인상됩니다.
파트너의 유효 예금은 300 만에서 800만으로 증가한 후 이자율은 1 % 인상됩니다.
파트너의 유효 예금이 800 만 이상 증가한 후 이자율이 1.5 % 증가했습니다.
연속 2주기 동안 파트너의 유효 예금은 800 만 이상 증가했으며 이자율은 2 % 증가했습니다. 그래서 상한선이 없으면 추가 기간마다 이자율이 0.5 % 인상됩니다.

240 시간마다 새로운 입금을 재 계산하고 가속 이율을 재설정합니다.
신규 유효 예금 : 레벨 1 파트너의 최대 성과를 뺀 레벨 5 내의 모든 파트너의 총 예금과 동일

글로벌 성과 보너스

240 시간 스냅 샷당 최대 레벨 5까지 상위 50 개의 신규 파트너 입금 순위를 매기고, 신규 입금액의 5 % 글로벌 보너스 풀을 성과 조건으로 나눕니다.

전 세계 실적 순위가 실시간으로 업데이트됩니다.
어워드는 새 단계가 시작될 때 잔액에 자동으로 지급되며 언제든지 철회 할 수 있습니다.
신규 유효 예금 : 레벨 1 파트너의 최대 성과를 뺀 레벨 5 내의 모든 파트너의 총 예금과 동일

작동 원리

수입을 얻는 간단한 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를 만들었습니까?

TRONCS는 커뮤니티에 속해 있고 특별한 권한이없는 암호 화폐 애호가 그룹에 의해 만들어졌습니다.

트론이란?

TRON (TRX)은 세계 최고의 암호 화폐 중 하나입니다. 2017 년에 설립 된 TRON 프로토콜은 맞춤형 스마트 계약 개발을 지원하는 성숙한 개발자 커뮤니티와 함께 세계에서 가장 큰 블록 체인 분산 애플리케이션 운영 체제 중 하나입니다. 모든 비즈니스 로직 및 재무 데이터 정보는 TRON 블록의 높이에 배치되며 조작 할 수 없습니다. 많은 암호 화폐 회사가이 플랫폼을 사용합니다.

스마트 계약이란 무엇입니까? 장점은 무엇입니까?

스마트 계약은 블록 체인 암호 화폐의 알고리즘입니다. TRON은 스마트 계약을 생성하기 위해 선호하는 플랫폼입니다. 스마트 계약은 제 3 자없이 신뢰할 수있는 거래를 허용하고 전체 거래 프로세스가 개방적이고 투명하도록 보장합니다.

어떤 지갑을 사용해야합니까?

TRONCS는 모든 암호화 된 지갑에 적용됩니다. 다음을 권장합니다.
-모바일 기기 (스마트 폰, 태블릿) 용 TRON 지갑 앱 https://tronwallet.me
-Tronlink, 컴퓨터 및 노트북 용 브라우저 확장 https://www.tronlink.org/

커뮤니티에 가입하려면 어떻게해야합니까?

기기 (스마트 폰, 태블릿, 컴퓨터)에 암호화 된 지갑과 텔레 그램을 설치하고 홈페이지의 커뮤니티 링크를 통해 공식 커뮤니티에 가입하세요

TRONCS에 대한 자세한 정보는 어디서 얻을 수 있습니까?

문제를보고하려면 Telegram에서 검증 된 TRONCS 채널을 구독하십시오. 회원들에게 보내 주시면 기꺼이 경험을 공유 할 것입니다.
Telegram의 채팅 페이지에 참여하세요.
https://t.me/troncs

위험은 무엇입니까?

TRONCS 플랫폼에는 위험이 없습니다. 플랫폼은 블록 체인 시스템의 스마트 계약 운영을 기반으로하며 스마트 계약 코드는 퍼블릭 체인에 작성됩니다. 모든 이체는 개인 지갑으로 직접 이동하고 숨겨진 수수료가 없으며 제 3 자 리소스를 사용하지 않으므로 적립 한 돈은 본인에게만 해당되며 지갑의 자금은 언제든지 인출 할 수 있습니다.

새 입금하기

중대한! 블록 체인 수수료를 잊지 마세요! 지갑에 30-50 TRX가 더 있어야합니다. 그렇지 않으면 거래가 에너지 상태에서 벗어납니다!

최소 입금액: 1000 TRX (최대 한도 없음)

우리는

TRON (TRX) 암호 화폐

수입은 지갑 잔액에 매 순간 발생하며 언제든지 원할 때 인출 할 수 있습니다.

100 % 안전한 투자 계획

...

총 회원

...

총 입금액

...

계약 잔액

우리에 대해

TRX 블록 체인 기반 투자 플랫폼

제로 위험

투명성 및 익명 성

100 % 안전한 투자

투자 조건

계약 보상

개인 보너스

추천 계획

가속 비율

글로벌 성과

200 % 예치금 적립

개인 보너스

파트너 추천 보상

Union Accelerated Rate

글로벌 성과 보너스

작동 원리

입금

수입 받기

인출 요청

TRONCS를 사용하여 더 많은 수익 창출

정직하고 투명한

감사 조직

자주 묻는 질문

TRONCS 란?

플랫폼을 관리하는 사람?

누가 TRONCS를 만들었습니까?

트론이란?

스마트 계약이란 무엇입니까? 장점은 무엇입니까?

어떤 지갑을 사용해야합니까?

커뮤니티에 가입하려면 어떻게해야합니까?

TRONCS에 대한 자세한 정보는 어디서 얻을 수 있습니까?

위험은 무엇입니까?

새 입금하기

지갑 통계