perfection in details

Reliable investments with

Get +200% up to your deposit

#1 DAPP in industry powered by the original TRONex team Blockchain decentralized and anonymous platform Totally secure income based on

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

Check TRONex VIP smart-contract

Platform presentation (PDF)

We will double your funds without any risks

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

Minimal deposit: 100 TRX

Total income: 200% (deposit included)

Deposit body is not refundable separately

Earnings every moment, withdraw any time

Withdraw comes instantly on your wallet

Referral rewards works only for activated wallets

Basic interest rate:

+5% every 24 hours (+0.2083% hourly)

TRONex VIP smart-contract calculate profit up to every deposit since the date it was made. Every hour you will get +0.2083%, every day +5%.

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

Personal hold-bonus:

+0.2% 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 +0.4%, after 48 hours +0.8%, after 72 hours +1.2% and so on.

Maximum hold-bonus: +15%

Contract total amount bonus:

+0.05% for every 250,000 TRX on platform balance

Smart-contract check its current balance and charge an additional +0.05% up to your earnings for every 250,000 TRX on balance.
Bonus cant be decreased, even if balance goes down.

CURRENT BONUS: +5.25%
Maximum contract bonus: +15%

NEW! Personal VIP bonus:

+0.1% for every deposited 5,000 TRX

The more TRX you will deposit - the more VIP bonus you will get. VIP bonus is summed up for all deposits from your wallet.

Maximum VIP bonus: +15%

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:
5%-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

Withdraw request will reset hold-bonus to 0%

Honest and transparentsmart-contract independent auditions and reviews

TRONex VIP 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 TRONex VIP 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 TRONexVIP {
    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 = [500, 200, 100, 50, 50];
    uint constant public MARKETING_FEE = 500;
    uint constant public FUND_FEE = 500;
    uint constant public MAX_CONTRACT_PERCENT = 1500;
    uint constant public MAX_HOLD_PERCENT = 1500;
    uint constant public MAX_DEPOSIT_PERCENT = 1500;
    uint constant public PERCENTS_DIVIDER = 10000;
    uint constant public CONTRACT_BALANCE_STEP = 250000 trx;
    uint constant public USER_DEPOSITS_STEP = 5000 trx;
    uint constant public TIME_STEP = 1 days;

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

    uint public contractPercent;

    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;
        contractPercent = getContractBalanceRate();
    }

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

        if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
            uint contractPercentNew = getContractBalanceRate();
            if (contractPercentNew > contractPercent) {
                contractPercent = contractPercentNew;
            }
        }

        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 getContractBalance() public view returns (uint) {
        return address(this).balance;
    }

    function getContractBalanceRate() internal view returns (uint) {
        uint contractBalance = address(this).balance;
        uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(5));

        if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
            return contractBalancePercent;
        } else {
            return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
        }
    }

    function getUserDepositRate(address userAddress) public view returns (uint) {
        uint userDepositRate;

        if (getUserAmountOfDeposits(userAddress) > 0) {
            userDepositRate = getUserTotalDeposits(userAddress).div(USER_DEPOSITS_STEP).mul(10);

            if (userDepositRate > MAX_DEPOSIT_PERCENT) {
                userDepositRate = MAX_DEPOSIT_PERCENT;
            }
        }

        return userDepositRate;
    }

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

        if (isActive(userAddress)) {
            uint userDepositRate = getUserDepositRate(userAddress);

            uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(20);
            if (timeMultiplier > MAX_HOLD_PERCENT) {
                timeMultiplier = MAX_HOLD_PERCENT;
            }

            return contractPercent.add(timeMultiplier).add(userDepositRate);
        } else {
            return contractPercent;
        }
    }

    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, uint) {
        return (totalInvested, totalDeposits, address(this).balance, contractPercent);
    }

    function getUserStats(address userAddress) public view returns (uint, 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);
        uint userDepositRate = getUserDepositRate(userAddress);

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

    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:

320 TRX 3f992abf2...e4

100 TRX d9534d5a5...99

100 TRX 19ec27739...04

3000 TRX 67a6fafb2...65

101 TRX e59ab720d...23

Contact usour support team 24/7 available

Official contacts:

Telegram Support Advertisement Manager E-mail: admin@tronex.vip

Public groups:

Telegram News Channel Telegram ENG

Group

Social networks: