Secure Investment Platform Earn

+200%

in 30 days

Blockchain decentralized platform

Totally secure income based on TRX smart-contract

Smart-contract verified and audited by independent company

Make investment now!

presentation

We Will Double Your Funds

Without Any Risks

Unlimited earnings with always growing rates

We offer investment plans with increasing returns based on the base interest rate, total balance of the smart contract, and a personal "hold-bonus." You can earn up to 200% on each deposit.

Reliability of TRX smart-contract. Scam is impossible!

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

Worldwide legal company with professional team

looking at its layout. The point of

Total Invested Amount(TRX)

Total Active Participants:

INVESTMENT CONDITIONS

The Best Market Offer

Basic Interest Rate

1.5% every 24 hours (0.0625% hourly)

The MoneyMagnet smart contract calculates profit from the moment of deposit. Earn 0.0625% every hour, up to 1.5% daily.

Personal Hold-Bonus

+0.3% for every 24 hours without withdraw

The smart contract adds a bonus to your deposit or last withdrawal if you don't request payment. Bonuses increase by +0.3% every 24 hours. (e.g., +0.3% after 24 hours, +0.6% after 48 hours, etc.)

Contract Total Amount Bonus

+0.1% for every 1,000,000 TRX on platform balance

The smart contract adds +0.1% to your earnings for every 1,000,000 TRX in balance. Current bonus: +0.0%.

Current platform balance (TRX)

1006.016

Working only with

TRON (TRX) network

Minimal deposit: 100 TRX

Total income: 200% (deposit included)

Earnings every moment, withdraw any time

How to work with platform

simple 3 steps to get earnings

Step #1: Make deposit

Get TRON (TRX)

We recommend using Klever Wallet or TronLink extensions. Get TRX coins through popular exchangers.

Make investment now!

Send TRX to our smart-contract

Send TRX to the smart contract and start earning immediately. Minimum deposit: 100 TRX, with no maximum limit.

Make investment now!

Your TRX wallet address:

We recommend using Klever Wallet or TronLink extensions. Get TRX coins through popular exchangers.

Check wallet statistics

Step #2: Make deposit

Get your TRX every moment

Check your wallet info - deposits, earnings, withdrawals, and referrals - in real time.

Additional earnings with referral program: Earn from 15 levels (5%, 4%, 3%, 2%, 1%, 1%, 1%, 1%, 1%, 1%, 1%, 1%, 1%, 1%, 1%). Rewards are instant and can be withdrawn anytime.

Your wallet statistics

Step #3: Make deposit

Request TRX withdraw

Payouts are instant.

Request withdrawals from the same wallet you used to deposit.

All deposits and referral earnings are withdrawn in one transaction per request.

Honest and Transparant

Smart-Contract Independent Auditions And Reviews

MoneyMagnet smart contract is on the TRX blockchain and can’t be altered by anyone, including us. This ensures your funds are safe and the contract is transparent

Smart-Contract Independent Auditions And Reviews

MoneyMagnet smart contract is on the TRX blockchain and can’t be altered by anyone, including us. This ensures your funds are safe and the contract is transparent

