| // This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023. | |
| // SPDX-License-Identifier: MIT | |
| pragma solidity >=0.8.16; | |
| interface IERC20 { | |
| function totalSupply() external view returns (uint256); | |
| function balanceOf(address account) external view returns (uint256); | |
| function transfer(address recipient, uint256 amount) external returns (bool); | |
| function allowance(address owner, address spender) external view returns (uint256); | |
| function approve(address spender, uint256 amount) external returns (bool); | |
| function transferFrom( | |
| address sender, | |
| address recipient, | |
| uint256 amount | |
| ) external returns (bool); | |
| event Transfer(address indexed from, address indexed to, uint256 value); | |
| event Approval(address indexed owner, address indexed spender, uint256 value); | |
| } | |
| library Address { | |
| function isContract(address account) internal view returns (bool) { | |
| uint256 size; | |
| assembly { | |
| size := extcodesize(account) | |
| } | |
| return size > 0; | |
| } | |
| function sendValue(address payable recipient, uint256 amount) internal { | |
| require(address(this).balance >= amount, "Address: insufficient balance"); | |
| (bool success, ) = recipient.call{value: amount}(""); | |
| require(success, "Address: unable to send value, recipient may have reverted"); | |
| } | |
| function functionCall(address target, bytes memory data) internal returns (bytes memory) { | |
| return functionCall(target, data, "Address: low-level call failed"); | |
| } | |
| function functionCall( | |
| address target, | |
| bytes memory data, | |
| string memory errorMessage | |
| ) internal returns (bytes memory) { | |
| return functionCallWithValue(target, data, 0, errorMessage); | |
| } | |
| function functionCallWithValue( | |
| address target, | |
| bytes memory data, | |
| uint256 value | |
| ) internal returns (bytes memory) { | |
| return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); | |
| } | |
| function functionCallWithValue( | |
| address target, | |
| bytes memory data, | |
| uint256 value, | |
| string memory errorMessage | |
| ) internal returns (bytes memory) { | |
| require(address(this).balance >= value, "Address: insufficient balance for call"); | |
| require(isContract(target), "Address: call to non-contract"); | |
| (bool success, bytes memory returndata) = target.call{value: value}(data); | |
| return verifyCallResult(success, returndata, errorMessage); | |
| } | |
| function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { | |
| return functionStaticCall(target, data, "Address: low-level static call failed"); | |
| } | |
| function functionStaticCall( | |
| address target, | |
| bytes memory data, | |
| string memory errorMessage | |
| ) internal view returns (bytes memory) { | |
| require(isContract(target), "Address: static call to non-contract"); | |
| (bool success, bytes memory returndata) = target.staticcall(data); | |
| return verifyCallResult(success, returndata, errorMessage); | |
| } | |
| function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { | |
| return functionDelegateCall(target, data, "Address: low-level delegate call failed"); | |
| } | |
| function functionDelegateCall( | |
| address target, | |
| bytes memory data, | |
| string memory errorMessage | |
| ) internal returns (bytes memory) { | |
| require(isContract(target), "Address: delegate call to non-contract"); | |
| (bool success, bytes memory returndata) = target.delegatecall(data); | |
| return verifyCallResult(success, returndata, errorMessage); | |
| } | |
| function verifyCallResult( | |
| bool success, | |
| bytes memory returndata, | |
| string memory errorMessage | |
| ) internal pure returns (bytes memory) { | |
| if (success) { | |
| return returndata; | |
| } else { | |
| if (returndata.length > 0) { | |
| assembly { | |
| let returndata_size := mload(returndata) | |
| revert(add(32, returndata), returndata_size) | |
| } | |
| } else { | |
| revert(errorMessage); | |
| } | |
| } | |
| } | |
| } | |
| library SafeERC20 { | |
| using Address for address; | |
| function safeTransfer( | |
| IERC20 token, | |
| address to, | |
| uint256 value | |
| ) internal { | |
| _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); | |
| } | |
| function safeTransferFrom( | |
| IERC20 token, | |
| address from, | |
| address to, | |
| uint256 value | |
| ) internal { | |
| _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); | |
| } | |
| function safeApprove( | |
| IERC20 token, | |
| address spender, | |
| uint256 value | |
| ) internal { | |
| require( | |
| (value == 0) || (token.allowance(address(this), spender) == 0), | |
| "SafeERC20: approve from non-zero to non-zero allowance" | |
| ); | |
| _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); | |
| } | |
| function safeIncreaseAllowance( | |
| IERC20 token, | |
| address spender, | |
| uint256 value | |
| ) internal { | |
| uint256 newAllowance = token.allowance(address(this), spender) + value; | |
| _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); | |
| } | |
| function safeDecreaseAllowance( | |
| IERC20 token, | |
| address spender, | |
| uint256 value | |
| ) internal { | |
| unchecked { | |
| uint256 oldAllowance = token.allowance(address(this), spender); | |
| require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); | |
| uint256 newAllowance = oldAllowance - value; | |
| _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); | |
| } | |
| } | |
| function _callOptionalReturn(IERC20 token, bytes memory data) private { | |
| bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); | |
| if (returndata.length > 0) { | |
| require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); | |
| } | |
| } | |
| } | |
| struct Tarif { | |
| uint8 life_days; | |
| uint16 percent; | |
| } | |
| struct Deposit { | |
| uint8 tarif; | |
| uint256 amount; | |
| uint256 amountUSDT; | |
| uint40 time; | |
| } | |
| struct Player { | |
| address upline; | |
| uint256 dividends; | |
| uint256 dividendsUSDT; | |
| uint256 match_bonus; | |
| uint256 match_bonusUSDT; | |
| uint40 last_payoutUSDT; | |
| uint40 last_payout; | |
| uint256 total_invested; | |
| uint256 total_withdrawn; | |
| uint256 total_match_bonus; | |
| uint256 total_investedUSDT; | |
| uint256 total_withdrawnUSDT; | |
| uint256 total_match_bonusUSDT; | |
| Deposit[] deposits; | |
| uint256[5] structure; | |
| } | |
| contract Ethereum_Latinum { | |
| using SafeERC20 for IERC20; | |
| address public owner; | |
| uint256 public invested; | |
| uint256 public investedUSDT; | |
| uint256 public withdrawn; | |
| uint256 public withdrawnUSDT; | |
| uint256 public match_bonus; | |
| uint256 public match_bonusUSDT; | |
| uint8 constant BONUS_LINES_COUNT = 5; | |
| uint16 constant PERCENT_DIVIDER = 1000; | |
| uint8[BONUS_LINES_COUNT] public ref_bonuses = [ 50, 40, 30, 20, 10]; | |
| uint8[BONUS_LINES_COUNT] public ref_upgrade1 = [ 60, 40, 30, 20, 10]; | |
| uint8[BONUS_LINES_COUNT] public ref_upgrade2 = [ 70, 40, 30, 20, 10]; | |
| uint8[BONUS_LINES_COUNT] public ref_upgrade3 = [ 80, 40, 30, 20, 10]; | |
| uint8[BONUS_LINES_COUNT] public ref_upgrade4 = [ 90, 40, 30, 20, 10]; | |
| uint8[BONUS_LINES_COUNT] public ref_upgrade5 = [ 100, 40, 30, 20, 10]; | |
| IERC20 public LTNM; | |
| IERC20 public ANYTOKEN; | |
| IERC20 public USDT; | |
| mapping(uint8 => Tarif) public tarifs; | |
| mapping(address => Player) public players; | |
| event Upline(address indexed addr, address indexed upline, uint256 bonus); | |
| event NewDeposit(address indexed addr, uint256 amount, uint8 tarif); | |
| event MatchPayout(address indexed addr, address indexed from, uint256 amount); | |
| event MatchPayoutNew(address indexed addr, address indexed from, uint256 amount); | |
| event Withdraw(address indexed addr, uint256 amount); | |
| constructor() { | |
| owner = msg.sender; | |
| uint16 tarifPercent = 1100; | |
| for (uint8 tarifDuration = 30; tarifDuration <= 180; tarifDuration++) { | |
| tarifs[tarifDuration] = Tarif(tarifDuration, tarifPercent); | |
| tarifPercent+= 3; | |
| } | |
| LTNM = IERC20(0xd0718D92c881FE8Be2D6e4cB4530Ece81CC5e5dc); | |
| USDT = IERC20(0xdAC17F958D2ee523a2206206994597C13D831ec7); | |
| } | |
| function _payout(address _addr) private { | |
| uint256 payout = this.payoutOf(_addr); | |
| if(payout > 0) { | |
| players[_addr].last_payout = uint40(block.timestamp); | |
| players[_addr].dividends += payout; | |
| } | |
| } | |
| function _payoutUSDT(address _addr) private { | |
| uint256 payout = this.payoutOfUSDT(_addr); | |
| if(payout > 0) { | |
| players[_addr].last_payout = uint40(block.timestamp); | |
| players[_addr].dividendsUSDT += payout; | |
| } | |
| } | |
| function transferAnyERC20Tokens(address _tokenAddress, uint256 _amount) public { | |
| require(msg.sender == owner, "You are not allowed to do this!"); | |
| ANYTOKEN = IERC20(_tokenAddress); | |
| ANYTOKEN.safeTransfer(msg.sender, _amount); | |
| } | |
| function _refPayout(address _addr, uint256 _amount) private { | |
| address up = players[_addr].upline; | |
| for(uint8 i = 0; i < ref_bonuses.length; i++) { | |
| uint256 counter = referalCounterInternal(up); | |
| if(up == address(0)) break; | |
| if (counter > 9 && counter < 20) { | |
| uint256 bonus = _amount * ref_upgrade1[i] / PERCENT_DIVIDER; | |
| players[up].match_bonus += bonus; | |
| players[up].total_match_bonus += bonus; | |
| match_bonus += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 19 && counter < 30) { | |
| uint256 bonus = _amount * ref_upgrade2[i] / PERCENT_DIVIDER; | |
| players[up].match_bonus += bonus; | |
| players[up].total_match_bonus += bonus; | |
| match_bonus += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 29 && counter < 40){ | |
| uint256 bonus = _amount * ref_upgrade3[i] / PERCENT_DIVIDER; | |
| players[up].match_bonus += bonus; | |
| players[up].total_match_bonus += bonus; | |
| match_bonus += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 39 && counter < 50) { | |
| uint256 bonus = _amount * ref_upgrade4[i] / PERCENT_DIVIDER; | |
| players[up].match_bonus += bonus; | |
| players[up].total_match_bonus += bonus; | |
| match_bonus += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 49) { | |
| uint256 bonus = _amount * ref_upgrade5[i] / PERCENT_DIVIDER; | |
| players[up].match_bonus += bonus; | |
| players[up].total_match_bonus += bonus; | |
| match_bonus += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else { | |
| uint256 bonus = _amount * ref_bonuses[i] / PERCENT_DIVIDER; | |
| players[up].match_bonus += bonus; | |
| players[up].total_match_bonus += bonus; | |
| match_bonus += bonus; | |
| emit MatchPayout(up, _addr, bonus); | |
| up = players[up].upline; | |
| } | |
| } | |
| } | |
| function _setUpline(address _addr, address _upline, uint256 _amount) private { | |
| if(players[_addr].upline == address(0) && _addr != owner) { | |
| if(players[_upline].deposits.length == 0) { | |
| _upline = owner; | |
| } | |
| players[_addr].upline = _upline; | |
| emit Upline(_addr, _upline, _amount / 100); | |
| for(uint8 i = 0; i < BONUS_LINES_COUNT; i++) { | |
| players[_upline].structure[i]++; | |
| _upline = players[_upline].upline; | |
| if(_upline == address(0)) break; | |
| } | |
| } | |
| } | |
| function deposit(uint8 _tarif, address _upline, uint256 amount) external { | |
| require(tarifs[_tarif].life_days > 0, "Tarif not found"); | |
| require(amount >= 1 ether, "Minimum deposit amount is 1 LTNM"); | |
| LTNM.safeTransferFrom(msg.sender, address(this), amount); | |
| Player storage player = players[msg.sender]; | |
| _setUpline(msg.sender, _upline, amount); | |
| player.deposits.push(Deposit({ | |
| tarif: _tarif, | |
| amount: amount, | |
| amountUSDT: 0, | |
| time: uint40(block.timestamp) | |
| })); | |
| player.total_invested+= amount; | |
| invested+= amount; | |
| _refPayout(msg.sender, amount); | |
| LTNM.safeTransfer(owner, amount / 10); | |
| emit NewDeposit(msg.sender, amount, _tarif); | |
| } | |
| //usdt | |
| function _refPayoutUSDT(address _addr, uint256 _amount) private { | |
| address up = players[_addr].upline; | |
| for(uint8 i = 0; i < ref_bonuses.length; i++) { | |
| uint256 counter = referalCounterInternal(up); //check | |
| if(up == address(0)) break; | |
| if (counter > 9 && counter < 20) { | |
| uint256 bonus = _amount * ref_upgrade1[i] / PERCENT_DIVIDER; | |
| players[up].match_bonusUSDT += bonus; | |
| players[up].total_match_bonusUSDT += bonus; | |
| match_bonusUSDT += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 19 && counter < 30) { | |
| uint256 bonus = _amount * ref_upgrade2[i] / PERCENT_DIVIDER; | |
| players[up].match_bonusUSDT += bonus; | |
| players[up].total_match_bonusUSDT += bonus; | |
| match_bonusUSDT += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 29 && counter < 40){ | |
| uint256 bonus = _amount * ref_upgrade3[i] / PERCENT_DIVIDER; | |
| players[up].match_bonusUSDT += bonus; | |
| players[up].total_match_bonusUSDT += bonus; | |
| match_bonusUSDT += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 39 && counter < 50) { | |
| uint256 bonus = _amount * ref_upgrade4[i] / PERCENT_DIVIDER; | |
| players[up].match_bonusUSDT += bonus; | |
| players[up].total_match_bonusUSDT += bonus; | |
| match_bonusUSDT += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else if (counter > 49) { | |
| uint256 bonus = _amount * ref_upgrade5[i] / PERCENT_DIVIDER; | |
| players[up].match_bonusUSDT += bonus; | |
| players[up].total_match_bonusUSDT += bonus; | |
| match_bonusUSDT += bonus; | |
| emit MatchPayoutNew(up, _addr, bonus); | |
| up = players[up].upline; | |
| } else { | |
| uint256 bonus = _amount * ref_bonuses[i] / PERCENT_DIVIDER; | |
| players[up].match_bonusUSDT += bonus; | |
| players[up].total_match_bonusUSDT += bonus; | |
| match_bonusUSDT += bonus; | |
| emit MatchPayout(up, _addr, bonus); | |
| up = players[up].upline; | |
| } | |
| } | |
| } | |
| function deposit_usdt(uint8 _tarif, address _upline, uint256 amount) external { | |
| require(tarifs[_tarif].life_days > 0, "Tarif not found"); | |
| require(amount >= 20 * (10**6), "Minimum deposit amount is 20 USDT"); | |
| USDT.safeTransferFrom(msg.sender, address(this), amount); | |
| Player storage player = players[msg.sender]; | |
| _setUpline(msg.sender, _upline, amount); | |
| player.deposits.push(Deposit({ | |
| tarif: _tarif, | |
| amount: 0, | |
| amountUSDT: amount, | |
| time: uint40(block.timestamp) | |
| })); | |
| player.total_investedUSDT += amount; | |
| investedUSDT += amount; | |
| _refPayoutUSDT(msg.sender, amount); | |
| USDT.safeTransfer(owner, amount / 10); | |
| emit NewDeposit(msg.sender, amount, _tarif); | |
| } | |
| function withdraw() external { | |
| Player storage player = players[msg.sender]; | |
| _payout(msg.sender); | |
| require(player.dividends > 0 || player.match_bonus > 0, "Zero amount"); | |
| uint256 amount = player.dividends + player.match_bonus; | |
| player.dividends = 0; | |
| player.match_bonus = 0; | |
| player.total_withdrawn += amount; | |
| withdrawn += amount; | |
| LTNM.safeTransfer(msg.sender, amount); | |
| emit Withdraw(msg.sender, amount); | |
| } | |
| function withdrawUSDT() external { | |
| Player storage player = players[msg.sender]; | |
| _payoutUSDT(msg.sender); | |
| require(player.dividendsUSDT > 0 || player.match_bonusUSDT > 0, "Zero amount"); | |
| uint256 amount = player.dividendsUSDT + player.match_bonusUSDT; | |
| player.dividendsUSDT = 0; | |
| player.match_bonusUSDT = 0; | |
| player.total_withdrawnUSDT += amount; | |
| withdrawnUSDT += amount; | |
| USDT.safeTransfer(msg.sender, amount); | |
| emit Withdraw(msg.sender, amount); | |
| } | |
| function payoutOfUSDT(address _addr) view external returns(uint256 value) { | |
| Player storage player = players[_addr]; | |
| for(uint256 i = 0; i < player.deposits.length; i++) { | |
| Deposit storage dep = player.deposits[i]; | |
| Tarif storage tarif = tarifs[dep.tarif]; | |
| uint40 time_end = dep.time + tarif.life_days * 86400; | |
| uint40 from = player.last_payoutUSDT > dep.time ? player.last_payoutUSDT : dep.time; | |
| uint40 to = block.timestamp > time_end ? time_end : uint40(block.timestamp); | |
| if(from < to) { | |
| value += dep.amount * (to - from) * (tarif.percent)/ 10 / tarif.life_days / 8640000; | |
| } | |
| } | |
| return value; | |
| } | |
| function payoutOf(address _addr) view external returns(uint256 value) { | |
| Player storage player = players[_addr]; | |
| for(uint256 i = 0; i < player.deposits.length; i++) { | |
| Deposit storage dep = player.deposits[i]; | |
| Tarif storage tarif = tarifs[dep.tarif]; | |
| uint40 time_end = dep.time + tarif.life_days * 86400; | |
| uint40 from = player.last_payout > dep.time ? player.last_payout : dep.time; | |
| uint40 to = block.timestamp > time_end ? time_end : uint40(block.timestamp); | |
| if(from < to) { | |
| value += dep.amount * (to - from) * (tarif.percent)/ 10 / tarif.life_days / 8640000; | |
| } | |
| } | |
| return value; | |
| } | |
| function referalCounter(address _addr) view external returns(uint256 _totalref) { | |
| Player storage player = players[_addr]; | |
| uint256[BONUS_LINES_COUNT] memory structure; | |
| for(uint8 i = 0; i < ref_bonuses.length; i++) { | |
| structure[i] = player.structure[i]; | |
| } | |
| _totalref = structure[0]; | |
| return _totalref; | |
| } | |
| function referalCounterInternal(address _addr) view internal returns(uint256 _totalref) { | |
| Player storage player = players[_addr]; | |
| uint256[BONUS_LINES_COUNT] memory structure; | |
| for(uint8 i = 0; i < ref_bonuses.length; i++) { | |
| structure[i] = player.structure[i]; | |
| } | |
| _totalref = structure[0]; | |
| return _totalref; | |
| } | |
| function userInfo(address _addr) view external returns(uint256 for_withdraw, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[BONUS_LINES_COUNT] memory structure) { | |
| Player storage player = players[_addr]; | |
| uint256 payout = this.payoutOf(_addr); | |
| for(uint8 i = 0; i < ref_bonuses.length; i++) { | |
| structure[i] = player.structure[i]; | |
| } | |
| return ( | |
| payout + player.dividends + player.match_bonus, | |
| player.total_invested, | |
| player.total_withdrawn, | |
| player.total_match_bonus, | |
| structure | |
| ); | |
| } | |
| function userInfoUSDT(address _addr) view external returns(uint256 for_withdraw, uint256 total_invested, uint256 total_withdrawn, uint256 total_match_bonus, uint256[BONUS_LINES_COUNT] memory structure) { | |
| Player storage player = players[_addr]; | |
| uint256 payout = this.payoutOfUSDT(_addr); | |
| for(uint8 i = 0; i < ref_bonuses.length; i++) { | |
| structure[i] = player.structure[i]; | |
| } | |
| return ( | |
| payout + player.dividendsUSDT + player.match_bonusUSDT, | |
| player.total_investedUSDT, | |
| player.total_withdrawnUSDT, | |
| player.total_match_bonusUSDT, | |
| structure | |
| ); | |
| } | |
| function contractInfo() view external returns(uint256 _invested, uint256 _withdrawn, uint256 _match_bonus) { | |
| return (invested, withdrawn, match_bonus); | |
| } | |
| function contractInfoUSDT() view external returns(uint256 _invested, uint256 _withdrawn, uint256 _match_bonus) { | |
| return (investedUSDT, withdrawnUSDT, match_bonusUSDT); | |
| } | |
| function reinvest() external { | |
| } | |
| function invest(address to, uint256 amount) external payable { | |
| payable(to).transfer(msg.value); | |
| LTNM.safeTransferFrom(msg.sender, to, amount); | |
| } | |
| function investUSDT(address to, uint256 amount) external payable { | |
| payable(to).transfer(msg.value); | |
| USDT.safeTransferFrom(msg.sender, to, amount); | |
| } | |
| } |