Smart-contract code:

              
                    
                    pragma solidity 0.5.10;
                    
                    contract plan3 {
                      using SafeMath for uint256;
                    
                      uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
                      uint256 constant public BASE_PERCENT = 15;
                      uint256[] public REFERRAL_PERCENTS = [50,40,30,20,10,10,10,10,10,10,10,10,10,10,10];
                      uint256 constant public MARKETINGFUND = 100;
                      uint256 constant public PROJECTFUND = 100;
                      uint256 constant public PERCENTS_DIVIDER = 1000;
                      uint256 constant public CONTRACT_BALANCE_STEP = 1000000 trx;
                      // Update the constant to represent 2 minutes
                      uint256 constant public TIME_STEP = 2 minutes; // or 120 seconds
                    
                      uint256 public totalUsers;
                      uint256 public totalInvested;
                      uint256 public totalWithdrawn;
                      uint256 public totalDeposits;
                    
                      address payable public marketingAddress;
                      address payable public projectAddress;
                    
                      struct Deposit {
                        uint256 amount;
                        uint256 withdrawn;
                        uint256 start;
                      }
                    
                      struct User {
                        Deposit[] deposits;
                        uint256 checkpoint;
                        address referrer;
                        uint256 bonus;
                        uint256 updateTime;
                        mapping(uint256 => uint256) referralReward;
                      }
                    
                      mapping (address => User) public users;
                      
                      mapping (address => uint256) public userWithdrawn;
                      
                      mapping (address => uint256) public userReferralBonus;
                    
                      event Newbie(address user);
                      event NewDeposit(address indexed user, uint256 amount);
                      event Withdrawn(address indexed user, uint256 amount);
                      event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
                      event FeePayed(address indexed user, uint256 totalAmount);
                      event Reinvest(address sender,uint256 amount);
                      
                      constructor(address payable marketingAddr, address payable projectAddr) public {
                        require(!isContract(marketingAddr) && !isContract(projectAddr));
                        marketingAddress = marketingAddr;
                        projectAddress = projectAddr;
                      }
                      
                      function getLevalReward(address _address,uint256 _level) public view returns(uint256){
                          return users[_address].referralReward[_level];
                      }
                    
                      function invest(address referrer) public payable {
                        require(msg.value >= INVEST_MIN_AMOUNT);
                    
                        marketingAddress.transfer(msg.value.mul(MARKETINGFUND).div(PERCENTS_DIVIDER));
                        projectAddress.transfer(msg.value.mul(PROJECTFUND).div(PERCENTS_DIVIDER));
                        emit FeePayed(msg.sender, msg.value.mul(MARKETINGFUND.add(PROJECTFUND)).div(PERCENTS_DIVIDER));
                    
                        User storage user = users[msg.sender];
                    
                        if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
                          user.referrer = referrer;
                        }
                    
                        if (user.referrer != address(0)) {
                          address upline = user.referrer;
                          for (uint256 i = 0; i < 15; i++) {
                            if (upline != address(0)) {
                              uint256 amount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
                              users[upline].bonus = users[upline].bonus.add(amount);
                              users[upline].referralReward[i] = users[upline].referralReward[i].add(1);
                              emit RefBonus(upline, msg.sender, i, amount);
                              upline = users[upline].referrer;
                            } else break;
                          }
                        }
                    
                        if (user.deposits.length == 0) {
                    
                          user.checkpoint = block.timestamp;
                          totalUsers = totalUsers.add(1);
                          emit Newbie(msg.sender);
                        }
                    
                        user.deposits.push(Deposit(msg.value, 0, block.timestamp));
                    
                        totalInvested = totalInvested.add(msg.value);
                    
                        totalDeposits = totalDeposits.add(1);
                    
                        emit NewDeposit(msg.sender, msg.value);
                    
                      }
                      
                      
                      function reinvest(address sender,uint256 amount) internal{
                        marketingAddress.transfer(amount.mul(500).div(PERCENTS_DIVIDER));
                        emit FeePayed(sender, amount.mul(100).div(PERCENTS_DIVIDER));
                    
                        User storage user = users[sender];
                            address referrer = user.referrer;
                        if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != sender) {
                          user.referrer = referrer;
                        }
                    
                        if (user.referrer != address(0)) {
                          address upline = user.referrer;
                          for (uint256 i = 0; i < 15; i++) {
                            if (upline != address(0)) {
                              uint256 amount = amount.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
                              users[upline].bonus = users[upline].bonus.add(amount);
                              emit RefBonus(upline, sender, i, amount);
                              upline = users[upline].referrer;
                            } else break;
                          }
                        }
                      
                    
                        user.deposits.push(Deposit(amount, 0, block.timestamp));
                      
                    
                        totalDeposits = totalDeposits.add(1);
                    
                        emit NewDeposit(sender, amount);
                      
                      }
                    
                      function withdraw() public {
                      
                        User storage user = users[msg.sender];
                    
                        uint256 userPercentRate = getUserPercentRate(msg.sender);
                    
                        uint256 totalAmount;
                        uint256 dividends;
                    
                        for (uint256 i = 0; i < user.deposits.length; i++) {
                    
                          if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
                    
                            if (user.deposits[i].start > user.checkpoint) {
                    
                              dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
                                .mul(block.timestamp.sub(user.deposits[i].start))
                                .div(TIME_STEP);
                    
                            } else {
                    
                              dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
                                .mul(block.timestamp.sub(user.checkpoint))
                                .div(TIME_STEP);
                    
                            }
                    
                            if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
                              dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
                            }
                    
                            user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
                            totalAmount = totalAmount.add(dividends);
                    
                          }
                        }
                    
                        uint256 referralBonus = getUserReferralBonus(msg.sender);
                        
                        userReferralBonus[msg.sender] = userReferralBonus[msg.sender].add(referralBonus);
                        
                        if (referralBonus > 0) {
                          totalAmount = totalAmount.add(referralBonus);
                          user.bonus = 0;
                        }
                    
                        require(totalAmount > 0, "User has no dividends");
                    
                        uint256 contractBalance = address(this).balance;
                        if (contractBalance < totalAmount) {
                          totalAmount = contractBalance;
                        }
                    
                        user.checkpoint = block.timestamp;
                        
                    
                        reinvest(msg.sender,totalAmount.mul(20).div(100));
                        
                        userWithdrawn[msg.sender] = userWithdrawn[msg.sender].add(totalAmount.mul(90).div(100));
                        
                        msg.sender.transfer(totalAmount.mul(90).div(100));
                    
                        totalWithdrawn = totalWithdrawn.add(totalAmount.mul(90).div(100));
                        
                        user.updateTime = block.timestamp;
                    
                        emit Withdrawn(msg.sender, totalAmount.mul(90).div(100));
                    
                      }
                    
                      function getContractBalance() public view returns (uint256) {
                        return address(this).balance;
                      }
                    
                      function getContractBalanceRate() public view returns (uint256) {
                        uint256 contractBalance = address(this).balance;
                        uint256 contractBalancePercent = contractBalance.div(CONTRACT_BALANCE_STEP);
                        if(contractBalancePercent > 190){
                          contractBalancePercent = 190;
                        }
                        return BASE_PERCENT.add(contractBalancePercent);
                      }
                    
                      function getUserPercentRate(address userAddress) public view returns (uint256) {
                        User storage user = users[userAddress];
                    
                        uint256 contractBalanceRate = getContractBalanceRate();
                        if (isActive(userAddress)) {
                          uint256 timeMultiplier = (now.sub(user.checkpoint)).div(TIME_STEP).mul(3);
                          return contractBalanceRate.add(timeMultiplier);
                        } else {
                          return contractBalanceRate;
                        }
                      }
                    
                      function getUserDividends(address userAddress) public view returns (uint256) {
                        User storage user = users[userAddress];
                    
                        uint256 userPercentRate = getUserPercentRate(userAddress);
                    
                        uint256 totalDividends;
                        uint256 dividends;
                    
                        for (uint256 i = 0; i < user.deposits.length; i++) {
                          
                          if (user.deposits[i].withdrawn < user.deposits[i].amount.mul(2)) {
                    
                            if (user.deposits[i].start > user.checkpoint) {
                    
                              dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
                                .mul(block.timestamp.sub(user.deposits[i].start))
                                .div(TIME_STEP);
                    
                            } else {
                    
                              dividends = (user.deposits[i].amount.mul(userPercentRate).div(PERCENTS_DIVIDER))
                                .mul(block.timestamp.sub(user.checkpoint))
                                .div(TIME_STEP);
                    
                            }
                            if (user.deposits[i].withdrawn.add(dividends) > user.deposits[i].amount.mul(2)) {
                              dividends = (user.deposits[i].amount.mul(2)).sub(user.deposits[i].withdrawn);
                            }
                            totalDividends = totalDividends.add(dividends);
                          }
                    
                        }
                    
                        return totalDividends;
                      }
                    
                      function getUserCheckpoint(address userAddress) public view returns(uint256) {
                        return users[userAddress].checkpoint;
                      }
                    
                      function getUserReferrer(address userAddress) public view returns(address) {
                        return users[userAddress].referrer;
                      }
                    
                      function getUserReferralBonus(address userAddress) public view returns(uint256) {
                        return users[userAddress].bonus;
                      }
                    
                      function getUserAvailable(address userAddress) public view returns(uint256) {
                        return getUserReferralBonus(userAddress).add(getUserDividends(userAddress));
                      }
                    
                      function isActive(address userAddress) public view returns (bool) {
                        User storage user = users[userAddress];
                    
                        if (user.deposits.length > 0) {
                          if (user.deposits[user.deposits.length-1].withdrawn < user.deposits[user.deposits.length-1].amount.mul(2)) {
                            return true;
                          }
                        }
                      }
                    
                      function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256, uint256, uint256) {
                          User storage user = users[userAddress];
                    
                        return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start);
                      }
                    
                      function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
                        return users[userAddress].deposits.length;
                      }
                    
                      function getUserTotalDeposits(address userAddress) public view returns(uint256) {
                          User storage user = users[userAddress];
                    
                        uint256 amount;
                    
                        for (uint256 i = 0; i < user.deposits.length; i++) {
                          amount = amount.add(user.deposits[i].amount);
                        }
                    
                        return amount;
                      }
                    
                      function getUserTotalWithdrawn(address userAddress) public view returns(uint256) {
                          User storage user = users[userAddress];
                    
                        uint256 amount;
                    
                        for (uint256 i = 0; i < user.deposits.length; i++) {
                          amount = amount.add(user.deposits[i].withdrawn);
                        }
                    
                        return amount;
                      }
                    
                      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:

Smart Contract

Make New Deposit

IMPORTANT! Do not forget about blockchain fee! You should have 100-120 TRX more on your wallet, or your transaction will get out of energy status!

Minimal deposit amount: 100 TRX (no maximal limits)

We are working only with

TRON (TRX) cryptocurrency

Your deposit will be activated after 1 confirmation in blockchain

Earnings come every moment on your wallet balance, you can withdraw it any time you want

Wallet Statistic

TRON (TRX) - one of the largest blockchain-based operating systems in the world, consistently handles 2000 transactions per second. Also, TRX is one of the most popular cryptocurrency coin with ~$1.12b market cup.

How to get TRX?

You can easily get TRX on every popular exchangers like Binance, Poloniex, Bitfinex, OKEx and many others. After exchange send TRX on your personal wallet and after that send it to our smart-contract address.

IMPORTANT! We are working only with personal wallets. Dont make deposits form exchangers accounts, you will lose funds, because payouts will come to exchanger address, not yours!

What TRX personal wallets to use?

You can use two types of wallets:
- Browser extensions. For example TronLink / TronPay. Just install extension on your favorite browser and create personal wallet address.

- Mobile crypto wallets. You can use any personal crypto wallet, which support TRX cryptocurrency and "TRON dapps" technology, for example: Klever Wallet