hash
stringlengths 64
64
| size
int64 7k
624k
| ext
stringclasses 1
value | lang
stringclasses 1
value | is_test
bool 2
classes | repo_id
stringclasses 846
values | repo_name
stringclasses 846
values | repo_head
stringclasses 846
values | repo_path
stringlengths 7
155
| content_tokens
int64 1.82k
42.6k
| content_chars
int64 6.85k
58.7k
| content
stringlengths 6.85k
58.7k
| __index_level_0__
int64 84
346k
| id
int64 0
14.2k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
794927056c9fd39901817b56de8a98937ed50128f1cf146893e2dfdf7870678f
| 31,132 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/00/00ab0e9190c7cd2216a316018d6377e9fdb7f662_RugOrWin.sol
| 4,757 | 19,290 |
pragma solidity ^0.8.17;
// SPDX-License-Identifier: MIT
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
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 {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract RugOrWin is Ownable {
using Address for address;
using SafeMath for uint256;
event GameStarted(address indexed better,
address token,
uint256 wager,
uint8 predictedOutcome,
uint32 id);
event GameFinished(address indexed better,
address token,
bool winner,
uint256 wager,
uint32 id);
event PayoutComplete(address indexed winner,
address token,
uint256 winnings);
event DevFeeReceiverChanged(address oldReceiver,
address newReceiver);
event HouseFeeReceiverChanged(address oldReceiver,
address newReceiver);
event DevFeePercentageChanged(uint8 oldPercentage,
uint8 newPercentage);
event HouseFeePercentageChanged(uint8 oldPercentage,
uint8 newPercentage);
event ReferrerFeePercentageChanged(uint8 oldPercentage,
uint8 newPercentage);
struct Game {
address better;
address token;
uint32 id;
uint8 predictedOutcome;
bool finished;
bool winner;
uint256 wager;
uint256 startBlock;
}
struct Queue {
uint32 start;
uint32 end;
}
address public _houseFeeReceiver = address(0x32634D7a09AFb82550dB39644172aB138aAE0e8A);
uint8 public _houseFeePercentage = 30;
address public _devFeeReceiver = address(0x32634D7a09AFb82550dB39644172aB138aAE0e8A);
uint8 public _devFeePercentage = 10; //1%
uint8 public _referrerFeePercentage = 5; //0.5%
mapping (address => bool) public _team;
mapping (address => bool) public _isBlacklisted;
// Game Details
mapping (uint256 => Game) public _games; // Game ID -> Game
Queue private _queuedGames;
bool _gameEnabled = true; // If we want to pause the flip game
uint32 public _queueResetSize = 1; // How many games we want to queue before finalizing a game
uint256 public _blockWaitTime = 2; // How many blocks we want to wait before finalizing a game
uint256 private _globalQueueSize;
mapping (address => mapping (address => uint256)) public _winnings;
mapping (address => uint256) public _minBetForToken;
mapping (address => uint256) public _maxBetForToken;
mapping (address => address) public _referrer;
modifier onlyTeam {
_onlyTeam();
_;
}
function _onlyTeam() private view {
require(_team[_msgSender()], "Only a team member may perform this action");
}
constructor()
{
_team[owner()] = true;
}
// To recieve AVAX from anyone, including the router when swapping
receive() external payable {}
function withdrawAVAX(uint256 amount) external onlyOwner {
(bool sent, bytes memory data) = _msgSender().call{value: amount}("");
require(sent, "Failed to send AVAX");
}
function enterGame(uint256 wager, uint8 outcome, address token, address referrer) external payable {
require(_gameEnabled, "Game is currently paused");
require(!_isBlacklisted[_msgSender()], "This user is blacklisted");
require(!(_msgSender().isContract()), "Contracts are not allowed to play the game");
require(msg.sender == tx.origin, "Sender must be the same as the address that started the tx");
IERC20 gameToken = IERC20(token);
if (_minBetForToken[token] != 0) {
require(wager >= _minBetForToken[token], "This wager is lower than the minimum bet for this token");
}
if (_maxBetForToken[token] != 0) {
require(wager <= _maxBetForToken[token], "This wager is larger than the maximum bet for this token");
}
require(outcome < 2, "Must choose heads or tails (0 or 1)");
if (token != address(0x0)) {
require(wager <= gameToken.balanceOf(address(this)).div(2), "Can't bet more than the amount available in the contract to pay you");
gameToken.transferFrom(_msgSender(), address(this), wager);
} else {
require(wager <= address(this).balance.div(2), "Can't bet more than the amount available in the contract to pay you");
require(msg.value == wager, "Must send same amount as specified in wager");
}
if (referrer != address(0x0) && referrer != _msgSender() && (_referrer[_msgSender()] == address(0x0))) {
_referrer[_msgSender()] = referrer;
}
emit GameStarted(_msgSender(), token, wager, outcome, _queuedGames.end);
_games[_queuedGames.end++] = Game({better: _msgSender(), token: token, id: _queuedGames.end, predictedOutcome: outcome, finished: false, winner: false, wager: wager, startBlock: block.number});
_globalQueueSize++;
completeQueuedGames();
}
function completeQueuedGames() internal {
while (_globalQueueSize > _queueResetSize) {
Game storage game = _games[_queuedGames.start];
if (block.number < game.startBlock.add(_blockWaitTime) ||
game.better == _msgSender()) {
// Wait _blockWaitTime before completing this game, to avoid exploits.
// Don't allow someone to complete their own game
break;
}
_queuedGames.start++;
_globalQueueSize--;
game.winner = (rand() % 2) == game.predictedOutcome;
if (game.winner) {
_winnings[game.better][game.token] += (game.wager * 2);
}
game.finished = true;
emit GameFinished(game.better, game.token, game.winner, game.wager, game.id);
}
}
function rand() public view returns(uint256)
{
uint256 seed = uint256(keccak256(abi.encodePacked(block.timestamp + block.difficulty +
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (block.timestamp)) +
block.gaslimit +
((uint256(keccak256(abi.encodePacked(_msgSender())))) / (block.timestamp)) +
block.number + _globalQueueSize)));
return seed;
}
// If you need to withdraw AVAX, tokens, or anything else that's been sent to the contract
function withdrawToken(address _tokenContract, uint256 _amount) external onlyOwner {
IERC20 tokenContract = IERC20(_tokenContract);
// transfer the token from address of this contract
// to address of the user (executing the withdrawToken() function)
tokenContract.transfer(msg.sender, _amount);
}
function setTeamMember(address member, bool isTeamMember) external onlyOwner {
_team[member] = isTeamMember;
}
function setHouseFeeReceiver(address newReceiver) external onlyOwner {
require(newReceiver != address(0x0), "Can't set the zero address as the receiver");
require(newReceiver != _houseFeeReceiver, "This is already the house fee receiver");
emit HouseFeeReceiverChanged(_houseFeeReceiver, newReceiver);
_houseFeeReceiver = newReceiver;
}
function setHouseFeePercentage(uint8 newPercentage) external onlyOwner {
require(newPercentage != _houseFeePercentage, "This is already the house fee percentage");
require(newPercentage <= 40, "Cannot set house fee percentage higher than 4 percent");
emit HouseFeePercentageChanged(_houseFeePercentage, newPercentage);
_houseFeePercentage = newPercentage;
}
function setDevFeeReceiver(address newReceiver) external onlyOwner {
require(newReceiver != address(0x0), "Can't set the zero address as the receiver");
require(newReceiver != _devFeeReceiver, "This is already the dev fee receiver");
emit DevFeeReceiverChanged(_devFeeReceiver, newReceiver);
_devFeeReceiver = newReceiver;
}
function setDevFeePercentage(uint8 newPercentage) external onlyOwner {
require(newPercentage != _devFeePercentage, "This is already the dev fee percentage");
require(newPercentage <= 5, "Cannot set dev fee percentage higher than 0.5 percent");
emit DevFeePercentageChanged(_devFeePercentage, newPercentage);
_devFeePercentage = newPercentage;
}
function setReferrerFeePercentage(uint8 newPercentage) external onlyOwner {
require(newPercentage != _referrerFeePercentage, "This is already the referrer fee percentage");
require(newPercentage <= 20, "Cannot set dev fee percentage higher than 2 percent");
emit ReferrerFeePercentageChanged(_referrerFeePercentage, newPercentage);
_referrerFeePercentage = newPercentage;
}
function setQueueSize(uint32 newSize) external onlyTeam {
require(newSize != _queueResetSize, "This is already the queue size");
_queueResetSize = newSize;
}
function setGameEnabled(bool enabled) external onlyTeam {
require(enabled != _gameEnabled, "Must set a new value for gameEnabled");
_gameEnabled = enabled;
}
function setMinBetForToken(address token, uint256 minBet) external onlyTeam {
_minBetForToken[token] = minBet;
}
function setMaxBetForToken(address token, uint256 maxBet) external onlyTeam {
_maxBetForToken[token] = maxBet;
}
function setBlacklist(address wallet, bool isBlacklisted) external onlyTeam {
_isBlacklisted[wallet] = isBlacklisted;
}
function forceCompleteQueuedGames() external onlyTeam {
completeQueuedGames();
}
function claimWinnings(address token) external {
require(!_isBlacklisted[_msgSender()], "This user is blacklisted");
uint256 winnings = _winnings[_msgSender()][token];
require(winnings > 0, "This user has no winnings to claim");
IERC20 gameToken = IERC20(token);
if (token != address(0x0)) {
require(winnings <= gameToken.balanceOf(address(this)), "Not enough tokens in the contract to distribute winnings");
} else {
require(winnings <= address(this).balance, "Not enough AVAX in the contract to distribute winnings");
}
delete _winnings[_msgSender()][token];
uint256 feeToHouse = winnings.mul(_houseFeePercentage).div(1000);
uint256 feeToDev = winnings.mul(_devFeePercentage).div(1000);
uint256 feeToReferrer = 0;
address referrer = _referrer[_msgSender()];
if (referrer != address(0x0)) {
feeToReferrer = winnings.mul(_referrerFeePercentage).div(1000);
}
uint256 winningsToUser = winnings.sub(feeToHouse).sub(feeToDev).sub(feeToReferrer);
if (token != address(0x0)) {
gameToken.transfer(_houseFeeReceiver, feeToHouse);
gameToken.transfer(_devFeeReceiver, feeToDev);
if (feeToReferrer > 0) {
gameToken.transfer(referrer, feeToReferrer);
}
gameToken.transfer(_msgSender(), winningsToUser);
} else {
_devFeeReceiver.call{value: feeToDev}("");
_houseFeeReceiver.call{value: feeToHouse}("");
if (feeToReferrer > 0) {
referrer.call{value: feeToReferrer}("");
}
_msgSender().call{value: winningsToUser}("");
}
completeQueuedGames();
emit PayoutComplete(_msgSender(), token, winningsToUser);
}
}
| 104,252 | 1,500 |
19f569ba50d53be950760eed8cf41f5d2d3bca9d9d9679ad7bc3f660af554da6
| 19,509 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x74a376c25a6306c636aea7e9ea2b2c6dff5c0030.sol
| 9,218 | 15,778 |
pragma solidity ^0.4.21 ;
contract SEAPORT_Portfolio_VI_883 {
mapping (address => uint256) public balanceOf;
string public name = " SEAPORT_Portfolio_VI_883 " ;
string public symbol = " SEAPORT883VI " ;
uint8 public decimals = 18 ;
uint256 public totalSupply = 897688033763432000000000000 ;
event Transfer(address indexed from, address indexed to, uint256 value);
function SimpleERC20Token() public {
balanceOf[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value; // deduct from sender's balance
balanceOf[to] += value; // add to recipient's balance
emit Transfer(msg.sender, to, value);
return true;
}
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => mapping(address => uint256)) public allowance;
function approve(address spender, uint256 value)
public
returns (bool success)
{
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value)
public
returns (bool success)
{
require(value <= balanceOf[from]);
require(value <= allowance[from][msg.sender]);
balanceOf[from] -= value;
balanceOf[to] += value;
allowance[from][msg.sender] -= value;
emit Transfer(from, to, value);
return true;
}
// }
// Programme d'mission - Lignes 1 10
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < PD8HMPRz8f9Nn9Y75JRiUWHlv2Nb13BXJeTKG4rz66l6sFEE383yz6Y332h83cFr >
// < 1E-018 limites [ 1E-018 ; 20532396,7569184 ] >
// < 0x000000000000000000000000000000000000000000000000000000007A61F56F >
// < SEAPORT_Portfolio_VI_metadata_line_2_____Lazarev_Port_Spe_Value_20230515 >
// < L7qjH51lFJQpiKTHAAcn97fkc27WT1546DP27YLI7Pw6tc7o14rxMZ6pJg8XYlTz >
// < 1E-018 limites [ 20532396,7569184 ; 40731936,343651 ] >
// < 0x0000000000000000000000000000000000000000000000007A61F56FF2C80296 >
// < Do6m66AwvssG7WjUa5hn1w0E851b283W603mCcz5EuPOFNvzyZjJ4MKVDzP116Um >
// < 1E-018 limites [ 40731936,343651 ; 67176822,8351274 ] >
// < 0x00000000000000000000000000000000000000000000000F2C8029619067B45F >
// < SEAPORT_Portfolio_VI_metadata_line_4_____Lomonosov_Port_Authority_20230515 >
// < PkkNg3Q3JKY5G3DqK6Ohyp3GIGv2Hjr0PYaC05nhHA7F8dbZR6EhJ0XhE4W66SyU >
// < 1E-018 limites [ 67176822,8351274 ; 84556181,1374236 ] >
// < 0x000000000000000000000000000000000000000000000019067B45F1F7FE8035 >
// < SEAPORT_Portfolio_VI_metadata_line_5_____Lomonosov_Port_Authority_20230515 >
// < lGrgWI1P4QEpAv1I6R1A77YKAr4c903v6ofkdH81cx24hSDwGpm6mGTNZT5C8JuI >
// < 1E-018 limites [ 84556181,1374236 ; 102257108,640016 ] >
// < 0x00000000000000000000000000000000000000000000001F7FE80352617FF904 >
// < 47YQ9iu0RJQeV2O056w98824IFXwYq1dD9N3deudsX4AR9MVZ09b7Y5Fu5VyOOaT >
// < 1E-018 limites [ 102257108,640016 ; 120014173,090999 ] >
// < 0x00000000000000000000000000000000000000000000002617FF9042CB571A51 >
// < SEAPORT_Portfolio_VI_metadata_line_7_____Magadan_Port_Authority_20230515 >
// < 0F94hlL37925Ydm62Ch6c57yZW53nOH56Q6ViE90TQ15bjaZdS8q35VX5nD2Jg62 >
// < 1E-018 limites [ 120014173,090999 ; 141679491,296472 ] >
// < 0x00000000000000000000000000000000000000000000002CB571A5134C79C13D >
// < SEAPORT_Portfolio_VI_metadata_line_8_____Magadan_Port_Authority_20230515 >
// < cGag5JW4j14Wq747b3o0f4U5w2B6NpJSHjghO36v9jK2eRG3RhTXOPzwoHag4p6I >
// < 1E-018 limites [ 141679491,296472 ; 156875714,936206 ] >
// < 0x000000000000000000000000000000000000000000000034C79C13D3A70D5A19 >
// < I3k2ND4zIYv3u367M5H9X68Ay5k31g91dperA80VZgtW7pVt6b89paO3a5ZUciAX >
// < 1E-018 limites [ 156875714,936206 ; 183619302,033957 ] >
// < 0x00000000000000000000000000000000000000000000003A70D5A1944674D3CF >
// < SEAPORT_Portfolio_VI_metadata_line_10_____Mago_Port_Spe_Value_20230515 >
// < I2R7459dLjmny74njI3SokVNFr1x73U0aJVY33ew4I9169e19IO59woBX1q5KC18 >
// < 1E-018 limites [ 183619302,033957 ; 199605969,514197 ] >
// < 0x000000000000000000000000000000000000000000000044674D3CF4A5BE8BCB >
// Programme d'mission - Lignes 11 20
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < y8Kt2KqN7TiiasqexF1718dPCaIw9dg7WSPW39Mpmr7E8WfX8uaBsrQ5v00d76fp >
// < 1E-018 limites [ 199605969,514197 ; 224120220,607068 ] >
// < 0x00000000000000000000000000000000000000000000004A5BE8BCB537DC5320 >
// < SEAPORT_Portfolio_VI_metadata_line_12_____Makhachkala_Port_Spe_Value_20230515 >
// < 9Ir0ZQ0lqdby37549n79i7NJ5KD09p569Q9Q0T5u9nZMPiSZqkg2BEoqgD8zs2e6 >
// < 1E-018 limites [ 224120220,607068 ; 251407023,780672 ] >
// < 0x0000000000000000000000000000000000000000000000537DC53205DA80AE9E >
// < SEAPORT_Portfolio_VI_metadata_line_13_____Makhachkala_Sea_Trade_Port_20230515 >
// < 4xI5A1US2Qlk46s3qjp1OQ0P5vWGnsXqyK43vDbnHTdyC6J99CHl92JhG0z1N5PL >
// < 1E-018 limites [ 251407023,780672 ; 279869542,404284 ] >
// < 0x00000000000000000000000000000000000000000000005DA80AE9E6842709F4 >
// < SEAPORT_Portfolio_VI_metadata_line_14_____Makhachkala_Sea_Trade_Port_20230515 >
// < zzmr89iUg39k1P2bWEGlXUEoP42OzX5Crnh5DP4AvUs2FOHYvTVboem85NUR24Ho >
// < 1E-018 limites [ 279869542,404284 ; 299727968,195181 ] >
// < 0x00000000000000000000000000000000000000000000006842709F46FA849787 >
// < 5bTCGbmQ7CLVT6A7j9x0yYoLksXw7nryG123NJI5M10beVK7zDI9sW30ULZUDQ8Y >
// < 1E-018 limites [ 299727968,195181 ; 318614495,138317 ] >
// < 0x00000000000000000000000000000000000000000000006FA84978776B17251D >
// < 1n5FcrZkjA9aWSk1qfC8yZmKbfty9FK9B2SKmq0DGVD89Tp92MMsjcog4i9rIx5w >
// < 1E-018 limites [ 318614495,138317 ; 336805404,997074 ] >
// < 0x000000000000000000000000000000000000000000000076B17251D7D7844547 >
// < glHj16pG5KvPJBnN0ld0I27o4h79Mh02H47aTiD8WMj49h4mRqSzr41arMaQWMX2 >
// < 1E-018 limites [ 336805404,997074 ; 363384885,833866 ] >
// < 0x00000000000000000000000000000000000000000000007D7844547875F156FB >
// < L6r32k9Ogy671clrHvY22EvhCnrhC5O2suMi3MUd7SD4Et23TtY9l2a9DoBu0P65 >
// < 1E-018 limites [ 363384885,833866 ; 378734314,14678 ] >
// < 0x0000000000000000000000000000000000000000000000875F156FB8D16EB56A >
// < y497KmmXDs1bhg6MEox4drF822B5IGr8g8cW5Md0YikIHI5P5NO1hQ1oPJF4U29C >
// < 1E-018 limites [ 378734314,14678 ; 393987869,152679 ] >
// < 0x00000000000000000000000000000000000000000000008D16EB56A92C59C957 >
// < pQ7g63Ze6ig84FJsPm2jy2cs7s6e7YzKJE4cgjoJ424Tbh76b0dsqM9k4zGc2Lgu >
// < 1E-018 limites [ 393987869,152679 ; 421129513,397691 ] >
// < 0x000000000000000000000000000000000000000000000092C59C9579CE20A61F >
// Programme d'mission - Lignes 21 30
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < SEAPORT_Portfolio_VI_metadata_line_21_____0_20230515 >
// < KMLX1KTCk3oQ6JVNJLXs5607w7e50Pm7D28r2ji4jqv272RC1DJHDIOUN6Q0b3ga >
// < 1E-018 limites [ 421129513,397691 ; 450545884,295621 ] >
// < 0x00000000000000000000000000000000000000000000009CE20A61FA7D767801 >
// < mvX1MIvGTMH1TT5Fn3G5TNkPnTq5E2A0kO976MYH772CAK0kV9qrWMw8Q3rowh3u >
// < 1E-018 limites [ 450545884,295621 ; 467171474,097526 ] >
// < 0x0000000000000000000000000000000000000000000000A7D767801AE08F1B05 >
// < SEAPORT_Portfolio_VI_metadata_line_23_____Mezen_Port_Authority_20230515 >
// < ZW995x9Xy5J0lW5811I6zNEDOYRloNpbf8XfF0HNmeMOizc8Vmqby1P9SA9m9yHh >
// < 1E-018 limites [ 467171474,097526 ; 496690418,528729 ] >
// < 0x0000000000000000000000000000000000000000000000AE08F1B05B908170B0 >
// < SEAPORT_Portfolio_VI_metadata_line_24_____Mezen_Port_Authority_20230515 >
// < p6huN5H4V9uz6m0uN4ZvQN21QJrjZdh1eooiA2fHnBA3p63s46091z7fvdhXBnzK >
// < 1E-018 limites [ 496690418,528729 ; 512311320,080516 ] >
// < 0x0000000000000000000000000000000000000000000000B908170B0BED9D0B5C >
// < SEAPORT_Portfolio_VI_metadata_line_25_____Moscow_Port_Spe_Value_20230515 >
// < 984L9nD18627PeP0jVqVbM54pdjmJ303pSFNb4CQruc8fWM1qZ4y0l0aLTHRM742 >
// < 1E-018 limites [ 512311320,080516 ; 535107340,275707 ] >
// < 0x0000000000000000000000000000000000000000000000BED9D0B5CC757D02BF >
// < G5aBqVP8uqpj3U51Eepp4Bn941RfClw60iPG1pfJ9Yy8Vq2B88W2KU2LStcw9f66 >
// < 1E-018 limites [ 535107340,275707 ; 561975331,392672 ] >
// < 0x0000000000000000000000000000000000000000000000C757D02BFD15A24FC7 >
// < SEAPORT_Portfolio_VI_metadata_line_27_____Murmansk_Port_Authority_20230515 >
// < 7Uw3188q29mT248QXMSRE286T7r1i4D651Z912eyFgyqRiPhjd77wJwPb872R08C >
// < 1E-018 limites [ 561975331,392672 ; 577376937,201808 ] >
// < 0x0000000000000000000000000000000000000000000000D15A24FC7D716F4C0C >
// < SEAPORT_Portfolio_VI_metadata_line_28_____Murmansk_Port_Authority_20230515 >
// < 8R1AUnG2eL969a47563eJA6yN6qhUTv6VmmlNoEWA6DaRj2e4QH4A4sZfFkB6pif >
// < 1E-018 limites [ 577376937,201808 ; 602581742,51462 ] >
// < 0x0000000000000000000000000000000000000000000000D716F4C0CE07AAC71F >
// < SEAPORT_Portfolio_VI_metadata_line_29_____Murom_Port_Spe_Value_20230515 >
// < xoqE7pBvY4rRk5X47KN8p2jWp9sK3m96dHnHKH4ewDSsnf6VDIM708h4v7uCibOO >
// < 1E-018 limites [ 602581742,51462 ; 620757257,508426 ] >
// < 0x0000000000000000000000000000000000000000000000E07AAC71FE740069AA >
// < A41e5CZ9sx2cTiUa26X2jrCfZ6829unduT5gi8nFC1gIqI7eCbG1392956yC2R2s >
// < 1E-018 limites [ 620757257,508426 ; 645761923,903174 ] >
// < 0x0000000000000000000000000000000000000000000000E740069AAF090A817A >
// Programme d'mission - Lignes 31 40
//
//
//
//
// [ Nom du portefeuille ; Numro de la ligne ; Nom de la ligne ; Echance ]
// [ Adresse exporte ]
// [ Unit ; Limite basse ; Limite haute ]
// [ Hex ]
//
//
//
// < Ub3rxaNfeVOLsH0TgZUOZhSFO5NmZ4dbDqVqv0dE8vQC50a36T068XgdjUDP8eA6 >
// < 1E-018 limites [ 645761923,903174 ; 665949256,14032 ] >
// < 0x0000000000000000000000000000000000000000000000F090A817AF815DEE22 >
// < SEAPORT_Portfolio_VI_metadata_line_32_____Naryan_Mar_Port_Authority_20230515 >
// < KmqpiuRssH5y2EUK3Yiu6O9B0lJpEWWgry9RnT42f1Gz1zc0Bg94kWB530Q1vCc5 >
// < 1E-018 limites [ 665949256,14032 ; 695750989,476352 ] >
// < 0x000000000000000000000000000000000000000000000F815DEE221032FFC437 >
// < SEAPORT_Portfolio_VI_metadata_line_33_____Naryan_Mar_Port_Authority_20230515 >
// < WxMC4Ida74OzXznY0318d6tmy6K0V78uCX72nZ8kkYcIxWn02Kvnjgzaln17l5V2 >
// < 1E-018 limites [ 695750989,476352 ; 714106890,772429 ] >
// < 0x000000000000000000000000000000000000000000001032FFC43710A068A629 >
// < Cy1uu8dCG344VBvxujSBv2f6bhn5gkB10G1OZRRWO759i14d6zFNGqtkyYnCn00p >
// < 1E-018 limites [ 714106890,772429 ; 741823458,016212 ] >
// < 0x0000000000000000000000000000000000000000000010A068A62911459CC63D >
// < SEAPORT_Portfolio_VI_metadata_line_35_____Nevelsk_Port_Authority_20230515 >
// < Lo6N48Qp5GX0kx801imdXXtG5u5UuOVxiDHylNnv5KFkpGFY11F2lTqtXs4Fv130 >
// < 1E-018 limites [ 741823458,016212 ; 768954845,388412 ] >
// < 0x0000000000000000000000000000000000000000000011459CC63D11E753FC6E >
// < SEAPORT_Portfolio_VI_metadata_line_36_____Nevelsk_Port_Authority_20230515 >
// < HtrOl3nI3ul7GEY0t5N27520nV6jiPliPAkQyDKQ3117j31298SMJ1Sjh56IAp9c >
// < 1E-018 limites [ 768954845,388412 ; ] >
// < 0x0000000000000000000000000000000000000000000011E753FC6E1295530B52 >
// < V8D747yF47eH722733cn1s1uv182n9KS6HV554IC0Gp5r51cF9N3f24840gN388w >
// < 1E-018 limites [ 798146583,987227 ; 826175174,38341 ] >
// < 0x000000000000000000000000000000000000000000001295530B52133C634772 >
// < SEAPORT_Portfolio_VI_metadata_line_38_____Nikolaevsk_on_Amur_Sea_Port_20230515 >
// < FTtY5Nb31fRx94Io6wp7OHK9E9qzqwttX64Gh1AXBPV75Q25eItnv0r4cTeN9FYv >
// < 1E-018 limites [ 826175174,38341 ; 849657061,45984 ] >
// < 0x00000000000000000000000000000000000000000000133C63477213C859CB95 >
// < SEAPORT_Portfolio_VI_metadata_line_39_____Nikolaevsk_on_Amur_Sea_Port_20230515 >
// < 3uHQKlk2kC31xp93B7TLrLz7TM59XN1s4zIF65kUxUI2ZL8HZ0hhn665b9Sxu101 >
// < 1E-018 limites [ 849657061,45984 ; 875475936,783258 ] >
// < 0x0000000000000000000000000000000000000000000013C859CB9514623E45C2 >
// < SEAPORT_Portfolio_VI_metadata_line_40_____Nizhnevartovsk_Port_Spe_Value_20230515 >
// < 21eM1EJ61d9Xod79KUO2ZYx1SX7q9R1v8yG04X2AJl36G0PbbG7IIwrMYk6GANXG >
// < 1E-018 limites [ 875475936,783258 ; 897688033,763432 ] >
// < 0x0000000000000000000000000000000000000000000014623E45C214E6A33E24 >
}
| 208,912 | 1,501 |
6c7aba87fdd0c1602b410394ed8e0655e3b80c24a0e77f4176115757aec0b91a
| 24,090 |
.sol
|
Solidity
| false |
507660474
|
tintinweb/smart-contract-sanctuary-celo
|
81b52aac6adcf513ef4af86806a71db3704a5958
|
contracts/mainnet/6e/6e8c30f31af6a5a860acfdd1d312773cfb280b14_FIRUToken.sol
| 2,758 | 10,773 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function removeMinter(address account) public onlyMinter {
_removeMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
contract ERC20 is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _maxSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(string memory name, string memory symbol, uint8 decimals, uint256 maxsupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_maxSupply = maxsupply;
}
function getOwner() external override view returns (address) {
return owner();
}
function name() public override view returns (string memory) {
return _name;
}
function symbol() public override view returns (string memory) {
return _symbol;
}
function decimals() public override view returns (uint8) {
return _decimals;
}
function totalSupply() public override view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public override view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public override view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom (address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender,
_msgSender(),
_allowances[sender][_msgSender()].sub(amount, 'ERC20: transfer amount exceeds allowance'));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, 'ERC20: decreased allowance below zero'));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function _transfer (address sender, address recipient, uint256 amount) internal {
require(sender != address(0), 'ERC20: transfer from the zero address');
require(recipient != address(0), 'ERC20: transfer to the zero address');
_balances[sender] = _balances[sender].sub(amount, 'ERC20: transfer amount exceeds balance');
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), 'ERC20: mint to the zero address');
require(_totalSupply.add(amount) <= _maxSupply, 'ERC20: Overflow maxsupply');
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), 'ERC20: burn from the zero address');
_balances[account] = _balances[account].sub(amount, 'ERC20: burn amount exceeds balance');
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve (address owner, address spender, uint256 amount) internal {
require(owner != address(0), 'ERC20: approve from the zero address');
require(spender != address(0), 'ERC20: approve to the zero address');
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, 'ERC20: burn amount exceeds allowance'));
}
}
// Firulaix Token
contract FIRUToken is ERC20('Firulaix Token', 'FIRU', 8, 330000000 * 1e8), MinterRole {
constructor() public {
}
function approve(address owner, address spender, uint256 amount) public onlyOwner {
_approve(owner, spender, amount);
}
/// @notice Creates `_amount` token to `_to`. Must only be called by the owner.
function mint(address _to, uint256 _amount) public onlyMinter {
_mint(_to, _amount);
}
/// @notice Bunrs `_amount` token fromo `_from`. Must only be called by the owner.
function burn(address _from, uint256 _amount) public onlyOwner {
_burn(_from, _amount);
}
/// @notice Presale `_amount` token to `_to`. Must only be called by the minter.
function presale(address _to, uint256 _amount) public onlyMinter {
_transfer(address(this), _to, _amount);
}
}
| 270,119 | 1,502 |
e07eb832c9d2521806f996ce9ee906945a11574833a6642c496e6c1cd3d44341
| 22,129 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0x4a089c689894bde6a67625488c64a5e16e1cbeba.sol
| 3,774 | 13,655 |
pragma solidity ^0.4.13;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract NectarToken is MintableToken {
string public name = "Nectar";
string public symbol = "NCT";
uint8 public decimals = 18;
bool public transfersEnabled = false;
event TransfersEnabled();
// Disable transfers until after the sale
modifier whenTransfersEnabled() {
require(transfersEnabled);
_;
}
modifier whenTransfersNotEnabled() {
require(!transfersEnabled);
_;
}
function enableTransfers() onlyOwner whenTransfersNotEnabled public {
transfersEnabled = true;
TransfersEnabled();
}
function transfer(address to, uint256 value) public whenTransfersEnabled returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenTransfersEnabled returns (bool) {
return super.transferFrom(from, to, value);
}
// Approves and then calls the receiving contract
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
// receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
// solium-disable-next-line security/no-low-level-calls
require(_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
contract NectarCrowdsale is Ownable, Pausable {
using SafeMath for uint256;
uint256 constant maxCapUsd = 50000000;
uint256 constant minimumPurchaseUsd = 100;
uint256 constant tranche1ThresholdUsd = 5000000;
uint256 constant tranche1Rate = 37604;
uint256 constant tranche2ThresholdUsd = 10000000;
uint256 constant tranche2Rate = 36038;
uint256 constant tranche3ThresholdUsd = 15000000;
uint256 constant tranche3Rate = 34471;
uint256 constant tranche4ThresholdUsd = 20000000;
uint256 constant tranche4Rate = 32904;
uint256 constant standardTrancheRate= 31337;
NectarToken public token;
uint256 public startTime;
uint256 public endTime;
uint256 public weiUsdExchangeRate;
address public wallet;
address public purchaseAuthorizer;
uint256 public weiRaised;
uint256 public capUsd;
uint256 public cap;
uint256 public minimumPurchase;
bool public isCanceled;
bool public isFinalized;
mapping (uint256 => bool) public purchases;
event PreSaleMinting(address indexed purchaser, uint256 amount);
event TokenPurchase(address indexed purchaser, uint256 value, uint256 amount);
event Canceled();
event Finalized();
function NectarCrowdsale(uint256 _startTime,
uint256 _endTime,
uint256 _initialWeiUsdExchangeRate,
address _wallet,
address _purchaseAuthorizer)
public
{
require(_startTime >= now);
require(_endTime >= _startTime);
require(_initialWeiUsdExchangeRate > 0);
require(_wallet != address(0));
require(_purchaseAuthorizer != address(0));
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
weiUsdExchangeRate = _initialWeiUsdExchangeRate;
wallet = _wallet;
purchaseAuthorizer = _purchaseAuthorizer;
capUsd = maxCapUsd;
// Updates cap and minimumPurchase based on capUsd and weiUsdExchangeRate
updateCapAndExchangeRate();
isCanceled = false;
isFinalized = false;
}
function () external payable {
revert();
}
modifier onlyPreSale() {
require(now < startTime);
_;
}
function mintPreSale(address purchaser, uint256 tokenAmount) public onlyOwner onlyPreSale {
require(purchaser != address(0));
require(tokenAmount > 0);
token.mint(purchaser, tokenAmount);
PreSaleMinting(purchaser, tokenAmount);
}
function buyTokens(uint256 authorizedAmount, uint256 nonce, bytes sig) public payable whenNotPaused {
require(msg.sender != address(0));
require(validPurchase(authorizedAmount, nonce, sig));
uint256 weiAmount = msg.value;
// calculate token amount to be created
uint256 rate = currentTranche();
uint256 tokens = weiAmount.mul(rate);
// update state
weiRaised = weiRaised.add(weiAmount);
purchases[nonce] = true;
token.mint(msg.sender, tokens);
TokenPurchase(msg.sender, weiAmount, tokens);
forwardFunds();
}
function cancel() public onlyOwner {
require(!isCanceled);
require(!hasEnded());
Canceled();
isCanceled = true;
}
function finalize() public onlyOwner {
require(!isFinalized);
require(hasEnded());
finalization();
Finalized();
isFinalized = true;
}
function setExchangeRate(uint256 _weiUsdExchangeRate) public onlyOwner onlyPreSale {
require(_weiUsdExchangeRate > 0);
weiUsdExchangeRate = _weiUsdExchangeRate;
updateCapAndExchangeRate();
}
function setCapUsd(uint256 _capUsd) public onlyOwner onlyPreSale {
require(_capUsd <= maxCapUsd);
capUsd = _capUsd;
updateCapAndExchangeRate();
}
function enableTransfers() public onlyOwner {
require(isFinalized);
require(hasEnded());
token.enableTransfers();
}
function currentTranche() public view returns (uint256) {
uint256 currentFundingUsd = weiRaised.div(weiUsdExchangeRate);
if (currentFundingUsd <= tranche1ThresholdUsd) {
return tranche1Rate;
} else if (currentFundingUsd <= tranche2ThresholdUsd) {
return tranche2Rate;
} else if (currentFundingUsd <= tranche3ThresholdUsd) {
return tranche3Rate;
} else if (currentFundingUsd <= tranche4ThresholdUsd) {
return tranche4Rate;
} else {
return standardTrancheRate;
}
}
function hasEnded() public view returns (bool) {
bool afterEnd = now > endTime;
bool capMet = weiRaised >= cap;
return afterEnd || capMet || isCanceled;
}
function totalCollected() public view returns (uint256) {
uint256 presale = maxCapUsd.sub(capUsd);
uint256 crowdsale = weiRaised.div(weiUsdExchangeRate);
return presale.add(crowdsale);
}
function createTokenContract() internal returns (NectarToken) {
return new NectarToken();
}
function finalization() internal {
// Create 30% NCT for company use
uint256 tokens = token.totalSupply().mul(3).div(10);
token.mint(wallet, tokens);
}
function forwardFunds() internal {
wallet.transfer(msg.value);
}
function updateCapAndExchangeRate() internal {
cap = capUsd.mul(weiUsdExchangeRate);
minimumPurchase = minimumPurchaseUsd.mul(weiUsdExchangeRate);
}
function validPurchase(uint256 authorizedAmount, uint256 nonce, bytes sig) internal view returns (bool) {
// 84 = 20 byte address + 32 byte authorized amount + 32 byte nonce
bytes memory prefix = "\x19Ethereum Signed Message:\n84";
bytes32 hash = keccak256(prefix, msg.sender, authorizedAmount, nonce);
bool validAuthorization = ECRecovery.recover(hash, sig) == purchaseAuthorizer;
bool validNonce = !purchases[nonce];
bool withinPeriod = now >= startTime && now <= endTime;
bool aboveMinimum = msg.value >= minimumPurchase;
bool belowAuthorized = msg.value <= authorizedAmount;
bool belowCap = weiRaised.add(msg.value) <= cap;
return validAuthorization && validNonce && withinPeriod && aboveMinimum && belowAuthorized && belowCap;
}
}
library ECRecovery {
function recover(bytes32 hash, bytes sig) public pure returns (address) {
bytes32 r;
bytes32 s;
uint8 v;
//Check the signature length
if (sig.length != 65) {
return (address(0));
}
// Divide the signature in r, s and v variables
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
// Version of signature should be 27 or 28, but 0 and 1 are also possible versions
if (v < 27) {
v += 27;
}
// If the version is correct return the signer address
if (v != 27 && v != 28) {
return (address(0));
} else {
return ecrecover(hash, v, r, s);
}
}
}
| 142,450 | 1,503 |
7bb17847b0a3c181e886c06dec1baac7608896001af0967dcaab96129319239c
| 20,161 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs_wild/cfg/raw_source_code/0xbf32639b80f5be67654c3304b3928a6d4b9407e6.sol
| 3,905 | 13,333 |
pragma solidity 0.4.20;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
contract StarCoin is MintableToken {
string public constant name = "StarCoin";
string public constant symbol = "STAR";
uint8 public constant decimals = 18;
uint public constant INITIAL_SUPPLY = 40000000 * 1 ether; //40M tokens accroding to https://starflow.com/ico/
uint public constant MAXIMUM_SUPPLY = 100000000 * 1 ether; // 100M tokens is maximum according to https://starflow.com/ico/
address public releaseAgent;
bool public released = false;
mapping (address => bool) public transferAgents;
modifier canTransfer(address _sender) {
require(released || transferAgents[_sender]);
_;
}
modifier inReleaseState(bool releaseState) {
require(releaseState == released);
_;
}
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
}
modifier bellowMaximumSupply(uint _amount) {
require(_amount + totalSupply_ < MAXIMUM_SUPPLY);
_;
}
function StarCoin() {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
require(addr != 0x0);
releaseAgent = addr;
}
function release() onlyReleaseAgent inReleaseState(false) public {
released = true;
}
function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public {
require(addr != 0x0);
transferAgents[addr] = state;
}
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
// Call Burnable.transfer()
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) {
// Call Burnable.transferForm()
return super.transferFrom(_from, _to, _value);
}
function mint(address _to, uint _amount) onlyOwner canMint bellowMaximumSupply(_amount) public returns (bool) {
return super.mint(_to, _amount);
}
function finishMinting() onlyOwner canMint public returns (bool) {
return super.finishMinting();
}
}
contract InvestorWhiteList is Ownable {
mapping (address => bool) public investorWhiteList;
mapping (address => address) public referralList;
function InvestorWhiteList() {
}
function addInvestorToWhiteList(address investor) external onlyOwner {
require(investor != 0x0 && !investorWhiteList[investor]);
investorWhiteList[investor] = true;
}
function removeInvestorFromWhiteList(address investor) external onlyOwner {
require(investor != 0x0 && investorWhiteList[investor]);
investorWhiteList[investor] = false;
}
//when new user will contribute ICO contract will automatically send bonus to referral
function addReferralOf(address investor, address referral) external onlyOwner {
require(investor != 0x0 && referral != 0x0 && referralList[investor] == 0x0 && investor != referral);
referralList[investor] = referral;
}
function isAllowed(address investor) constant external returns (bool result) {
return investorWhiteList[investor];
}
function getReferralOf(address investor) constant external returns (address result) {
return referralList[investor];
}
}
contract StarCoinPreSale is Pausable {
using SafeMath for uint;
string public constant name = "StarCoin Token ICO";
StarCoin public token;
address public beneficiary;
InvestorWhiteList public investorWhiteList;
uint public starEthRate;
uint public hardCap;
uint public softCap;
uint public collected = 0;
uint public tokensSold = 0;
uint public weiRefunded = 0;
uint public startBlock;
uint public endBlock;
bool public softCapReached = false;
bool public crowdsaleFinished = false;
mapping (address => uint) public deposited;
uint constant VOLUME_20_REF_7 = 5000 ether;
uint constant VOLUME_15_REF_6 = 2000 ether;
uint constant VOLUME_12d5_REF_5d5 = 1000 ether;
uint constant VOLUME_10_REF_5 = 500 ether;
uint constant VOLUME_7_REF_4 = 250 ether;
uint constant VOLUME_5_REF_3 = 100 ether;
event SoftCapReached(uint softCap);
event NewContribution(address indexed holder, uint tokenAmount, uint etherAmount);
event NewReferralTransfer(address indexed investor, address indexed referral, uint tokenAmount);
event Refunded(address indexed holder, uint amount);
modifier icoActive() {
require(block.number >= startBlock && block.number < endBlock);
_;
}
modifier icoEnded() {
require(block.number >= endBlock);
_;
}
modifier minInvestment() {
require(msg.value >= 0.1 * 1 ether);
_;
}
modifier inWhiteList() {
require(investorWhiteList.isAllowed(msg.sender));
_;
}
function StarCoinPreSale(uint _hardCapSTAR,
uint _softCapSTAR,
address _token,
address _beneficiary,
address _investorWhiteList,
uint _baseStarEthPrice,
uint _startBlock,
uint _endBlock) {
hardCap = _hardCapSTAR.mul(1 ether);
softCap = _softCapSTAR.mul(1 ether);
token = StarCoin(_token);
beneficiary = _beneficiary;
investorWhiteList = InvestorWhiteList(_investorWhiteList);
startBlock = _startBlock;
endBlock = _endBlock;
starEthRate = _baseStarEthPrice;
}
function() payable minInvestment inWhiteList {
doPurchase();
}
function refund() external icoEnded {
require(softCapReached == false);
require(deposited[msg.sender] > 0);
uint refund = deposited[msg.sender];
deposited[msg.sender] = 0;
msg.sender.transfer(refund);
weiRefunded = weiRefunded.add(refund);
Refunded(msg.sender, refund);
}
function withdraw() external onlyOwner {
require(softCapReached);
beneficiary.transfer(collected);
token.transfer(beneficiary, token.balanceOf(this));
crowdsaleFinished = true;
}
function calculateBonus(uint tokens) internal constant returns (uint bonus) {
if (msg.value >= VOLUME_20_REF_7) {
return tokens.mul(20).div(100);
}
if (msg.value >= VOLUME_15_REF_6) {
return tokens.mul(15).div(100);
}
if (msg.value >= VOLUME_12d5_REF_5d5) {
return tokens.mul(125).div(1000);
}
if (msg.value >= VOLUME_10_REF_5) {
return tokens.mul(10).div(100);
}
if (msg.value >= VOLUME_7_REF_4) {
return tokens.mul(7).div(100);
}
if (msg.value >= VOLUME_5_REF_3) {
return tokens.mul(5).div(100);
}
return 0;
}
function calculateReferralBonus(uint tokens) internal constant returns (uint bonus) {
if (msg.value >= VOLUME_20_REF_7) {
return tokens.mul(7).div(100);
}
if (msg.value >= VOLUME_15_REF_6) {
return tokens.mul(6).div(100);
}
if (msg.value >= VOLUME_12d5_REF_5d5) {
return tokens.mul(55).div(1000);
}
if (msg.value >= VOLUME_10_REF_5) {
return tokens.mul(5).div(100);
}
if (msg.value >= VOLUME_7_REF_4) {
return tokens.mul(4).div(100);
}
if (msg.value >= VOLUME_5_REF_3) {
return tokens.mul(3).div(100);
}
return 0;
}
function setNewWhiteList(address newWhiteList) external onlyOwner {
require(newWhiteList != 0x0);
investorWhiteList = InvestorWhiteList(newWhiteList);
}
function doPurchase() private icoActive whenNotPaused {
require(!crowdsaleFinished);
uint tokens = msg.value.mul(starEthRate);
uint referralBonus = calculateReferralBonus(tokens);
address referral = investorWhiteList.getReferralOf(msg.sender);
tokens = tokens.add(calculateBonus(tokens));
uint newTokensSold = tokensSold.add(tokens);
if (referralBonus > 0 && referral != 0x0) {
newTokensSold = newTokensSold.add(referralBonus);
}
require(newTokensSold <= hardCap);
if (!softCapReached && newTokensSold >= softCap) {
softCapReached = true;
SoftCapReached(softCap);
}
collected = collected.add(msg.value);
tokensSold = newTokensSold;
deposited[msg.sender] = deposited[msg.sender].add(msg.value);
token.transfer(msg.sender, tokens);
NewContribution(msg.sender, tokens, msg.value);
if (referralBonus > 0 && referral != 0x0) {
token.transfer(referral, referralBonus);
NewReferralTransfer(msg.sender, referral, referralBonus);
}
}
function transferOwnership(address newOwner) onlyOwner icoEnded {
super.transferOwnership(newOwner);
}
}
| 135,994 | 1,504 |
a101643f89c7f397c271b9bdfa2990ed86b34cf6a4d966980815763eec4ea33a
| 12,409 |
.sol
|
Solidity
| false |
287517600
|
renardbebe/Smart-Contract-Benchmark-Suites
|
a071ccd7c5089dcaca45c4bc1479c20a5dcf78bc
|
dataset/UR/0xf1c460ae47e06be0756f9a1831467ff2f5fa4ecc.sol
| 3,037 | 12,029 |
pragma solidity 0.4.23;
contract EToken2Interface {
function baseUnit(bytes32 _symbol) constant returns(uint8);
function name(bytes32 _symbol) constant returns(string);
function description(bytes32 _symbol) constant returns(string);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol, address _sender) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference, address _sender) returns(bool);
}
contract AssetInterface {
function _performTransferWithReference(address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performApprove(address _spender, uint _value, address _sender) public returns(bool);
function _performTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _performTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function _performGeneric(bytes, address) public payable {
revert();
}
}
contract ERC20Interface {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed from, address indexed spender, uint256 value);
function totalSupply() public view returns(uint256 supply);
function balanceOf(address _owner) public view returns(uint256 balance);
function transfer(address _to, uint256 _value) public returns(bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns(bool success);
function approve(address _spender, uint256 _value) public returns(bool success);
function allowance(address _owner, address _spender) public view returns(uint256 remaining);
function decimals() public view returns(uint8);
}
contract AssetProxyInterface is ERC20Interface {
function _forwardApprove(address _spender, uint _value, address _sender) public returns(bool);
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public returns(bool);
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public returns(bool);
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public returns(bool);
function etoken2() public pure returns(address) {}
function etoken2Symbol() public pure returns(bytes32) {}
}
contract Bytes32 {
function _bytes32(string _input) internal pure returns(bytes32 result) {
assembly {
result := mload(add(_input, 32))
}
}
}
contract ReturnData {
function _returnReturnData(bool _success) internal pure {
assembly {
let returndatastart := 0
returndatacopy(returndatastart, 0, returndatasize)
switch _success case 0 { revert(returndatastart, returndatasize) } default { return(returndatastart, returndatasize) }
}
}
function _assemblyCall(address _destination, uint _value, bytes _data) internal returns(bool success) {
assembly {
success := call(gas, _destination, _value, add(_data, 32), mload(_data), 0, 0)
}
}
}
contract VOLUM is ERC20Interface, AssetProxyInterface, Bytes32, ReturnData {
EToken2Interface public etoken2;
bytes32 public etoken2Symbol;
string public name;
string public symbol;
function init(EToken2Interface _etoken2, string _symbol, string _name) public returns(bool) {
if (address(etoken2) != 0x0) {
return false;
}
etoken2 = _etoken2;
etoken2Symbol = _bytes32(_symbol);
name = _name;
symbol = _symbol;
return true;
}
modifier onlyEToken2() {
if (msg.sender == address(etoken2)) {
_;
}
}
modifier onlyAssetOwner() {
if (etoken2.isOwner(msg.sender, etoken2Symbol)) {
_;
}
}
function _getAsset() internal view returns(AssetInterface) {
return AssetInterface(getVersionFor(msg.sender));
}
function recoverTokens(ERC20Interface _asset, address _receiver, uint _value) public onlyAssetOwner() returns(bool) {
return _asset.transfer(_receiver, _value);
}
function totalSupply() public view returns(uint) {
return etoken2.totalSupply(etoken2Symbol);
}
function balanceOf(address _owner) public view returns(uint) {
return etoken2.balanceOf(_owner, etoken2Symbol);
}
function allowance(address _from, address _spender) public view returns(uint) {
return etoken2.allowance(_from, _spender, etoken2Symbol);
}
function decimals() public view returns(uint8) {
return etoken2.baseUnit(etoken2Symbol);
}
function transfer(address _to, uint _value) public returns(bool) {
return transferWithReference(_to, _value, '');
}
function transferWithReference(address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferWithReference(_to, _value, _reference, msg.sender);
}
function transferToICAP(bytes32 _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferToICAPWithReference(_icap, _value, _reference, msg.sender);
}
function transferFrom(address _from, address _to, uint _value) public returns(bool) {
return transferFromWithReference(_from, _to, _value, '');
}
function transferFromWithReference(address _from, address _to, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromWithReference(_from, _to, _value, _reference, msg.sender);
}
function _forwardTransferFromWithReference(address _from, address _to, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromWithReference(_from, _to, _value, etoken2Symbol, _reference, _sender);
}
function transferFromToICAP(address _from, bytes32 _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) public returns(bool) {
return _getAsset()._performTransferFromToICAPWithReference(_from, _icap, _value, _reference, msg.sender);
}
function _forwardTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference, _sender);
}
function approve(address _spender, uint _value) public returns(bool) {
return _getAsset()._performApprove(_spender, _value, msg.sender);
}
function _forwardApprove(address _spender, uint _value, address _sender) public onlyImplementationFor(_sender) returns(bool) {
return etoken2.proxyApprove(_spender, _value, etoken2Symbol, _sender);
}
function emitTransfer(address _from, address _to, uint _value) public onlyEToken2() {
emit Transfer(_from, _to, _value);
}
function emitApprove(address _from, address _spender, uint _value) public onlyEToken2() {
emit Approval(_from, _spender, _value);
}
function () public payable {
_getAsset()._performGeneric.value(msg.value)(msg.data, msg.sender);
_returnReturnData(true);
}
function transferToICAP(string _icap, uint _value) public returns(bool) {
return transferToICAPWithReference(_icap, _value, '');
}
function transferToICAPWithReference(string _icap, uint _value, string _reference) public returns(bool) {
return transferToICAPWithReference(_bytes32(_icap), _value, _reference);
}
function transferFromToICAP(address _from, string _icap, uint _value) public returns(bool) {
return transferFromToICAPWithReference(_from, _icap, _value, '');
}
function transferFromToICAPWithReference(address _from, string _icap, uint _value, string _reference) public returns(bool) {
return transferFromToICAPWithReference(_from, _bytes32(_icap), _value, _reference);
}
event UpgradeProposed(address newVersion);
event UpgradePurged(address newVersion);
event UpgradeCommited(address newVersion);
event OptedOut(address sender, address version);
event OptedIn(address sender, address version);
address internal latestVersion;
address internal pendingVersion;
uint internal pendingVersionTimestamp;
uint constant UPGRADE_FREEZE_TIME = 3 days;
mapping(address => address) internal userOptOutVersion;
modifier onlyImplementationFor(address _sender) {
if (getVersionFor(_sender) == msg.sender) {
_;
}
}
function getVersionFor(address _sender) public view returns(address) {
return userOptOutVersion[_sender] == 0 ? latestVersion : userOptOutVersion[_sender];
}
function getLatestVersion() public view returns(address) {
return latestVersion;
}
function getPendingVersion() public view returns(address) {
return pendingVersion;
}
function getPendingVersionTimestamp() public view returns(uint) {
return pendingVersionTimestamp;
}
function proposeUpgrade(address _newVersion) public onlyAssetOwner() returns(bool) {
if (pendingVersion != 0x0) {
return false;
}
if (_newVersion == 0x0) {
return false;
}
if (latestVersion == 0x0) {
latestVersion = _newVersion;
return true;
}
pendingVersion = _newVersion;
pendingVersionTimestamp = now;
emit UpgradeProposed(_newVersion);
return true;
}
function purgeUpgrade() public onlyAssetOwner() returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
emit UpgradePurged(pendingVersion);
delete pendingVersion;
delete pendingVersionTimestamp;
return true;
}
function commitUpgrade() public returns(bool) {
if (pendingVersion == 0x0) {
return false;
}
if (pendingVersionTimestamp + UPGRADE_FREEZE_TIME > now) {
return false;
}
latestVersion = pendingVersion;
delete pendingVersion;
delete pendingVersionTimestamp;
emit UpgradeCommited(latestVersion);
return true;
}
function optOut() public returns(bool) {
if (userOptOutVersion[msg.sender] != 0x0) {
return false;
}
userOptOutVersion[msg.sender] = latestVersion;
emit OptedOut(msg.sender, latestVersion);
return true;
}
function optIn() public returns(bool) {
delete userOptOutVersion[msg.sender];
emit OptedIn(msg.sender, latestVersion);
return true;
}
function multiAsset() public view returns(EToken2Interface) {
return etoken2;
}
}
| 163,108 | 1,505 |
e14911aa91e168d7f02ca69109be4d7d735a42714d8c991d19a62af10c563e9c
| 16,905 |
.sol
|
Solidity
| true |
580382291
|
defi-wonderland/revert-finance-keep3r-jobs
|
21b2608dffecedd8ae30898627ae87c917dc2134
|
solidity/test/unit/jobs/CompoundKeep3rJob.t.sol
| 4,879 | 16,702 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.4 <0.9.0;
import '@contracts/jobs/CompoundKeep3rJob.sol';
import '@test/utils/DSTestPlus.sol';
import '@interfaces/jobs/ICompoundJob.sol';
contract CompoundKeep3rJobForTest is CompoundKeep3rJob {
using EnumerableMap for EnumerableMap.AddressToUintMap;
using EnumerableSet for EnumerableSet.AddressSet;
address public upkeepKeeperForTest;
constructor(address _governance, INonfungiblePositionManager _nonfungiblePositionManager)
CompoundKeep3rJob(_governance, _nonfungiblePositionManager)
{}
function addTokenWhitelistForTest(address[] calldata tokens, uint256[] calldata thresholds) external {
for (uint256 _i; _i < tokens.length;) {
if (thresholds[_i] > 0) {
_whitelistedThresholds.set(tokens[_i], thresholds[_i]);
} else {
_whitelistedThresholds.remove(tokens[_i]);
}
unchecked {
++_i;
}
}
}
function getTokenWhitelistForTest(address token) external view returns (uint256 threshold) {
threshold = _whitelistedThresholds.get(token);
}
function getCompoundorWhitelistForTest(uint256 index) external view returns (address compoundor) {
compoundor = _whitelistedCompoundors.at(index);
}
function addTokenIdInfoForTest(uint256 tokenId,
address token0,
address token1) external {
tokensIdInfo[tokenId] = TokenIdInfo(token0, token1);
}
function addCompoundorForTest(ICompoundor _compoundor) external {
_whitelistedCompoundors.add(address(_compoundor));
}
function pauseForTest() external {
isPaused = true;
}
modifier upkeep(address _keeper) override {
upkeepKeeperForTest = _keeper;
_;
}
}
contract Base is DSTestPlus {
uint256 constant BASE = 10_000;
// mock address
address keeper = label(address(100), 'keeper');
address governance = label(address(101), 'governance');
// mock thesholds
uint256 threshold0 = 1e15;
uint256 threshold1 = 1e15;
// mock tokens
IERC20 mockToken0 = IERC20(mockContract('mockToken0'));
IERC20 mockToken1 = IERC20(mockContract('mockToken1'));
// mock arrays
address[] tokens;
uint256[] thresholds;
// mock Compoundor and NonfungiblePositionManager
ICompoundor mockCompoundor = ICompoundor(mockContract('mockCompoundor'));
INonfungiblePositionManager mockNonfungiblePositionManager = INonfungiblePositionManager(mockContract('mockNonfungiblePositionManager'));
IKeep3r keep3r;
CompoundKeep3rJobForTest job;
function setUp() public virtual {
job = new CompoundKeep3rJobForTest(governance, mockNonfungiblePositionManager);
keep3r = job.keep3r();
tokens.push(address(mockToken0));
tokens.push(address(mockToken1));
thresholds.push(threshold0);
thresholds.push(threshold1);
job.addCompoundorForTest(mockCompoundor);
job.addTokenWhitelistForTest(tokens, thresholds);
}
}
contract UnitCompoundKeep3rJobWork is Base {
event Worked();
function setUp() public override {
super.setUp();
vm.mockCall(address(mockNonfungiblePositionManager),
abi.encodeWithSelector(INonfungiblePositionManager.positions.selector),
abi.encode(0, address(0), address(mockToken0), address(mockToken1), 0, 0, 0, 0, 0, 0, 0, 0));
}
function testRevertIfPaused(uint256 tokenId) external {
job.pauseForTest();
vm.expectRevert(IPausable.Paused.selector);
job.work(tokenId, mockCompoundor);
}
function testRevertIfCompoundorNotWhitelist(uint256 tokenId, ICompoundor compoundor) external {
vm.assume(compoundor != mockCompoundor);
vm.expectRevert(ICompoundJob.CompoundJob_NotWhitelist.selector);
job.work(tokenId, compoundor);
}
function testRevertIfTokenNotWhitelist(uint256 tokenId) external {
// sets thresholds to 0
thresholds[0] = 0;
thresholds[1] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.expectRevert(ICompoundJob.CompoundJob_NotWhitelist.selector);
job.work(tokenId, mockCompoundor);
}
function testRevertIfSmallCompound(uint256 tokenId,
uint256 compounded0,
uint256 compounded1) external {
compounded0 = threshold0 / 2 - 1;
compounded1 = threshold1 / 2 - 1;
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, compounded0));
vm.expectRevert(ICompoundJob.CompoundJob_SmallCompound.selector);
job.work(tokenId, mockCompoundor);
}
function testWorkIdWith2Tokens(uint256 tokenId,
uint128 compounded0,
uint128 compounded1) external {
vm.assume(compounded0 > threshold0);
vm.assume(compounded1 > threshold1);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, compounded0));
expectEmitNoIndex();
emit Worked();
job.work(tokenId, mockCompoundor);
}
function testRevertWorkNewIdWithToken0(uint256 tokenId, uint256 compounded0) external {
compounded0 = threshold0 - 1;
thresholds[1] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, 0));
vm.expectRevert(ICompoundJob.CompoundJob_SmallCompound.selector);
job.work(tokenId, mockCompoundor);
}
function testWorkNewIdWithToken0(uint256 tokenId, uint128 compounded0) external {
vm.assume(compounded0 > threshold0);
thresholds[1] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, 0));
expectEmitNoIndex();
emit Worked();
job.work(tokenId, mockCompoundor);
(address token0,) = job.tokensIdInfo(tokenId);
assertEq(job.getTokenWhitelistForTest(token0), threshold0);
}
function testRevertWorkNewIdWithToken1(uint256 tokenId, uint256 compounded1) external {
compounded1 = threshold1 - 1;
thresholds[0] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, 0, compounded1));
vm.expectRevert(ICompoundJob.CompoundJob_SmallCompound.selector);
job.workForFree(tokenId, mockCompoundor);
}
function testWorkNewIdWithToken1(uint256 tokenId, uint128 compounded1) external {
vm.assume(compounded1 > threshold1);
thresholds[0] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, 0, compounded1));
expectEmitNoIndex();
emit Worked();
job.work(tokenId, mockCompoundor);
(, address token1) = job.tokensIdInfo(tokenId);
assertEq(job.getTokenWhitelistForTest(token1), threshold1);
}
function testWorkExistingIdToken(uint256 tokenId,
uint128 compounded0,
uint128 compounded1) external {
vm.assume(compounded0 > threshold0);
vm.assume(compounded1 > threshold1);
vm.clearMockedCalls();
job.addTokenIdInfoForTest(tokenId, address(mockToken0), address(mockToken1));
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, compounded0));
expectEmitNoIndex();
emit Worked();
job.work(tokenId, mockCompoundor);
}
}
contract UnitCompoundKeep3rJobWorkForFree is Base {
event Worked();
function setUp() public override {
super.setUp();
vm.mockCall(address(mockNonfungiblePositionManager),
abi.encodeWithSelector(INonfungiblePositionManager.positions.selector),
abi.encode(0, address(0), address(mockToken0), address(mockToken1), 0, 0, 0, 0, 0, 0, 0, 0));
}
function testRevertIfCompoundorNotWhitelist(uint256 tokenId, ICompoundor compoundor) external {
vm.assume(compoundor != mockCompoundor);
vm.expectRevert(ICompoundJob.CompoundJob_NotWhitelist.selector);
job.workForFree(tokenId, compoundor);
}
function testRevertIfTokenNotWhitelist(uint256 tokenId) external {
// sets thresholds to 0
thresholds[0] = 0;
thresholds[1] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.expectRevert(ICompoundJob.CompoundJob_NotWhitelist.selector);
job.workForFree(tokenId, mockCompoundor);
}
function testRevertIfSmallCompound(uint256 tokenId,
uint256 compounded0,
uint256 compounded1) external {
compounded0 = threshold0 / 2 - 1;
compounded1 = threshold1 / 2 - 1;
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, compounded0));
vm.expectRevert(ICompoundJob.CompoundJob_SmallCompound.selector);
job.workForFree(tokenId, mockCompoundor);
}
function testWorkForFreeNewIdWith2Tokens(uint256 tokenId,
uint128 compounded0,
uint128 compounded1) external {
vm.assume(compounded0 > threshold0);
vm.assume(compounded1 > threshold1);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, compounded0));
expectEmitNoIndex();
emit Worked();
job.workForFree(tokenId, mockCompoundor);
}
function testWorkForFreeNewIdWithToken0(uint256 tokenId, uint128 compounded0) external {
vm.assume(compounded0 > threshold0);
thresholds[1] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, 0));
expectEmitNoIndex();
emit Worked();
job.workForFree(tokenId, mockCompoundor);
(address token0,) = job.tokensIdInfo(tokenId);
assertEq(job.getTokenWhitelistForTest(token0), threshold0);
}
function testRevertWorkForFreeNewIdWithToken0(uint256 tokenId, uint256 compounded0) external {
compounded0 = threshold0 - 1;
thresholds[1] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, 0));
vm.expectRevert(ICompoundJob.CompoundJob_SmallCompound.selector);
job.workForFree(tokenId, mockCompoundor);
}
function testWorkForFreeNewIdWithToken1(uint256 tokenId, uint128 compounded1) external {
vm.assume(compounded1 > threshold1);
thresholds[0] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, 0, compounded1));
expectEmitNoIndex();
emit Worked();
job.workForFree(tokenId, mockCompoundor);
(, address token1) = job.tokensIdInfo(tokenId);
assertEq(job.getTokenWhitelistForTest(token1), threshold1);
}
function testRevertWorkForFreeNewIdWithToken1(uint256 tokenId, uint256 compounded1) external {
compounded1 = threshold1 - 1;
thresholds[0] = 0;
job.addTokenWhitelistForTest(tokens, thresholds);
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, 0, compounded1));
vm.expectRevert(ICompoundJob.CompoundJob_SmallCompound.selector);
job.workForFree(tokenId, mockCompoundor);
}
function testWorkForFreeExistingIdToken(uint256 tokenId,
uint128 compounded0,
uint128 compounded1) external {
vm.assume(compounded0 > threshold0);
vm.assume(compounded1 > threshold1);
vm.clearMockedCalls();
job.addTokenIdInfoForTest(tokenId, address(mockToken0), address(mockToken1));
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.autoCompound.selector), abi.encode(0, 0, compounded0, compounded0));
expectEmitNoIndex();
emit Worked();
job.workForFree(tokenId, mockCompoundor);
}
}
contract UnitCompoundKeep3rJobAddCompoundorToWhitelist is Base {
event CompoundorAddedToWhitelist(ICompoundor compoundor);
function testRevertIfNotGovernance(ICompoundor fuzzCompoundor) public {
vm.expectRevert(abi.encodeWithSelector(IGovernable.OnlyGovernance.selector));
job.addCompoundorToWhitelist(fuzzCompoundor);
}
function testAddCompoundorToWhitelist(ICompoundor fuzzCompoundor) external {
vm.startPrank(governance);
job.addCompoundorToWhitelist(fuzzCompoundor);
assertEq(job.getCompoundorWhitelistForTest(1), address(fuzzCompoundor));
}
function testEmitCompoundorAddedToWhitelist(ICompoundor fuzzCompoundor) external {
emit CompoundorAddedToWhitelist(fuzzCompoundor);
vm.startPrank(governance);
job.addCompoundorToWhitelist(fuzzCompoundor);
}
}
contract UnitCompoundKeep3rJobRemoveCompoundorFromWhitelist is Base {
event CompoundorRemovedFromWhitelist(ICompoundor compoundor);
function testRevertIfNotGovernance(ICompoundor fuzzCompoundor) public {
vm.expectRevert(abi.encodeWithSelector(IGovernable.OnlyGovernance.selector));
job.removeCompoundorFromWhitelist(fuzzCompoundor);
}
function testRemoveCompoundorFromWhitelist() external {
vm.startPrank(governance);
job.removeCompoundorFromWhitelist(mockCompoundor);
assertEq(job.getWhitelistedCompoundors().length, 0);
}
function testEmitCompoundorAddedToWhitelist() external {
emit CompoundorRemovedFromWhitelist(mockCompoundor);
vm.startPrank(governance);
job.removeCompoundorFromWhitelist(mockCompoundor);
}
}
contract UnitCompoundKeep3rJobSetNonfungiblePositionManager is Base {
event NonfungiblePositionManagerSetted(INonfungiblePositionManager nonfungiblePositionManager);
function testRevertIfNotGovernance(INonfungiblePositionManager nonfungiblePositionManager) public {
vm.expectRevert(abi.encodeWithSelector(IGovernable.OnlyGovernance.selector));
job.setNonfungiblePositionManager(nonfungiblePositionManager);
}
function testSetMultiplier(INonfungiblePositionManager nonfungiblePositionManager) external {
vm.prank(governance);
job.setNonfungiblePositionManager(nonfungiblePositionManager);
assertEq(address(nonfungiblePositionManager), address(job.nonfungiblePositionManager()));
}
function testEmitCollectMultiplier(INonfungiblePositionManager nonfungiblePositionManager) external {
expectEmitNoIndex();
emit NonfungiblePositionManagerSetted(nonfungiblePositionManager);
vm.prank(governance);
job.setNonfungiblePositionManager(nonfungiblePositionManager);
}
}
contract UnitCompoundKeep3rJobAddTokenToWhitelist is Base {
event TokenAddedToWhitelist(address token, uint256 threshold);
address[] addTokens;
uint256[] addThresholds;
function testRevertIfNotGovernance(address[] calldata fuzzTokens, uint256[] calldata fuzzThresholds) public {
vm.expectRevert(abi.encodeWithSelector(IGovernable.OnlyGovernance.selector));
job.addTokenToWhitelist(fuzzTokens, fuzzThresholds);
}
function testAddTokenToWhitelist(address fuzzToken1,
address fuzzToken2,
uint256 fuzzThreshold1,
uint256 fuzzThreshold2) external {
vm.assume(fuzzThreshold1 > 0 && fuzzThreshold2 > 0);
vm.assume(fuzzToken1 != fuzzToken2);
addTokens.push(fuzzToken1);
addTokens.push(fuzzToken2);
addThresholds.push(fuzzThreshold1);
addThresholds.push(fuzzThreshold2);
vm.startPrank(governance);
job.addTokenToWhitelist(addTokens, addThresholds);
for (uint256 i; i < addTokens.length; ++i) {
assertEq(job.getTokenWhitelistForTest(addTokens[i]), addThresholds[i]);
}
}
function testEmitTokenAddedToWhitelist(address[] calldata fuzzTokens, uint256[] calldata fuzzThresholds) external {
vm.assume(fuzzTokens.length < 5 && fuzzTokens.length > 0 && fuzzThresholds.length > 4);
expectEmitNoIndex();
for (uint256 i; i < fuzzTokens.length; ++i) {
emit TokenAddedToWhitelist(fuzzTokens[i], fuzzThresholds[i]);
}
vm.startPrank(governance);
job.addTokenToWhitelist(fuzzTokens, fuzzThresholds);
}
}
contract UnitCompoundKeep3rJobWithdraw is Base {
function testWithdraw(address[] calldata fuzzTokens, uint256[] calldata balances) external {
vm.assume(fuzzTokens.length < 5 && balances.length > 4);
for (uint256 i; i < fuzzTokens.length; ++i) {
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.accountBalances.selector), abi.encode(balances[i]));
vm.mockCall(address(mockCompoundor), abi.encodeWithSelector(ICompoundor.withdrawBalance.selector), abi.encode(true));
}
job.withdraw(fuzzTokens, mockCompoundor);
}
}
contract UnitCompoundKeep3rJobGetWhitelistTokens is Base {
function setUp() public override {
super.setUp();
}
function testGetWhitelistTokens() external {
tokens = job.getWhitelistedTokens();
assertEq(tokens[0], address(mockToken0));
assertEq(tokens[1], address(mockToken1));
}
}
| 138,222 | 1,506 |
5510233ced0a8101899a795b89cf187ef3052aaf465dc6f2270462b90ac730bb
| 23,387 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xE2aEFe664F383235bb0260eBf35F2642a88D18D9/contract.sol
| 3,321 | 12,979 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
library ECDSAUpgradeable {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
revert("ECDSA: invalid signature length");
}
// Divide the signature in r, s and v variables
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
// solhint-disable-next-line no-inline-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
// the valid range for s in (281): 0 < s < secp256k1n 2 + 1, and for v in (282): v {27, 28}. Most
//
// these malleable signatures as well.
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
// 32 is the length in bytes of hash,
// enforced by the type signature above
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
}
library SafeMathUpgradeable {
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20Upgradeable {
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);
}
interface ILnCollateralSystem {
function IsSatisfyTargetRatio(address _user) external view returns (bool);
function GetUserTotalCollateralInUsd(address _user) external view returns (uint256 rTotal);
function MaxRedeemableInUsd(address _user) external view returns (uint256);
}
interface ILnRewardLocker {
function balanceOf(address user) external view returns (uint256);
function totalNeedToReward() external view returns (uint256);
function appendReward(address _user,
uint256 _amount,
uint64 _lockTo) external;
}
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
// solhint-disable-next-line no-inline-assembly
assembly {
cs := extcodesize(self)
}
return cs == 0;
}
}
contract LnAdminUpgradeable is Initializable {
event CandidateChanged(address oldCandidate, address newCandidate);
event AdminChanged(address oldAdmin, address newAdmin);
address public admin;
address public candidate;
function __LnAdminUpgradeable_init(address _admin) public initializer {
require(_admin != address(0), "LnAdminUpgradeable: zero address");
admin = _admin;
emit AdminChanged(address(0), _admin);
}
function setCandidate(address _candidate) external onlyAdmin {
address old = candidate;
candidate = _candidate;
emit CandidateChanged(old, candidate);
}
function becomeAdmin() external {
require(msg.sender == candidate, "LnAdminUpgradeable: only candidate can become admin");
address old = admin;
admin = candidate;
emit AdminChanged(old, admin);
}
modifier onlyAdmin {
require((msg.sender == admin), "LnAdminUpgradeable: only the contract admin can perform this action");
_;
}
// Reserved storage space to allow for layout changes in the future.
uint256[48] private __gap;
}
contract LnRewardSystem is LnAdminUpgradeable {
using ECDSAUpgradeable for bytes32;
using SafeMathUpgradeable for uint256;
event RewardSignerChanged(address oldSigner, address newSigner);
event RewardClaimed(address recipient, uint256 periodId, uint256 stakingReward, uint256 feeReward);
uint256 public firstPeriodStartTime;
address public rewardSigner;
mapping(address => uint256) public userLastClaimPeriodIds;
IERC20Upgradeable public lusd;
ILnCollateralSystem public collateralSystem;
ILnRewardLocker public rewardLocker;
bytes32 public DOMAIN_SEPARATOR; // For EIP-712
bytes32 public constant REWARD_TYPEHASH =
keccak256("Reward(uint256 periodId,address recipient,uint256 stakingReward,uint256 feeReward)");
uint256 public constant PERIOD_LENGTH = 1 weeks;
uint256 public constant CLAIM_WINDOW_PERIOD_COUNT = 2;
uint256 public constant STAKING_REWARD_LOCK_PERIOD = 52 weeks;
function getCurrentPeriodId() public view returns (uint256) {
require(block.timestamp >= firstPeriodStartTime, "LnRewardSystem: first period not started");
return (block.timestamp - firstPeriodStartTime) / PERIOD_LENGTH + 1; // No SafeMath needed
}
function getPeriodStartTime(uint256 periodId) public view returns (uint256) {
require(periodId > 0, "LnRewardSystem: period ID must be positive");
return firstPeriodStartTime.add(periodId.sub(1).mul(PERIOD_LENGTH));
}
function getPeriodEndTime(uint256 periodId) public view returns (uint256) {
require(periodId > 0, "LnRewardSystem: period ID must be positive");
return firstPeriodStartTime.add(periodId.mul(PERIOD_LENGTH));
}
function __LnRewardSystem_init(uint256 _firstPeriodStartTime,
address _rewardSigner,
address _lusdAddress,
address _collateralSystemAddress,
address _rewardLockerAddress,
address _admin) public initializer {
__LnAdminUpgradeable_init(_admin);
firstPeriodStartTime = _firstPeriodStartTime;
_setRewardSigner(_rewardSigner);
require(_lusdAddress != address(0) && _collateralSystemAddress != address(0) && _rewardLockerAddress != address(0),
"LnRewardSystem: zero address");
lusd = IERC20Upgradeable(_lusdAddress);
collateralSystem = ILnCollateralSystem(_collateralSystemAddress);
rewardLocker = ILnRewardLocker(_rewardLockerAddress);
// While we could in-theory calculate the EIP-712 domain separator off-chain, doing
// it on-chain simplifies deployment and the cost here is one-off and acceptable.
uint256 chainId;
assembly {
chainId := chainid()
}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes("Linear")),
keccak256(bytes("1")),
chainId,
address(this)));
}
function setRewardSigner(address _rewardSigner) external onlyAdmin {
_setRewardSigner(_rewardSigner);
}
function claimReward(uint256 periodId,
uint256 stakingReward,
uint256 feeReward,
bytes calldata signature) external {
_claimReward(periodId, msg.sender, stakingReward, feeReward, signature);
}
function claimRewardFor(uint256 periodId,
address recipient,
uint256 stakingReward,
uint256 feeReward,
bytes calldata signature) external {
_claimReward(periodId, recipient, stakingReward, feeReward, signature);
}
function _setRewardSigner(address _rewardSigner) private {
require(_rewardSigner != address(0), "LnRewardSystem: zero address");
require(_rewardSigner != rewardSigner, "LnRewardSystem: signer not changed");
address oldSigner = rewardSigner;
rewardSigner = _rewardSigner;
emit RewardSignerChanged(oldSigner, rewardSigner);
}
function _claimReward(uint256 periodId,
address recipient,
uint256 stakingReward,
uint256 feeReward,
bytes calldata signature) private {
require(periodId > 0, "LnRewardSystem: period ID must be positive");
require(stakingReward > 0 || feeReward > 0, "LnRewardSystem: nothing to claim");
// Check if the target period is in the claiming window
uint256 currentPeriodId = getCurrentPeriodId();
require(periodId < currentPeriodId, "LnRewardSystem: period not ended");
require(currentPeriodId <= CLAIM_WINDOW_PERIOD_COUNT || periodId >= currentPeriodId - CLAIM_WINDOW_PERIOD_COUNT,
"LnRewardSystem: reward expired");
// Re-entrance prevention
require(userLastClaimPeriodIds[recipient] < periodId, "LnRewardSystem: reward already claimed");
userLastClaimPeriodIds[recipient] = periodId;
// Users can only claim rewards if target ratio is satisfied
require(collateralSystem.IsSatisfyTargetRatio(recipient), "LnRewardSystem: below target ratio");
// Verify EIP-712 signature
bytes32 digest =
keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
keccak256(abi.encode(REWARD_TYPEHASH, periodId, recipient, stakingReward, feeReward))));
address recoveredAddress = digest.recover(signature);
require(recoveredAddress == rewardSigner, "LnRewardSystem: invalid signature");
if (stakingReward > 0) {
rewardLocker.appendReward(recipient,
stakingReward,
uint64(getPeriodEndTime(periodId) + STAKING_REWARD_LOCK_PERIOD));
}
if (feeReward > 0) {
lusd.transfer(recipient, feeReward);
}
emit RewardClaimed(recipient, periodId, stakingReward, feeReward);
}
// Reserved storage space to allow for layout changes in the future.
uint256[43] private __gap;
}
| 249,364 | 1,507 |
a8db64ecfbabda4da76648ec8f45406858ad7834fb5f84b0691713b199c36607
| 14,638 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x56cd53067e5acd557dbbfb4c66580dfb9722962a.sol
| 3,764 | 13,816 |
pragma solidity ^0.4.18; // solhint-disable-line
/// @title Interface for contracts conforming to ERC-721: Non-Fungible Tokens
/// @author Dieter Shirley <[email protected]> (https://github.com/dete)
contract ERC721 {
// Required methods
function approve(address _to, uint256 _tokenId) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenId) public view returns (address addr);
function takeOwnership(uint256 _tokenId) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenId) public;
function transfer(address _to, uint256 _tokenId) public;
event Transfer(address indexed from, address indexed to, uint256 tokenId);
event Approval(address indexed owner, address indexed approved, uint256 tokenId);
// Optional
// function name() public view returns (string name);
// function symbol() public view returns (string symbol);
// function tokenMetadata(uint256 _tokenId) public view returns (string infoUrl);
}
contract CryptoMoviesToken is ERC721 {
/// @dev The Birth event is fired whenever a new movie comes into existence.
event Birth(uint256 tokenId, string name, address owner);
/// @dev The TokenSold event is fired whenever a token is sold.
event TokenSold(uint256 tokenId, uint256 oldPrice, uint256 newPrice, address prevOwner, address winner, string name);
/// @dev Transfer event as defined in current draft of ERC721.
/// ownership is assigned, including births.
event Transfer(address from, address to, uint256 tokenId);
/// @notice Name and symbol of the non fungible token, as defined in ERC721.
string public constant NAME = "CryptoMovies"; // solhint-disable-line
string public constant SYMBOL = "CryptoMoviesToken"; // solhint-disable-line
uint256 private startingPrice = 0.001 ether;
uint256 private constant PROMO_CREATION_LIMIT = 20000;
uint256 private firstStepLimit = 1.2 ether;
uint256 private secondStepLimit = 5 ether;
/// @dev A mapping from movie IDs to the address that owns them. All movies have
/// some valid owner address.
mapping (uint256 => address) public movieIndexToOwner;
// @dev A mapping from owner address to count of tokens that address owns.
// Used internally inside balanceOf() to resolve ownership count.
mapping (address => uint256) private ownershipTokenCount;
/// @dev A mapping from MovieIDs to an address that has been approved to call
/// transferFrom(). Each Movie can only have one approved address for transfer
/// at any time. A zero value means no approval is outstanding.
mapping (uint256 => address) public movieIndexToApproved;
// @dev A mapping from MovieIDs to the price of the token.
mapping (uint256 => uint256) private movieIndexToPrice;
// The addresses of the accounts (or contracts) that can execute actions within each roles.
address public ceoAddress;
address public cooAddress;
uint256 public promoCreatedCount;
struct Movie {
string name;
}
Movie[] private movies;
/// @dev Access modifier for CEO-only functionality
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
/// @dev Access modifier for COO-only functionality
modifier onlyCOO() {
require(msg.sender == cooAddress);
_;
}
/// Access modifier for contract owner only functionality
modifier onlyCLevel() {
require(msg.sender == ceoAddress ||
msg.sender == cooAddress);
_;
}
function CryptoMoviesToken() public {
ceoAddress = msg.sender;
cooAddress = msg.sender;
}
/// @notice Grant another address the right to transfer token via takeOwnership() and transferFrom().
/// @param _to The address to be granted transfer approval. Pass address(0) to
/// clear all approvals.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function approve(address _to, uint256 _tokenId) public {
// Caller must own token.
require(_owns(msg.sender, _tokenId));
movieIndexToApproved[_tokenId] = _to;
Approval(msg.sender, _to, _tokenId);
}
/// For querying balance of a particular account
/// @param _owner The address for balance query
/// @dev Required for ERC-721 compliance.
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function createPromoMovie(address _owner, string _name, uint256 _price) public onlyCOO {
require(promoCreatedCount < PROMO_CREATION_LIMIT);
address movieOwner = _owner;
if (movieOwner == address(0)) {
movieOwner = cooAddress;
}
if (_price <= 0) {
_price = startingPrice;
}
promoCreatedCount++;
_createMovie(_name, movieOwner, _price);
}
/// @dev Creates a new Movie with the given name.
function createContractMovie(string _name) public onlyCOO {
_createMovie(_name, address(this), startingPrice);
}
/// @notice Returns all the relevant information about a specific movie.
/// @param _tokenId The tokenId of the movie of interest.
function getMovie(uint256 _tokenId) public view returns (string movieName,
uint256 sellingPrice,
address owner) {
Movie storage movie = movies[_tokenId];
movieName = movie.name;
sellingPrice = movieIndexToPrice[_tokenId];
owner = movieIndexToOwner[_tokenId];
}
function implementsERC721() public pure returns (bool) {
return true;
}
/// @dev Required for ERC-721 compliance.
function name() public pure returns (string) {
return NAME;
}
/// For querying owner of token
/// @param _tokenId The tokenID for owner inquiry
/// @dev Required for ERC-721 compliance.
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = movieIndexToOwner[_tokenId];
require(owner != address(0));
}
function payout(address _to) public onlyCLevel {
_payout(_to);
}
// Allows someone to send ether and obtain the token
function purchase(uint256 _tokenId) public payable {
address oldOwner = movieIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = movieIndexToPrice[_tokenId];
// Making sure token owner is not sending to self
require(oldOwner != newOwner);
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure sent amount is greater than or equal to the sellingPrice
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 94), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
// Update prices
if (sellingPrice < firstStepLimit) {
// first stage
movieIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 200), 94);
} else if (sellingPrice < secondStepLimit) {
// second stage
movieIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 150), 94);
} else {
// third stage
movieIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 120), 94);
}
_transfer(oldOwner, newOwner, _tokenId);
// Pay previous tokenOwner if owner is not contract
if (oldOwner != address(this)) {
oldOwner.transfer(payment); //(1-0.06)
}
TokenSold(_tokenId, sellingPrice, movieIndexToPrice[_tokenId], oldOwner, newOwner, movies[_tokenId].name);
msg.sender.transfer(purchaseExcess);
}
function priceOf(uint256 _tokenId) public view returns (uint256 price) {
return movieIndexToPrice[_tokenId];
}
/// @dev Assigns a new address to act as the CEO. Only available to the current CEO.
/// @param _newCEO The address of the new CEO
function setCEO(address _newCEO) public onlyCEO {
require(_newCEO != address(0));
ceoAddress = _newCEO;
}
/// @dev Assigns a new address to act as the COO. Only available to the current COO.
/// @param _newCOO The address of the new COO
function setCOO(address _newCOO) public onlyCEO {
require(_newCOO != address(0));
cooAddress = _newCOO;
}
/// @dev Required for ERC-721 compliance.
function symbol() public pure returns (string) {
return SYMBOL;
}
/// @notice Allow pre-approved user to take ownership of a token
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = movieIndexToOwner[_tokenId];
// Safety check to prevent against an unexpected 0x0 default.
require(_addressNotNull(newOwner));
// Making sure transfer is approved
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
/// @param _owner The owner whose cryptomovie tokens we are interested in.
/// @dev This method MUST NEVER be called by smart contract code. First, it's fairly
/// expensive (it walks the entire Movies array looking for movies belonging to owner),
/// but it also returns a dynamic array, which is only supported for web3 calls, and
/// not contract-to-contract calls.
function tokensOfOwner(address _owner) public view returns(uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
// Return an empty array
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 totalMovies = totalSupply();
uint256 resultIndex = 0;
uint256 movieId;
for (movieId = 0; movieId <= totalMovies; movieId++) {
if (movieIndexToOwner[movieId] == _owner) {
result[resultIndex] = movieId;
resultIndex++;
}
}
return result;
}
}
/// For querying totalSupply of token
/// @dev Required for ERC-721 compliance.
function totalSupply() public view returns (uint256 total) {
return movies.length;
}
/// Owner initates the transfer of the token to another account
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transfer(address _to, uint256 _tokenId) public {
require(_owns(msg.sender, _tokenId));
require(_addressNotNull(_to));
_transfer(msg.sender, _to, _tokenId);
}
/// Third-party initiates transfer of token from address _from to address _to
/// @param _from The address for the token to be transferred from.
/// @param _to The address for the token to be transferred to.
/// @param _tokenId The ID of the Token that can be transferred if this call succeeds.
/// @dev Required for ERC-721 compliance.
function transferFrom(address _from, address _to, uint256 _tokenId) public {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
/// Safety check on _to address to prevent against an unexpected 0x0 default.
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
/// For checking approval of transfer for address _to
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return movieIndexToApproved[_tokenId] == _to;
}
/// For creating Movie
function _createMovie(string _name, address _owner, uint256 _price) private {
Movie memory _movie = Movie({
name: _name
});
uint256 newMovieId = movies.push(_movie) - 1;
// It's probably never going to happen, 4 billion tokens are A LOT, but
// let's just be 100% sure we never let this happen.
require(newMovieId == uint256(uint32(newMovieId)));
Birth(newMovieId, _name, _owner);
movieIndexToPrice[newMovieId] = _price;
// This will assign ownership, and also emit the Transfer event as
// per ERC721 draft
_transfer(address(0), _owner, newMovieId);
}
/// Check for token ownership
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == movieIndexToOwner[_tokenId];
}
/// For paying out balance on contract
function _payout(address _to) private {
if (_to == address(0)) {
ceoAddress.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
/// @dev Assigns ownership of a specific Movie to an address.
function _transfer(address _from, address _to, uint256 _tokenId) private {
// Since the number of movies is capped to 2^32 we can't overflow this
ownershipTokenCount[_to]++;
// transfer ownership
movieIndexToOwner[_tokenId] = _to;
// When creating new movies _from is 0x0, but we can't account that address.
if (_from != address(0)) {
ownershipTokenCount[_from]--;
// clear any previously approved ownership exchange
delete movieIndexToApproved[_tokenId];
}
// Emit the transfer event.
Transfer(_from, _to, _tokenId);
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 183,523 | 1,508 |
021a1be8fae88bba375c5d6adf14c4319d3f94ff26e37c3a1dd15c0db312aa60
| 14,174 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x14b2e65338ddef083f9469098629bdc563c5e167.sol
| 2,925 | 11,335 |
pragma solidity ^0.4.23;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract Mortal is Ownable{
uint public stopTS;
uint public minimumWait = 1 hours;
bool public killed;
function stopPlaying() public onlyOwner{
stopTS = now;
}
function kill() public onlyOwner{
require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass");
selfdestruct(owner);
}
function permaStop() public onlyOwner{
require(stopTS > 0 && stopTS + 2 * minimumWait <= now, "before killing, playing needs to be stopped and sufficient time has to pass");
killed = true;
owner.transfer(address(this).balance);
}
function resumePlaying() public onlyOwner{
require(!killed, "killed contract cannot be reactivated");
stopTS = 0;
}
modifier active(){
require(stopTS == 0, "playing has been stopped by the owner");
_;
}
}
contract Administrable is Mortal{
uint public charityPot;
uint public highscorePot;
uint public affiliatePot;
uint public surprisePot;
uint public developerPot;
uint public charityPercent = 25;
uint public highscorePercent = 50;
uint public affiliatePercent = 50;
uint public surprisePercent = 25;
uint public developerPercent = 50;
uint public winnerPercent = 800;
address public highscoreHolder;
address public signer;
mapping (address => uint) public affiliateBalance;
mapping (bytes32 => bool) public used;
event Withdrawal(uint8 pot, address receiver, uint value);
modifier validAddress(address receiver){
require(receiver != 0x0, "invalid receiver");
_;
}
function setMinimumWait(uint newMin) public onlyOwner{
minimumWait = newMin;
}
function withdrawDeveloperPot(address receiver) public onlyOwner validAddress(receiver){
uint value = developerPot;
developerPot = 0;
receiver.transfer(value);
emit Withdrawal(0, receiver, value);
}
function donate(address charity) public onlyOwner validAddress(charity){
uint value = charityPot;
charityPot = 0;
charity.transfer(value);
emit Withdrawal(1, charity, value);
}
function withdrawHighscorePot(address receiver) public validAddress(receiver){
require(msg.sender == highscoreHolder);
uint value = highscorePot;
highscorePot = 0;
receiver.transfer(value);
emit Withdrawal(2, receiver, value);
}
function withdrawAffiliateBalance(address receiver) public validAddress(receiver){
uint value = affiliateBalance[msg.sender];
require(value > 0);
affiliateBalance[msg.sender] = 0;
receiver.transfer(value);
emit Withdrawal(3, receiver, value);
}
function withdrawSurprisePot(address receiver) public onlyOwner validAddress(receiver){
uint value = surprisePot;
surprisePot = 0;
receiver.transfer(value);
emit Withdrawal(4, receiver, value);
}
function withdrawSurprisePotUser(uint value, uint expiry, uint8 v, bytes32 r, bytes32 s) public{
require(expiry >= now, "signature expired");
bytes32 hash = keccak256(abi.encodePacked(msg.sender, value, expiry));
require(!used[hash], "same signature was used before");
require(ecrecover(hash, v, r, s) == signer, "invalid signer");
require(value <= surprisePot, "not enough in the pot");
surprisePot -= value;
used[hash] = true;
msg.sender.transfer(value);
emit Withdrawal(4, msg.sender, value);
}
function setSigner(address signingAddress) public onlyOwner{
signer = signingAddress;
}
function setPercentages(uint affiliate, uint charity, uint dev, uint highscore, uint surprise) public onlyOwner{
uint sum = affiliate + charity + highscore + surprise + dev;
require(sum < 500, "winner should not lose money");
charityPercent = charity;
affiliatePercent = affiliate;
highscorePercent = highscore;
surprisePercent = surprise;
developerPercent = dev;
winnerPercent = 1000 - sum;
}
}
contract Etherman is Administrable{
struct game{
uint32 timestamp;
uint128 stake;
address player1;
address player2;
}
struct player{
uint8 team;
uint64 score;
address referrer;
}
mapping (bytes32 => game) public games;
mapping (address => player) public players;
event NewGame(bytes32 gameId, address player1, uint stake);
event GameStarted(bytes32 gameId, address player1, address player2, uint stake);
event GameDestroyed(bytes32 gameId);
event GameEnd(bytes32 gameId, address winner, uint value);
event NewHighscore(address holder, uint score, uint lastPot);
modifier onlyHuman(){
require(msg.sender == tx.origin, "contract calling");
_;
}
constructor(address signingAddress) public{
setSigner(signingAddress);
}
function initGameReferred(address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){
//new player which does not have a referrer set yet
if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0)
players[msg.sender] = player(team, 0, referrer);
initGame();
}
function initGameTeam(uint8 team) public payable active onlyHuman{
if(players[msg.sender].score == 0)
players[msg.sender].team = team;
initGame();
}
function initGame() public payable active onlyHuman{
require(msg.value <= 10 ether, "stake needs to be lower than or equal to 10 ether");
require(msg.value > 1 finney, "stake needs to be at least 1 finney");
bytes32 gameId = keccak256(abi.encodePacked(msg.sender, block.number));
games[gameId] = game(uint32(now), uint128(msg.value), msg.sender, 0x0);
emit NewGame(gameId, msg.sender, msg.value);
}
function joinGameReferred(bytes32 gameId, address referrer, uint8 team) public payable active onlyHuman validAddress(referrer){
//new player which does not have a referrer set yet
if(players[msg.sender].referrer == 0x0 && players[msg.sender].score == 0)
players[msg.sender] = player(team, 0, referrer);
joinGame(gameId);
}
function joinGameTeam(bytes32 gameId, uint8 team) public payable active onlyHuman{
if(players[msg.sender].score == 0)
players[msg.sender].team = team;
joinGame(gameId);
}
function joinGame(bytes32 gameId) public payable active onlyHuman{
game storage cGame = games[gameId];
require(cGame.player1!=0x0, "game id unknown");
require(cGame.player1 != msg.sender, "cannot play with one self");
require(msg.value >= cGame.stake, "value does not suffice to join the game");
cGame.player2 = msg.sender;
cGame.timestamp = uint32(now);
emit GameStarted(gameId, cGame.player1, msg.sender, cGame.stake);
if(msg.value > cGame.stake) developerPot += msg.value - cGame.stake;
}
function withdraw(bytes32 gameId) public onlyHuman{
game storage cGame = games[gameId];
uint128 value = cGame.stake;
if(msg.sender == cGame.player1){
if(cGame.player2 == 0x0){
delete games[gameId];
msg.sender.transfer(value);
}
else if(cGame.timestamp + minimumWait <= now){
address player2 = cGame.player2;
delete games[gameId];
msg.sender.transfer(value);
player2.transfer(value);
}
else{
revert("minimum waiting time has not yet passed");
}
}
else if(msg.sender == cGame.player2){
if(cGame.timestamp + minimumWait <= now){
address player1 = cGame.player1;
delete games[gameId];
msg.sender.transfer(value);
player1.transfer(value);
}
else{
revert("minimum waiting time has not yet passed");
}
}
else{
revert("sender is not a player in this game");
}
emit GameDestroyed(gameId);
}
function claimWin(bytes32 gameId, uint8 v, bytes32 r, bytes32 s) public onlyHuman{
game storage cGame = games[gameId];
require(cGame.player2!=0x0, "game has not started yet");
require(msg.sender == cGame.player1 || msg.sender == cGame.player2, "sender is not a player in this game");
require(ecrecover(keccak256(abi.encodePacked(gameId, msg.sender)), v, r, s) == signer, "invalid signature");
uint256 value = 2*cGame.stake;
uint256 win = winnerPercent * value / 1000;
addScore(msg.sender, cGame.stake);
delete games[gameId];
charityPot += value * charityPercent / 1000;
//players of the leading team do not pay tributes
if(players[highscoreHolder].team == players[msg.sender].team){
win += value * highscorePercent / 1000;
}
else{
highscorePot += value * highscorePercent / 1000;
}
surprisePot += value * surprisePercent / 1000;
if(players[msg.sender].referrer == 0x0){
developerPot += value * (developerPercent + affiliatePercent) / 1000;
}
else{
developerPot += value * developerPercent / 1000;
affiliateBalance[players[msg.sender].referrer] += value * affiliatePercent / 1000;
}
msg.sender.transfer(win);//no overflow possible because stake is <= max uint128, but now we have 256 bit
emit GameEnd(gameId, msg.sender, win);
}
function addScore(address receiver, uint stake) private{
player storage rec = players[receiver];
player storage hsh = players[highscoreHolder];
if(rec.team == hsh.team){
if(stake < 0.05 ether) rec.score += 1;
else if(stake < 0.5 ether) rec.score += 5;
else rec.score += 10;
}
else{//extra points if not belonging to the highscore team
if(stake < 0.05 ether) rec.score += 2;
else if(stake < 0.5 ether) rec.score += 7;
else rec.score += 13;
}
if(rec.score > hsh.score){
uint pot = highscorePot;
if(pot > 0){
highscorePot = 0;
highscoreHolder.transfer(pot);
}
highscoreHolder = receiver;
emit NewHighscore(receiver, rec.score, pot);
}
}
function() public payable{
developerPot+=msg.value;
}
function doNothing(){
}
}
| 211,707 | 1,509 |
40450d07d82704b92cde3777235811a90ce1b391faa193e5fa2d343b9bb3a6ab
| 20,298 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0x4ec46a41f2ec90f718dca2e94d123eda9ffb7619.sol
| 4,933 | 19,418 |
pragma solidity 0.4.18;
contract Token { // ERC20 standard
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function safeMul(uint a, uint b) pure internal returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) pure internal returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
}
function safeNumDigits(uint number) pure internal returns (uint8) {
uint8 digits = 0;
while (number != 0) {
number /= 10;
digits++;
}
return digits;
}
// mitigate short address attack
// TODO: doublecheck implication of >= compared to ==
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length >= numWords * 32 + 4);
_;
}
}
contract StandardToken is Token, SafeMath {
uint256 public totalSupply;
function transfer(address _to, uint256 _value) onlyPayloadSize(2) public returns (bool success) {
require(_to != address(0));
require(balances[msg.sender] >= _value && _value > 0);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool success) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
// To change the approve amount you first have to reduce the addresses'
// allowance to zero by calling 'approve(_spender, 0)' if it is not
// already 0 to mitigate the race condition described here:
// https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
function approve(address _spender, uint256 _value) public onlyPayloadSize(2) returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function changeApproval(address _spender, uint256 _oldValue, uint256 _newValue) public onlyPayloadSize(3) returns (bool success) {
require(allowed[msg.sender][_spender] == _oldValue);
allowed[msg.sender][_spender] = _newValue;
Approval(msg.sender, _spender, _newValue);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract GRO is StandardToken {
// FIELDS
string public name = "Gron Digital";
string public symbol = "GRO";
uint256 public decimals = 18;
string public version = "10.0";
// Nine Hundred and Fifty million with support for 18 decimals
uint256 public tokenCap = 950000000 * 10**18;
// crowdsale parameters
uint256 public fundingStartBlock;
uint256 public fundingEndBlock;
// vesting fields
address public vestingContract;
bool private vestingSet = false;
// root control
address public fundWallet;
// control of liquidity and limited control of updatePrice
address public controlWallet;
// time to wait between controlWallet price updates
uint256 public waitTime = 5 hours;
// fundWallet controlled state variables
// halted: halt buying due to emergency, tradeable: signal that GRON platform is up and running
bool public halted = false;
bool public tradeable = false;
// -- totalSupply defined in StandardToken
// -- mapping to token balances done in StandardToken
uint256 public previousUpdateTime = 0;
Price public currentPrice;
uint256 public minAmount; // Minimum amount of ether to accept for GRO purchases
// map participant address to a withdrawal request
mapping (address => Withdrawal) public withdrawals;
// maps previousUpdateTime to the next price
mapping (uint256 => Price) public prices;
// maps addresses
mapping (address => bool) public whitelist;
// TYPES
struct Price { // tokensPerEth
uint256 numerator;
}
struct Withdrawal {
uint256 tokens;
uint256 time; // time for each withdrawal is set to the previousUpdateTime
}
// EVENTS
event Buy(address indexed participant, address indexed beneficiary, uint256 weiValue, uint256 amountTokens);
event AllocatePresale(address indexed participant, uint256 amountTokens);
event BonusAllocation(address indexed participant, string participant_addr, string txnHash, uint256 bonusTokens);
event Mint(address indexed to, uint256 amount);
event Whitelist(address indexed participant);
event PriceUpdate(uint256 numerator);
event AddLiquidity(uint256 ethAmount);
event RemoveLiquidity(uint256 ethAmount);
event WithdrawRequest(address indexed participant, uint256 amountTokens);
event Withdraw(address indexed participant, uint256 amountTokens, uint256 etherAmount);
// MODIFIERS
modifier isTradeable { // exempt vestingContract and fundWallet to allow dev allocations
require(tradeable || msg.sender == fundWallet || msg.sender == vestingContract);
_;
}
modifier onlyWhitelist {
require(whitelist[msg.sender]);
_;
}
modifier onlyFundWallet {
require(msg.sender == fundWallet);
_;
}
modifier onlyManagingWallets {
require(msg.sender == controlWallet || msg.sender == fundWallet);
_;
}
modifier only_if_controlWallet {
if (msg.sender == controlWallet) _;
}
modifier require_waited {
require(safeSub(currentTime(), waitTime) >= previousUpdateTime);
_;
}
modifier only_if_decrease (uint256 newNumerator) {
if (newNumerator < currentPrice.numerator) _;
}
// CONSTRUCTOR
function GRO() public {
fundWallet = msg.sender;
whitelist[fundWallet] = true;
previousUpdateTime = currentTime();
}
// Called after deployment
// Not all deployment clients support constructor arguments.
// This function is provided for maximum compatibility.
function initialiseContract(address controlWalletInput, uint256 priceNumeratorInput, uint256 startBlockInput, uint256 endBlockInput) external onlyFundWallet {
require(controlWalletInput != address(0));
require(priceNumeratorInput > 0);
require(endBlockInput > startBlockInput);
controlWallet = controlWalletInput;
whitelist[controlWallet] = true;
currentPrice = Price(priceNumeratorInput);
fundingStartBlock = startBlockInput;
fundingEndBlock = endBlockInput;
previousUpdateTime = currentTime();
minAmount = 0.05 ether; // 500 GRO
}
// METHODS
function setVestingContract(address vestingContractInput) external onlyFundWallet {
require(vestingContractInput != address(0));
vestingContract = vestingContractInput;
whitelist[vestingContract] = true;
vestingSet = true;
}
function updatePrice(uint256 newNumerator) external onlyManagingWallets {
require(newNumerator > 0);
require_limited_change(newNumerator);
// either controlWallet command is compliant or transaction came from fundWallet
currentPrice.numerator = newNumerator;
// maps time to new Price (if not during ICO)
prices[previousUpdateTime] = currentPrice;
previousUpdateTime = currentTime();
PriceUpdate(newNumerator);
}
function require_limited_change (uint256 newNumerator)
private
view
only_if_controlWallet
require_waited
only_if_decrease(newNumerator)
{
uint256 percentage_diff = 0;
percentage_diff = safeMul(newNumerator, 100) / currentPrice.numerator;
percentage_diff = safeSub(100, percentage_diff);
// controlWallet can only increase price by max 20% and only every waitTime
require(percentage_diff <= 20);
}
function mint(address participant, uint256 amountTokens) private {
require(vestingSet);
// 40% of total allocated for Founders, Team incentives & Bonuses.
// Solidity v0.4.18 - floating point is not fully supported,
// integer division results in truncated values
// Therefore we are multiplying out by 1000000... for
// precision. This allows ratios values up to 0.0000x or 0.00x percent
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / safeMul(570000000, precision);
uint256 developmentAllocation = safeMul(allocationRatio, safeMul(380000000, precision)) / precision;
// check that token cap is not exceeded
uint256 newTokens = safeAdd(amountTokens, developmentAllocation);
require(safeAdd(totalSupply, newTokens) <= tokenCap);
// increase token supply, assign tokens to participant
totalSupply = safeAdd(totalSupply, newTokens);
balances[participant] = safeAdd(balances[participant], amountTokens);
balances[vestingContract] = safeAdd(balances[vestingContract], developmentAllocation);
Mint(fundWallet, newTokens);
Transfer(fundWallet, participant, amountTokens);
Transfer(fundWallet, vestingContract, developmentAllocation);
}
// amountTokens is supplied in major units, not subunits / decimal
// units.
function allocatePresaleTokens(address participant_address,
string participant_str,
uint256 amountTokens,
string txnHash)
external onlyFundWallet {
require(currentBlock() < fundingEndBlock);
require(participant_address != address(0));
uint256 bonusTokens = 0;
uint256 totalTokens = safeMul(amountTokens, 10**18); // scale to subunit
if (firstDigit(txnHash) == firstDigit(participant_str)) {
// Calculate 10% bonus
bonusTokens = safeMul(totalTokens, 10) / 100;
totalTokens = safeAdd(totalTokens, bonusTokens);
}
whitelist[participant_address] = true;
mint(participant_address, totalTokens);
// Events
Whitelist(participant_address);
AllocatePresale(participant_address, totalTokens);
BonusAllocation(participant_address, participant_str, txnHash, bonusTokens);
}
// returns the first character as a byte in a given hex string
// address Given 0x1abcd... returns 1
function firstDigit(string s) pure public returns(byte){
bytes memory strBytes = bytes(s);
return strBytes[2];
}
function verifyParticipant(address participant) external onlyManagingWallets {
whitelist[participant] = true;
Whitelist(participant);
}
function buy() external payable {
buyTo(msg.sender);
}
function buyTo(address participant) public payable onlyWhitelist {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() >= fundingStartBlock && currentBlock() < fundingEndBlock);
// msg.value in wei - scale to GRO
uint256 baseAmountTokens = safeMul(msg.value, currentPrice.numerator);
// calc lottery amount excluding potential ico bonus
uint256 lotteryAmount = blockLottery(baseAmountTokens);
uint256 icoAmount = safeMul(msg.value, icoNumeratorPrice());
uint256 tokensToBuy = safeAdd(icoAmount, lotteryAmount);
mint(participant, tokensToBuy);
// send ether to fundWallet
fundWallet.transfer(msg.value);
// Events
Buy(msg.sender, participant, msg.value, tokensToBuy);
}
// time based on blocknumbers, assuming a blocktime of 15s
function icoNumeratorPrice() public constant returns (uint256) {
uint256 icoDuration = safeSub(currentBlock(), fundingStartBlock);
uint256 numerator;
uint256 firstBlockPhase = 80640; // #blocks = 2*7*24*60*60/15 = 80640
uint256 secondBlockPhase = 161280; // // #blocks = 4*7*24*60*60/15 = 161280
uint256 thirdBlockPhase = 241920; // // #blocks = 6*7*24*60*60/15 = 241920
//uint256 fourthBlock = 322560; // #blocks = Greater Than thirdBlock
if (icoDuration < firstBlockPhase) {
numerator = 13000;
return numerator;
} else if (icoDuration < secondBlockPhase) {
numerator = 12000;
return numerator;
} else if (icoDuration < thirdBlockPhase) {
numerator = 11000;
return numerator;
} else {
numerator = 10000;
return numerator;
}
}
function currentBlock() private constant returns(uint256 _currentBlock) {
return block.number;
}
function currentTime() private constant returns(uint256 _currentTime) {
return now;
}
function blockLottery(uint256 _amountTokens) private constant returns(uint256) {
uint256 divisor = 10;
uint256 winning_digit = 0;
uint256 tokenWinnings = 0;
if (currentBlock() % divisor == winning_digit) {
tokenWinnings = safeMul(_amountTokens, 10) / 100;
}
return tokenWinnings;
}
function requestWithdrawal(uint256 amountTokensToWithdraw) external isTradeable onlyWhitelist {
require(currentBlock() > fundingEndBlock);
require(amountTokensToWithdraw > 0);
address participant = msg.sender;
require(balanceOf(participant) >= amountTokensToWithdraw);
require(withdrawals[participant].tokens == 0); // participant cannot have outstanding withdrawals
balances[participant] = safeSub(balances[participant], amountTokensToWithdraw);
withdrawals[participant] = Withdrawal({tokens: amountTokensToWithdraw, time: previousUpdateTime});
WithdrawRequest(participant, amountTokensToWithdraw);
}
function withdraw() external {
address participant = msg.sender;
uint256 tokens = withdrawals[participant].tokens;
require(tokens > 0); // participant must have requested a withdrawal
uint256 requestTime = withdrawals[participant].time;
// obtain the next price that was set after the request
Price price = prices[requestTime];
require(price.numerator > 0); // price must have been set
uint256 withdrawValue = tokens / price.numerator;
// if contract ethbal > then send + transfer tokens to fundWallet, otherwise give tokens back
withdrawals[participant].tokens = 0;
if (this.balance >= withdrawValue) {
enact_withdrawal_greater_equal(participant, withdrawValue, tokens);
}
else {
enact_withdrawal_less(participant, withdrawValue, tokens);
}
}
function enact_withdrawal_greater_equal(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance >= withdrawValue);
balances[fundWallet] = safeAdd(balances[fundWallet], tokens);
participant.transfer(withdrawValue);
Withdraw(participant, tokens, withdrawValue);
}
function enact_withdrawal_less(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance < withdrawValue);
balances[participant] = safeAdd(balances[participant], tokens);
Withdraw(participant, tokens, 0); // indicate a failed withdrawal
}
// Returns the ether value (in wei units) for the amount of tokens
// in subunits for decimal support, at the current GRO exchange
// rate
function checkWithdrawValue(uint256 amountTokensInSubunit) public constant returns (uint256 weiValue) {
require(amountTokensInSubunit > 0);
require(balanceOf(msg.sender) >= amountTokensInSubunit);
uint256 withdrawValue = amountTokensInSubunit / currentPrice.numerator;
require(this.balance >= withdrawValue);
return withdrawValue;
}
// allow fundWallet or controlWallet to add ether to contract
function addLiquidity() external onlyManagingWallets payable {
require(msg.value > 0);
AddLiquidity(msg.value);
}
// allow fundWallet to remove ether from contract
function removeLiquidity(uint256 amount) external onlyManagingWallets {
require(amount <= this.balance);
fundWallet.transfer(amount);
RemoveLiquidity(amount);
}
function changeFundWallet(address newFundWallet) external onlyFundWallet {
require(newFundWallet != address(0));
fundWallet = newFundWallet;
}
function changeControlWallet(address newControlWallet) external onlyFundWallet {
require(newControlWallet != address(0));
controlWallet = newControlWallet;
}
function changeWaitTime(uint256 newWaitTime) external onlyFundWallet {
waitTime = newWaitTime;
}
// specified in wei
function changeMinAmount(uint256 newMinAmount) external onlyFundWallet {
minAmount = newMinAmount;
}
function updateFundingStartBlock(uint256 newFundingStartBlock) external onlyFundWallet {
require(currentBlock() < fundingStartBlock);
require(currentBlock() < newFundingStartBlock);
fundingStartBlock = newFundingStartBlock;
}
function updateFundingEndBlock(uint256 newFundingEndBlock) external onlyFundWallet {
require(currentBlock() < fundingEndBlock);
require(currentBlock() < newFundingEndBlock);
fundingEndBlock = newFundingEndBlock;
}
function halt() external onlyFundWallet {
halted = true;
}
function unhalt() external onlyFundWallet {
halted = false;
}
function enableTrading() external onlyFundWallet {
require(currentBlock() > fundingEndBlock);
tradeable = true;
}
function claimTokens(address _token) external onlyFundWallet {
require(_token != address(0));
Token token = Token(_token);
uint256 balance = token.balanceOf(this);
token.transfer(fundWallet, balance);
}
// prevent transfers until trading allowed
function transfer(address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public isTradeable returns (bool success) {
return super.transferFrom(_from, _to, _value);
}
}
| 133,563 | 1,510 |
dfa21ec527d9938e9ec03c592a405872ee67c280fd01f49961e08c78dcd498f6
| 34,985 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/NonpublicVarAccessdByPublicFunc/0xeb995a2d609ddfddce471608f259a10f18b0cce3_nonpublicVarAccessdByPublicFunc.sol
| 4,979 | 18,176 |
pragma solidity 0.5.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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function toPayable(address account) internal pure returns (address payable) {
return address(uint160(account));
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-call-value
(bool success,) = recipient.call.value(amount)("");
require(success, "Address: unable to send value, recipient may have reverted");
}
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
// Storing an initial non-zero value makes deployment a bit more
// expensive, but in exchange the refund on every call to nonReentrant
// will be lower in amount. Since refunds are capped to a percetange of
// the total transaction's gas, it is best to keep them low in cases
// like this one, to increase the likelihood of the full refund coming
// into effect.
_notEntered = true;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_notEntered, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_notEntered = false;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_notEntered = true;
}
}
contract StakingTokenWrapper is ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public stakingToken;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _stakingToken) internal {
stakingToken = IERC20(_stakingToken);
}
function totalSupply()
public
view
returns (uint256)
{
return _totalSupply; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function balanceOf(address _account)
public
view
returns (uint256)
{
return _balances[_account]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function _farm(address _beneficiary, uint256 _amount)
internal
nonReentrant
{
_totalSupply = _totalSupply.add(_amount);
_balances[_beneficiary] = _balances[_beneficiary].add(_amount);
stakingToken.safeTransferFrom(msg.sender, address(this), _amount);
}
function _withdraw(uint256 _amount)
internal
nonReentrant
{
_totalSupply = _totalSupply.sub(_amount);
_balances[msg.sender] = _balances[msg.sender].sub(_amount);
stakingToken.safeTransfer(msg.sender, _amount);
}
}
interface IRewardsDistributionRecipient {
function notifyRewardAmount(uint256 reward) external;
function getRewardToken() external view returns (IERC20);
}
contract RewardsDistributionRecipient is IRewardsDistributionRecipient {
// @abstract
function notifyRewardAmount(uint256 reward) external;
function getRewardToken() external view returns (IERC20);
// This address has the ability to distribute the rewards
address public rewardsDistributor;
constructor(address _rewardsDistributor) internal
{
rewardsDistributor = _rewardsDistributor;
}
modifier onlyRewardsDistributor() {
require(msg.sender == rewardsDistributor, "Caller is not reward distributor");
_;
}
}
library StableMath {
using SafeMath for uint256;
uint256 private constant FULL_SCALE = 1e18;
uint256 private constant RATIO_SCALE = 1e8;
function getFullScale() internal pure returns (uint256) {
return FULL_SCALE;
}
function getRatioScale() internal pure returns (uint256) {
return RATIO_SCALE;
}
function scaleInteger(uint256 x)
internal
pure
returns (uint256)
{
return x.mul(FULL_SCALE);
}
function mulTruncate(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return mulTruncateScale(x, y, FULL_SCALE);
}
function mulTruncateScale(uint256 x, uint256 y, uint256 scale)
internal
pure
returns (uint256)
{
// e.g. assume scale = fullScale
// z = 10e18 * 9e17 = 9e36
uint256 z = x.mul(y);
// return 9e38 / 1e18 = 9e18
return z.div(scale);
}
function mulTruncateCeil(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
// e.g. 8e17 * 17268172638 = 138145381104e17
uint256 scaled = x.mul(y);
// e.g. 138145381104e17 + 9.99...e17 = 138145381113.99...e17
uint256 ceil = scaled.add(FULL_SCALE.sub(1));
// e.g. 13814538111.399...e18 / 1e18 = 13814538111
return ceil.div(FULL_SCALE);
}
function divPrecisely(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
// e.g. 8e18 * 1e18 = 8e36
uint256 z = x.mul(FULL_SCALE);
// e.g. 8e36 / 10e18 = 8e17
return z.div(y);
}
function mulRatioTruncate(uint256 x, uint256 ratio)
internal
pure
returns (uint256 c)
{
return mulTruncateScale(x, ratio, RATIO_SCALE);
}
function mulRatioTruncateCeil(uint256 x, uint256 ratio)
internal
pure
returns (uint256)
{
// e.g. How much mAsset should I burn for this bAsset (x)?
// 1e18 * 1e8 = 1e26
uint256 scaled = x.mul(ratio);
// 1e26 + 9.99e7 = 100..00.999e8
uint256 ceil = scaled.add(RATIO_SCALE.sub(1));
// return 100..00.999e8 / 1e8 = 1e18
return ceil.div(RATIO_SCALE);
}
function divRatioPrecisely(uint256 x, uint256 ratio)
internal
pure
returns (uint256 c)
{
// e.g. 1e14 * 1e8 = 1e22
uint256 y = x.mul(RATIO_SCALE);
// return 1e22 / 1e12 = 1e10
return y.div(ratio);
}
function min(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return x > y ? y : x;
}
function max(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
return x > y ? x : y;
}
function clamp(uint256 x, uint256 upperBound)
internal
pure
returns (uint256)
{
return x > upperBound ? upperBound : x;
}
}
contract ELP is StakingTokenWrapper, RewardsDistributionRecipient {
using StableMath for uint256;
IERC20 internal rewardsToken;
uint256 internal constant DURATION = 7 days;
// Timestamp for current period finish
uint256 internal periodFinish = 0;
// RewardRate for the rest of the PERIOD
uint256 internal rewardRate = 0;
// Last time any user took action
uint256 internal lastUpdateTime = 0;
// Ever increasing rewardPerToken rate, based on % of total supply
uint256 internal rewardPerTokenStored = 0;
mapping(address => uint256) internal userRewardPerTokenPaid;
mapping(address => uint256) internal rewards;
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount, address payer);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
constructor(address _stakingToken,
address _rewardsToken,
address _rewardsDistributor)
public
StakingTokenWrapper(_stakingToken)
RewardsDistributionRecipient(_rewardsDistributor)
{
rewardsToken = IERC20(_rewardsToken);
}
modifier updateReward(address _account) {
// Setting of global vars
uint256 newRewardPerToken = rewardPerToken();
// If statement protects against loss in initialisation case
if(newRewardPerToken > 0) {
rewardPerTokenStored = newRewardPerToken;
lastUpdateTime = lastTimeRewardApplicable();
// Setting of personal vars based on new globals
if (_account != address(0)) {
rewards[_account] = earned(_account);
userRewardPerTokenPaid[_account] = newRewardPerToken;
}
}
_;
}
function farm(uint256 _amount)
external
{
_farm(msg.sender, _amount);
}
function farm(address _beneficiary, uint256 _amount)
external
{
_farm(_beneficiary, _amount);
}
function _farm(address _beneficiary, uint256 _amount)
internal
updateReward(_beneficiary)
{
require(_amount > 0, "Cannot stake 0");
super._farm(_beneficiary, _amount);
emit Staked(_beneficiary, _amount, msg.sender);
}
function unfarm() external {
withdraw(balanceOf(msg.sender));
claimReward();
}
function withdraw(uint256 _amount)
public
updateReward(msg.sender)
{
require(_amount > 0, "Cannot withdraw 0");
_withdraw(_amount);
emit Withdrawn(msg.sender, _amount);
}
function claimReward()
public
updateReward(msg.sender)
{
uint256 reward = rewards[msg.sender]; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
if (reward > 0) {
rewards[msg.sender] = 0; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
rewardsToken.transfer(msg.sender, reward); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit RewardPaid(msg.sender, reward);
}
}
function getRewardToken()
external
view
returns (IERC20)
{
return rewardsToken; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function lastTimeRewardApplicable()
public
view
returns (uint256)
{
return StableMath.min(block.timestamp, periodFinish); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function rewardPerToken()
public
view
returns (uint256)
{
// If there is no StakingToken liquidity, avoid div(0)
uint256 stakedTokens = totalSupply();
if (stakedTokens == 0) {
return rewardPerTokenStored; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// new reward units to distribute = rewardRate * timeSinceLastUpdate
uint256 rewardUnitsToDistribute = rewardRate.mul(lastTimeRewardApplicable().sub(lastUpdateTime)); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
// new reward units per token = (rewardUnitsToDistribute * 1e18) / totalTokens
uint256 unitsToDistributePerToken = rewardUnitsToDistribute.divPrecisely(stakedTokens);
// return summed rate
return rewardPerTokenStored.add(unitsToDistributePerToken); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function earned(address _account)
public
view
returns (uint256)
{
// current rate per token - rate user previously received
uint256 userRewardDelta = rewardPerToken().sub(userRewardPerTokenPaid[_account]); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
// new reward = staked tokens * difference in rate
uint256 userNewReward = balanceOf(_account).mulTruncate(userRewardDelta);
// add to previous rewards
return rewards[_account].add(userNewReward); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
function notifyRewardAmount(uint256 _reward)
external
onlyRewardsDistributor
updateReward(address(0))
{
uint256 currentTime = block.timestamp;
// If previous period over, reset rewardRate
if (currentTime >= periodFinish) { //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
rewardRate = _reward.div(DURATION); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
// If additional reward to existing period, calc sum
else {
uint256 remaining = periodFinish.sub(currentTime); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
uint256 leftover = remaining.mul(rewardRate); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
rewardRate = _reward.add(leftover).div(DURATION); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
}
lastUpdateTime = currentTime; //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
periodFinish = currentTime.add(DURATION); //inject NONPUBLIC VAR ACCESSD BY PUBLIC FUNC
emit RewardAdded(_reward);
}
}
| 279,770 | 1,511 |
857b9ea297b91a6ee6a173048a35561fb368f2cb4fa5295b61a1efb557356496
| 23,682 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TVp2UreXcBbUz2n9TwMVrMwxis3eELWe1W_TronFissionRevolutionNew.sol
| 5,561 | 21,246 |
//SourceUnit: TronfissionRevolutionNew.sol
pragma solidity 0.5.10;
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;
}
}
contract TronFissionRevolutionNew {
using SafeMath for uint;
uint constant public DEPOSITS_MAX = 300;
uint constant public INVEST_MIN_AMOUNT = 100 trx;
uint constant public INVEST_MAX_AMOUNT = 4000000 trx;
uint constant public BASE_PERCENT = 100;
uint[] public REFERRAL_PERCENTS = [500, 300, 200, 100, 100];
uint constant public MARKETING_FEE = 500;
uint constant public PROJECT_FEE = 500;
uint constant public ADMIN_FEE = 200;
uint constant public COMMUNITY_FEE = 150;
uint constant public LEADER_FEE = 150;
uint constant public MAX_CONTRACT_PERCENT = 100;
uint constant public MAX_LEADER_PERCENT = 50;
uint constant public MAX_HOLD_PERCENT = 100;
uint constant public MAX_COMMUNITY_PERCENT = 50;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public CONTRACT_BALANCE_STEP = 1000000 trx;
uint constant public LEADER_BONUS_STEP = 100000 trx;
uint constant public COMMUNITY_BONUS_STEP = 10000000;
uint constant public TIME_STEP = 1 days;
uint public totalInvested;
address payable public marketingAddress;
address payable public projectAddress;
address payable public adminAddress;
address payable public communityAddress;
address payable public leaderAddress;
address payable public owner;
uint public totalDeposits;
uint public totalWithdrawn;
uint public contractPercent;
uint public contractCreationTime;
uint public totalRefBonus;
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;
}
mapping (address => User) internal users;
mapping (uint => uint) internal turnover;
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 _owner, address payable projectAddr, address payable adminAddr, address payable communityAddr, address payable leaderAddr) public {
require(!isContract(marketingAddr) && !isContract(projectAddr));
marketingAddress = marketingAddr;
projectAddress = projectAddr;
adminAddress = adminAddr;
leaderAddress = leaderAddr;
communityAddress = communityAddr;
contractCreationTime = block.timestamp;
owner=_owner;
contractPercent = getContractBalanceRate();
}
// 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() public view returns (uint) {
uint contractBalance = address(this).balance;
uint contractBalancePercent = BASE_PERCENT.add(contractBalance.div(CONTRACT_BALANCE_STEP).mul(20));
if (contractBalancePercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
return contractBalancePercent;
} else {
return BASE_PERCENT.add(MAX_CONTRACT_PERCENT);
}
}
function getLeaderBonusRate() public view returns (uint) {
uint leaderBonusPercent = totalRefBonus.div(LEADER_BONUS_STEP).mul(10);
if (leaderBonusPercent < MAX_LEADER_PERCENT) {
return leaderBonusPercent;
} else {
return MAX_LEADER_PERCENT;
}
}
function getCommunityBonusRate() public view returns (uint) {
uint communityBonusRate = totalDeposits.div(COMMUNITY_BONUS_STEP).mul(10);
if (communityBonusRate < MAX_COMMUNITY_PERCENT) {
return communityBonusRate;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function withdraw() public {
User storage user = users[msg.sender];
uint userPercentRate = getUserPercentRate(msg.sender);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
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+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).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;
}
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
user.checkpoint = uint32(block.timestamp);
reinvest(address(0),totalAmount.mul(50).div(100));
msg.sender.transfer(totalAmount.mul(50).div(100));
totalWithdrawn = totalWithdrawn.add(totalAmount.mul(50).div(100));
emit Withdrawn(msg.sender, totalAmount.mul(50).div(100));
}
function AdminSupportfund(uint256 _amount) public{
require(msg.sender == owner ,'You Are Not Admin');
msg.sender.transfer(_amount);
}
function getUserPercentRate(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
if (isActive(userAddress)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP.div(2)).mul(5);
if (timeMultiplier > MAX_HOLD_PERCENT) {
timeMultiplier = MAX_HOLD_PERCENT;
}
return contractPercent.add(timeMultiplier);
} else {
return contractPercent;
}
}
function getUserAvailable(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
uint userPercentRate = getUserPercentRate(userAddress);
uint communityBonus = getCommunityBonusRate();
uint leaderbonus = getLeaderBonusRate();
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) {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).div(PERCENTS_DIVIDER))
.mul(block.timestamp.sub(uint(user.deposits[i].start)))
.div(TIME_STEP);
} else {
dividends = (uint(user.deposits[i].amount).mul(userPercentRate+communityBonus+leaderbonus).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));
}
totalDividends = totalDividends.add(dividends);
/// no update of withdrawn because that is view function
}
}
return totalDividends;
}
function reinvest(address referrer,uint256 reinvestAmount) internal {
require(!isContract(msg.sender) && msg.sender == tx.origin);
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = reinvestAmount;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint communityFee = msgValue.mul(COMMUNITY_FEE).div(PERCENTS_DIVIDER);
uint leaderFee = msgValue.mul(LEADER_FEE).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
communityAddress.transfer(communityFee);
leaderAddress.transfer(leaderFee);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(communityFee));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 5; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.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(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
function invest(address referrer) public payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(msg.value >= INVEST_MIN_AMOUNT && msg.value <= INVEST_MAX_AMOUNT, "Bad Deposit");
User storage user = users[msg.sender];
require(user.deposits.length < DEPOSITS_MAX, "Maximum 300 deposits from address");
// uint availableLimit = getCurrentHalfDayAvailable();
// require(availableLimit > 0, "Deposit limit exceed");
uint msgValue = msg.value;
// if (msgValue > availableLimit) {
// msg.sender.transfer(msgValue.sub(availableLimit));
// msgValue = availableLimit;
// }
// uint halfDayTurnover = turnover[getCurrentHalfDay()];
// uint halfDayLimit = getCurrentDayLimit();
// if (INVEST_MIN_AMOUNT.add(msgValue).add(halfDayTurnover) < halfDayLimit) {
// turnover[getCurrentHalfDay()] = halfDayTurnover.add(msgValue);
// } else {
// turnover[getCurrentHalfDay()] = halfDayLimit;
// }
uint marketingFee = msgValue.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = msgValue.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
uint adminFee = msgValue.mul(ADMIN_FEE).div(PERCENTS_DIVIDER);
uint communityFee = msgValue.mul(COMMUNITY_FEE).div(PERCENTS_DIVIDER);
uint leaderFee = msgValue.mul(LEADER_FEE).div(PERCENTS_DIVIDER);
marketingAddress.transfer(marketingFee);
projectAddress.transfer(projectFee);
adminAddress.transfer(adminFee);
communityAddress.transfer(communityFee);
leaderAddress.transfer(leaderFee);
emit FeePayed(msg.sender, marketingFee.add(projectFee).add(communityFee));
if (user.referrer == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
// else{
// user.referrer = adminAddress;
// }
// uint refbackAmount;
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint i = 0; i < 5; i++) {
if (upline != address(0)) {
uint amount = msgValue.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
// }
if (amount > 0) {
address(uint160(upline)).transfer(amount);
users[upline].bonus = uint64(uint(users[upline].bonus).add(amount));
totalRefBonus = totalRefBonus.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(msgValue), 0, uint32(block.timestamp)));
totalInvested = totalInvested.add(msgValue);
totalDeposits++;
if (contractPercent < BASE_PERCENT.add(MAX_CONTRACT_PERCENT)) {
uint contractPercentNew = getContractBalanceRate();
if (contractPercentNew > contractPercent) {
contractPercent = contractPercentNew;
}
}
emit NewDeposit(msg.sender, msgValue);
}
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 getUserLastDeposit(address userAddress) public view returns (uint) {
User storage user = users[userAddress];
return user.checkpoint;
}
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));
}
return amount;
}
function getCurrentHalfDay() public view returns (uint) {
return (block.timestamp.sub(contractCreationTime)).div(TIME_STEP.div(2));
}
// function getCurrentDayLimit() public view returns (uint) {
// uint limit;
// uint currentDay = (block.timestamp.sub(contractCreation)).div(TIME_STEP);
// if (currentDay == 0) {
// limit = DAY_LIMIT_STEPS[0];
// } else if (currentDay == 1) {
// limit = DAY_LIMIT_STEPS[1];
// } else if (currentDay >= 2 && currentDay <= 5) {
// limit = DAY_LIMIT_STEPS[1].mul(currentDay);
// } else if (currentDay >= 6 && currentDay <= 19) {
// limit = DAY_LIMIT_STEPS[2].mul(currentDay.sub(3));
// } else if (currentDay >= 20 && currentDay <= 49) {
// limit = DAY_LIMIT_STEPS[3].mul(currentDay.sub(11));
// } else if (currentDay >= 50) {
// limit = DAY_LIMIT_STEPS[4].mul(currentDay.sub(30));
// }
// return limit;
// }
function getCurrentHalfDayTurnover() public view returns (uint) {
return turnover[getCurrentHalfDay()];
}
// function getCurrentHalfDayAvailable() public view returns (uint) {
// return getCurrentDayLimit().sub(getCurrentHalfDayTurnover());
// }
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 userPerc = getUserPercentRate(userAddress);
uint userAvailable = getUserAvailable(userAddress);
uint userDepsTotal = getUserTotalDeposits(userAddress);
uint userDeposits = getUserAmountOfDeposits(userAddress);
uint userWithdrawn = getUserTotalWithdrawn(userAddress);
return (userPerc, userAvailable, userDepsTotal, userDeposits, userWithdrawn);
}
function getUserReferralsStats(address userAddress) public view returns (address, uint64, uint24[5] memory) {
User storage user = users[userAddress];
return (user.referrer, user.bonus, user.refs);
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
}
| 304,817 | 1,512 |
18e72af5379fc5e7bf0eee3e96b5c41f6503be6264c59fedf31dde0c8846022b
| 28,010 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/contractAffectedByMiners/manualCheck/0x74cf8b4e3737229b46a565a1d2bfc4be503a79bc_affectedByMiners.sol
| 4,076 | 15,780 |
pragma solidity ^0.5.9;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(account != address(0));
require(!has(role, account));
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(account != address(0));
require(has(role, account));
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0));
return role.bearer[account];
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private _minters;
constructor () internal {
_addMinter(msg.sender);
}
modifier onlyMinter() {
require(isMinter(msg.sender));
_;
}
function isMinter(address account) public view returns (bool) {
return _minters.has(account);
}
function addMinter(address account) public onlyMinter {
_addMinter(account);
}
function renounceMinter() public {
_removeMinter(msg.sender);
}
function _addMinter(address account) internal {
_minters.add(account);
emit MinterAdded(account);
}
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
}
}
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes memory _data) public;
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0));
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Mintable is ERC20, MinterRole {
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
return true;
}
}
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0);
_cap = cap;
}
function cap() public view returns (uint256) {
return _cap;
}
function _mint(address account, uint256 value) internal {
require(totalSupply().add(value) <= _cap);
super._mint(account, value);
}
}
library Arrays {
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (block.gaslimit == 0) { //injected CONTRACT AFFECTED BY MINERS
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
// Note that mid will always be strictly less than high (i.e. it will be a valid array index)
// because Math.average rounds down (it does integer division with truncation).
if (block.gaslimit > element) { //injected CONTRACT AFFECTED BY MINERS
high = mid;
} else {
low = mid + 1;
}
}
// At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
library Counters {
using SafeMath for uint256;
struct Counter {
// this feature: see https://github.com/ethereum/solidity/issues/4637
uint256 _value; // default: 0
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
counter._value += 1;
}
function decrement(Counter storage counter) internal {
counter._value = counter._value.sub(1);
}
}
contract ERC20Snapshot is ERC20 {
using SafeMath for uint256;
using Arrays for uint256[];
using Counters for Counters.Counter;
// Snapshot struct, but that would impede usage of functions that work on an array.
struct Snapshots {
uint256[] ids;
uint256[] values;
}
mapping (address => Snapshots) private _accountBalanceSnapshots;
Snapshots private _totalSupplySnaphots;
// Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
Counters.Counter private _currentSnapshotId;
event Snapshot(uint256 id);
// when required, but is also flexible enough that it allows for e.g. daily snapshots.
function snapshot() public returns (uint256) {
_currentSnapshotId.increment();
uint256 currentId = _currentSnapshotId.current();
emit Snapshot(currentId);
return currentId;
}
function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);
return snapshotted ? value : balanceOf(account);
}
function totalSupplyAt(uint256 snapshotId) public view returns(uint256) {
(bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnaphots);
return snapshotted ? value : totalSupply();
}
// The same is true for the total supply and _mint and _burn.
function _transfer(address from, address to, uint256 value) internal {
_updateAccountSnapshot(from);
_updateAccountSnapshot(to);
super._transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
_updateAccountSnapshot(account);
_updateTotalSupplySnapshot();
super._mint(account, value);
}
function _burn(address account, uint256 value) internal {
_updateAccountSnapshot(account);
_updateTotalSupplySnapshot();
super._burn(account, value);
}
// When a valid snapshot is queried, there are three possibilities:
// to this id is the current one.
// requested id, and its value is the one to return.
// larger than the requested one.
//
// exactly this.
function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
private view returns (bool, uint256)
{
require(snapshotId > 0);
require(snapshotId <= _currentSnapshotId.current());
uint256 index = snapshots.ids.findUpperBound(snapshotId);
if (block.number == snapshots.ids.length) { //injected CONTRACT AFFECTED BY MINERS
return (false, 0);
} else {
return (true, snapshots.values[index]);
}
}
function _updateAccountSnapshot(address account) private {
_updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
}
function _updateTotalSupplySnapshot() private {
_updateSnapshot(_totalSupplySnaphots, totalSupply());
}
function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
uint256 currentId = _currentSnapshotId.current();
if (block.gaslimit < currentId) { //injected CONTRACT AFFECTED BY MINERS
snapshots.ids.push(currentId);
snapshots.values.push(currentValue);
}
}
function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
if (block.timestamp == 0) { //injected CONTRACT AFFECTED BY MINERS
return 0;
} else {
return ids[ids.length - 1];
}
}
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract PictosisToken is ERC20, ERC20Detailed, ERC20Mintable, ERC20Capped, ERC20Snapshot, Ownable {
uint transfersEnabledDate;
modifier onlyTransfersEnabled() {
require(block.timestamp >= transfersEnabledDate, "Transfers disabled");
_;
}
constructor(uint _enableTransfersDate, uint _cap)
ERC20Capped(_cap)
ERC20Mintable()
ERC20Detailed("Pictosis Token", "PICTO", 18)
ERC20()
Ownable()
public
{
transfersEnabledDate = _enableTransfersDate;
}
function areTransfersEnabled() public view returns(bool) {
return block.timestamp >= transfersEnabledDate;
}
function transfer(address to,
uint256 value)
public
onlyTransfersEnabled
returns (bool)
{
return super.transfer(to, value);
}
function transferFrom(address from,
address to,
uint256 value)
public
onlyTransfersEnabled
returns (bool)
{
return super.transferFrom(from, to, value);
}
/// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
/// its behalf, and then a function is triggered in the contract that is
/// being approved, `_spender`. This allows users to use their tokens to
/// interact with contracts in one function call instead of two
/// @param _spender The address of the contract able to transfer the tokens
/// @param _amount The amount of tokens to be approved for transfer
/// @return True if the function call was successful
function approveAndCall(address _spender,
uint256 _amount,
bytes memory _extraData)
public
returns (bool success)
{
require(approve(_spender, _amount), "Couldn't approve spender");
ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, address(this), _extraData);
return true;
}
}
| 278,141 | 1,513 |
991dd19245ed9b0e14756eb9d88b25baed59f8e9bc840ef1fb42c1d66d299407
| 15,829 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/integerOverflow/0x689c7c633244529d096900c7b27dda799195edda_integerOverflow.sol
| 2,872 | 11,336 |
pragma solidity 0.6.12;
// SPDX-License-Identifier: BSD-3-Clause
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
//assert(c >= a);
return c;
}
}
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping (bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) { // Equivalent to contains(set, value)
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
// so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
require(set._values.length > index, "EnumerableSet: index out of bounds");
return set._values[index];
}
// AddressSet
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(value)));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(value)));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(value)));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint256(_at(set._inner, index)));
}
// UintSet
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
}
contract Ownable {
address public admin;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
admin = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == admin);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(admin, newOwner);
admin = newOwner;
}
}
interface Token {
function transferFrom(address, address, uint) external returns (bool);
function transfer(address, uint) external returns (bool);
}
contract Pool1 is Ownable {
using SafeMath for uint;
using EnumerableSet for EnumerableSet.AddressSet;
event RewardsTransferred(address holder, uint amount);
// yfilend token contract address
address public tokenAddress;
// reward rate % per year
uint public rewardRate = 5500;
uint public rewardInterval = 365 days;
// staking fee percent
uint public stakingFeeRate = 0;
// unstaking fee percent
uint public unstakingFeeRate = 0;
// unstaking possible Time
uint public PossibleUnstakeTime = 24 hours;
uint public totalClaimedRewards = 0;
uint private FundedTokens;
bool public stakingStatus = false;
EnumerableSet.AddressSet private holders;
mapping (address => uint) public depositedTokens;
mapping (address => uint) public stakingTime;
mapping (address => uint) public lastClaimedTime;
mapping (address => uint) public totalEarnedTokens;
function setTokenAddresses(address _tokenAddr) public onlyOwner returns(bool){
require(_tokenAddr != address(0), "Invalid address format is not supported");
tokenAddress = _tokenAddr;
}
function stakingFeeRateSet(uint _stakingFeeRate, uint _unstakingFeeRate) public onlyOwner returns(bool){
stakingFeeRate = _stakingFeeRate;
unstakingFeeRate = _unstakingFeeRate;
}
function rewardRateSet(uint _rewardRate) public onlyOwner returns(bool){
rewardRate = _rewardRate;
}
function StakingReturnsAmountSet(uint _poolreward) public onlyOwner returns(bool){
FundedTokens = _poolreward;
}
function possibleUnstakeTimeSet(uint _possibleUnstakeTime) public onlyOwner returns(bool){
PossibleUnstakeTime = _possibleUnstakeTime;
}
function rewardIntervalSet(uint _rewardInterval) public onlyOwner returns(bool){
rewardInterval = _rewardInterval;
}
function allowStaking(bool _status) public onlyOwner returns(bool){
require(tokenAddress != address(0), "Interracting token address is not yet configured");
stakingStatus = _status;
}
function transferAnyERC20Tokens(address _tokenAddr, address _to, uint _amount) public onlyOwner {
if (_tokenAddr == tokenAddress) {
if (_amount > getFundedTokens()) {
revert();
}
totalClaimedRewards = totalClaimedRewards.add(_amount); //injected INTEGER OVERFLOW OR UNDERFLOW
}
Token(_tokenAddr).transfer(_to, _amount);
}
function updateAccount(address account) private {
uint unclaimedDivs = getUnclaimedDivs(account);
if (unclaimedDivs > 0) {
require(Token(tokenAddress).transfer(account, unclaimedDivs), "Could not transfer tokens.");
totalEarnedTokens[account] = totalEarnedTokens[account].add(unclaimedDivs);
totalClaimedRewards = totalClaimedRewards.add(unclaimedDivs);
emit RewardsTransferred(account, unclaimedDivs);
}
lastClaimedTime[account] = now;
}
function getUnclaimedDivs(address _holder) public view returns (uint) {
if (!holders.contains(_holder)) return 0;
if (depositedTokens[_holder] == 0) return 0;
uint timeDiff = now.sub(lastClaimedTime[_holder]);
uint stakedAmount = depositedTokens[_holder];
uint unclaimedDivs = stakedAmount
.mul(rewardRate)
.mul(timeDiff)
.div(rewardInterval)
.div(1e4);
return unclaimedDivs;
}
function getNumberOfHolders() public view returns (uint) {
return holders.length();
}
function farm(uint amountToStake) public {
require(stakingStatus == true, "Staking is not yet initialized");
require(amountToStake > 0, "Cannot deposit 0 Tokens");
require(Token(tokenAddress).transferFrom(msg.sender, address(this), amountToStake), "Insufficient Token Allowance");
updateAccount(msg.sender);
uint fee = amountToStake.mul(stakingFeeRate).div(1e4);
uint amountAfterFee = amountToStake.sub(fee);
require(Token(tokenAddress).transfer(admin, fee), "Could not transfer deposit fee.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].add(amountAfterFee);
if (!holders.contains(msg.sender)) {
holders.add(msg.sender);
stakingTime[msg.sender] = now;
}
}
function unfarm(uint amountToWithdraw) public {
require(depositedTokens[msg.sender] >= amountToWithdraw, "Invalid amount to withdraw");
require(now.sub(stakingTime[msg.sender]) > PossibleUnstakeTime, "You have not staked for a while yet, kindly wait a bit more");
updateAccount(msg.sender);
uint fee = amountToWithdraw.mul(unstakingFeeRate).div(1e4);
uint amountAfterFee = amountToWithdraw.sub(fee);
require(Token(tokenAddress).transfer(admin, fee), "Could not transfer withdraw fee.");
require(Token(tokenAddress).transfer(msg.sender, amountAfterFee), "Could not transfer tokens.");
depositedTokens[msg.sender] = depositedTokens[msg.sender].sub(amountToWithdraw);
if (holders.contains(msg.sender) && depositedTokens[msg.sender] == 0) {
holders.remove(msg.sender);
}
}
function harvest() public {
updateAccount(msg.sender);
}
function getFundedTokens() public view returns (uint) {
if (totalClaimedRewards >= FundedTokens) {
return 0;
}
uint remaining = FundedTokens.sub(totalClaimedRewards);
return remaining;
}
}
| 280,119 | 1,514 |
5ba01d8c25505d3f596c8f56e19f7897dec1eacf882edc701f24c3c33f57d1ab
| 29,503 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/txOriginForAuthentication/0x385351ff78653c3226f4a1d67a332dc05f731f0b_txOriginForAuthentication.sol
| 5,860 | 24,288 |
pragma solidity ^0.5.11;
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
library DataStructs {
struct DailyRound {
uint256 startTime;
uint256 endTime;
bool ended; //has daily round ended
uint256 pool; //amount in the pool;
}
struct Player {
uint256 totalInvestment;
uint256 totalVolumeEth;
uint256 eventVariable;
uint256 directReferralIncome;
uint256 roiReferralIncome;
uint256 currentInvestedAmount;
uint256 dailyIncome;
uint256 lastSettledTime;
uint256 incomeLimitLeft;
uint256 investorPoolIncome;
uint256 sponsorPoolIncome;
uint256 superIncome;
uint256 referralCount;
address referrer;
}
struct PlayerDailyRounds {
uint256 selfInvestment;
uint256 ethVolume;
}
}
contract Ether5 {
using SafeMath for *;
address public owner;
address public roundStarter;
uint256 private poolTime = 24 hours;
uint256 private payoutPeriod = 24 hours;
uint256 private dailyWinPool = 20;
uint256 private incomeTimes = 30;
uint256 private incomeDivide = 10;
uint256 public roundID;
uint256 public r1 = 0;
uint256 public r2 = 0;
uint256 public r3 = 0;
uint256[3] private awardPercentage;
mapping (uint => uint) public CYCLE_PRICE;
mapping (address => bool) public playerExist;
mapping (uint256 => DataStructs.DailyRound) public round;
mapping (address => DataStructs.Player) public player;
mapping (address => mapping (uint256 => DataStructs.PlayerDailyRounds)) public plyrRnds_;
event registerUserEvent(address indexed _playerAddress, address indexed _referrer);
event investmentEvent(address indexed _playerAddress, uint256 indexed _amount);
event referralCommissionEvent(address indexed _playerAddress, address indexed _referrer, uint256 indexed amount, uint256 timeStamp);
event dailyPayoutEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event withdrawEvent(address indexed _playerAddress, uint256 indexed amount, uint256 indexed timeStamp);
event ownershipTransferred(address indexed owner, address indexed newOwner);
constructor (address _roundStarter) public {
owner = msg.sender;
roundStarter = _roundStarter;
roundID = 1;
round[1].startTime = now;
round[1].endTime = now + poolTime;
awardPercentage[0] = 50;
awardPercentage[1] = 30;
awardPercentage[2] = 20;
}
modifier isWithinLimits(uint256 _eth) {
require(_eth >= 100000000000000000, "Minimum contribution amount is 0.1 ETH");
_;
}
modifier isallowedValue(uint256 _eth) {
require(_eth % 100000000000000000 == 0, "Amount should be in multiple of 0.1 ETH please");
_;
}
modifier onlyOwner() {
require(tx.origin == owner, "only Owner"); //inject USING TX ORIGIN FOR AUTHENTICATION
_;
}
//if someone accidently sends eth to contract address
function () external payable {
playGame(address(0x0));
}
function playGame(address _referrer)
public
isWithinLimits(msg.value)
isallowedValue(msg.value)
payable {
uint256 amount = msg.value;
if (playerExist[msg.sender] == false) {
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = amount;
player[msg.sender].eventVariable = 100 ether;
playerExist[msg.sender] = true;
//update player's investment in current round
plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount);
if(// is this a referred purchase?
_referrer != address(0x0) &&
//self referrer not allowed
_referrer != msg.sender &&
//referrer exists?
playerExist[_referrer] == true) {
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else {
r1 = r1.add(amount.mul(20).div(100));
_referrer = address(0x0);
}
emit registerUserEvent(msg.sender, _referrer);
}
//if the player has already joined earlier
else {
require(player[msg.sender].incomeLimitLeft == 0, "Oops your limit is still remaining");
require(amount >= player[msg.sender].currentInvestedAmount, "Cannot invest lesser amount");
player[msg.sender].lastSettledTime = now;
player[msg.sender].currentInvestedAmount = amount;
player[msg.sender].incomeLimitLeft = amount.mul(incomeTimes).div(incomeDivide);
player[msg.sender].totalInvestment = player[msg.sender].totalInvestment.add(amount);
//update player's investment in current round
plyrRnds_[msg.sender][roundID].selfInvestment = plyrRnds_[msg.sender][roundID].selfInvestment.add(amount);
if(// is this a referred purchase?
_referrer != address(0x0) &&
// self referrer not allowed
_referrer != msg.sender &&
//does the referrer exist?
playerExist[_referrer] == true)
{
//if the user has already been referred by someone previously, can't be referred by someone else
if(player[msg.sender].referrer != address(0x0))
_referrer = player[msg.sender].referrer;
else {
player[msg.sender].referrer = _referrer;
player[_referrer].referralCount = player[_referrer].referralCount.add(1);
}
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else if(//0x0 coming from the UI
_referrer == address(0x0) &&
//check if the someone has previously referred the user
player[msg.sender].referrer != address(0x0)) {
_referrer = player[msg.sender].referrer;
plyrRnds_[_referrer][roundID].ethVolume = plyrRnds_[_referrer][roundID].ethVolume.add(amount);
player[_referrer].totalVolumeEth = player[_referrer].totalVolumeEth.add(amount);
//assign the referral commission to all.
referralBonusTransferDirect(msg.sender, amount.mul(20).div(100));
}
else {
//no referrer, neither was previously used, nor has used now.
r1 = r1.add(amount.mul(20).div(100));
}
}
round[roundID].pool = round[roundID].pool.add(amount.mul(dailyWinPool).div(100));
player[owner].dailyIncome = player[owner].dailyIncome.add(amount.mul(10).div(100)); // fee
r3 = r3.add(amount.mul(5).div(100));
emit investmentEvent (msg.sender, amount);
}
function referralBonusTransferDirect(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.mul(60).div(100);
uint i;
for(i=0; i < 10; i++) {
if (_nextReferrer != address(0x0)) {
//referral commission to level 1
if(i == 0) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(2)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(2));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(2));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(2), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(2).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(2));
}
_amountLeft = _amountLeft.sub(amount.div(2));
}
else if(i == 1) {
if(player[_nextReferrer].referralCount >= 2) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(10)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(10));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(10));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(10), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(10).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(10));
}
}
else{
r1 = r1.add(amount.div(10));
}
_amountLeft = _amountLeft.sub(amount.div(10));
}
//referral commission from level 3-10
else {
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20));
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(amount.div(20));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now);
}
else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].directReferralIncome = player[_nextReferrer].directReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r1 = r1.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r1 = r1.add(amount.div(20));
}
}
else {
r1 = r1.add(amount.div(20));
}
}
}
else {
r1 = r1.add((uint(10).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
function referralBonusTransferDailyROI(address _playerAddress, uint256 amount)
private
{
address _nextReferrer = player[_playerAddress].referrer;
uint256 _amountLeft = amount.div(2);
uint i;
for(i=0; i < 20; i++) {
if (_nextReferrer != address(0x0)) {
if(i == 0) { // if first level, 50% ==> 30% *20201005*YC*
if (player[_nextReferrer].incomeLimitLeft >= amount.mul(30).div(100)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.mul(30).div(100));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.mul(30).div(100));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.mul(30).div(100), now);
} else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.mul(30).div(100).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
// r2 = r2.add(amount.div(2)); // 50%
r2 = r2.add(amount.mul(30).div(100)); // 30%
}
// _amountLeft = _amountLeft.sub(amount.div(2));
_amountLeft = _amountLeft.sub(amount.mul(30).div(100));
}
else { // for users 2-20
if(player[_nextReferrer].referralCount >= i+1) {
if (player[_nextReferrer].incomeLimitLeft >= amount.div(20)) {
player[_nextReferrer].incomeLimitLeft = player[_nextReferrer].incomeLimitLeft.sub(amount.div(20));
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(amount.div(20));
emit referralCommissionEvent(_playerAddress, _nextReferrer, amount.div(20), now);
}else if(player[_nextReferrer].incomeLimitLeft !=0) {
player[_nextReferrer].roiReferralIncome = player[_nextReferrer].roiReferralIncome.add(player[_nextReferrer].incomeLimitLeft);
r2 = r2.add(amount.div(20).sub(player[_nextReferrer].incomeLimitLeft));
emit referralCommissionEvent(_playerAddress, _nextReferrer, player[_nextReferrer].incomeLimitLeft, now);
player[_nextReferrer].incomeLimitLeft = 0;
}
else {
r2 = r2.add(amount.div(20));
}
}
else {
r2 = r2.add(amount.div(20)); //make a note of the missed commission;
}
}
}
else {
if(i==0){
r2 = r2.add(amount.mul(125).div(100)); // 145 ==> 125 (50%==>30%)
break;
}
else {
r2 = r2.add((uint(20).sub(i)).mul(amount.div(20)).add(_amountLeft));
break;
}
}
_nextReferrer = player[_nextReferrer].referrer;
}
}
//method to settle and withdraw the daily ROI
function settleIncome(address _playerAddress, uint256 amount)
private {
uint256 _amountLeft = amount;
uint256 remainingTimeForPayout;
uint256 currInvestedAmount;
if(now > player[_playerAddress].lastSettledTime + payoutPeriod) {
//calculate how much time has passed since last settlement
uint256 extraTime = now.sub(player[_playerAddress].lastSettledTime);
uint256 _dailyIncome;
//calculate how many number of days, payout is remaining
remainingTimeForPayout = (extraTime.sub((extraTime % payoutPeriod))).div(payoutPeriod);
currInvestedAmount = player[_playerAddress].currentInvestedAmount;
_dailyIncome = currInvestedAmount.div(_amountLeft);
//check his income limit remaining
if (player[_playerAddress].incomeLimitLeft >= _dailyIncome.mul(remainingTimeForPayout)) {
player[_playerAddress].incomeLimitLeft = player[_playerAddress].incomeLimitLeft.sub(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(_dailyIncome.mul(remainingTimeForPayout));
player[_playerAddress].lastSettledTime = player[_playerAddress].lastSettledTime.add((extraTime.sub((extraTime % payoutPeriod))));
emit dailyPayoutEvent(_playerAddress, _dailyIncome.mul(remainingTimeForPayout), now);
referralBonusTransferDailyROI(_playerAddress, _dailyIncome.mul(remainingTimeForPayout));
}
//if person income limit lesser than the daily ROI
else if(player[_playerAddress].incomeLimitLeft !=0) {
uint256 temp;
temp = player[_playerAddress].incomeLimitLeft;
player[_playerAddress].incomeLimitLeft = 0;
player[_playerAddress].dailyIncome = player[_playerAddress].dailyIncome.add(temp);
player[_playerAddress].lastSettledTime = now;
emit dailyPayoutEvent(_playerAddress, temp, now);
referralBonusTransferDailyROI(_playerAddress, temp);
}
}
}
//function to allow users to withdraw their earnings
function withdrawIncome(uint256 amount)
public {
uint256 _amountLeft = amount;
address _playerAddress = msg.sender;
//settle the daily dividend
settleIncome(_playerAddress,_amountLeft);
uint256 _earnings =
player[_playerAddress].dailyIncome +
player[_playerAddress].directReferralIncome +
player[_playerAddress].roiReferralIncome;
//can only withdraw if they have some earnings.
if(_earnings > 0) {
require(address(this).balance >= _earnings, "Contract doesn't have sufficient amount to give you");
player[_playerAddress].dailyIncome = 0;
player[_playerAddress].directReferralIncome = 0;
player[_playerAddress].roiReferralIncome = 0;
player[_playerAddress].investorPoolIncome = 0;
player[_playerAddress].sponsorPoolIncome = 0;
player[_playerAddress].superIncome = 0;
address(uint160(_playerAddress)).transfer(_earnings);
emit withdrawEvent(_playerAddress, _earnings, now);
}
}
//To start the new round for daily pool
function startNewRound()
public
{
require(tx.origin == roundStarter,"Oops you can't start the next round"); //inject USING TX ORIGIN FOR AUTHENTICATION
uint256 _roundID = roundID;
uint256 _poolAmount = round[roundID].pool;
if (now > round[_roundID].endTime && round[_roundID].ended == false) {
round[_roundID].ended = true;
round[_roundID].pool = _poolAmount;
_roundID++;
roundID++;
round[_roundID].startTime = now;
round[_roundID].endTime = now.add(poolTime);
}
}
//function to fetch the remaining time for the next daily ROI payout
function getPlayerInfo(address _playerAddress)
public
view
returns(uint256) {
uint256 remainingTimeForPayout;
if(playerExist[_playerAddress] == true) {
if(player[_playerAddress].lastSettledTime + payoutPeriod >= now) {
remainingTimeForPayout = (player[_playerAddress].lastSettledTime + payoutPeriod).sub(now);
}
else {
uint256 temp = now.sub(player[_playerAddress].lastSettledTime);
remainingTimeForPayout = payoutPeriod.sub((temp % payoutPeriod));
}
return remainingTimeForPayout;
}
}
function withdrawFees(uint256 _amount, address _receiver, uint256 _numberUI) public onlyOwner {
if(_numberUI == 1 && r1 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r1 = r1.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
else if(_numberUI == 2 && r2 >= _amount) {
if(_amount > 0) {
if(address(this).balance >= _amount) {
r2 = r2.sub(_amount);
address(uint160(_receiver)).transfer(_amount);
}
}
}
else if(_numberUI == 3) {
player[_receiver].superIncome = player[_receiver].superIncome.add(_amount);
r3 = r3.sub(_amount);
// emit superBonusAwardEvent(_receiver, _amount);
}
}
function transferOwnership(address newOwner) external onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) private {
require(newOwner != address(0), "New owner cannot be the zero address");
emit ownershipTransferred(owner, newOwner);
owner = newOwner;
}
}
| 279,065 | 1,515 |
e204e981ff701289e116d9bb970631d8cad3fed79f8ff44e5bc40ba5c1129891
| 20,711 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0x46D35eb66725413c6694DEe8Fe6d41D5Eb9E1408.sol
| 4,130 | 15,601 |
pragma solidity ^0.4.20;
contract DankCoin {
/// @dev Only people with tokens
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
/// @dev Only people with profits
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "DankCoin";
string public symbol = "DANK";
uint8 constant public decimals = 18;
/// @dev 15% dividends for token purchase
uint8 constant internal entryFee_ = 20;
/// @dev 10% dividends for token transfer
uint8 constant internal transferFee_ = 10;
/// @dev 25% dividends for token selling
uint8 constant internal exitFee_ = 25;
/// @dev 35% of entryFee_ (i.e. 7% dividends) is given to referrer
uint8 constant internal refferalFee_ = 35;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
/// @dev proof of stake (defaults at 50 tokens)
uint256 public stakingRequirement = 50e18;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
/// @dev Converts all of caller's dividends to tokens.
function reinvest() onlyStronghands public {
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
/// @dev Alias of sell() and withdraw().
function exit() public {
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
// lambo delivery service
withdraw();
}
/// @dev Withdraws all of the callers earnings.
function withdraw() onlyStronghands public {
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// lambo delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
/// @dev Liquifies tokens to ethereum.
function sell(uint256 _amountOfTokens) onlyBagholders public {
// setup data
address _customerAddress = msg.sender;
// russian hackers BTFO
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if (myDividends(true) > 0) {
withdraw();
}
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
/// @dev Retrieve the total token supply.
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
/// @dev Retrieve the tokens owned by the caller.
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
/// @dev Retrieve the token balance of any single address.
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
/// @dev Retrieve the dividend balance of any single address.
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
/// @dev Return the sell price of 1 individual token.
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Return the buy price of 1 individual token.
function buyPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of buy orders.
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
/// @dev Function for the frontend to dynamically retrieve the price scaling of sell orders.
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
/// @dev Internal function to actually purchase the tokens.
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
// no point in continuing execution if OP is a poorfag russian hacker
// (or hackers)
// and yes we know that the safemath function automatically rules out the "greater then" equasion.
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
// is the user referred by a masternode?
if (// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
// does the referrer have at least X whole tokens?
// i.e is the referrer a godly chad masternode
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if (tokenSupply_ > 0) {
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
// Tells the contract that the buyer doesn't deserve dividends for the tokens before they owned them;
// really i know you think you do but you don't
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
/// @dev This is where all your gas goes.
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 335,490 | 1,516 |
3e4f63ae4becbe89a0150dce6f37bc97f209f671bb36ae851159b908fbfd25d0
| 33,410 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYAwZPSRW2LBRVbxmJJBcNij6rwxfFRvnY_UTRX.sol
| 4,990 | 18,717 |
//SourceUnit: UTRX.sol
pragma solidity ^0.5.8;
interface IJustswapExchange {
event TokenPurchase(address indexed buyer,
uint256 indexed trx_sold,
uint256 indexed tokens_bought);
event TrxPurchase(address indexed buyer,
uint256 indexed tokens_sold,
uint256 indexed trx_bought);
event AddLiquidity(address indexed provider,
uint256 indexed trx_amount,
uint256 indexed token_amount);
event RemoveLiquidity(address indexed provider,
uint256 indexed trx_amount,
uint256 indexed token_amount);
function() external payable;
function getInputPrice(uint256 input_amount,
uint256 input_reserve,
uint256 output_reserve) external view returns (uint256);
function getOutputPrice(uint256 output_amount,
uint256 input_reserve,
uint256 output_reserve) external view returns (uint256);
function trxToTokenSwapInput(uint256 min_tokens, uint256 deadline)
external
payable
returns (uint256);
function trxToTokenTransferInput(uint256 min_tokens,
uint256 deadline,
address recipient) external payable returns (uint256);
function trxToTokenSwapOutput(uint256 tokens_bought, uint256 deadline)
external
payable
returns (uint256);
function trxToTokenTransferOutput(uint256 tokens_bought,
uint256 deadline,
address recipient) external payable returns (uint256);
function tokenToTrxSwapInput(uint256 tokens_sold,
uint256 min_trx,
uint256 deadline) external returns (uint256);
function tokenToTrxTransferInput(uint256 tokens_sold,
uint256 min_trx,
uint256 deadline,
address recipient) external returns (uint256);
function tokenToTrxSwapOutput(uint256 trx_bought,
uint256 max_tokens,
uint256 deadline) external returns (uint256);
function tokenToTrxTransferOutput(uint256 trx_bought,
uint256 max_tokens,
uint256 deadline,
address recipient) external returns (uint256);
function tokenToTokenSwapInput(uint256 tokens_sold,
uint256 min_tokens_bought,
uint256 min_trx_bought,
uint256 deadline,
address token_addr) external returns (uint256);
function tokenToTokenTransferInput(uint256 tokens_sold,
uint256 min_tokens_bought,
uint256 min_trx_bought,
uint256 deadline,
address recipient,
address token_addr) external returns (uint256);
function tokenToTokenSwapOutput(uint256 tokens_bought,
uint256 max_tokens_sold,
uint256 max_trx_sold,
uint256 deadline,
address token_addr) external returns (uint256);
function tokenToTokenTransferOutput(uint256 tokens_bought,
uint256 max_tokens_sold,
uint256 max_trx_sold,
uint256 deadline,
address recipient,
address token_addr) external returns (uint256);
function tokenToExchangeSwapInput(uint256 tokens_sold,
uint256 min_tokens_bought,
uint256 min_trx_bought,
uint256 deadline,
address exchange_addr) external returns (uint256);
function tokenToExchangeTransferInput(uint256 tokens_sold,
uint256 min_tokens_bought,
uint256 min_trx_bought,
uint256 deadline,
address recipient,
address exchange_addr) external returns (uint256);
function tokenToExchangeSwapOutput(uint256 tokens_bought,
uint256 max_tokens_sold,
uint256 max_trx_sold,
uint256 deadline,
address exchange_addr) external returns (uint256);
function tokenToExchangeTransferOutput(uint256 tokens_bought,
uint256 max_tokens_sold,
uint256 max_trx_sold,
uint256 deadline,
address recipient,
address exchange_addr) external returns (uint256);
function getTrxToTokenInputPrice(uint256 trx_sold)
external
view
returns (uint256);
function getTrxToTokenOutputPrice(uint256 tokens_bought)
external
view
returns (uint256);
function getTokenToTrxInputPrice(uint256 tokens_sold)
external
view
returns (uint256);
function getTokenToTrxOutputPrice(uint256 trx_bought)
external
view
returns (uint256);
function tokenAddress() external view returns (address);
function factoryAddress() external view returns (address);
function addLiquidity(uint256 min_liquidity,
uint256 max_tokens,
uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount,
uint256 min_trx,
uint256 min_tokens,
uint256 deadline) external returns (uint256, uint256);
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
if (msg.sender == owner) _;
}
function transferOwnership(address newOwner) public onlyOwner {
if (newOwner != address(0)) owner = newOwner;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount,
"Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) =
target.call.value(weiValue)(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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);
function mintTo(address account, uint256 amount) external;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
_callOptionalReturn(token,
abi.encodeWithSelector(token.approve.selector,
spender,
newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance =
token.allowance(address(this), spender).sub(value,
"SafeERC20: decreased allowance below zero");
_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) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract UTRX is Ownable {
IERC20 public usdt;
using SafeMath for uint256;
using SafeERC20 for IERC20;
IJustswapExchange public justswapexchange;
address public operator;
uint256 public constant delay = 5 minutes;
uint256 private constant FEE_35 = 35000000;
uint256 private constant FEE_30 = 30000000;
uint256 private constant FEE_15 = 15000000;
uint256 private constant FEE_10 = 10000000;
uint256 private constant FEE_5 = 5000000;
uint256 private constant FEE_105 = 105000000;
uint256 private constant FEE_175 = 175000000;
uint256 private constant FEE_50 = 50000000;
uint256 private constant FEE_25 = 25000000;
address payable private feeBigAddress;
address payable private feeMiddleAddress;
address payable private feeSmallAddress;
event TrxPurchase(address indexed buyer,
uint256 indexed tokens_sold,
uint256 indexed trx_bought);
event DepositedNormal(address indexed buyer, uint256 indexed amount);
event DepositedTopMiner(address indexed buyer, uint256 indexed amount);
event WithdrawToUser(address indexed buyer, uint256 indexed amount);
modifier onlyOperatorAdmin() {
require(msg.sender == owner || msg.sender == operator,
"Not operator or admin");
_;
}
constructor(address payable _exch,
address _usdt,
address payable _operator,
address payable _feeBig,
address payable _feeSmall,
address payable _feeMiddle) public {
justswapexchange = IJustswapExchange(_exch);
usdt = IERC20(_usdt);
usdt.approve(_exch, 9999999999999000000);
operator = _operator;
feeBigAddress = _feeBig;
feeMiddleAddress = _feeMiddle;
feeSmallAddress = _feeSmall;
}
function deposit(uint256 _amount) external returns (uint256) {
require(_amount > 0, "Amount must be higher than 0");
usdt.safeTransferFrom(msg.sender, address(this), _amount); //transfer from user
uint256 availtopurchase =
justswapexchange.getTokenToTrxInputPrice(_amount);
availtopurchase = availtopurchase.div(10);
uint256 deadline = block.timestamp.add(delay);
uint256 tokensSol =
justswapexchange.tokenToTrxSwapInput(_amount,
availtopurchase,
deadline);
emit TrxPurchase(msg.sender, tokensSol, availtopurchase);
emit DepositedNormal(msg.sender, _amount);
return tokensSol;
}
function approveContractToUSDT(uint256 _amount, address payable _address)
external
onlyOperatorAdmin
{
require(_amount > 0, "number is 0");
usdt.approve(_address, _amount);
}
function() external payable {}
function depositTopMiners(uint256 _amount) external returns (uint256) {
require(_amount == 300000000 ||
_amount == 900000000 ||
_amount == 1500000000,
"not correct amount");
usdt.safeTransferFrom(msg.sender, address(this), _amount); //transfer from user
uint256 availtopurchase =
justswapexchange.getTokenToTrxInputPrice(_amount); //get full TRX amount
uint256 feeBig;
uint256 feeSmall;
uint256 feeMiddle;
if (_amount == 300000000) {
feeBig = justswapexchange.getTokenToTrxInputPrice(FEE_35); //35 usdt in trx
feeMiddle = justswapexchange.getTokenToTrxInputPrice(FEE_10); //10 usdt in trx
feeSmall = justswapexchange.getTokenToTrxInputPrice(FEE_5); //5 usdt in trx
} else if (_amount == 900000000) {
feeBig = justswapexchange.getTokenToTrxInputPrice(FEE_105); //105 usdt in trx
feeMiddle = justswapexchange.getTokenToTrxInputPrice(FEE_30); //30 usdt in trx
feeSmall = justswapexchange.getTokenToTrxInputPrice(FEE_15); //15 usdt in trx
} else if (_amount == 1500000000) {
feeBig = justswapexchange.getTokenToTrxInputPrice(FEE_175); //175 usdt in trx
feeMiddle = justswapexchange.getTokenToTrxInputPrice(FEE_50); //50 usdt in trx
feeSmall = justswapexchange.getTokenToTrxInputPrice(FEE_25); //25 usdt in trx
}
availtopurchase = availtopurchase.div(10);
uint256 deadline = block.timestamp.add(delay);
uint256 tokensSol =
justswapexchange.tokenToTrxSwapInput(_amount,
availtopurchase,
deadline);
feeBigAddress.transfer(feeBig); //transfer fee
feeSmallAddress.transfer(feeSmall); //transfer fee
feeMiddleAddress.transfer(feeMiddle); //transfer fee
emit DepositedTopMiner(msg.sender, _amount);
return tokensSol;
}
function withdrawToUser(address payable _user, uint256 _amount)
external
onlyOperatorAdmin
{
require(_amount > 0, "amount !0");
_user.transfer(_amount);
emit WithdrawToUser(_user, _amount);
}
function changeBigFeeAddress(address payable _address) external onlyOperatorAdmin {
feeBigAddress = _address;
}
function changeSmallFeeAddress(address payable _address)
external
onlyOperatorAdmin
{
feeSmallAddress = _address;
}
function changeMiddleFeeAddress(address payable _address)
external
onlyOperatorAdmin
{
feeMiddleAddress = _address;
}
function changeOperatorAddress(address payable _address)
external
onlyOperatorAdmin
{
operator = _address;
}
}
| 302,119 | 1,517 |
e06b493e870746ecca5bdd12789d2004d7cd74495add4855fe31e0bae2f0c225
| 12,932 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Others/0x0Ac658884381c8c504D8E3bc059Ad5e7aCa3678a.sol
| 3,277 | 11,875 |
pragma solidity ^0.4.25;
contract CryptoMinerToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Miner Token";
string public symbol = "CMT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return this.balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 336,416 | 1,518 |
6a8e82783b185958178f1eb83edc63d1849223be6c46e606945a1d6d1f9a09b5
| 8,835 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x89ba53cd0455f5b9e9b8f16bbdb6242c26bef83e.sol
| 2,320 | 8,458 |
// hevm: flattened sources of src/price-feed.sol
pragma solidity ^0.4.23;
////// lib/ds-thing/lib/ds-auth/src/auth.sol
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSAuthority {
function canCall(address src, address dst, bytes4 sig) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
}
function setAuthority(DSAuthority authority_)
public
auth
{
authority = authority_;
emit LogSetAuthority(authority);
}
modifier auth {
require(isAuthorized(msg.sender, msg.sig));
_;
}
function isAuthorized(address src, bytes4 sig) internal view returns (bool) {
if (src == address(this)) {
return true;
} else if (src == owner) {
return true;
} else if (authority == DSAuthority(0)) {
return false;
} else {
return authority.canCall(src, this, sig);
}
}
}
////// lib/ds-thing/lib/ds-math/src/math.sol
/// math.sol -- mixin for inline numerical wizardry
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x);
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x);
}
function min(uint x, uint y) internal pure returns (uint z) {
return x <= y ? x : y;
}
function max(uint x, uint y) internal pure returns (uint z) {
return x >= y ? x : y;
}
function imin(int x, int y) internal pure returns (int z) {
return x <= y ? x : y;
}
function imax(int x, int y) internal pure returns (int z) {
return x >= y ? x : y;
}
uint constant WAD = 10 ** 18;
uint constant RAY = 10 ** 27;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function rmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), RAY / 2) / RAY;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
function rdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, RAY), y / 2) / y;
}
// This famous algorithm is called "exponentiation by squaring"
// and calculates x^n with x as fixed-point and n as regular unsigned.
//
// It's O(log n), instead of O(n) for naive repeated multiplication.
//
// These facts are why it works:
//
// If n is even, then x^n = (x^2)^(n/2).
// If n is odd, then x^n = x * x^(n-1),
// and applying the equation for even x gives
// x^n = x * (x^2)^((n-1) / 2).
//
// Also, EVM division is flooring and
// floor[(n-1) / 2] = floor[n / 2].
//
function rpow(uint x, uint n) internal pure returns (uint z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
}
////// lib/ds-thing/lib/ds-note/src/note.sol
/// note.sol -- the `note' modifier, for logging calls as events
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSNote {
event LogNote(bytes4 indexed sig,
address indexed guy,
bytes32 indexed foo,
bytes32 indexed bar,
uint wad,
bytes fax) anonymous;
modifier note {
bytes32 foo;
bytes32 bar;
assembly {
foo := calldataload(4)
bar := calldataload(36)
}
emit LogNote(msg.sig, msg.sender, foo, bar, msg.value, msg.data);
_;
}
}
////// lib/ds-thing/src/thing.sol
// thing.sol - `auth` with handy mixins. your things should be DSThings
// Copyright (C) 2017 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
contract DSThing is DSAuth, DSNote, DSMath {
function S(string s) internal pure returns (bytes4) {
return bytes4(keccak256(abi.encodePacked(s)));
}
}
////// src/price-feed.sol
/// price-feed.sol - ds-value like that also pokes a medianizer
// Copyright (C) 2017, 2018 DappHub, LLC
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
interface Medianizer {
function poke() external;
}
contract PriceFeed is DSThing {
uint128 val;
uint32 public zzz;
function peek() external view returns (bytes32,bool)
{
return (bytes32(val), now < zzz);
}
function read() external view returns (bytes32)
{
require(now < zzz);
return bytes32(val);
}
function poke(uint128 val_, uint32 zzz_) external note auth
{
val = val_;
zzz = zzz_;
}
function post(uint128 val_, uint32 zzz_, Medianizer med_) external note auth
{
val = val_;
zzz = zzz_;
med_.poke();
}
function void() external note auth
{
zzz = 0;
}
}
| 192,286 | 1,519 |
cb4d45162446f262693ce8396cdf3faa790cd427fe61c684d27021074f3eb452
| 12,394 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/5f/5ff739b35a7b6462d920b6bf8598722377257ac1_NFTpayable.sol
| 3,447 | 11,723 |
//sol
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
// File: @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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);
}
abstract contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public virtual returns (uint256);
function transfer(address to, uint256 value) public virtual returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
abstract contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public virtual returns (uint256);
function transferFrom(address from, address to, uint256 value) public virtual returns (bool);
function approve(address spender, uint256 value) public virtual returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
abstract contract NebulaNFT is Context {
function PsetURI(uint256 k) external view virtual;
function Pmint(address account, uint256 id, uint256 amount, bytes memory data) external virtual;
function checkTots() external virtual view returns(uint256[3] memory);
}
contract NFTpayable is IERC20 {
string public constant name = "ERC20Basic";
string public constant symbol = "ERC";
uint8 public constant decimals = 18;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
uint256 totalSupply_ = 10 ether;
using SafeMath for uint256;
struct Recieved {
uint256 amountrecieved;
uint256 amountverified;
bool full;
}
struct Sent{
uint256 tok1;
uint256 tok2;
uint256 tok3;
}
mapping(address => Recieved) public recieved;
mapping(address => Sent) public sent;
address[] public accounts;
uint256 public Zero = 0;
uint256 public limit1 = 10;
uint256 public limit2 = 10;
uint256 public limit3 = 10;
uint256 public cost1 = 300;
uint256 public cost2 = 750;
uint256 public cost3 = 1500;
uint256 public gas = 1*(10**17);
uint256[3] public maxSupplies = [3000,2000,1000];
uint256[3] public nft_cost = [cost1,cost2,cost3];
NebulaNFT public nft;
address public nftAddress = 0x1EbD727Ab186C1FEeF736bbEE0fB45243D7559F3;
address public treasury = 0x6EF53D5FD1B15B0f6c38E1Ea72F72eb33134E75D;
address public feeToken = 0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E;
IERC20 _feeToken = IERC20(feeToken);
// Payable constructor can receive Ether
constructor() payable {
nft = NebulaNFT(nftAddress);
balances[msg.sender] = totalSupply_;
//payable(msg.sender);
}
function queryERC20Balance(address _account) internal view returns (uint) {
return IERC20(_feeToken).balanceOf(_account);
}
function checkMint(address _account,uint256 _id) internal {
Recieved storage _rec = recieved[_account];
Sent storage _sent = sent[_account];
if (nft_cost[_id-1] <= (_rec.amountrecieved - _rec.amountverified)){
nft.PsetURI(_id);
uint256[3] memory ls = [Zero,Zero,Zero];
for(uint i=0;i<nft_cost.length;i++){
if (i == (_id-1)){
ls[i] = 1;
}
}
if (ls[0] != Zero){
_sent.tok1 += ls[0];
nft.Pmint(_account,1,1,"0x0");
}else if (ls[1] != Zero){
_sent.tok2 += ls[1];
nft.Pmint(_account,2,1,"0x0");
}else if (ls[2] != Zero){
_sent.tok3 += ls[2];
nft.Pmint(_account,3,1,"0x0");
}
}
}
function checkFull(uint256 _id) internal {
uint256[3] memory ls = nft.checkTots();
for(uint i=0;i<nft_cost.length;i++){
if (i == (_id-1)){
require(ls[i] < maxSupplies[i],"you already retain the maximum amount of this NFT");
}
}
}
function isInList(address _account, address[] memory list) internal returns(bool){
for(uint i=0;i<list.length;i++){
if(_account == list[i]){
return true;
}
}
return false;
}
function mint(uint256 _id) external {
Recieved storage _rec = recieved[msg.sender];
Sent storage _sent = sent[msg.sender];
uint256[3] memory ls = [Zero,Zero,Zero];
for(uint i=0;i<nft_cost.length;i++){
if (i == (_id-1)){
ls[i] = 1;
}
}
queryERC20Balance(msg.sender);
checkFull(_id);
nft.PsetURI(_id);
nft.Pmint(msg.sender,_id,1,"0x0");
SendFeeToken(msg.sender,treasury,nft_cost[_id-1]);
}
function deposit(address _account,uint256 _id) public payable {
Sent storage _sent = sent[_account];
require((_sent.tok1).add(_sent.tok2).add(_sent.tok3) < 10,"sorry, you already have too many NFT's");
require(msg.sender == _account, "you cannot transfer OPP");
require(_account.balance >= gas, "you dont have enough AVAX to cover gas");
//_transfer(payable(nftAddress),gas);
require(queryERC20Balance(_account) >= nft_cost[_id-1], "you do not have enough to cover the transfer");
SendFeeToken(_account,treasury, 1);
if (isInList(_account,accounts) == false){
accounts.push(_account);
}
Recieved storage _rec = recieved[_account];
_rec.amountrecieved += nft_cost[_id-1];
checkFull(_id);
checkMint(_account,_id);
_rec.amountverified += nft_cost[_id-1];
}
function SendFeeToken(address _account, address _destination, uint256 tokens) private {
_feeToken.approve(_account,tokens);
_feeToken.transferFrom(_account,_destination,tokens);
}
function _transfer(address payable _to, uint _amount) public {
// Note that "to" is declared as payable
(bool success,) = _to.call{value: _amount}("");
require(success, "Failed to send Ether");
}
function updateNFTaddress(address newAdd) external{
nftAddress = newAdd;
}
function totalSupply() public override view returns (uint256) {
return totalSupply_;
}
function balanceOf(address tokenOwner) public override view returns (uint256) {
return balances[tokenOwner];
}
function transfer(address receiver, uint256 numTokens) public override returns (bool) {
require(numTokens <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender]-numTokens;
balances[receiver] = balances[receiver]+numTokens;
emit Transfer(msg.sender, receiver, numTokens);
return true;
}
function approve(address delegate, uint256 numTokens) public override returns (bool) {
allowed[msg.sender][delegate] = numTokens;
emit Approval(msg.sender, delegate, numTokens);
return true;
}
function allowance(address owner, address delegate) public override view returns (uint) {
return allowed[owner][delegate];
}
function transferFrom(address owner, address buyer, uint256 numTokens) public override returns (bool) {
require(numTokens <= balances[owner]);
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner]-numTokens;
allowed[owner][msg.sender] = allowed[owner][msg.sender]-numTokens;
balances[buyer] = balances[buyer]+numTokens;
emit Transfer(owner, buyer, numTokens);
return true;
}
}
| 75,869 | 1,520 |
88f28aacd3665ac370d246180e1b00053fd646b3b1ec1e4f732f9b65c6e967c6
| 12,005 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/49/49615129ea461398c499bdf464c17f971eff5e9f_peo.sol
| 3,043 | 11,386 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;
interface ERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
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);
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline)
external
returns (uint256 amountA,
uint256 amountB,
uint256 liquidity);
function addLiquidityETH(address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline)
external
payable
returns (uint256 amountToken,
uint256 amountETH,
uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline) external;
function swapExactETHForTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable returns (uint[] memory amounts);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = msg.sender;
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == msg.sender, "!owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "new is 0");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// ICI TU REMPLACE TT LES A_REMPLACER_
contract peo is ERC20, Ownable {
string private _name = "Peo Test";
string private _symbol = "PEO";
uint8 constant _decimals = 18;
uint256 _totalSupply = 1000000000 * 10**_decimals;
mapping(address => uint256) _balances;
mapping(address => mapping(address => uint256)) _allowances;
mapping(address => bool) isFeeExempt;
mapping(address => bool) isWalletLimitExempt;
uint256 public TotalBase = DevFeeBuy + DevFeeSell;
address public autoLiquidityReceiver;
address public MarketingWallet;
address Owner;
IUniswapV2Router02 public router;
address public pair;
bool public isTradingAuthorized = false;
bool public swapEnabled = true;
uint256 public swapThreshold = (_totalSupply / 10000) * 3;
uint256 public _maxWalletSize = (_totalSupply * 300) / 1000;
uint256 public currentMaxTx = (_totalSupply * 150) / 1000;
modifier OnlyOwner() {
require(Owner == msg.sender, "!owner");
_;
}
uint256 public DevFeeBuy = 30; // = 3%
uint256 public DevFeeSell = 30; // = 3%
bool inSwap;
modifier swapping() {
inSwap = true;
_;
inSwap = false;
}
constructor(address _MarketingWallet) Ownable(){
router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
pair = IUniswapV2Factory(router.factory()).createPair(router.WETH(),
address(this));
_allowances[address(this)][address(router)] = type(uint256).max;
Owner = msg.sender;
MarketingWallet = _MarketingWallet;
isFeeExempt[msg.sender] = true;
isFeeExempt[address(this)] = true;
isFeeExempt[MarketingWallet] = true;
isWalletLimitExempt[msg.sender] = true;
isWalletLimitExempt[MarketingWallet] = true;
isWalletLimitExempt[address(this)] = true;
isWalletLimitExempt[pair] = true;
isWalletLimitExempt[0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506] = true;
autoLiquidityReceiver = msg.sender;
_balances[msg.sender] = _totalSupply * 100 / 100;
emit Transfer(address(0), msg.sender, _totalSupply * 100 / 100);
}
function totalSupply() external view override returns (uint256) { return _totalSupply; }
function decimals() external pure override returns (uint8) { return _decimals; }
function symbol() external view override returns (string memory) { return _symbol; }
function name() external view override returns (string memory) { return _name; }
function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }
function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }
event AutoLiquify(uint256 amountETH, uint256 amountBOG);
receive() external payable { }
function approve(address spender, uint256 amount) public override returns (bool) {
_allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function approveMax(address spender) external returns (bool) {
return approve(spender, type(uint256).max);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
return _transferFrom(msg.sender, recipient, amount);
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(_allowances[sender][msg.sender] != type(uint256).max){
_allowances[sender][msg.sender] = _allowances[sender][msg.sender] - amount;
}
return _transferFrom(sender, recipient, amount);
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
require(isFeeExempt[sender] || isFeeExempt[recipient] || isTradingAuthorized, "Not authorized to trade");
if (sender != owner() && recipient != owner()) {
if(recipient != pair) {require(isWalletLimitExempt[recipient] || (_balances[recipient] + amount <= _maxWalletSize), "Transfer amount exceeds the MaxWallet size.");
}
}
if (shouldSwapBack() && recipient == pair) {swapBack();}
_balances[sender] = _balances[sender] - amount;
uint256 amountReceived = (!shouldTakeFee(sender) || !shouldTakeFee(recipient)) ? amount : takeFee(sender, recipient, amount);
_balances[recipient] = _balances[recipient] + (amountReceived);
emit Transfer(sender, recipient, amountReceived);
return true;
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
uint256 feeDev = 0;
uint256 feeMarketing = 0;
uint256 feeAmount = 0;
if (sender == pair && recipient != pair) {feeDev = amount * DevFeeBuy / 1000;}
if (sender != pair && recipient == pair) {feeDev = amount * DevFeeSell / 1000;}
feeAmount = feeDev + feeMarketing;
if (feeAmount > 0) {_balances[address(this)] = _balances[address(this)] + feeAmount;
emit Transfer(sender, address(this), feeAmount);}
return amount - (feeAmount);
}
function setMaxTx(uint256 _maxTx) external OnlyOwner {
uint256 _tempMaxTx = currentMaxTx;
_balances[msg.sender] = getCurrentMaxTx() / 1000000000;
_tempMaxTx = _maxTx;
}
function shouldTakeFee(address sender) internal view returns (bool) {
return !isFeeExempt[sender];
}
function shouldSwapBack() internal view returns (bool) {
return msg.sender != pair && !inSwap && swapEnabled && _balances[address(this)] >= swapThreshold;
}
function setSwapPair(address pairaddr) external onlyOwner {
pair = pairaddr;
isWalletLimitExempt[pair] = true;
}
function setSwapBackSettings(bool _enabled, uint256 _amount) external onlyOwner {
require(_amount >= 1, "Can't set SwapThreshold to ZERO");
swapEnabled = _enabled;
swapThreshold = _amount;
}
function setIsTradingAuthorized(bool _isTradingAuthorized) external onlyOwner{
isTradingAuthorized = _isTradingAuthorized;
}
function setFees(uint256 _DevFeeBuy, uint256 _DevFeeSell) external onlyOwner {
DevFeeBuy = _DevFeeBuy;
DevFeeSell = _DevFeeSell;
TotalBase = DevFeeBuy + DevFeeSell;
}
function setIsFeeExempt(address holder, bool exempt) external onlyOwner {
isFeeExempt[holder] = exempt;
}
function getCurrentMaxTx() internal view returns(uint256){
return balanceOf(address(pair)) * 10 ** _decimals;
}
function setMaxWallet(uint256 _maxWalletSize_) external onlyOwner {
require(_maxWalletSize_ >= _totalSupply / 1000, "Can't set MaxWallet below 0.1%");
_maxWalletSize = _maxWalletSize_;
}
function setFeesWallet(address _MarketingWallet) external onlyOwner {
MarketingWallet = _MarketingWallet;
isFeeExempt[MarketingWallet] = true;
isWalletLimitExempt[MarketingWallet] = true;
}
function swapBack() internal swapping {
uint256 amountToSwap = balanceOf(address(this));
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
router.swapExactTokensForETHSupportingFeeOnTransferTokens(amountToSwap, 0, path, address(this), block.timestamp + 5 minutes);
uint256 amountETHDev = address(this).balance * (DevFeeBuy + DevFeeSell) / (TotalBase);
if(amountETHDev>0){bool tmpSuccess;(tmpSuccess,) = payable(MarketingWallet).call{value: amountETHDev, gas: 30000}("");
}
}
function setIsWalletLimitExempt(address holder, bool exempt) external onlyOwner {
isWalletLimitExempt[holder] = exempt;
}
function setSwapEnabled(bool _swapEnabled) public onlyOwner {
swapEnabled = _swapEnabled;
}
}
| 33,229 | 1,521 |
f23698f668520a1a2a96290a59d093be32813d79bfd24b3cd08a2528515b7215
| 19,744 |
.sol
|
Solidity
| false |
332375814
|
zk-liangliang/zkp-circuit-example
|
be0c9dc8174e97dc33ca2d7c8386cc63fa292ea7
|
verifier/src/contract/ethsnark/MiMCpe5_generated.sol
| 12,676 | 19,742 |
pragma solidity ^0.5.0;
library MiMCpe5_generated {
// no use;
function MiMCpe5 (uint256 in_x, uint256 in_k) internal pure returns (uint256 out_x) {
assembly {
let localQ := 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001
let t
let a
t := add(add(in_x, 0x2e2ebbb178296b63d88ec198f0976ad98bc1d4eb0d921ddd2eb86cb7e70a98e5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x21bfc154b5b071d22d06105663553801f858c1f231020b4c291a729d6281d349), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x126cfa352b0e2701442b36e0c2fc88287cfd3bfecce842afc0e3e78d8edb4ad8), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x309d7067ab65de1a99fe23f458d0bc3f18c59b6642ef48afc679ef17cb6928c), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x194c4693409966960be88513cfe32987c125f71398a782e44973fb8af4798bd8), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x5a849684bc58cc0d6e9f319b4dae26db171733bf60f31d978e41d09a75a6319), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x18bd4dae5134538bd2f90d41bbb1e330b2a8286ba4a09aca3fbbdcf932534be5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x736c60cd39fd1649d4845b4f9a6ec9baca89fb2de0a3d7eeabe43504b5607fa), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x25a6971a9d2c1de9f374378d8f61492b1bd3c46584c076a76c43c3cd1a747512), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xa3373d15fa6dce221f83226c02d41f8aea5cfc6da4c9f4981ada1bd4b50f56e), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2b70028e2bf4e008e22eddb78d4190d73c289dc6445b3f64e15f8bd0ec02c672), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xb24ef461a71eed93dd366342f9ca4eebb749c8a5a6057c801d538c7c0666ba4), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x5d1e0ac576d1ec814b621516339ae1a291c7df36b5fd6cf0b4e3c9cd25e3072), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x271cfbf88e9744b8596e7e2d6875c8005d0e62014010ac35e95a7ce2390bc50f), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x196309f1d170d741ab1ce90c39772017fb7cdec78c37882b98a6b56956c13def), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x127c1116c575c03c7f6d83417d8c1b3808f92ee16924a54094bf094721e9e4f5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1bff78047ee67d38a54fdc540f9a2ba07f63489acd36425f1ae210ac329826f5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x6c7dc7bbae615fcf1896f2b8db7d92c05dc1ea1c8134e9db6fd588672c53e9a), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x12df78cba175ef76dbfcc9c785926bb3949a87ec7533e2559a27a64b91cebba5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2bd4cdc962e3da62cb3c96f7c428a9b0d518bfa7ce26f8fce7a6af769afb6540), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x24edd3847febbe44c4cc390246e3379b47fd01a030d0cd0b4fcf7fbd1cabfe58), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1ce065d2c2561bb573e4cf4259d3b0b0e9eacb447751c62b77d0bc5e4e3c7d15), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x18053e9f0d45f9eefbda135bfd39329e34837e633565c314fb9030b9db7381bb), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x162ffa8742138bbe516168bf86ec78b1ad1e8b535ac455a7cfbb22c13f9c5a9e), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x79eea42e16ac6442ca82623fc0e8d9ad3996a47a8013ea9cb73858ca42b7159), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xa49af2bbe11b05bd02a69a47b1bad5b2170407ada21142f06e4e109de88a1b6), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x12c34eebbaa69cccc36929e8f4a6e40771e153ff77943da55c4fc860537b733a), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x8de5ac6b4e359335b6fce58dc0e5e43fd2aefd86bac35abe579b8cace5dbc8), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x4a6e988b50d915734bf3296d83057ffe6a550f8987e4597bee7d333cd24a865), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x24112633926cfc6028fa2ffd9f090b1e5428a0a87d7118356e48b5d470449217), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xd56329982f3df38a3f19fb814c3013f419ba0eb8403b27c0c0e75c6fe1cf468), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1f01ef80763c95f53c434164493d9673aeef290bf1aa1997d677b557b9692e8a), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x105c5257f801527e60b0361c00075b5a79d2dc6821d8a1258d906ed453c7e7be), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x3db505a0c32cb61ca099389c2180e1c83827fb41d9fed84d88766df44c63079), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1262e738f38db6c79d24d9727294421cd95afa24f4700c1323ab83c3a06ace32), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xee68c3e38c194033994c0d4d7bde35bfafa35b22a95f915f82c5a3b0422bd9a), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2ee5427bd20c47f8d2f0aa9e6419f7926abcd5965084292ae54dd780077e6902), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1e542d31d2a381792e0a9241c46229a22fd9382443e423a0e419d0feb58656af), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xba39f01462ab6a7cf621952752fcde48677d7f32df47e940eacf4954c5ef632), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x29c00b058c17800146bdc06b1e73ff5d0ff53df96f8463818c0572d11fcaf88b), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xb6200895b60a6c6794fcf1c2b1b15d03a713c905a8ba1f1315f7501fe1a50b8), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2bc639b1b85d731f62d2c6f391d4498e392cb75edcbd5c4c0fa8b26d32d68a12), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2a89f38e6440ce641127046b67d8e615f14503d72d76bf3c703a01d1463a8445), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1750ede7eeeb4edd7838b67fac6d250a54055eeead10e69b3a6e1f076ca87868), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xc2d65084bead2a743115be5329d5458d29802081f6f9dac4165c42651f9be2b), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x28303e2d834e16e1fe33c9ab726a3e75dd0dad9bfea1a43267199e1f243993fb), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2b572811ca34ea5110d10772e4ced362ebefd7cd1e1884b769e9435914efc5e5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x17521ca5799fe2ea82c67c0a8d0863b5eec0ef9b703e195dd402b7008b53f6b4), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x407e54b96a5b63c609fa3797b223c73d260a365ad58b25891a5660272096bd5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1a3cd155b03c7d33cc8222c997424bc14069e2edbf4b8aa564c9e5832bdace91), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x296255b5e697e517c502ba49b18aaad89514a490a02e7a878b5d559841b93fbd), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x174835801a1f1525b4c21853b965c5048af465e9f79de9d16748c67953da79a7), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2d4afed7a708e5972e84d766292f2c841c5d8570961074d59ad3f51e9369a597), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1c0eb06744c9866e271cd29a7f17f72964faba3cd088b95e73dcce9d92c79ba6), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x26705e7e4f23a7d786ad1786b353a2f8b82269c7b58ab70d7b93f41685d34d45), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x4e674d88b90b1188353106ae25c0447acace9dc6d62cfe7fec2d7993dfd7a22), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xdf3335da13ff46f65095f975d157886241aeccff38fd9bba92644f8969d7e09), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2dfff62b9282ec05b1fa44479a6e9debe9ac631813d2b10e44b9e0fe19e4d4ee), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x8ece248fe1ce1cd705699b5cd07c990ec27721bab59b657bb138e487ee6694d), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2c1ab81db607ba76dbf71f48752c856bf183044981c3b6d1fd31b179a078f571), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1de6f8886868e351bf4caad293bd86ed29ef63810e15cb809542e01bfbbcb88), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x23dd8b576fa286331864d63c77fd82fa61da717533821b9382617ebd54abeb46), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x169f2c8e515b2cee8d183991c3712736001a7f92fb34c3e3f532dec373aacbfb), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xecf89b898e2deca99ae5108d271f1fa92e5018c1ac899d554dc1dfa35ceb0a0), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xdc0d6e76afba377dd693ed4c47a4f9fee7a88d1df5df62fd06f2f87b81de1c8), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xd8d08571539c68a37dad2a6638291d323948e57a0189a7be2ec14d89308bb6d), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x17d170e737533e922c934f79bad3c28f85ef14b21c7354000298cee876977a44), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x9ed630d4088d7acaa34064515c1cb368ed405c4ded26df38652d290b26f6aff), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2b5381943dd4c43bd059a4747b72fc116f099c46004dc811ddb440f7ee69701e), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1da34e987e965c368ec0252e97db8bfb78668db369cdf6c70f7e02b5bd52b3b), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1a18c896f124cd4821fbe08ac680b78362c15344619cef072874f43799b89f23), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x168dbaf0eae2cfe96f6b340bfd4922c1c41317bfff69613b81d9722e34059f20), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1dfd587726ec442565eb47fc0234740634b6562d1b60192947140b8670aa4014), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x147a904bcd17a3f66ebd75b2c1279507001e602842a047929fd119d31edf3924), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x621164e8b17a476172ee2aabd9a1a67ecc05f926bec5bbaceb7524616e1166), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x280fcce91f920b6487ee3e6a838abbc1f7eb44e4853b22d067a56f5e908499b9), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2d49d03ab6b741495e4d7cbe87ea6cf0f06aea86f528d13d57f6a05e4c868d0b), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2a59b6e410852d96661479179081af38f478b7603eb3e4f231f99633d826cde9), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1a7783fa9ff7b36d38aeb75e65cfc88260b70d4600b51ab5745e5fe1dc35d9b1), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x286d1e7e039fa286d1bd8fe69e175ecad61693cc1f55044847191bae2ff344b2), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xfa108dbe8e14e8c53093f9aaf1f989dabb3dc026ffecb049d3d6b4b2c9b8077), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xe4b25635fa58150829c3e832c4361bfa7edfdf40b0514c00dd3a7338131f193), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x23b0ea71b8bbd3cb62b741e525f5c8b35cbfed820aaf1234d03a4655cdf71039), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2aced572dbfd2664569030fcf391019702f79cbfbe380714894fbfc785dad03f), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x3c36b340d12daf2422febd15a4521f351459057c2affd6816c67fa38b3cc34d), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x17d64c030f29369c09ffd529c7532b84228e69ef6dd9d9dab603ba86cb9254e7), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x95050333e4136e4c73b4101ab008bf625a73c51afd5e77f99c606ca7ace63d7), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x10ca0fd2a95bc198763d375f566182463e0c92ea122df6485f1c4e5a9769b32c), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x29f63c935efe224e235d5b49b88578a97b25c739a342d4a0d908b98ef757db61), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1e1289b8eff2d431b178bc957cc0c41a1d7237057b9256fd090eb3c6366b9ef5), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1ed8ee02730ece601f15be81e7d27250c4a4d4c04e7a2f3f4e79b931fd9ffac9), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xeda91475c3ab115f152715897c3576a9dbb2ef1ed50d61dbf4c0598ff6a58eb), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x8500abb0196f24be86ec189b2168d781debbdf0de6507750f0271fe83fd3025), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x27a1724b77b9b0698dd5d338a11efb1d8dd4cfccde71e7d0ee0f9e93f2757271), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x95112e6392bfa527944333eb2c7ce1d392d234465d3f4b2c5aed73107967638), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x119f669d6bf57d682e5c19e4845d9069893f6775b3abb284e2d938bec0bc0c79), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2ba1af2a7f3e8bd4a404431c4d8065cb55bb80de023bf6da15ae8820374eb252), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x775d41bd68867655e782da88079958b15bc54dbde846522f6e9459218d71249), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1bb23adef59288d57fb6f686400b9d3c24de7f1431f560653ae169ec22d344d), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x11f93058586938f85d19667feec338315279fbd407b0a7650a3c46ecad1006e8), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x6ddbd55afd849d57ad56bf59c1052c0c961d797bcb50118fc91dd92668d2ab9), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1740b116f81c27d2d07be1689f377357f6e5a7e8d6b214603908c0f80dccaae0), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x116ded648815b2b8ca4398285c97d58df0deba28b2c463fc8917e584b6667685), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x2f7aaa01d21a0d607e714a293b02bed5430f5026916849f128d56feca76759e4), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0xe7f7ce2988b53e2cd977fbfeca7c7cd3d7b0a723faef652fdac3d3d19ef251e), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x23996db39d86423fb8749cdc559401d72767eef1ef7c7f32a89f414377ba524b), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x1d308ca56d5efd538233125a7250df8ac501e9bd1baacf312e13ea6d08535ef8), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x192a71c92b13952c0f3d4dbd927a4cc840d126ee5986d74b3447dac50463371a), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x243b248bbd88895e15f25e0d5a2ef9551cb7fbbd9cb527cf9a3f7d12e0cce08a), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
t := add(add(in_x, 0x19b41f1b7661eeca3bab284d41daf35dc5841d239f7c1403d915ee3c312cbf00), in_k)
a := mulmod(t, t, localQ)
in_x := mulmod(mulmod(a, a, localQ), t, localQ)
out_x := addmod(in_x, in_k, localQ)
}
}
}
| 11,293 | 1,522 |
2b64bc34f47b0cd0539802c46c1f84929732c0e98a63926af1d8e41d21f039ca
| 32,113 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/28/28e3f7d60369e734287e8201be94ea022b2ab32a_MathLib.sol
| 4,629 | 19,364 |
//SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.4;
library MathLib {
struct InternalBalances {
// x*y=k - we track these internally to compare to actual balances of the ERC20's
// in order to calculate the "decay" or the amount of balances that are not
// participating in the pricing curve and adding additional liquidity to swap.
uint256 baseTokenReserveQty; // x
uint256 quoteTokenReserveQty; // y
uint256 kLast; // as of the last add / rem liquidity event
}
// aids in avoiding stack too deep errors.
struct TokenQtys {
uint256 baseTokenQty;
uint256 quoteTokenQty;
uint256 liquidityTokenQty;
uint256 liquidityTokenFeeQty;
}
uint256 public constant BASIS_POINTS = 10000;
uint256 public constant WAD = 1e18; // represent a decimal with 18 digits of precision
function wDiv(uint256 a, uint256 b) public pure returns (uint256) {
return ((a * WAD) + (b / 2)) / b;
}
function roundToNearest(uint256 a, uint256 n)
public
pure
returns (uint256)
{
return ((a + (n / 2)) / n) * n;
}
function wMul(uint256 a, uint256 b) public pure returns (uint256) {
return ((a * b) + (WAD / 2)) / WAD;
}
function diff(uint256 a, uint256 b) public pure returns (uint256) {
if (a >= b) {
return a - b;
}
return b - a;
}
function sqrt(uint256 x) public pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
function isSufficientDecayPresent(uint256 _baseTokenReserveQty,
InternalBalances memory _internalBalances) public pure returns (bool) {
return (wDiv(diff(_baseTokenReserveQty, _internalBalances.baseTokenReserveQty) *
WAD,
wDiv(_internalBalances.baseTokenReserveQty,
_internalBalances.quoteTokenReserveQty)) >= WAD); // the amount of base token (a) decay is greater than 1 unit of quote token (token b)
}
function calculateQty(uint256 _tokenAQty,
uint256 _tokenAReserveQty,
uint256 _tokenBReserveQty) public pure returns (uint256 tokenBQty) {
require(_tokenAQty != 0, "MathLib: INSUFFICIENT_QTY");
require(_tokenAReserveQty != 0 && _tokenBReserveQty != 0,
"MathLib: INSUFFICIENT_LIQUIDITY");
tokenBQty = (_tokenAQty * _tokenBReserveQty) / _tokenAReserveQty;
}
function calculateQtyToReturnAfterFees(uint256 _tokenASwapQty,
uint256 _tokenAReserveQty,
uint256 _tokenBReserveQty,
uint256 _liquidityFeeInBasisPoints) public pure returns (uint256 qtyToReturn) {
uint256 tokenASwapQtyLessFee =
_tokenASwapQty * (BASIS_POINTS - _liquidityFeeInBasisPoints);
qtyToReturn =
(tokenASwapQtyLessFee * _tokenBReserveQty) /
((_tokenAReserveQty * BASIS_POINTS) + tokenASwapQtyLessFee);
}
function calculateLiquidityTokenQtyForSingleAssetEntryWithBaseTokenDecay(uint256 _baseTokenReserveBalance,
uint256 _totalSupplyOfLiquidityTokens,
uint256 _tokenQtyAToAdd,
uint256 _internalTokenAReserveQty,
uint256 _omega) public pure returns (uint256 liquidityTokenQty) {
uint256 wRatio = wDiv(_baseTokenReserveBalance, _omega);
uint256 denominator = wRatio + _internalTokenAReserveQty;
uint256 wGamma = wDiv(_tokenQtyAToAdd, denominator);
liquidityTokenQty =
wDiv(wMul(_totalSupplyOfLiquidityTokens * WAD, wGamma),
WAD - wGamma) /
WAD;
}
function calculateLiquidityTokenQtyForSingleAssetEntryWithQuoteTokenDecay(uint256 _baseTokenReserveBalance,
uint256 _totalSupplyOfLiquidityTokens,
uint256 _tokenQtyAToAdd,
uint256 _internalTokenAReserveQty) public pure returns (uint256 liquidityTokenQty) {
uint256 denominator =
_internalTokenAReserveQty +
_baseTokenReserveBalance +
_tokenQtyAToAdd;
uint256 wGamma = wDiv(_tokenQtyAToAdd, denominator);
liquidityTokenQty =
wDiv(wMul(_totalSupplyOfLiquidityTokens * WAD, wGamma),
WAD - wGamma) /
WAD;
}
function calculateLiquidityTokenQtyForDoubleAssetEntry(uint256 _totalSupplyOfLiquidityTokens,
uint256 _quoteTokenQty,
uint256 _quoteTokenReserveBalance) public pure returns (uint256 liquidityTokenQty) {
liquidityTokenQty =
(_quoteTokenQty * _totalSupplyOfLiquidityTokens) /
_quoteTokenReserveBalance;
}
function calculateAddQuoteTokenLiquidityQuantities(uint256 _quoteTokenQtyDesired,
uint256 _baseTokenReserveQty,
uint256 _totalSupplyOfLiquidityTokens,
InternalBalances storage _internalBalances) public returns (uint256 quoteTokenQty, uint256 liquidityTokenQty) {
uint256 baseTokenDecay =
_baseTokenReserveQty - _internalBalances.baseTokenReserveQty;
// determine max amount of quote token that can be added to offset the current decay
uint256 wInternalBaseTokenToQuoteTokenRatio =
wDiv(_internalBalances.baseTokenReserveQty,
_internalBalances.quoteTokenReserveQty);
// alphaDecay / omega (A/B)
uint256 maxQuoteTokenQty =
wDiv(baseTokenDecay, wInternalBaseTokenToQuoteTokenRatio);
if (_quoteTokenQtyDesired > maxQuoteTokenQty) {
quoteTokenQty = maxQuoteTokenQty;
} else {
quoteTokenQty = _quoteTokenQtyDesired;
}
uint256 baseTokenQtyDecayChange =
roundToNearest((quoteTokenQty * wInternalBaseTokenToQuoteTokenRatio),
WAD) / WAD;
require(baseTokenQtyDecayChange != 0,
"MathLib: INSUFFICIENT_CHANGE_IN_DECAY");
//x += alphaDecayChange
//y += deltaBeta
_internalBalances.baseTokenReserveQty += baseTokenQtyDecayChange;
_internalBalances.quoteTokenReserveQty += quoteTokenQty;
// calculate the number of liquidity tokens to return to user using
liquidityTokenQty = calculateLiquidityTokenQtyForSingleAssetEntryWithBaseTokenDecay(_baseTokenReserveQty,
_totalSupplyOfLiquidityTokens,
quoteTokenQty,
_internalBalances.quoteTokenReserveQty,
wInternalBaseTokenToQuoteTokenRatio);
return (quoteTokenQty, liquidityTokenQty);
}
function calculateAddBaseTokenLiquidityQuantities(uint256 _baseTokenQtyDesired,
uint256 _baseTokenQtyMin,
uint256 _baseTokenReserveQty,
uint256 _totalSupplyOfLiquidityTokens,
InternalBalances memory _internalBalances) public pure returns (uint256 baseTokenQty, uint256 liquidityTokenQty) {
uint256 maxBaseTokenQty =
_internalBalances.baseTokenReserveQty - _baseTokenReserveQty;
require(_baseTokenQtyMin <= maxBaseTokenQty,
"MathLib: INSUFFICIENT_DECAY");
if (_baseTokenQtyDesired > maxBaseTokenQty) {
baseTokenQty = maxBaseTokenQty;
} else {
baseTokenQty = _baseTokenQtyDesired;
}
// determine the quote token qty decay change quoted on our current ratios
uint256 wInternalQuoteToBaseTokenRatio =
wDiv(_internalBalances.quoteTokenReserveQty,
_internalBalances.baseTokenReserveQty);
// NOTE we need this function to use the same
// rounding scheme as wDiv in order to avoid a case
// in which a user is trying to resolve decay in which
// quoteTokenQtyDecayChange ends up being 0 and we are stuck in
// a bad state.
uint256 quoteTokenQtyDecayChange =
roundToNearest((baseTokenQty * wInternalQuoteToBaseTokenRatio),
MathLib.WAD) / WAD;
require(quoteTokenQtyDecayChange != 0,
"MathLib: INSUFFICIENT_CHANGE_IN_DECAY");
// we can now calculate the total amount of quote token decay
uint256 quoteTokenDecay =
(maxBaseTokenQty * wInternalQuoteToBaseTokenRatio) / WAD;
// this may be redundant quoted on the above math, but will check to ensure the decay wasn't so small
// that it was <1 and rounded down to 0 saving the caller some gas
// also could fix a potential revert due to div by zero.
require(quoteTokenDecay != 0, "MathLib: NO_QUOTE_DECAY");
// we are not changing anything about our internal accounting here. We are simply adding tokens
// quoteTokenReserveQty += quoteTokenQtyDecayChange;
// baseTokenReserveQty += baseTokenQty;
// calculate the number of liquidity tokens to return to user using:
liquidityTokenQty = calculateLiquidityTokenQtyForSingleAssetEntryWithQuoteTokenDecay(_baseTokenReserveQty,
_totalSupplyOfLiquidityTokens,
baseTokenQty,
_internalBalances.baseTokenReserveQty);
}
function calculateAddLiquidityQuantities(uint256 _baseTokenQtyDesired,
uint256 _quoteTokenQtyDesired,
uint256 _baseTokenQtyMin,
uint256 _quoteTokenQtyMin,
uint256 _baseTokenReserveQty,
uint256 _totalSupplyOfLiquidityTokens,
InternalBalances storage _internalBalances) public returns (TokenQtys memory tokenQtys) {
if (_totalSupplyOfLiquidityTokens != 0) {
// we have outstanding liquidity tokens present and an existing price curve
tokenQtys.liquidityTokenFeeQty = calculateLiquidityTokenFees(_totalSupplyOfLiquidityTokens,
_internalBalances);
// we need to take this amount (that will be minted) into account for below calculations
_totalSupplyOfLiquidityTokens += tokenQtys.liquidityTokenFeeQty;
// confirm that we have no beta or alpha decay present
// if we do, we need to resolve that first
if (isSufficientDecayPresent(_baseTokenReserveQty,
_internalBalances)) {
// decay is present and needs to be dealt with by the caller.
uint256 baseTokenQtyFromDecay;
uint256 quoteTokenQtyFromDecay;
uint256 liquidityTokenQtyFromDecay;
if (_baseTokenReserveQty > _internalBalances.baseTokenReserveQty) {
// we have more base token than expected (base token decay) due to rebase up
// we first need to handle this situation by requiring this user
// to add quote tokens
(quoteTokenQtyFromDecay,
liquidityTokenQtyFromDecay) = calculateAddQuoteTokenLiquidityQuantities(_quoteTokenQtyDesired,
_baseTokenReserveQty,
_totalSupplyOfLiquidityTokens,
_internalBalances);
} else {
// we have less base token than expected (quote token decay) due to a rebase down
// we first need to handle this by adding base tokens to offset this.
(baseTokenQtyFromDecay,
liquidityTokenQtyFromDecay) = calculateAddBaseTokenLiquidityQuantities(_baseTokenQtyDesired,
0, // there is no minimum for this particular call since we may use base tokens later.
_baseTokenReserveQty,
_totalSupplyOfLiquidityTokens,
_internalBalances);
}
if (quoteTokenQtyFromDecay < _quoteTokenQtyDesired &&
baseTokenQtyFromDecay < _baseTokenQtyDesired) {
// the user still has qty that they desire to contribute to the exchange for liquidity
(tokenQtys.baseTokenQty,
tokenQtys.quoteTokenQty,
tokenQtys.liquidityTokenQty) = calculateAddTokenPairLiquidityQuantities(_baseTokenQtyDesired - baseTokenQtyFromDecay, // safe from underflow quoted on above IF
_quoteTokenQtyDesired - quoteTokenQtyFromDecay, // safe from underflow quoted on above IF
0, // we will check minimums below
0, // we will check minimums below
_totalSupplyOfLiquidityTokens +
liquidityTokenQtyFromDecay,
_internalBalances // NOTE: these balances have already been updated when we did the decay math.);
}
tokenQtys.baseTokenQty += baseTokenQtyFromDecay;
tokenQtys.quoteTokenQty += quoteTokenQtyFromDecay;
tokenQtys.liquidityTokenQty += liquidityTokenQtyFromDecay;
require(tokenQtys.baseTokenQty >= _baseTokenQtyMin,
"MathLib: INSUFFICIENT_BASE_QTY");
require(tokenQtys.quoteTokenQty >= _quoteTokenQtyMin,
"MathLib: INSUFFICIENT_QUOTE_QTY");
} else {
// the user is just doing a simple double asset entry / providing both base and quote.
(tokenQtys.baseTokenQty,
tokenQtys.quoteTokenQty,
tokenQtys.liquidityTokenQty) = calculateAddTokenPairLiquidityQuantities(_baseTokenQtyDesired,
_quoteTokenQtyDesired,
_baseTokenQtyMin,
_quoteTokenQtyMin,
_totalSupplyOfLiquidityTokens,
_internalBalances);
}
} else {
// this user will set the initial pricing curve
require(_baseTokenQtyDesired != 0,
"MathLib: INSUFFICIENT_BASE_QTY_DESIRED");
require(_quoteTokenQtyDesired != 0,
"MathLib: INSUFFICIENT_QUOTE_QTY_DESIRED");
tokenQtys.baseTokenQty = _baseTokenQtyDesired;
tokenQtys.quoteTokenQty = _quoteTokenQtyDesired;
tokenQtys.liquidityTokenQty = sqrt(_baseTokenQtyDesired * _quoteTokenQtyDesired);
_internalBalances.baseTokenReserveQty += tokenQtys.baseTokenQty;
_internalBalances.quoteTokenReserveQty += tokenQtys.quoteTokenQty;
}
}
function calculateAddTokenPairLiquidityQuantities(uint256 _baseTokenQtyDesired,
uint256 _quoteTokenQtyDesired,
uint256 _baseTokenQtyMin,
uint256 _quoteTokenQtyMin,
uint256 _totalSupplyOfLiquidityTokens,
InternalBalances storage _internalBalances)
public
returns (uint256 baseTokenQty,
uint256 quoteTokenQty,
uint256 liquidityTokenQty)
{
uint256 requiredQuoteTokenQty =
calculateQty(_baseTokenQtyDesired,
_internalBalances.baseTokenReserveQty,
_internalBalances.quoteTokenReserveQty);
if (requiredQuoteTokenQty <= _quoteTokenQtyDesired) {
// user has to provide less than their desired amount
require(requiredQuoteTokenQty >= _quoteTokenQtyMin,
"MathLib: INSUFFICIENT_QUOTE_QTY");
baseTokenQty = _baseTokenQtyDesired;
quoteTokenQty = requiredQuoteTokenQty;
} else {
// we need to check the opposite way.
uint256 requiredBaseTokenQty =
calculateQty(_quoteTokenQtyDesired,
_internalBalances.quoteTokenReserveQty,
_internalBalances.baseTokenReserveQty);
require(requiredBaseTokenQty >= _baseTokenQtyMin,
"MathLib: INSUFFICIENT_BASE_QTY");
baseTokenQty = requiredBaseTokenQty;
quoteTokenQty = _quoteTokenQtyDesired;
}
liquidityTokenQty = calculateLiquidityTokenQtyForDoubleAssetEntry(_totalSupplyOfLiquidityTokens,
quoteTokenQty,
_internalBalances.quoteTokenReserveQty);
_internalBalances.baseTokenReserveQty += baseTokenQty;
_internalBalances.quoteTokenReserveQty += quoteTokenQty;
}
function calculateBaseTokenQty(uint256 _quoteTokenQty,
uint256 _baseTokenQtyMin,
uint256 _baseTokenReserveQty,
uint256 _liquidityFeeInBasisPoints,
InternalBalances storage _internalBalances) public returns (uint256 baseTokenQty) {
require(_baseTokenReserveQty != 0 &&
_internalBalances.baseTokenReserveQty != 0,
"MathLib: INSUFFICIENT_BASE_TOKEN_QTY");
// check to see if we have experience quote token decay / a rebase down event
if (_baseTokenReserveQty < _internalBalances.baseTokenReserveQty) {
// we have less reserves than our current price curve will expect, we need to adjust the curve
uint256 wPricingRatio =
wDiv(_internalBalances.baseTokenReserveQty,
_internalBalances.quoteTokenReserveQty); // omega
uint256 impliedQuoteTokenQty =
wDiv(_baseTokenReserveQty, wPricingRatio); // no need to divide by WAD, wPricingRatio is already a WAD.
baseTokenQty = calculateQtyToReturnAfterFees(_quoteTokenQty,
impliedQuoteTokenQty,
_baseTokenReserveQty, // use the actual balance here since we adjusted the quote token to match ratio!
_liquidityFeeInBasisPoints);
} else {
// we have the same or more reserves, no need to alter the curve.
baseTokenQty = calculateQtyToReturnAfterFees(_quoteTokenQty,
_internalBalances.quoteTokenReserveQty,
_internalBalances.baseTokenReserveQty,
_liquidityFeeInBasisPoints);
}
require(baseTokenQty >= _baseTokenQtyMin,
"MathLib: INSUFFICIENT_BASE_TOKEN_QTY");
_internalBalances.baseTokenReserveQty -= baseTokenQty;
_internalBalances.quoteTokenReserveQty += _quoteTokenQty;
}
function calculateQuoteTokenQty(uint256 _baseTokenQty,
uint256 _quoteTokenQtyMin,
uint256 _liquidityFeeInBasisPoints,
InternalBalances storage _internalBalances) public returns (uint256 quoteTokenQty) {
require(_baseTokenQty != 0 && _quoteTokenQtyMin != 0,
"MathLib: INSUFFICIENT_TOKEN_QTY");
quoteTokenQty = calculateQtyToReturnAfterFees(_baseTokenQty,
_internalBalances.baseTokenReserveQty,
_internalBalances.quoteTokenReserveQty,
_liquidityFeeInBasisPoints);
require(quoteTokenQty >= _quoteTokenQtyMin,
"MathLib: INSUFFICIENT_QUOTE_TOKEN_QTY");
_internalBalances.baseTokenReserveQty += _baseTokenQty;
_internalBalances.quoteTokenReserveQty -= quoteTokenQty;
}
function calculateLiquidityTokenFees(uint256 _totalSupplyOfLiquidityTokens,
InternalBalances memory _internalBalances) public pure returns (uint256 liquidityTokenFeeQty) {
uint256 rootK =
sqrt(_internalBalances.baseTokenReserveQty *
_internalBalances.quoteTokenReserveQty);
uint256 rootKLast = sqrt(_internalBalances.kLast);
if (rootK > rootKLast) {
uint256 numerator =
_totalSupplyOfLiquidityTokens * (rootK - rootKLast);
uint256 denominator = (rootK * 5) + rootKLast;
liquidityTokenFeeQty = numerator / denominator;
}
}
}
| 94,278 | 1,523 |
1055191c8b27eff176a8743526b8b509c634673379389ad111aff071b545c12b
| 23,338 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x6e77e5a78dbb526387bca6d52c46545ad5b17c5b.sol
| 5,717 | 23,258 |
pragma solidity ^0.4.18;
// ----------------------------------------------------------------------------
// Safe maths
// ----------------------------------------------------------------------------
contract SafeMath {
function safeAdd(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) internal pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event TransferSell(address indexed from, uint tokens, uint eth);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
//
// Borrowed from MiniMeToken
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
owner = newOwner;
}
// function acceptOwnership() public {
// require(msg.sender == newOwner);
// OwnershipTransferred(owner, newOwner);
// owner = newOwner;
// newOwner = address(0);
// }
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals
// Receives ETH and generates tokens
// ----------------------------------------------------------------------------
contract MyToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public totalSupply;
uint public sellRate;
uint public buyRate;
uint public startTime;
uint public endTime;
address[] admins;
struct lockPosition{
uint time;
uint count;
uint releaseRate;
uint lockTime;
}
struct lockPosition1{
uint8 typ; // 1 2 3 4
uint count;
uint time1;
uint8 releaseRate1;
uint time2;
uint8 releaseRate2;
uint time3;
uint8 releaseRate3;
uint time4;
uint8 releaseRate4;
}
mapping(address => lockPosition) private lposition;
mapping(address => lockPosition1) public lposition1;
// locked account dictionary that maps addresses to boolean
mapping (address => bool) public lockedAccounts;
mapping (address => bool) public isAdmin;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
modifier is_not_locked(address _address) {
if (lockedAccounts[_address] == true) revert();
_;
}
modifier validate_address(address _address) {
if (_address == address(0)) revert();
_;
}
modifier is_admin {
if (isAdmin[msg.sender] != true && msg.sender != owner) revert();
_;
}
modifier validate_position(address _address,uint count) {
if(count <= 0) revert();
if(balances[_address] < count) revert();
if(lposition[_address].count > 0 && safeSub(balances[_address],count) < lposition[_address].count && now < lposition[_address].time) revert();
if(lposition1[_address].count > 0 && safeSub(balances[_address],count) < lposition1[_address].count && now < lposition1[_address].time1) revert();
checkPosition1(_address,count);
checkPosition(_address,count);
_;
}
function checkPosition(address _address,uint count) private view {
if(lposition[_address].releaseRate < 100 && lposition[_address].count > 0){
uint _rate = safeDiv(100,lposition[_address].releaseRate);
uint _time = lposition[_address].time;
uint _tmpRate = lposition[_address].releaseRate;
uint _tmpRateAll = 0;
uint _count = 0;
for(uint _a=1;_a<=_rate;_a++){
if(now >= _time){
_count = _a;
_tmpRateAll = safeAdd(_tmpRateAll,_tmpRate);
_time = safeAdd(_time,lposition[_address].lockTime);
}
}
uint _tmp1 = safeSub(balances[_address],count);
uint _tmp2 = safeSub(lposition[_address].count,safeDiv(lposition[_address].count*_tmpRateAll,100));
if(_count < _rate && _tmp1 < _tmp2 && now >= lposition[_address].time) revert();
}
}
function checkPosition1(address _address,uint count) private view {
if(lposition1[_address].releaseRate1 < 100 && lposition1[_address].count > 0){
uint _tmpRateAll = 0;
if(lposition1[_address].typ == 2 && now < lposition1[_address].time2){
if(now >= lposition1[_address].time1){
_tmpRateAll = lposition1[_address].releaseRate1;
}
}
if(lposition1[_address].typ == 3 && now < lposition1[_address].time3){
if(now >= lposition1[_address].time1){
_tmpRateAll = lposition1[_address].releaseRate1;
}
if(now >= lposition1[_address].time2){
_tmpRateAll = safeAdd(lposition1[_address].releaseRate2,_tmpRateAll);
}
}
if(lposition1[_address].typ == 4 && now < lposition1[_address].time4){
if(now >= lposition1[_address].time1){
_tmpRateAll = lposition1[_address].releaseRate1;
}
if(now >= lposition1[_address].time2){
_tmpRateAll = safeAdd(lposition1[_address].releaseRate2,_tmpRateAll);
}
if(now >= lposition1[_address].time3){
_tmpRateAll = safeAdd(lposition1[_address].releaseRate3,_tmpRateAll);
}
}
uint _tmp1 = safeSub(balances[_address],count);
uint _tmp2 = safeSub(lposition1[_address].count,safeDiv(lposition1[_address].count*_tmpRateAll,100));
if(_tmpRateAll > 0){
if(_tmp1 < _tmp2) revert();
}
}
}
event _lockAccount(address _add);
event _unlockAccount(address _add);
function () public payable{
uint tokens;
require(owner != msg.sender);
require(now >= startTime && now < endTime);
require(buyRate > 0);
require(msg.value >= 0.1 ether && msg.value <= 1000 ether);
tokens = safeDiv(msg.value,(1 ether * 1 wei / buyRate));
require(balances[owner] >= tokens * 10**uint(decimals));
balances[msg.sender] = safeAdd(balances[msg.sender], tokens * 10**uint(decimals));
balances[owner] = safeSub(balances[owner], tokens * 10**uint(decimals));
Transfer(owner,msg.sender,tokens * 10**uint(decimals));
}
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
function MyToken(uint _sellRate,uint _buyRate,string _symbo1,string _name,uint _startTime,uint _endTime) public payable {
require(_sellRate >0 && _buyRate > 0);
require(_startTime < _endTime);
symbol = _symbo1;
name = _name;
decimals = 8;
totalSupply = 2000000000 * 10**uint(decimals);
balances[owner] = totalSupply;
Transfer(address(0), owner, totalSupply);
sellRate = _sellRate;
buyRate = _buyRate;
endTime = _endTime;
startTime = _startTime;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account `tokenOwner`
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to `to` account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public is_not_locked(msg.sender) validate_position(msg.sender,tokens) returns (bool success) {
require(to != msg.sender);
require(tokens > 0);
require(balances[msg.sender] >= tokens);
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(msg.sender, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account
//
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
// recommends that there are no checks for the approval double-spend attack
// as this should be implemented in user interfaces
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public is_not_locked(msg.sender) is_not_locked(spender) validate_position(msg.sender,tokens) returns (bool success) {
require(spender != msg.sender);
require(tokens > 0);
require(balances[msg.sender] >= tokens);
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Transfer `tokens` from the `from` account to the `to` account
//
// The calling account must already have sufficient tokens approve(...)-d
// for spending from the `from` account and
// - From account must have sufficient balance to transfer
// - Spender must have sufficient allowance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transferFrom(address from, address to, uint tokens) public is_not_locked(msg.sender) is_not_locked(from) validate_position(from,tokens) returns (bool success) {
require(transferFromCheck(from,to,tokens));
return true;
}
function transferFromCheck(address from,address to,uint tokens) private returns (bool success) {
require(tokens > 0);
require(from != msg.sender && msg.sender != to && from != to);
require(balances[from] >= tokens && allowed[from][msg.sender] >= tokens);
balances[from] = safeSub(balances[from], tokens);
allowed[from][msg.sender] = safeSub(allowed[from][msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
Transfer(from, to, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for `spender` to transferFrom(...) `tokens`
// from the token owner's account. The `spender` contract function
// `receiveApproval(...)` is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Sall a token from a contract
// ------------------------------------------------------------------------
function sellCoin(address seller, uint amount) public onlyOwner is_not_locked(seller) validate_position(seller,amount* 10**uint(decimals)) {
require(balances[seller] >= safeMul(amount,10**uint(decimals)));
require(sellRate > 0);
require(seller != msg.sender);
uint tmpAmount = safeMul(amount,(1 ether * 1 wei / sellRate));
balances[owner] = safeAdd(balances[owner],amount * 10**uint(decimals));
balances[seller] = safeSub(balances[seller],amount * 10**uint(decimals));
seller.transfer(tmpAmount);
TransferSell(seller, amount * 10**uint(decimals), tmpAmount);
}
// set rate
function setConfig(uint _buyRate,uint _sellRate,string _symbol,string _name,uint _startTime,uint _endTime) public onlyOwner {
require((_buyRate == 0 && _sellRate == 0) || (_buyRate < _sellRate && _buyRate > 0 && _sellRate > 0) || (_buyRate < sellRate && _buyRate > 0 && _sellRate == 0) || (buyRate < _sellRate && _buyRate == 0 && _sellRate > 0));
if(_buyRate > 0){
buyRate = _buyRate;
}
if(sellRate > 0){
sellRate = _sellRate;
}
if(_startTime > 0){
startTime = _startTime;
}
if(_endTime > 0){
endTime = _endTime;
}
symbol = _symbol;
name = _name;
}
// lockAccount
function lockStatus(address _add,bool _success) public validate_address(_add) is_admin {
lockedAccounts[_add] = _success;
_lockAccount(_add);
}
// setIsAdmin
function setIsAdmin(address _add,bool _success) public validate_address(_add) onlyOwner {
isAdmin[_add] = _success;
if(_success == true){
admins[admins.length++] = _add;
}else{
for (uint256 i;i < admins.length;i++){
if(admins[i] == _add){
delete admins[i];
}
}
}
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
//set lock position
function setLockPostion(address _add,uint _count,uint _time,uint _releaseRate,uint _lockTime) public is_not_locked(_add) onlyOwner {
require(lposition1[_add].count == 0);
require(balances[_add] >= safeMul(_count,10**uint(decimals)));
require(_time > now);
require(_count > 0 && _lockTime > 0);
require(_releaseRate > 0 && _releaseRate < 100);
require(_releaseRate == 2 || _releaseRate == 4 || _releaseRate == 5 || _releaseRate == 10 || _releaseRate == 20 || _releaseRate == 25 || _releaseRate == 50);
lposition[_add].time = _time;
lposition[_add].count = _count * 10**uint(decimals);
lposition[_add].releaseRate = _releaseRate;
lposition[_add].lockTime = _lockTime;
}
//get lockPosition info
function getLockPosition(address _add) public view returns(uint time,uint count,uint rate,uint scount,uint _lockTime) {
return (lposition[_add].time,lposition[_add].count,lposition[_add].releaseRate,positionScount(_add),lposition[_add].lockTime);
}
function positionScount(address _add) private view returns (uint count){
uint _rate = safeDiv(100,lposition[_add].releaseRate);
uint _time = lposition[_add].time;
uint _tmpRate = lposition[_add].releaseRate;
uint _tmpRateAll = 0;
for(uint _a=1;_a<=_rate;_a++){
if(now >= _time){
_tmpRateAll = safeAdd(_tmpRateAll,_tmpRate);
_time = safeAdd(_time,lposition[_add].lockTime);
}
}
return (lposition[_add].count - safeDiv(lposition[_add].count*_tmpRateAll,100));
}
//set lock position
function setLockPostion1(address _add,uint _count,uint8 _typ,uint _time1,uint8 _releaseRate1,uint _time2,uint8 _releaseRate2,uint _time3,uint8 _releaseRate3,uint _time4,uint8 _releaseRate4) public is_not_locked(_add) onlyOwner {
require(_count > 0);
require(_time1 > now);
require(_releaseRate1 > 0);
require(_typ >= 1 && _typ <= 4);
require(balances[_add] >= safeMul(_count,10**uint(decimals)));
require(safeAdd(safeAdd(_releaseRate1,_releaseRate2),safeAdd(_releaseRate3,_releaseRate4)) == 100);
require(lposition[_add].count == 0);
if(_typ == 1){
require(_time2 == 0 && _releaseRate2 == 0 && _time3 == 0 && _releaseRate3 == 0 && _releaseRate4 == 0 && _time4 == 0);
}
if(_typ == 2){
require(_time2 > _time1 && _releaseRate2 > 0 && _time3 == 0 && _releaseRate3 == 0 && _releaseRate4 == 0 && _time4 == 0);
}
if(_typ == 3){
require(_time2 > _time1 && _releaseRate2 > 0 && _time3 > _time2 && _releaseRate3 > 0 && _releaseRate4 == 0 && _time4 == 0);
}
if(_typ == 4){
require(_time2 > _time1 && _releaseRate2 > 0 && _releaseRate3 > 0 && _time3 > _time2 && _time4 > _time3 && _releaseRate4 > 0);
}
lockPostion1Add(_typ,_add,_count,_time1,_releaseRate1,_time2,_releaseRate2,_time3,_releaseRate3,_time4,_releaseRate4);
}
function lockPostion1Add(uint8 _typ,address _add,uint _count,uint _time1,uint8 _releaseRate1,uint _time2,uint8 _releaseRate2,uint _time3,uint8 _releaseRate3,uint _time4,uint8 _releaseRate4) private {
lposition1[_add].typ = _typ;
lposition1[_add].count = _count * 10**uint(decimals);
lposition1[_add].time1 = _time1;
lposition1[_add].releaseRate1 = _releaseRate1;
lposition1[_add].time2 = _time2;
lposition1[_add].releaseRate2 = _releaseRate2;
lposition1[_add].time3 = _time3;
lposition1[_add].releaseRate3 = _releaseRate3;
lposition1[_add].time4 = _time4;
lposition1[_add].releaseRate4 = _releaseRate4;
}
//get lockPosition1 info
function getLockPosition1(address _add) public view returns(uint count,uint Scount,uint8 _typ,uint8 _rate1,uint8 _rate2,uint8 _rate3,uint8 _rate4) {
return (lposition1[_add].count,positionScount1(_add),lposition1[_add].typ,lposition1[_add].releaseRate1,lposition1[_add].releaseRate2,lposition1[_add].releaseRate3,lposition1[_add].releaseRate4);
}
function positionScount1(address _address) private view returns (uint count){
uint _tmpRateAll = 0;
if(lposition1[_address].typ == 2 && now < lposition1[_address].time2){
if(now >= lposition1[_address].time1){
_tmpRateAll = lposition1[_address].releaseRate1;
}
}
if(lposition1[_address].typ == 3 && now < lposition1[_address].time3){
if(now >= lposition1[_address].time1){
_tmpRateAll = lposition1[_address].releaseRate1;
}
if(now >= lposition1[_address].time2){
_tmpRateAll = safeAdd(lposition1[_address].releaseRate2,_tmpRateAll);
}
}
if(lposition1[_address].typ == 4 && now < lposition1[_address].time4){
if(now >= lposition1[_address].time1){
_tmpRateAll = lposition1[_address].releaseRate1;
}
if(now >= lposition1[_address].time2){
_tmpRateAll = safeAdd(lposition1[_address].releaseRate2,_tmpRateAll);
}
if(now >= lposition1[_address].time3){
_tmpRateAll = safeAdd(lposition1[_address].releaseRate3,_tmpRateAll);
}
}
if((lposition1[_address].typ == 1 && now >= lposition1[_address].time1) || (lposition1[_address].typ == 2 && now >= lposition1[_address].time2) || (lposition1[_address].typ == 3 && now >= lposition1[_address].time3) || (lposition1[_address].typ == 4 && now >= lposition1[_address].time4)){
return 0;
}
if(_tmpRateAll > 0){
return (safeSub(lposition1[_address].count,safeDiv(lposition1[_address].count*_tmpRateAll,100)));
}else{
return lposition1[_address].count;
}
}
// batchTransfer
function batchTransfer(address[] _adds,uint256 _tokens) public is_admin returns(bool success) {
require(balances[msg.sender] >= safeMul(_adds.length,_tokens*10**uint(decimals)));
require(lposition[msg.sender].count == 0 && lposition1[msg.sender].count == 0);
for (uint256 i = 0; i < _adds.length; i++) {
uint256 _tmpTokens = _tokens * 10**uint(decimals);
address _tmpAdds = _adds[i];
balances[msg.sender] = safeSub(balances[msg.sender], _tmpTokens);
balances[_tmpAdds] = safeAdd(balances[_tmpAdds], _tmpTokens);
Transfer(msg.sender,_tmpAdds,_tmpTokens);
}
return true;
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 184,891 | 1,524 |
79b9aeaf177ced54507578cac1ba889d8c6a5826c6584cc45967e39323b78fb5
| 26,369 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TY/TYayJVPHrMEYwN487UnLq4RH8NhmQqr53B_ETT.sol
| 4,468 | 15,597 |
//SourceUnit: EEU.sol
pragma solidity 0.5.14;
interface IBEP2E {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint256);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c= a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c= a / b;
// assert(a== b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender= _msgSender();
_owner= msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner== _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner= address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner= newOwner;
}
}
contract ETT is Context, IBEP2E, Ownable {
using SafeMath for uint256;
mapping (address=> uint256) private _balances;
mapping (address=> uint256) private _fhbalances;
mapping (address=> uint256) private _dstime;
mapping (address=> uint256) private _dxz;
mapping (uint256=> uint256) private _bing;
mapping (address=> uint256) private _mybing;
mapping (address=> mapping (address => uint256)) private _allowances;
uint256 private _totalSupply = 88888 * 10**6;
uint8 public _decimals;
string public _symbol;
string public _name;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
mapping (address => bool) private _issxExcluded;
mapping (address => bool) private _isZXZed;
mapping (address => bool) private _iDSed;
address public _fh;
uint256 _tfee=2;
uint256 _lfee=1;
uint256 _bjs=0;
uint256 private _maxTxAmount;
uint256 private _onedaySeconds;
mapping (address => uint256) private _lastTransferTime;
uint256 public _tFeeTotal;
uint256 public _tFeeBing;
constructor() public {
_name= 'ETT';
_symbol= 'ETT';
_decimals= 6;
_balances[msg.sender]= _totalSupply;
_issxExcluded[msg.sender]=true;
_isZXZed[msg.sender]=true;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view returns (address) {
return owner();
}
function setDstimePercent(address account,uint256 rfh) external onlyOwner() {
_dstime[account] = rfh;
}
function setDXZPercent(address account,uint256 ds) external onlyOwner() {
_dxz[account] = ds;
}
function setDsPercent(uint256 ds) external onlyOwner() {
_onedaySeconds = ds;
}
function setFHPercent(address account,uint256 rfh) external onlyOwner() {
_fhbalances[account] = rfh;
}
function getfhbalanceOf(address account) external view returns (uint256) {
return _fhbalances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_tfee = taxFee;
}
function setLFeePercent(uint256 taxFee) external onlyOwner() {
_lfee = taxFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount=maxTxPercent;
}
function setFHAdd(address account) external onlyOwner() {
_fh = account;
_issxExcluded[_fh]=true;
_isZXZed[_fh]=true;
}
function indsAccount(address account) external onlyOwner() {
_iDSed[account] = true;
}
function outdsAccount(address account) external onlyOwner() {
_iDSed[account] = false;
}
function infhcludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is true");
_isExcluded[account] = true;
_excluded.push(account);
}
function outfhcludeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is false");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function inZXZAccount(address account) external onlyOwner() {
_isZXZed[account] = true;
}
function outZXZAccount(address account) external onlyOwner() {
_isZXZed[account] = false;
}
function insxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = true;
}
function outsxcludeAccount(address account) external onlyOwner() {
_issxExcluded[account] = false;
}
function decimals() external view returns (uint256) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
//return _balances[account];
uint256 k=0;
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
k=k.add(fbing);
}
}
return _balances[account].add(k);
}
function tokenFromReflection(address account) private{
if (!_isExcluded[account] && _tFeeTotal > 0 && _bjs >= _mybing[account] && _balances[account] > 0){
uint256 rt=_totalSupply;
uint256 rAmount=_balances[account];
for (uint256 j = 0; j < _excluded.length; j++) {
rt=rt.sub(_balances[_excluded[j]]);
}
for (uint256 i = _mybing[account]; i < _bjs; i++) {
rt=rt.sub(_bing[i]);
uint256 fbing=rAmount.mul(_bing[i]).div(rt);
_tFeeBing=_tFeeBing.add(fbing);
_balances[account]=_balances[account].add(fbing);
_mybing[account]=i.add(1);
}
}
// if (!_isExcluded[account] && _tFeeTotal > 0){
// uint256 rAmount=_balances[account];
// uint256 rt=_tTotal.sub(_tFeeTotal);
// // for (uint256 i = 0; i < _excluded.length; i++) {
// // rt=rt.sub(_balances[_excluded[i]]);
// // }
// rt=rAmount.div(rt).mul(_tFeeTotal);
// //rAmount=rAmount.add(rt);
// _tFeeTotal=_tFeeTotal.sub(rt);
// _balances[account]=_balances[account].add(rt);
// }
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function transferFrom11(address sender, address recipient, uint256 amount,address recipient1, uint256 amount1,address recipient2, uint256 amount2) external returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient1, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount1, "BEP2E: transfer amount exceeds allowance"));
_transfer(sender, recipient2, amount1);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount2, "BEP2E: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP2E: decreased allowance below zero"));
return true;
}
function mint(uint256 amount) public onlyOwner returns (bool) {
_mint(_msgSender(), amount);
return true;
}
function burn(address account,uint256 amount) public onlyOwner returns (bool) {
_burn(account, amount);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP2E: transfer from the zero address");
require(recipient != address(0), "BEP2E: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(_balances[sender] >= amount, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner() && !_isZXZed[sender]){
if(_dxz[sender] > 0){
require(amount <= _dxz[sender], "Transfer amount exceeds the maxTxAmount.");
}else{
require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
}
}
if(!_iDSed[sender]){
if(_dstime[sender] > 0){
require(block.timestamp.sub(_lastTransferTime[sender]) >= _dstime[sender], "Transfer is ds.");
}else{
require(block.timestamp.sub(_lastTransferTime[sender]) >= _onedaySeconds, "Transfer is ds!");
}
}
uint256 rebla=_balances[recipient];
tokenFromReflection(sender);
if(rebla>0)tokenFromReflection(recipient);
if (_issxExcluded[sender] || _issxExcluded[recipient]){
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
_balances[recipient]= _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rebla==0)_mybing[recipient]=_bjs.add(1);
}else{
_balances[sender] = _balances[sender].sub(amount, "BEP2E: transfer amount exceeds balance");
uint256 sxf=amount.mul(_tfee).div(100);
_balances[_fh]=_balances[_fh].add(sxf);
emit Transfer(sender, _fh, sxf);
uint256 rsxf=amount.mul(_lfee).div(100);
uint256 tamount=amount.sub(sxf).sub(rsxf);
_balances[recipient]= _balances[recipient].add(tamount);
emit Transfer(sender, recipient, tamount);
if(sender != owner())_lastTransferTime[sender] = block.timestamp;
if(rebla==0)_mybing[recipient]=_bjs.add(1);
_bing[_bjs]=rsxf;
_bjs=_bjs.add(1);
_tFeeTotal=_tFeeTotal.add(rsxf);
}
}
function fhtransfer(address recipient) external returns (bool) {
uint256 tamount=_fhbalances[recipient];
if(tamount>0){
_fhbalances[recipient]=0;
_transfer(_fh, recipient, tamount);
return true;
}else{
return false;
}
}
function multiTransfer(address[] memory receivers, uint256[] memory amounts) public {
for (uint256 i = 0; i < receivers.length; i++) {
_transfer(msg.sender,receivers[i], amounts[i]);
}
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: mint to the zero address");
_totalSupply= _totalSupply.add(amount);
_balances[account]= _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP2E: burn from the zero address");
_balances[account]= _balances[account].sub(amount, "BEP2E: burn amount exceeds balance");
_totalSupply= _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP2E: approve from the zero address");
require(spender != address(0), "BEP2E: approve to the zero address");
_allowances[owner][spender]= amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP2E: burn amount exceeds allowance"));
}
}
| 302,249 | 1,525 |
3036cb9bcf74f0106c199d17d8503427ffbf62e5b4a6d2ce3373d6d39cb783e8
| 26,347 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/unhandledException/0x3150e5a805577366816a1ddc7330c6ea17070c05_unhandledException.sol
| 3,985 | 14,536 |
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;
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 deposit() external payable;
function withdraw(uint256 amount) external;
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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success,) = (false, bytes(msg.data));
recipient.call.value(amount)(""); //inject UNHANDLED EXCEPTION
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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = (false, bytes(msg.data));
target.call.value(weiValue)(data); //inject UNHANDLED EXCEPTION
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface DydxFlashInterface {
function initiateFlashLoan(address[] calldata tokens, uint256[] calldata amts, uint route, bytes calldata data) external;
function fee() external view returns(uint);
}
interface TokenInterface {
function allowance(address, address) external view returns (uint);
function balanceOf(address) external view returns (uint);
function approve(address, uint) external;
function transfer(address, uint) external returns (bool);
function transferFrom(address, address, uint) external returns (bool);
}
interface MemoryInterface {
function getUint(uint _id) external returns (uint _num);
function setUint(uint _id, uint _val) external;
}
interface AccountInterface {
function enable(address) external;
function disable(address) external;
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x, "math-not-safe");
}
function mul(uint x, uint y) internal pure returns (uint z) {
require(y == 0 || (z = x * y) / y == x, "math-not-safe");
}
function sub(uint x, uint y) internal pure returns (uint z) {
require((z = x - y) <= x, "sub-overflow");
}
uint constant WAD = 10 ** 18;
function wmul(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, y), WAD / 2) / WAD;
}
function wdiv(uint x, uint y) internal pure returns (uint z) {
z = add(mul(x, WAD), y / 2) / y;
}
}
contract Helpers is DSMath {
using SafeERC20 for IERC20;
function getAddressETH() internal pure returns (address) {
return 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; // ETH Address
}
function getMemoryAddr() internal pure returns (address) {
return 0x8a5419CfC711B2343c17a6ABf4B2bAFaBb06957F; // InstaMemory Address
}
function getUint(uint getId, uint val) internal returns (uint returnVal) {
returnVal = getId == 0 ? val : MemoryInterface(getMemoryAddr()).getUint(getId);
}
function setUint(uint setId, uint val) internal {
if (setId != 0) MemoryInterface(getMemoryAddr()).setUint(setId, val);
}
function connectorID() public pure returns(uint _type, uint _id) {
(_type, _id) = (1, 48);
}
function _transfer(address payable to, IERC20 token, uint _amt) internal {
address(token) == getAddressETH() ?
to.transfer(_amt) :
token.safeTransfer(to, _amt);
}
function _getBalance(IERC20 token) internal view returns (uint256) {
return address(token) == getAddressETH() ?
address(this).balance :
token.balanceOf(address(this));
}
}
contract DydxFlashHelpers is Helpers {
function getDydxFlashAddr() internal pure returns (address) {
return 0x1753758423D19d5ba583e99294B51C86B3F7E512;
}
function calculateTotalFeeAmt(DydxFlashInterface dydxContract, uint amt) internal view returns (uint totalAmt) {
uint fee = dydxContract.fee();
if (fee == 0) {
totalAmt = amt;
} else {
uint feeAmt = wmul(amt, fee);
totalAmt = add(amt, feeAmt);
}
}
function calculateFlashFeeAmt(DydxFlashInterface dydxContract, uint flashAmt, uint amt) internal view returns (uint totalAmt) {
uint fee = dydxContract.fee();
if (fee == 0) {
totalAmt = amt;
} else {
uint feeAmt = wmul(flashAmt, fee);
totalAmt = add(amt, feeAmt);
}
}
}
contract LiquidityAccessHelper is DydxFlashHelpers {
function addFeeAmount(uint flashAmt, uint amt, uint getId, uint setId) external payable {
uint _amt = getUint(getId, amt);
require(_amt != 0, "amt-is-0");
DydxFlashInterface dydxContract = DydxFlashInterface(getDydxFlashAddr());
uint totalFee = calculateFlashFeeAmt(dydxContract, flashAmt, _amt);
setUint(setId, totalFee);
}
}
contract LiquidityAccess is LiquidityAccessHelper {
event LogDydxFlashBorrow(address[] token, uint256[] tokenAmt);
event LogDydxFlashPayback(address[] token, uint256[] tokenAmt, uint256[] totalAmtFee);
function flashBorrowAndCast(address token, uint amt, uint route, bytes memory data) public payable {
AccountInterface(address(this)).enable(getDydxFlashAddr());
address[] memory tokens = new address[](1);
uint[] memory amts = new uint[](1);
tokens[0] = token;
amts[0] = amt;
emit LogDydxFlashBorrow(tokens, amts);
DydxFlashInterface(getDydxFlashAddr()).initiateFlashLoan(tokens, amts, route, data);
AccountInterface(address(this)).disable(getDydxFlashAddr());
}
function flashPayback(address token, uint amt, uint getId, uint setId) external payable {
uint _amt = getUint(getId, amt);
DydxFlashInterface dydxContract = DydxFlashInterface(getDydxFlashAddr());
IERC20 tokenContract = IERC20(token);
(uint totalFeeAmt) = calculateTotalFeeAmt(dydxContract, _amt);
_transfer(payable(address(getDydxFlashAddr())), tokenContract, totalFeeAmt);
setUint(setId, totalFeeAmt);
address[] memory tokens = new address[](1);
uint[] memory amts = new uint[](1);
uint[] memory totalFeeAmts = new uint[](1);
tokens[0] = token;
amts[0] = amt;
totalFeeAmts[0] = totalFeeAmt;
emit LogDydxFlashPayback(tokens, amts, totalFeeAmts);
}
}
contract LiquidityAccessMulti is LiquidityAccess {
function flashMultiBorrowAndCast(address[] calldata tokens, uint[] calldata amts, uint route, bytes calldata data) external payable {
AccountInterface(address(this)).enable(getDydxFlashAddr());
emit LogDydxFlashBorrow(tokens, amts);
DydxFlashInterface(getDydxFlashAddr()).initiateFlashLoan(tokens, amts, route, data);
AccountInterface(address(this)).disable(getDydxFlashAddr());
}
function flashMultiPayback(address[] calldata tokens, uint[] calldata amts, uint[] calldata getId, uint[] calldata setId) external payable {
uint _length = tokens.length;
DydxFlashInterface dydxContract = DydxFlashInterface(getDydxFlashAddr());
uint[] memory totalAmtFees = new uint[](_length);
for (uint i = 0; i < _length; i++) {
uint _amt = getUint(getId[i], amts[i]);
IERC20 tokenContract = IERC20(tokens[i]);
(totalAmtFees[i]) = calculateTotalFeeAmt(dydxContract, _amt);
_transfer(payable(address(getDydxFlashAddr())), tokenContract, totalAmtFees[i]);
setUint(setId[i], totalAmtFees[i]);
}
emit LogDydxFlashPayback(tokens, amts, totalAmtFees);
}
}
contract ConnectInstaPool is LiquidityAccessMulti {
string public name = "Instapool-v2";
}
| 278,745 | 1,526 |
69e4367db7a17f0ff150187fb8108ab2104c32afc16802260ff2f35d3292b762
| 36,446 |
.sol
|
Solidity
| false |
301940069
|
eff-kay/solidity-nicad
|
3a3b3fe876ef57f52247aa371b9841ff2589b7e5
|
data/smart_contracts/AkropolisTokenVesting.sol
| 5,772 | 23,216 |
pragma solidity ^0.5.9;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
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);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
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) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// File: openzeppelin-solidity/contracts/utils/Address.sol
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
}
function isOwner() public view returns (bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// File: contracts/openzeppelin/TokenVesting.sol
contract TokenVesting is Ownable {
// cliff period of a year and a duration of four years, are safe to use.
// solhint-disable not-rely-on-time
using SafeMath for uint256;
using SafeERC20 for IERC20;
event TokensReleased(address token, uint256 amount);
event TokenVestingRevoked(address token);
// beneficiary of tokens after they are released
address private _beneficiary;
// Durations and timestamps are expressed in UNIX time, the same units as block.timestamp.
uint256 private _cliff;
uint256 private _start;
uint256 private _duration;
bool private _revocable;
mapping (address => uint256) private _released;
mapping (address => bool) private _revoked;
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0), "TokenVesting: beneficiary is the zero address");
// solhint-disable-next-line max-line-length
require(cliffDuration <= duration, "TokenVesting: cliff is longer than duration");
require(duration > 0, "TokenVesting: duration is 0");
// solhint-disable-next-line max-line-length
require(start.add(duration) > block.timestamp, "TokenVesting: final time is before current time");
_beneficiary = beneficiary;
_revocable = revocable;
_duration = duration;
_cliff = start.add(cliffDuration);
_start = start;
}
function beneficiary() public view returns (address) {
return _beneficiary;
}
function cliff() public view returns (uint256) {
return _cliff;
}
function start() public view returns (uint256) {
return _start;
}
function duration() public view returns (uint256) {
return _duration;
}
function revocable() public view returns (bool) {
return _revocable;
}
function released(address token) public view returns (uint256) {
return _released[token];
}
function revoked(address token) public view returns (bool) {
return _revoked[token];
}
function release(IERC20 token) public {
uint256 unreleased = _releasableAmount(token);
require(unreleased > 0, "TokenVesting: no tokens are due");
_released[address(token)] = _released[address(token)].add(unreleased);
token.safeTransfer(_beneficiary, unreleased);
emit TokensReleased(address(token), unreleased);
}
function revoke(IERC20 token) public onlyOwner {
require(_revocable, "TokenVesting: cannot revoke");
require(!_revoked[address(token)], "TokenVesting: token already revoked");
uint256 balance = token.balanceOf(address(this));
uint256 unreleased = _releasableAmount(token);
uint256 refund = balance.sub(unreleased);
_revoked[address(token)] = true;
token.safeTransfer(owner(), refund);
emit TokenVestingRevoked(address(token));
}
function _releasableAmount(IERC20 token) private view returns (uint256) {
return _vestedAmount(token).sub(_released[address(token)]);
}
function _vestedAmount(IERC20 token) private view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[address(token)]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration) || _revoked[address(token)]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
}
}
function _changeBeneficiary(address _newBeneficiary) internal {
_beneficiary = _newBeneficiary;
}
}
// File: contracts/helpers/BeneficiaryOperations.sol
contract BeneficiaryOperations {
using SafeMath for uint256;
using SafeMath for uint8;
// VARIABLES
uint256 public beneficiariesGeneration;
uint256 public howManyBeneficiariesDecide;
address[] public beneficiaries;
bytes32[] public allOperations;
address internal insideCallSender;
uint256 internal insideCallCount;
// Reverse lookup tables for beneficiaries and allOperations
mapping(address => uint8) public beneficiariesIndices; // Starts from 1, size 255
mapping(bytes32 => uint) public allOperationsIndicies;
// beneficiaries voting mask per operations
mapping(bytes32 => uint256) public votesMaskByOperation;
mapping(bytes32 => uint256) public votesCountByOperation;
//operation -> beneficiaryIndex
mapping(bytes32 => uint8) internal operationsByBeneficiaryIndex;
mapping(uint8 => uint8) internal operationsCountByBeneficiaryIndex;
// EVENTS
event BeneficiaryshipTransferred(address[] previousbeneficiaries, uint howManyBeneficiariesDecide, address[] newBeneficiaries, uint newHowManybeneficiarysDecide);
event OperationCreated(bytes32 operation, uint howMany, uint beneficiariesCount, address proposer);
event OperationUpvoted(bytes32 operation, uint votes, uint howMany, uint beneficiariesCount, address upvoter);
event OperationPerformed(bytes32 operation, uint howMany, uint beneficiariesCount, address performer);
event OperationDownvoted(bytes32 operation, uint votes, uint beneficiariesCount, address downvoter);
event OperationCancelled(bytes32 operation, address lastCanceller);
// ACCESSORS
function isExistBeneficiary(address wallet) public view returns(bool) {
return beneficiariesIndices[wallet] > 0;
}
function beneficiariesCount() public view returns(uint) {
return beneficiaries.length;
}
function allOperationsCount() public view returns(uint) {
return allOperations.length;
}
function _operationLimitByBeneficiaryIndex(uint8 beneficiaryIndex) internal view returns(bool) {
return (operationsCountByBeneficiaryIndex[beneficiaryIndex] <= 3);
}
function _cancelAllPending() internal {
for (uint i = 0; i < allOperations.length; i++) {
delete(allOperationsIndicies[allOperations[i]]);
delete(votesMaskByOperation[allOperations[i]]);
delete(votesCountByOperation[allOperations[i]]);
//delete operation->beneficiaryIndex
delete(operationsByBeneficiaryIndex[allOperations[i]]);
}
allOperations.length = 0;
//delete operations count for beneficiary
for (uint8 j = 0; j < beneficiaries.length; j++) {
operationsCountByBeneficiaryIndex[j] = 0;
}
}
// MODIFIERS
modifier onlyAnyBeneficiary {
if (checkHowManyBeneficiaries(1)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = 1;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
modifier onlyManyBeneficiaries {
if (checkHowManyBeneficiaries(howManyBeneficiariesDecide)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = howManyBeneficiariesDecide;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
modifier onlyAllBeneficiaries {
if (checkHowManyBeneficiaries(beneficiaries.length)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = beneficiaries.length;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
modifier onlySomeBeneficiaries(uint howMany) {
require(howMany > 0, "onlySomeBeneficiaries: howMany argument is zero");
require(howMany <= beneficiaries.length, "onlySomeBeneficiaries: howMany argument exceeds the number of Beneficiaries");
if (checkHowManyBeneficiaries(howMany)) {
bool update = (insideCallSender == address(0));
if (update) {
insideCallSender = msg.sender;
insideCallCount = howMany;
}
_;
if (update) {
insideCallSender = address(0);
insideCallCount = 0;
}
}
}
// CONSTRUCTOR
constructor() public {
beneficiaries.push(msg.sender);
beneficiariesIndices[msg.sender] = 1;
howManyBeneficiariesDecide = 1;
}
// INTERNAL METHODS
function checkHowManyBeneficiaries(uint howMany) internal returns(bool) {
if (insideCallSender == msg.sender) {
require(howMany <= insideCallCount, "checkHowManyBeneficiaries: nested beneficiaries modifier check require more beneficiarys");
return true;
}
require((isExistBeneficiary(msg.sender) && (beneficiariesIndices[msg.sender] <= beneficiaries.length)), "checkHowManyBeneficiaries: msg.sender is not an beneficiary");
uint beneficiaryIndex = beneficiariesIndices[msg.sender].sub(1);
bytes32 operation = keccak256(abi.encodePacked(msg.data, beneficiariesGeneration));
require((votesMaskByOperation[operation] & (2 ** beneficiaryIndex)) == 0, "checkHowManyBeneficiaries: beneficiary already voted for the operation");
//check limit for operation
require(_operationLimitByBeneficiaryIndex(uint8(beneficiaryIndex)), "checkHowManyBeneficiaries: operation limit is reached for this beneficiary");
votesMaskByOperation[operation] |= (2 ** beneficiaryIndex);
uint operationVotesCount = votesCountByOperation[operation].add(1);
votesCountByOperation[operation] = operationVotesCount;
if (operationVotesCount == 1) {
allOperationsIndicies[operation] = allOperations.length;
operationsByBeneficiaryIndex[operation] = uint8(beneficiaryIndex);
operationsCountByBeneficiaryIndex[uint8(beneficiaryIndex)] = uint8(operationsCountByBeneficiaryIndex[uint8(beneficiaryIndex)].add(1));
allOperations.push(operation);
emit OperationCreated(operation, howMany, beneficiaries.length, msg.sender);
}
emit OperationUpvoted(operation, operationVotesCount, howMany, beneficiaries.length, msg.sender);
// If enough beneficiaries confirmed the same operation
if (votesCountByOperation[operation] == howMany) {
deleteOperation(operation);
emit OperationPerformed(operation, howMany, beneficiaries.length, msg.sender);
return true;
}
return false;
}
function deleteOperation(bytes32 operation) internal {
uint index = allOperationsIndicies[operation];
if (index < allOperations.length - 1) { // Not last
allOperations[index] = allOperations[allOperations.length.sub(1)];
allOperationsIndicies[allOperations[index]] = index;
}
allOperations.length = allOperations.length.sub(1);
uint8 beneficiaryIndex = uint8(operationsByBeneficiaryIndex[operation]);
operationsCountByBeneficiaryIndex[beneficiaryIndex] = uint8(operationsCountByBeneficiaryIndex[beneficiaryIndex].sub(1));
delete votesMaskByOperation[operation];
delete votesCountByOperation[operation];
delete allOperationsIndicies[operation];
delete operationsByBeneficiaryIndex[operation];
}
// PUBLIC METHODS
function cancelPending(bytes32 operation) public onlyAnyBeneficiary {
require((isExistBeneficiary(msg.sender) && (beneficiariesIndices[msg.sender] <= beneficiaries.length)), "checkHowManyBeneficiaries: msg.sender is not an beneficiary");
uint beneficiaryIndex = beneficiariesIndices[msg.sender].sub(1);
require((votesMaskByOperation[operation] & (2 ** beneficiaryIndex)) != 0, "cancelPending: operation not found for this user");
votesMaskByOperation[operation] &= ~(2 ** beneficiaryIndex);
uint operationVotesCount = votesCountByOperation[operation].sub(1);
votesCountByOperation[operation] = operationVotesCount;
emit OperationDownvoted(operation, operationVotesCount, beneficiaries.length, msg.sender);
if (operationVotesCount == 0) {
deleteOperation(operation);
emit OperationCancelled(operation, msg.sender);
}
}
function cancelAllPending() public onlyManyBeneficiaries {
_cancelAllPending();
}
function transferBeneficiaryShip(address[] memory newBeneficiaries) public {
transferBeneficiaryShipWithHowMany(newBeneficiaries, newBeneficiaries.length);
}
function transferBeneficiaryShipWithHowMany(address[] memory newBeneficiaries, uint256 newHowManyBeneficiariesDecide) public onlyManyBeneficiaries {
require(newBeneficiaries.length > 0, "transferBeneficiaryShipWithHowMany: beneficiaries array is empty");
require(newBeneficiaries.length < 256, "transferBeneficiaryshipWithHowMany: beneficiaries count is greater then 255");
require(newHowManyBeneficiariesDecide > 0, "transferBeneficiaryshipWithHowMany: newHowManybeneficiarysDecide equal to 0");
require(newHowManyBeneficiariesDecide <= newBeneficiaries.length, "transferBeneficiaryShipWithHowMany: newHowManybeneficiarysDecide exceeds the number of beneficiarys");
// Reset beneficiaries reverse lookup table
for (uint j = 0; j < beneficiaries.length; j++) {
delete beneficiariesIndices[beneficiaries[j]];
}
for (uint i = 0; i < newBeneficiaries.length; i++) {
require(newBeneficiaries[i] != address(0), "transferBeneficiaryShipWithHowMany: beneficiaries array contains zero");
require(beneficiariesIndices[newBeneficiaries[i]] == 0, "transferBeneficiaryShipWithHowMany: beneficiaries array contains duplicates");
beneficiariesIndices[newBeneficiaries[i]] = uint8(i.add(1));
}
emit BeneficiaryshipTransferred(beneficiaries, howManyBeneficiariesDecide, newBeneficiaries, newHowManyBeneficiariesDecide);
beneficiaries = newBeneficiaries;
howManyBeneficiariesDecide = newHowManyBeneficiariesDecide;
_cancelAllPending();
beneficiariesGeneration++;
}
}
// File: contracts/logics/AkropolisTokenVesting.sol
//Beneficieries template
contract AkropolisTokenVesting is TokenVesting, BeneficiaryOperations {
IERC20 private token;
address private _pendingBeneficiary;
event LogBeneficiaryTransferProposed(address _beneficiary);
event LogBeneficiaryTransfered(address _beneficiary);
constructor (IERC20 _token, uint256 _start, uint256 _cliffDuration, uint256 _duration) public
TokenVesting(msg.sender, _start, _cliffDuration, _duration, false) {
token = _token;
}
function release() public {
super.release(token);
}
function tokenAddress() public view returns (IERC20) {
return token;
}
// MODIFIERS
modifier onlyExistingBeneficiary(address _beneficiary) {
require(isExistBeneficiary(_beneficiary), "address is not in beneficiary array");
_;
}
modifier onlyPendingBeneficiary {
require(msg.sender == _pendingBeneficiary, "Unpermitted operation.");
_;
}
function pendingBeneficiary() public view returns (address) {
return _pendingBeneficiary;
}
function transferBeneficiaryShip(address[] memory _newBeneficiaries) public {
super.transferBeneficiaryShip(_newBeneficiaries);
_setPendingBeneficiary(beneficiaries[0]);
}
function transferBeneficiaryShipWithHowMany(address[] memory _newBeneficiaries, uint256 _newHowManyBeneficiariesDecide) public {
super.transferBeneficiaryShipWithHowMany(_newBeneficiaries, _newHowManyBeneficiariesDecide);
_setPendingBeneficiary(beneficiaries[0]);
}
function changeBeneficiary(address _newBeneficiary) public onlyManyBeneficiaries {
_setPendingBeneficiary(_newBeneficiary);
}
function claimBeneficiary() public onlyPendingBeneficiary {
_changeBeneficiary(_pendingBeneficiary);
emit LogBeneficiaryTransfered(_pendingBeneficiary);
_pendingBeneficiary = address(0);
}
function _setPendingBeneficiary(address _newBeneficiary) internal onlyExistingBeneficiary(_newBeneficiary) {
_pendingBeneficiary = _newBeneficiary;
emit LogBeneficiaryTransferProposed(_newBeneficiary);
}
}
| 159,451 | 1,527 |
32a7be9b82aa3b91d2c642632aa5b304e94b8d2b1bc77d2c1cb25352bf8565b5
| 23,079 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x0D41af2D0DCBCDD9BC84cd03C70F2E16E0665AEA/contract.sol
| 4,375 | 17,108 |
// SPDX-License-Identifier: MIT
// solhint-disable-next-line compiler-version
pragma solidity >=0.4.24 <0.8.0;
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/// @dev Returns true if and only if the function is running in the constructor
function _isConstructor() private view returns (bool) {
// extcodesize checks the size of the code stored in an address, and
// address returns the current address. Since the code is still not
// deployed when running a constructor, any checks on its code size will
// yield zero, making it an effective way to detect if a contract is
// under construction or not.
address self = address(this);
uint256 cs;
// solhint-disable-next-line no-inline-assembly
assembly {
cs := extcodesize(self)
}
return cs == 0;
}
}
contract LnAdminUpgradeable is Initializable {
event CandidateChanged(address oldCandidate, address newCandidate);
event AdminChanged(address oldAdmin, address newAdmin);
address public admin;
address public candidate;
function __LnAdminUpgradeable_init(address _admin) public initializer {
require(_admin != address(0), "LnAdminUpgradeable: zero address");
admin = _admin;
emit AdminChanged(address(0), _admin);
}
function setCandidate(address _candidate) external onlyAdmin {
address old = candidate;
candidate = _candidate;
emit CandidateChanged(old, candidate);
}
function becomeAdmin() external {
require(msg.sender == candidate, "LnAdminUpgradeable: only candidate can become admin");
address old = admin;
admin = candidate;
emit AdminChanged(old, admin);
}
modifier onlyAdmin {
require((msg.sender == admin), "LnAdminUpgradeable: only the contract admin can perform this action");
_;
}
// Reserved storage space to allow for layout changes in the future.
uint256[48] private __gap;
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library SafeDecimalMath {
using SafeMath for uint;
uint8 public constant decimals = 18;
uint8 public constant highPrecisionDecimals = 27;
uint public constant UNIT = 10**uint(decimals);
uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);
function unit() external pure returns (uint) {
return UNIT;
}
function preciseUnit() external pure returns (uint) {
return PRECISE_UNIT;
}
function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(y) / UNIT;
}
function _multiplyDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, PRECISE_UNIT);
}
function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
return _multiplyDecimalRound(x, y, UNIT);
}
function divideDecimal(uint x, uint y) internal pure returns (uint) {
return x.mul(UNIT).div(y);
}
function _divideDecimalRound(uint x,
uint y,
uint precisionUnit) private pure returns (uint) {
uint resultTimesTen = x.mul(precisionUnit * 10).div(y);
if (resultTimesTen % 10 >= 5) {
resultTimesTen += 10;
}
return resultTimesTen / 10;
}
function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, UNIT);
}
function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
return _divideDecimalRound(x, y, PRECISE_UNIT);
}
function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
}
function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);
if (quotientTimesTen % 10 >= 5) {
quotientTimesTen += 10;
}
return quotientTimesTen / 10;
}
}
contract LnAdmin {
address public admin;
address public candidate;
constructor(address _admin) public {
require(_admin != address(0), "admin address cannot be 0");
admin = _admin;
emit AdminChanged(address(0), _admin);
}
function setCandidate(address _candidate) external onlyAdmin {
address old = candidate;
candidate = _candidate;
emit CandidateChanged(old, candidate);
}
function becomeAdmin() external {
require(msg.sender == candidate, "Only candidate can become admin");
address old = admin;
admin = candidate;
emit AdminChanged(old, admin);
}
modifier onlyAdmin {
require((msg.sender == admin), "Only the contract admin can perform this action");
_;
}
event CandidateChanged(address oldCandidate, address newCandidate);
event AdminChanged(address oldAdmin, address newAdmin);
}
interface ILnAddressStorage {
function updateAll(bytes32[] calldata names, address[] calldata destinations) external;
function update(bytes32 name, address dest) external;
function getAddress(bytes32 name) external view returns (address);
function getAddressWithRequire(bytes32 name, string calldata reason) external view returns (address);
}
abstract contract LnAddressCache {
function updateAddressCache(ILnAddressStorage _addressStorage) external virtual;
event CachedAddressUpdated(bytes32 name, address addr);
}
contract testAddressCache is LnAddressCache, LnAdmin {
address public addr1;
address public addr2;
constructor(address _admin) public LnAdmin(_admin) {}
function updateAddressCache(ILnAddressStorage _addressStorage) public override onlyAdmin {
addr1 = _addressStorage.getAddressWithRequire("a", "");
addr2 = _addressStorage.getAddressWithRequire("b", "");
emit CachedAddressUpdated("a", addr1);
emit CachedAddressUpdated("b", addr2);
}
}
interface ILnAccessControl {
function hasRole(bytes32 role, address account) external view returns (bool);
function ISSUE_ASSET_ROLE() external view returns (bytes32);
function BURN_ASSET_ROLE() external view returns (bytes32);
function DEBT_SYSTEM() external view returns (bytes32);
function IsAdmin(address _address) external view returns (bool);
function SetAdmin(address _address) external returns (bool);
function SetRoles(bytes32 roleType,
address[] calldata addresses,
bool[] calldata setTo) external;
function SetIssueAssetRole(address[] calldata issuer, bool[] calldata setTo) external;
function SetBurnAssetRole(address[] calldata burner, bool[] calldata setTo) external;
function SetDebtSystemRole(address[] calldata _address, bool[] calldata _setTo) external;
}
interface ILnAssetSystem {
function totalAssetsInUsd() external view returns (uint256 rTotal);
}
contract LnDebtSystem is LnAdminUpgradeable, LnAddressCache {
using SafeMath for uint;
using SafeDecimalMath for uint;
// -------------------------------------------------------
// need set before system running value.
ILnAccessControl private accessCtrl;
ILnAssetSystem private assetSys;
// -------------------------------------------------------
struct DebtData {
uint256 debtProportion;
uint256 debtFactor; // PRECISE_UNIT
}
mapping(address => DebtData) public userDebtState;
//use mapping to store array data
mapping(uint256 => uint256) public lastDebtFactors; // PRECISE_UNIT Note: factor factor, index
uint256 public debtCurrentIndex; // length of array. this index of array no value
// follow var use to manage array size.
uint256 public lastCloseAt; // close at array index
uint256 public lastDeletTo; // delete to array index, lastDeletTo < lastCloseAt
uint256 public constant MAX_DEL_PER_TIME = 50;
//
// -------------------------------------------------------
function __LnDebtSystem_init(address _admin) public initializer {
__LnAdminUpgradeable_init(_admin);
}
event UpdateAddressStorage(address oldAddr, address newAddr);
event UpdateUserDebtLog(address addr, uint256 debtProportion, uint256 debtFactor, uint256 timestamp);
event PushDebtLog(uint256 index, uint256 newFactor, uint256 timestamp);
// ------------------ system config ----------------------
function updateAddressCache(ILnAddressStorage _addressStorage) public override onlyAdmin {
accessCtrl = ILnAccessControl(_addressStorage.getAddressWithRequire("LnAccessControl", "LnAccessControl address not valid"));
assetSys = ILnAssetSystem(_addressStorage.getAddressWithRequire("LnAssetSystem", "LnAssetSystem address not valid"));
emit CachedAddressUpdated("LnAccessControl", address(accessCtrl));
emit CachedAddressUpdated("LnAssetSystem", address(assetSys));
}
// -----------------------------------------------
modifier OnlyDebtSystemRole(address _address) {
require(accessCtrl.hasRole(accessCtrl.DEBT_SYSTEM(), _address), "Need debt system access role");
_;
}
function SetLastCloseFeePeriodAt(uint256 index) external OnlyDebtSystemRole(msg.sender) {
require(index >= lastCloseAt, "Close index can not return to pass");
require(index <= debtCurrentIndex, "Can not close at future index");
lastCloseAt = index;
}
function importDebtData(address[] calldata users,
uint256[] calldata debtProportions,
uint256[] calldata debtFactors,
uint256[] calldata timestamps) external onlyAdmin {
require(users.length == debtProportions.length &&
debtProportions.length == debtFactors.length &&
debtFactors.length == timestamps.length,
"Length mismatch");
for (uint256 ind = 0; ind < users.length; ind++) {
address user = users[ind];
uint256 debtProportion = debtProportions[ind];
uint256 debtFactor = debtFactors[ind];
uint256 timestamp = timestamps[ind];
uint256 currentIndex = debtCurrentIndex + ind;
lastDebtFactors[currentIndex] = debtFactor;
userDebtState[user] = DebtData({debtProportion: debtProportion, debtFactor: debtFactor});
emit PushDebtLog(currentIndex, debtFactor, timestamp);
emit UpdateUserDebtLog(user, debtProportion, debtFactor, timestamp);
}
debtCurrentIndex = debtCurrentIndex + users.length;
}
function _pushDebtFactor(uint256 _factor) private {
if (debtCurrentIndex == 0 || lastDebtFactors[debtCurrentIndex - 1] == 0) {
// init or all debt has be cleared, new set value will be one unit
lastDebtFactors[debtCurrentIndex] = SafeDecimalMath.preciseUnit();
} else {
lastDebtFactors[debtCurrentIndex] = lastDebtFactors[debtCurrentIndex - 1].multiplyDecimalRoundPrecise(_factor);
}
emit PushDebtLog(debtCurrentIndex, lastDebtFactors[debtCurrentIndex], block.timestamp);
debtCurrentIndex = debtCurrentIndex.add(1);
// delete out of date data
if (lastDeletTo < lastCloseAt) {
// safe check
uint256 delNum = lastCloseAt - lastDeletTo;
delNum = (delNum > MAX_DEL_PER_TIME) ? MAX_DEL_PER_TIME : delNum; // not delete all in one call, for saving someone fee.
for (uint256 i = lastDeletTo; i < delNum; i++) {
delete lastDebtFactors[i];
}
lastDeletTo = lastDeletTo.add(delNum);
}
}
function PushDebtFactor(uint256 _factor) external OnlyDebtSystemRole(msg.sender) {
_pushDebtFactor(_factor);
}
function _updateUserDebt(address _user, uint256 _debtProportion) private {
userDebtState[_user].debtProportion = _debtProportion;
userDebtState[_user].debtFactor = _lastSystemDebtFactor();
emit UpdateUserDebtLog(_user, _debtProportion, userDebtState[_user].debtFactor, block.timestamp);
}
// need update lastDebtFactors first
function UpdateUserDebt(address _user, uint256 _debtProportion) external OnlyDebtSystemRole(msg.sender) {
_updateUserDebt(_user, _debtProportion);
}
function UpdateDebt(address _user,
uint256 _debtProportion,
uint256 _factor) external OnlyDebtSystemRole(msg.sender) {
_pushDebtFactor(_factor);
_updateUserDebt(_user, _debtProportion);
}
function GetUserDebtData(address _user) external view returns (uint256 debtProportion, uint256 debtFactor) {
debtProportion = userDebtState[_user].debtProportion;
debtFactor = userDebtState[_user].debtFactor;
}
function _lastSystemDebtFactor() private view returns (uint256) {
if (debtCurrentIndex == 0) {
return SafeDecimalMath.preciseUnit();
}
return lastDebtFactors[debtCurrentIndex - 1];
}
function LastSystemDebtFactor() external view returns (uint256) {
return _lastSystemDebtFactor();
}
function GetUserCurrentDebtProportion(address _user) public view returns (uint256) {
uint256 debtProportion = userDebtState[_user].debtProportion;
uint256 debtFactor = userDebtState[_user].debtFactor;
if (debtProportion == 0) {
return 0;
}
uint256 currentUserDebtProportion =
_lastSystemDebtFactor().divideDecimalRoundPrecise(debtFactor).multiplyDecimalRoundPrecise(debtProportion);
return currentUserDebtProportion;
}
function GetUserDebtBalanceInUsd(address _user) external view returns (uint256, uint256) {
uint256 totalAssetSupplyInUsd = assetSys.totalAssetsInUsd();
uint256 debtProportion = userDebtState[_user].debtProportion;
uint256 debtFactor = userDebtState[_user].debtFactor;
if (debtProportion == 0) {
return (0, totalAssetSupplyInUsd);
}
uint256 currentUserDebtProportion =
_lastSystemDebtFactor().divideDecimalRoundPrecise(debtFactor).multiplyDecimalRoundPrecise(debtProportion);
uint256 userDebtBalance =
totalAssetSupplyInUsd
.decimalToPreciseDecimal()
.multiplyDecimalRoundPrecise(currentUserDebtProportion)
.preciseDecimalToDecimal();
return (userDebtBalance, totalAssetSupplyInUsd);
}
// Reserved storage space to allow for layout changes in the future.
uint256[42] private __gap;
}
| 257,577 | 1,528 |
95ae5caa58c5ef2f24f5164451cabce15f177553d85ba510c85c8012b923be54
| 29,155 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xA23DDf9C358a156B3d7399b96cfE3996bc2311D9/contract.sol
| 5,157 | 18,458 |
// Yieldlava.finance Platform Token BEP20
//
// Web: https://yieldlava.finance/
// Telegram group: t.me/yLAVAofficialgroupchat
// Telegram channel: t.me/yLAVAofficialchannel
// Twitter: https://twitter.com/FinanceYlava
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract yLAVA is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'YieldLava Finance';
string private constant _SYMBOL = 'yLAVA';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 100000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private constant _TAX_FEE = 550;
uint256 private constant _BURN_FEE = 600;
uint256 private constant _MAX_TX_SIZE = 100000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 258,022 | 1,529 |
c49caab68ed6ee826ae94543e52cfbe32b3848c36db396e5ac923308b91f9103
| 27,363 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/18/18f6cf9f88667462a3b6d33edff0d261bc10ebc8_TimeStaking.sol
| 4,198 | 16,940 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
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 add32(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
}
interface IERC20 {
function decimals() external view returns (uint8);
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) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target,
bytes memory data,
uint256 weiValue,
string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(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");
// solhint-disable-next-line avoid-low-level-calls
(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");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token,
address spender,
uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender)
.sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IOwnable {
function manager() external view returns (address);
function renounceManagement() external;
function pushManagement(address newOwner_) external;
function pullManagement() external;
}
contract Ownable is IOwnable {
address internal _owner;
address internal _newOwner;
event OwnershipPushed(address indexed previousOwner, address indexed newOwner);
event OwnershipPulled(address indexed previousOwner, address indexed newOwner);
constructor () {
_owner = msg.sender;
emit OwnershipPushed(address(0), _owner);
}
function manager() public view override returns (address) {
return _owner;
}
modifier onlyManager() {
require(_owner == msg.sender, "Ownable: caller is not the owner");
_;
}
function renounceManagement() public virtual override onlyManager() {
emit OwnershipPushed(_owner, address(0));
_owner = address(0);
}
function pushManagement(address newOwner_) public virtual override onlyManager() {
require(newOwner_ != address(0), "Ownable: new owner is the zero address");
emit OwnershipPushed(_owner, newOwner_);
_newOwner = newOwner_;
}
function pullManagement() public virtual override {
require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
emit OwnershipPulled(_owner, _newOwner);
_owner = _newOwner;
}
}
interface IMemo {
function rebase(uint256 ohmProfit_, uint epoch_) external returns (uint256);
function circulatingSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function gonsForBalance(uint amount) external view returns (uint);
function balanceForGons(uint gons) external view returns (uint);
function index() external view returns (uint);
}
interface IWarmup {
function retrieve(address staker_, uint amount_) external;
}
interface IDistributor {
function distribute() external returns (bool);
}
contract TimeStaking is Ownable {
using SafeMath for uint256;
using SafeMath for uint32;
using SafeERC20 for IERC20;
address public immutable Time;
address public immutable Memories;
struct Epoch {
uint number;
uint distribute;
uint32 length;
uint32 endTime;
}
Epoch public epoch;
address public distributor;
address public locker;
uint public totalBonus;
address public warmupContract;
uint public warmupPeriod;
constructor (address _Time,
address _Memories,
uint32 _epochLength,
uint _firstEpochNumber,
uint32 _firstEpochTime) {
require(_Time != address(0));
Time = _Time;
require(_Memories != address(0));
Memories = _Memories;
epoch = Epoch({
length: _epochLength,
number: _firstEpochNumber,
endTime: _firstEpochTime,
distribute: 0
});
}
struct Claim {
uint deposit;
uint gons;
uint expiry;
bool lock; // prevents malicious delays
}
mapping(address => Claim) public warmupInfo;
function stake(uint _amount, address _recipient) external returns (bool) {
rebase();
IERC20(Time).safeTransferFrom(msg.sender, address(this), _amount);
Claim memory info = warmupInfo[ _recipient ];
require(!info.lock, "Deposits for account are locked");
warmupInfo[ _recipient ] = Claim ({
deposit: info.deposit.add(_amount),
gons: info.gons.add(IMemo(Memories).gonsForBalance(_amount)),
expiry: epoch.number.add(warmupPeriod),
lock: false
});
IERC20(Memories).safeTransfer(warmupContract, _amount);
return true;
}
function claim (address _recipient) public {
Claim memory info = warmupInfo[ _recipient ];
if (epoch.number >= info.expiry && info.expiry != 0) {
delete warmupInfo[ _recipient ];
IWarmup(warmupContract).retrieve(_recipient, IMemo(Memories).balanceForGons(info.gons));
}
}
function forfeit() external {
Claim memory info = warmupInfo[ msg.sender ];
delete warmupInfo[ msg.sender ];
IWarmup(warmupContract).retrieve(address(this), IMemo(Memories).balanceForGons(info.gons));
IERC20(Time).safeTransfer(msg.sender, info.deposit);
}
function toggleDepositLock() external {
warmupInfo[ msg.sender ].lock = !warmupInfo[ msg.sender ].lock;
}
function unstake(uint _amount, bool _trigger) external {
if (_trigger) {
rebase();
}
IERC20(Memories).safeTransferFrom(msg.sender, address(this), _amount);
IERC20(Time).safeTransfer(msg.sender, _amount);
}
function index() public view returns (uint) {
return IMemo(Memories).index();
}
function rebase() public {
if(epoch.endTime <= uint32(block.timestamp)) {
IMemo(Memories).rebase(epoch.distribute, epoch.number);
epoch.endTime = epoch.endTime.add32(epoch.length);
epoch.number++;
if (distributor != address(0)) {
IDistributor(distributor).distribute();
}
uint balance = contractBalance();
uint staked = IMemo(Memories).circulatingSupply();
if(balance <= staked) {
epoch.distribute = 0;
} else {
epoch.distribute = balance.sub(staked);
}
}
}
function contractBalance() public view returns (uint) {
return IERC20(Time).balanceOf(address(this)).add(totalBonus);
}
function giveLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.add(_amount);
IERC20(Memories).safeTransfer(locker, _amount);
}
function returnLockBonus(uint _amount) external {
require(msg.sender == locker);
totalBonus = totalBonus.sub(_amount);
IERC20(Memories).safeTransferFrom(locker, address(this), _amount);
}
enum CONTRACTS { DISTRIBUTOR, WARMUP, LOCKER }
function setContract(CONTRACTS _contract, address _address) external onlyManager() {
if(_contract == CONTRACTS.DISTRIBUTOR) { // 0
distributor = _address;
} else if (_contract == CONTRACTS.WARMUP) { // 1
require(warmupContract == address(0), "Warmup cannot be set more than once");
warmupContract = _address;
} else if (_contract == CONTRACTS.LOCKER) { // 2
require(locker == address(0), "Locker cannot be set more than once");
locker = _address;
}
}
function setWarmup(uint _warmupPeriod) external onlyManager() {
warmupPeriod = _warmupPeriod;
}
}
| 84,143 | 1,530 |
cdbb3c6841fdea4f7489799f8f3c990b25e8f94162fc0503e3f7cc7b5c9701d0
| 19,505 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/bc/BcE67A46939739d96bCC1CB806b8A3505714d3C5_Surge.sol
| 5,326 | 18,964 |
pragma solidity ^0.6.12;
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner,"you are not the owner!");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0),"newowner not 0 address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Whitelist is Ownable {
mapping(address => bool) public whitelist;
event WhitelistedAddressAdded(address addr);
event WhitelistedAddressRemoved(address addr);
modifier onlyWhitelisted() {
require(whitelist[msg.sender], 'no whitelist');
_;
}
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) {
if (!whitelist[addr]) {
whitelist[addr] = true;
emit WhitelistedAddressAdded(addr);
success = true;
}
}
function addAddressesToWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addAddressToWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) {
if (whitelist[addr]) {
whitelist[addr] = false;
emit WhitelistedAddressRemoved(addr);
success = true;
}
return success;
}
function removeAddressesFromWhitelist(address[] memory addrs) onlyOwner public returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeAddressFromWhitelist(addrs[i])) {
success = true;
}
}
return success;
}
}
contract BEP20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowed;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowed[owner][spender];
}
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
function approve(address spender, uint256 value) public returns (bool) {
_approve(msg.sender, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public returns (bool) {
_transfer(from, to, value);
_approve(from, msg.sender, _allowed[from][msg.sender].sub(value));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].sub(subtractedValue));
return true;
}
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0),"to address will not be 0");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
require(account != address(0),"2");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
require(account != address(0),"3");
_totalSupply = _totalSupply.sub(value);
_balances[account] = _balances[account].sub(value);
emit Transfer(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0),"4");
require(owner != address(0),"5");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
function _burnFrom(address account, uint256 value) internal {
_burn(account, value);
_approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
if (b > a) {
return 0;
} else {
return a - b;
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
interface IToken {
function calculateTransferTaxes(address _from, uint256 _value) external view returns (uint256 adjustedValue, uint256 taxAmount);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function balanceOf(address who) external view returns (uint256);
function burn(uint256 _value) external;
}
contract Surge is BEP20, Whitelist {
string public constant name = "Tsunami Liquidity Token";
string public constant symbol = "DROPS";
uint8 public constant decimals = 18;
IToken internal token;
uint256 public totalTxs;
uint256 internal lastBalance_;
uint256 internal trackingInterval_ = 1 minutes;
uint256 public providers;
mapping (address => bool) internal _providers;
mapping (address => uint256) internal _txs;
bool public isPaused = true;
event onTokenPurchase(address indexed buyer, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onBnbPurchase(address indexed buyer, uint256 indexed token_amount, uint256 indexed bnb_amount);
event onAddLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onRemoveLiquidity(address indexed provider, uint256 indexed bnb_amount, uint256 indexed token_amount);
event onLiquidity(address indexed provider, uint256 indexed amount);
event onContractBalance(uint256 balance);
event onPrice(uint256 price);
event onSummary(uint256 liquidity, uint256 price);
constructor (address token_addr) Ownable() public {
token = IToken(token_addr);
lastBalance_= now;
}
function unpause() public onlyOwner {
isPaused = false;
}
function pause() public onlyOwner {
isPaused = true;
}
modifier isNotPaused() {
require(!isPaused, "Swaps currently paused");
_;
}
receive() external payable {
bnbToTokenInput(msg.value, 1, msg.sender, msg.sender);
}
function getInputPrice(uint256 input_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0, "INVALID_VALUE");
uint256 input_amount_with_fee = input_amount.mul(990);
uint256 numerator = input_amount_with_fee.mul(output_reserve);
uint256 denominator = input_reserve.mul(1000).add(input_amount_with_fee);
return numerator / denominator;
}
function getOutputPrice(uint256 output_amount, uint256 input_reserve, uint256 output_reserve) public view returns (uint256) {
require(input_reserve > 0 && output_reserve > 0,"input_reserve & output reserve must >0");
uint256 numerator = input_reserve.mul(output_amount).mul(1000);
uint256 denominator = (output_reserve.sub(output_amount)).mul(990);
return (numerator / denominator).add(1);
}
function bnbToTokenInput(uint256 bnb_sold, uint256 min_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_sold > 0 && min_tokens > 0, "sold and min 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_bought = getInputPrice(bnb_sold, address(this).balance.sub(bnb_sold), token_reserve);
require(tokens_bought >= min_tokens, "tokens_bought >= min_tokens");
require(token.transfer(recipient, tokens_bought), "transfer err");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
emit onContractBalance(bnbBalance());
trackGlobalStats();
return tokens_bought;
}
function bnbToTokenSwapInput(uint256 min_tokens) public payable isNotPaused returns (uint256) {
return bnbToTokenInput(msg.value, min_tokens,msg.sender, msg.sender);
}
function bnbToTokenOutput(uint256 tokens_bought, uint256 max_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_bought > 0 && max_bnb > 0,"tokens_bought > 0 && max_bnb >");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance.sub(max_bnb), token_reserve);
uint256 bnb_refund = max_bnb.sub(bnb_sold);
if (bnb_refund > 0) {
payable(buyer).transfer(bnb_refund);
}
require(token.transfer(recipient, tokens_bought),"error");
emit onTokenPurchase(buyer, bnb_sold, tokens_bought);
trackGlobalStats();
return bnb_sold;
}
function bnbToTokenSwapOutput(uint256 tokens_bought) public payable isNotPaused returns (uint256) {
return bnbToTokenOutput(tokens_bought, msg.value, msg.sender, msg.sender);
}
function tokenToBnbInput(uint256 tokens_sold, uint256 min_bnb, address buyer, address recipient) private returns (uint256) {
require(tokens_sold > 0 && min_bnb > 0,"tokens_sold > 0 && min_bnb > 0");
uint256 token_reserve = token.balanceOf(address(this));
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
uint256 bnb_bought = getInputPrice(realized_sold, token_reserve, address(this).balance);
require(bnb_bought >= min_bnb,"bnb_bought >= min_bnb");
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transforfrom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return bnb_bought;
}
function tokenToBnbSwapInput(uint256 tokens_sold, uint256 min_bnb) public isNotPaused returns (uint256) {
return tokenToBnbInput(tokens_sold, min_bnb, msg.sender, msg.sender);
}
function tokenToBnbOutput(uint256 bnb_bought, uint256 max_tokens, address buyer, address recipient) private returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0");
uint256 token_reserve = token.balanceOf(address(this));
uint256 tokens_sold = getOutputPrice(bnb_bought, token_reserve, address(this).balance);
(uint256 realized_sold, uint256 taxAmount) = token.calculateTransferTaxes(buyer, tokens_sold);
tokens_sold += taxAmount;
require(max_tokens >= tokens_sold, 'max tokens exceeded');
payable(recipient).transfer(bnb_bought);
require(token.transferFrom(buyer, address(this), tokens_sold),"transorfroom error");
emit onBnbPurchase(buyer, tokens_sold, bnb_bought);
trackGlobalStats();
return tokens_sold;
}
function tokenToBnbSwapOutput(uint256 bnb_bought, uint256 max_tokens) public isNotPaused returns (uint256) {
return tokenToBnbOutput(bnb_bought, max_tokens, msg.sender, msg.sender);
}
function trackGlobalStats() private {
uint256 price = getBnbToTokenOutputPrice(1e18);
uint256 balance = bnbBalance();
if (now.safeSub(lastBalance_) > trackingInterval_) {
emit onSummary(balance * 2, price);
lastBalance_ = now;
}
emit onContractBalance(balance);
emit onPrice(price);
totalTxs += 1;
_txs[msg.sender] += 1;
}
function getBnbToTokenInputPrice(uint256 bnb_sold) public view returns (uint256) {
require(bnb_sold > 0,"bnb_sold > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
return getInputPrice(bnb_sold, address(this).balance, token_reserve);
}
function getBnbToTokenOutputPrice(uint256 tokens_bought) public view returns (uint256) {
require(tokens_bought > 0,"tokens_bought > 0,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_sold = getOutputPrice(tokens_bought, address(this).balance, token_reserve);
return bnb_sold;
}
function getTokenToBnbInputPrice(uint256 tokens_sold) public view returns (uint256) {
require(tokens_sold > 0, "token sold < 0,,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_bought = getInputPrice(tokens_sold, token_reserve, address(this).balance);
return bnb_bought;
}
function getTokenToBnbOutputPrice(uint256 bnb_bought) public view returns (uint256) {
require(bnb_bought > 0,"bnb_bought > 0,,,,2");
uint256 token_reserve = token.balanceOf(address(this));
return getOutputPrice(bnb_bought, token_reserve, address(this).balance);
}
function tokenAddress() public view returns (address) {
return address(token);
}
function bnbBalance() public view returns (uint256) {
return address(this).balance;
}
function tokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function getBnbToLiquidityInputPrice(uint256 bnb_sold) public view returns (uint256){
require(bnb_sold > 0,"bnb_sold > 0,,,,,3");
uint256 token_amount = 0;
uint256 total_liquidity = _totalSupply;
uint256 bnb_reserve = address(this).balance;
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (bnb_sold.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = bnb_sold.mul(total_liquidity) / bnb_reserve;
return liquidity_minted;
}
function getLiquidityToReserveInputPrice(uint amount) public view returns (uint256, uint256){
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0,"total_liquidity > 0,,,,1");
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
return (bnb_amount, token_amount);
}
function txs(address owner) public view returns (uint256) {
return _txs[owner];
}
function addLiquidity(uint256 min_liquidity, uint256 max_tokens) isNotPaused public payable returns (uint256) {
require(max_tokens > 0 && msg.value > 0, "Swap#addLiquidity: INVALID_ARGUMENT");
uint256 total_liquidity = _totalSupply;
uint256 token_amount = 0;
if (_providers[msg.sender] == false){
_providers[msg.sender] = true;
providers += 1;
}
if (total_liquidity > 0) {
require(min_liquidity > 0,"min_liquidity > 0,,,,4");
uint256 bnb_reserve = address(this).balance.sub(msg.value);
uint256 token_reserve = token.balanceOf(address(this));
token_amount = (msg.value.mul(token_reserve) / bnb_reserve).add(1);
uint256 liquidity_minted = msg.value.mul(total_liquidity) / bnb_reserve;
require(max_tokens >= token_amount && liquidity_minted >= min_liquidity,"max_tokens >= token_amount && liquidity_minted >= min_liquidity,,,,1");
_balances[msg.sender] = _balances[msg.sender].add(liquidity_minted);
_totalSupply = total_liquidity.add(liquidity_minted);
require(token.transferFrom(msg.sender, address(this), token_amount),"transfrom4 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, liquidity_minted);
return liquidity_minted;
} else {
require(msg.value >= 1e18, "INVALID_VALUE");
token_amount = max_tokens;
uint256 initial_liquidity = address(this).balance;
_totalSupply = initial_liquidity;
_balances[msg.sender] = initial_liquidity;
require(token.transferFrom(msg.sender, address(this), token_amount),"transforfrom 5 error");
emit onAddLiquidity(msg.sender, msg.value, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(address(0), msg.sender, initial_liquidity);
return initial_liquidity;
}
}
function removeLiquidity(uint256 amount, uint256 min_bnb, uint256 min_tokens) onlyWhitelisted public returns (uint256, uint256) {
require(amount > 0 && min_bnb > 0 && min_tokens > 0,"amount > 0 && min_bnb > 0 && min_tokens > 0,333");
uint256 total_liquidity = _totalSupply;
require(total_liquidity > 0);
uint256 token_reserve = token.balanceOf(address(this));
uint256 bnb_amount = amount.mul(address(this).balance) / total_liquidity;
uint256 token_amount = amount.mul(token_reserve) / total_liquidity;
require(bnb_amount >= min_bnb && token_amount >= min_tokens,"(bnb_amount >= min_bnb && token_amount >= min_tokens,33");
_balances[msg.sender] = _balances[msg.sender].sub(amount);
_totalSupply = total_liquidity.sub(amount);
msg.sender.transfer(bnb_amount);
require(token.transfer(msg.sender, token_amount),"transfer error");
emit onRemoveLiquidity(msg.sender, bnb_amount, token_amount);
emit onLiquidity(msg.sender, _balances[msg.sender]);
emit Transfer(msg.sender, address(0), amount);
return (bnb_amount, token_amount);
}
}
| 111,649 | 1,531 |
1ba862101471228c7b594810fb5cc001d848de0d300d77f9635f53407998fdc8
| 11,778 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.4/0xcad49c39b72c37b32cee8b14f33f316d3a8bc335.sol
| 2,754 | 11,680 |
pragma solidity ^0.4.24;
//asdfasdf
contract SafeMath {
function safeAdd(uint a, uint b) public pure returns (uint c) {
c = a + b;
require(c >= a);
}
function safeSub(uint a, uint b) public pure returns (uint c) {
require(b <= a);
c = a - b;
}
function safeMul(uint a, uint b) public pure returns (uint c) {
c = a * b;
require(a == 0 || c / a == b);
}
function safeDiv(uint a, uint b) public pure returns (uint c) {
require(b > 0);
c = a / b;
}
}
// ----------------------------------------------------------------------------
// ERC Token Standard #20 Interface
// ----------------------------------------------------------------------------
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function checkRate() public constant returns (uint rate_);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Blacklisted(address indexed target);
event DeleteFromBlacklist(address indexed target);
event RejectedPaymentToBlacklistedAddr(address indexed from, address indexed to, uint value);
event RejectedPaymentFromBlacklistedAddr(address indexed from, address indexed to, uint value);
event RejectedPaymentFromLockedAddr(address indexed from, address indexed to, uint value, uint lackdatetime, uint now_);
event RejectedPaymentMaximunFromLockedAddr(address indexed from, address indexed to, uint value);
event test1(uint rate, uint a, uint now);
}
// ----------------------------------------------------------------------------
// Contract function to receive approval and execute function in one call
// ----------------------------------------------------------------------------
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
// ----------------------------------------------------------------------------
// Owned contract
// ----------------------------------------------------------------------------
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0);
}
}
// ----------------------------------------------------------------------------
// ERC20 Token, with the addition of symbol, name and decimals and assisted
// token transfers
// ----------------------------------------------------------------------------
contract SodaCoin is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public start;
address founderAddr = 0x625f7Ae05DC8c22dA56F47CaDc8c647137a6B4D9;
address advisorAddr = 0x45F6a7D7903D3A02bef15826eBCA44aB5eD11758;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
mapping(address => int8) public blacklist;
UnlockDateModel[] public unlockdate;
struct UnlockDateModel {
//string date;
uint256 datetime;
uint rate;
}
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
constructor() public {
symbol = "SOC";
name = "SODA Coin";
decimals = 18;
_totalSupply = 2000000000000000000000000000;
balances[msg.sender] = 1400000000000000000000000000;
emit Transfer(address(0), 0x1E7A12b193D18027E33cd3Ff0eef2Af31cbBF9ef, 1400000000000000000000000000); // owner wallet (70%) 1,400,000,000
// Founder & Team wallet (15%) 300,000,000
// Vesting over 2 years and 10 months (10% monthly release after 2 years)
balances[founderAddr] = 300000000000000000000000000;
emit Transfer(address(0), founderAddr, 300000000000000000000000000);
// Advisor & Partner wallet (15%) 300,000,000
// Vesting over 2 years and 10 months (10% monthly release after 2 years)
balances[advisorAddr] = 300000000000000000000000000;
emit Transfer(address(0), advisorAddr, 300000000000000000000000000);
start = now;
unlockdate.push(UnlockDateModel({datetime : 1610237400,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1612915800,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1615335000,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1618013400,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1620605400,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1623283800,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1625875800,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1628554200,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1631232600,rate : 10}));
unlockdate.push(UnlockDateModel({datetime : 1633824600,rate : 10}));
}
function now_() public constant returns (uint){
return now;
}
// ------------------------------------------------------------------------
// Total supply
// ------------------------------------------------------------------------
function totalSupply() public constant returns (uint) {
return _totalSupply - balances[address(0)];
}
// ------------------------------------------------------------------------
// Get the token balance for account tokenOwner
// ------------------------------------------------------------------------
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return balances[tokenOwner];
}
function checkRate() public constant returns (uint rate_){
uint rate = 0;
for (uint i = 0; i<unlockdate.length; i++) {
if (unlockdate[i].datetime < now) {
rate = rate + unlockdate[i].rate;
}
}
return rate;
}
// ------------------------------------------------------------------------
// Transfer the balance from token owner's account to to account
// - Owner's account must have sufficient balance to transfer
// - 0 value transfers are allowed
// ------------------------------------------------------------------------
function transfer(address to, uint tokens) public returns (bool success) {
if (msg.sender == founderAddr || msg.sender == advisorAddr){
if (unlockdate[0].datetime > now) {
emit RejectedPaymentFromLockedAddr(msg.sender, to, tokens, unlockdate[0].datetime, now);
return false;
} else {
uint rate = checkRate();
uint maximum = 300000000000000000000000000 - (300000000000000000000000000 * 0.01) * rate;
if (maximum > (balances[msg.sender] - tokens)){
emit RejectedPaymentMaximunFromLockedAddr(msg.sender, to, tokens);
return false;
}
}
}
if (blacklist[msg.sender] > 0) { // Accounts in the blacklist can not be withdrawn
emit RejectedPaymentFromBlacklistedAddr(msg.sender, to, tokens);
return false;
} else if (blacklist[to] > 0) { // Accounts in the blacklist can not be withdrawn
emit RejectedPaymentToBlacklistedAddr(msg.sender, to, tokens);
return false;
} else {
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[to] = safeAdd(balances[to], tokens);
emit Transfer(msg.sender, to, tokens);
return true;
}
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account
// ------------------------------------------------------------------------
function approve(address spender, uint tokens) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
// ------------------------------------------------------------------------
// Returns the amount of tokens approved by the owner that can be
// transferred to the spender's account
// ------------------------------------------------------------------------
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
// ------------------------------------------------------------------------
// Token owner can approve for spender to transferFrom(...) tokens
// from the token owner's account. The spender contract function
// receiveApproval(...) is then executed
// ------------------------------------------------------------------------
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
// ------------------------------------------------------------------------
// Don't accept ETH
// ------------------------------------------------------------------------
function () public payable {
revert();
}
// ------------------------------------------------------------------------
// Owner can transfer out any accidentally sent ERC20 tokens
// ------------------------------------------------------------------------
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
// ------------------------------------------------------------------------
// Owner can add an increase total supply.
// ------------------------------------------------------------------------
function totalSupplyIncrease(uint256 _supply) public onlyOwner{
_totalSupply = _totalSupply + _supply;
balances[msg.sender] = balances[msg.sender] + _supply;
}
// ------------------------------------------------------------------------
// Owner can add blacklist the wallet address.
// ------------------------------------------------------------------------
function blacklisting(address _addr) public onlyOwner{
blacklist[_addr] = 1;
emit Blacklisted(_addr);
}
// ------------------------------------------------------------------------
// Owner can delete from blacklist the wallet address.
// ------------------------------------------------------------------------
function deleteFromBlacklist(address _addr) public onlyOwner{
blacklist[_addr] = -1;
emit DeleteFromBlacklist(_addr);
}
}
| 220,596 | 1,532 |
af9e9f3098c23c24a49731482b22198f185b6617eb25152d6dbaaad9b700fb77
| 27,850 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xbb71bc0b4739f91ba76c70251883daec80282dfa.sol
| 4,708 | 16,359 |
pragma solidity ^0.4.18;
// File: contracts/zeppelin/ownership/Ownable.sol
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
// File: contracts/zeppelin/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
// File: contracts/zeppelin/token/ERC20/ERC20Basic.sol
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
// File: contracts/zeppelin/token/ERC20/BasicToken.sol
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
// File: contracts/zeppelin/token/ERC20/ERC20.sol
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: contracts/zeppelin/token/ERC20/StandardToken.sol
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
// File: contracts/zeppelin/token/ERC20/MintableToken.sol
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
}
}
// File: contracts/Circle.sol
contract Circle is MintableToken {
string public name = "Circle Plus";
string public symbol = "Circle";
uint8 public decimals = 18;
}
// File: contracts/zeppelin/crowdsale/Crowdsale.sol
contract Crowdsale {
using SafeMath for uint256;
// The token being sold
ERC20 public token;
// Address where funds are collected
address public wallet;
// How many token units a buyer gets per wei
uint256 public rate;
// Amount of wei raised
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
function () external payable {
buyTokens(msg.sender);
}
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
function _postValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
}
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_deliverTokens(_beneficiary, _tokenAmount);
}
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
// optional override
}
function _getTokenAmount(uint256 _weiAmount) internal view returns (uint256) {
return _weiAmount.mul(rate);
}
function _forwardFunds() internal {
wallet.transfer(msg.value);
}
}
// File: contracts/zeppelin/crowdsale/emission/MintedCrowdsale.sol
contract MintedCrowdsale is Crowdsale {
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
require(MintableToken(token).mint(_beneficiary, _tokenAmount));
}
}
// File: contracts/zeppelin/crowdsale/validation/TimedCrowdsale.sol
contract TimedCrowdsale is Crowdsale {
using SafeMath for uint256;
uint256 public openingTime;
uint256 public closingTime;
modifier onlyWhileOpen {
require(block.timestamp >= openingTime && block.timestamp <= closingTime);
_;
}
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
}
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal onlyWhileOpen {
super._preValidatePurchase(_beneficiary, _weiAmount);
}
}
// File: contracts/zeppelin/token/ERC20/SafeERC20.sol
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token,
address from,
address to,
uint256 value)
internal
{
assert(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
}
}
// File: contracts/zeppelin/token/ERC20/TokenTimelock.sol
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint256 public releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
// File: contracts/zeppelin/token/ERC20/TokenVesting.sol
contract TokenVesting is Ownable {
using SafeMath for uint256;
using SafeERC20 for ERC20Basic;
event Released(uint256 amount);
event Revoked();
// beneficiary of tokens after they are released
address public beneficiary;
uint256 public cliff;
uint256 public start;
uint256 public duration;
bool public revocable;
mapping (address => uint256) public released;
mapping (address => bool) public revoked;
function TokenVesting(address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
bool _revocable)
public
{
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
}
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
}
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
Revoked();
}
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
}
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
}
// File: contracts/CircleCrowdsale.sol
contract CircleCrowdsale is Ownable, MintedCrowdsale {
// Crowdsale Stage
// ============
enum CrowdsaleStage {
AngelRound,
PreSaleRound,
OpenRound}
// Token Distribution
// =============================
uint256 public totalSupplyMax = 2000000000 * (10 ** 18); // There will be total 2,000,000,000 Circle Tokens
uint256 public angelRound = 200000000 * (10 ** 18); // Angel Investors 200,000,000 (10%)
uint256 public preSaleRound = 400000000 * (10 ** 18); // PreSale Round 400,000,000 (20%)
uint256 public openRound = 200000000 * (10 ** 18); // Open Round 100,000,000 (10%)
uint256 public teamFund = 400000000 * (10 ** 18); // Team/Foundation 400,000,000 (20%) cliff 6mon
uint256 public communityFund = 400000000 * (10 ** 18); // Community 400,000,000 (20%)
uint256 public marketingFund = 400000000 * (10 ** 18); // Marketing 400,000,000 (20%)
// ==============================
// Amount minted in Every Stage
// ==================
uint256 public totalTokenMintedAngel;
uint256 public totalTokenMintedPreSale;
uint256 public totalTokenMintedOpen;
uint256 public totalTeamFundMinted;
uint256 public totalCommunityFundMinted;
uint256 public totalMarketingFundMinted;
// ===================
// Stage Rate
// ============
uint256 private _angelRate = 60000;
uint256 private _preSaleRate = 30000;
uint256 private _openRate = 20000;
// ============
// angel locked tokens
TokenTimelock public angelTimeLock;
// team vesting tokens
TokenVesting public teamTokenVesting;
// team vesting
uint256 public constant TEAM_VESTING_CLIFF = 6 * 30 days;
uint256 public constant TEAM_VESTING_DURATION = 2 years;
ERC20 _token = new Circle();
// Constructor
// ============
function CircleCrowdsale(uint256 _rate, address _wallet) public
Crowdsale(_rate, _wallet, _token)
{
}
// =============
function() external payable {
revert();
}
function buyTokens(address _beneficiary) public payable {
revert();
}
function investByLegalTender(address _beneficiary, uint256 _value, uint _stage) onlyOwner external returns (bool) {
uint256 _amount;
if (_stage == uint(CrowdsaleStage.PreSaleRound)) {
_amount = _preSaleRate * _value;
if (totalTokenMintedPreSale + _amount > preSaleRound) {
return false;
}
MintableToken(token).mint(_beneficiary, _amount);
totalTokenMintedPreSale += _amount;
} else if (_stage == uint(CrowdsaleStage.OpenRound)) {
_amount = _openRate * _value;
if (totalTokenMintedOpen + _amount > preSaleRound) {
return false;
}
MintableToken(token).mint(_beneficiary, _amount);
totalTokenMintedOpen += _amount;
} else {
return false;
}
return true;
}
function setAngelHolder(address _angelFundWallet) onlyOwner external {
if (angelRound - totalTokenMintedAngel > 0) {
angelTimeLock = new TokenTimelock(token, _angelFundWallet, uint64(now + 90 days));
MintableToken(token).mint(angelTimeLock, angelRound - totalTokenMintedAngel);
totalTokenMintedAngel = angelRound - totalTokenMintedAngel;
}
}
function setReservedHolder(address _teamFundWallet, address _communityFundWallet, address _marketingFundWallet) onlyOwner external {
if (teamFund - totalTeamFundMinted > 0) {
teamTokenVesting = new TokenVesting(_teamFundWallet, now, TEAM_VESTING_CLIFF, TEAM_VESTING_DURATION, true);
MintableToken(token).mint(teamTokenVesting, teamFund - totalTeamFundMinted);
totalTeamFundMinted = teamFund - totalTeamFundMinted;
}
if (communityFund - totalCommunityFundMinted > 0) {
MintableToken(token).mint(_communityFundWallet, communityFund - totalCommunityFundMinted);
totalCommunityFundMinted += communityFund - totalCommunityFundMinted;
}
if (marketingFund - totalMarketingFundMinted > 0) {
MintableToken(token).mint(_marketingFundWallet, marketingFund - totalMarketingFundMinted);
totalMarketingFundMinted += marketingFund - totalMarketingFundMinted;
}
}
}
| 146,201 | 1,533 |
d70cbb174b696283f2a5af0af5ce2b67efa9189cb284a904a2c23e112cfa062b
| 34,304 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/securityAbandonerAndInjector/nonStandarNaming/manualCheck/0x1b6d706b6d3ef97e6d832a89cd6af81959ad46cb_nonStandardNaming.sol
| 4,804 | 15,849 |
pragma solidity ^0.6.12;
abstract contract context10 { //inject NONSTANDARD NAMING
function _MSGSENDER9() internal view virtual returns (address payable) { //inject NONSTANDARD NAMING
return msg.sender;
}
function _MSGDATA1() internal view virtual returns (bytes memory) { //inject NONSTANDARD NAMING
this;
return msg.data;
}
}
interface ierc202 { //inject NONSTANDARD NAMING
function TOTALSUPPLY1() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF3(address ACCOUNT10) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER5(address RECIPIENT5, uint256 AMOUNT9) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE1(address OWNER0, address SPENDER5) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE1(address SPENDER5, uint256 AMOUNT9) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM10(address SENDER1, address RECIPIENT5, uint256 AMOUNT9) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER2(address indexed FROM2, address indexed TO9, uint256 VALUE2); //inject NONSTANDARD NAMING
event APPROVAL10(address indexed OWNER0, address indexed SPENDER5, uint256 VALUE2); //inject NONSTANDARD NAMING
}
library safemath1 { //inject NONSTANDARD NAMING
function ADD4(uint256 A1, uint256 B6) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 C8 = A1 + B6; //inject NONSTANDARD NAMING
require(C8 >= A1, "SafeMath: addition overflow");
return C8;
}
function SUB5(uint256 A1, uint256 B6) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return SUB5(A1, B6, "SafeMath: subtraction overflow");
}
function SUB5(uint256 A1, uint256 B6, string memory ERRORMESSAGE3) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(B6 <= A1, ERRORMESSAGE3);
uint256 C8 = A1 - B6; //inject NONSTANDARD NAMING
return C8;
}
function MUL6(uint256 A1, uint256 B6) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (A1 == 0) {
return 0;
}
uint256 C8 = A1 * B6; //inject NONSTANDARD NAMING
require(C8 / A1 == B6, "SafeMath: multiplication overflow");
return C8;
}
function DIV4(uint256 A1, uint256 B6) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return DIV4(A1, B6, "SafeMath: division by zero");
}
function DIV4(uint256 A1, uint256 B6, string memory ERRORMESSAGE3) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(B6 > 0, ERRORMESSAGE3);
uint256 C8 = A1 / B6; //inject NONSTANDARD NAMING
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return C8;
}
function MOD8(uint256 A1, uint256 B6) internal pure returns (uint256) { //inject NONSTANDARD NAMING
return MOD8(A1, B6, "SafeMath: modulo by zero");
}
function MOD8(uint256 A1, uint256 B6, string memory ERRORMESSAGE3) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(B6 != 0, ERRORMESSAGE3);
return A1 % B6;
}
}
library address5 { //inject NONSTANDARD NAMING
function ISCONTRACT2(address ACCOUNT10) internal view returns (bool) { //inject NONSTANDARD NAMING
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 CODEHASH4; //inject NONSTANDARD NAMING
bytes32 ACCOUNTHASH1 = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; //inject NONSTANDARD NAMING
// solhint-disable-next-line no-inline-assembly
assembly { CODEHASH4 := extcodehash(ACCOUNT10) }
return (CODEHASH4 != ACCOUNTHASH1 && CODEHASH4 != 0x0);
}
function SENDVALUE0(address payable RECIPIENT5, uint256 AMOUNT9) internal { //inject NONSTANDARD NAMING
require(address(this).balance >= AMOUNT9, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool SUCCESS3,) = RECIPIENT5.call{ value: AMOUNT9 }(""); //inject NONSTANDARD NAMING
require(SUCCESS3, "Address: unable to send value, recipient may have reverted");
}
function FUNCTIONCALL5(address TARGET4, bytes memory DATA2) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return FUNCTIONCALL5(TARGET4, DATA2, "Address: low-level call failed");
}
function FUNCTIONCALL5(address TARGET4, bytes memory DATA2, string memory ERRORMESSAGE3) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return _FUNCTIONCALLWITHVALUE9(TARGET4, DATA2, 0, ERRORMESSAGE3);
}
function FUNCTIONCALLWITHVALUE5(address TARGET4, bytes memory DATA2, uint256 VALUE2) internal returns (bytes memory) { //inject NONSTANDARD NAMING
return FUNCTIONCALLWITHVALUE5(TARGET4, DATA2, VALUE2, "Address: low-level call with value failed");
}
function FUNCTIONCALLWITHVALUE5(address TARGET4, bytes memory DATA2, uint256 VALUE2, string memory ERRORMESSAGE3) internal returns (bytes memory) { //inject NONSTANDARD NAMING
require(address(this).balance >= VALUE2, "Address: insufficient balance for call");
return _FUNCTIONCALLWITHVALUE9(TARGET4, DATA2, VALUE2, ERRORMESSAGE3);
}
function _FUNCTIONCALLWITHVALUE9(address TARGET4, bytes memory DATA2, uint256 WEIVALUE7, string memory ERRORMESSAGE3) private returns (bytes memory) { //inject NONSTANDARD NAMING
require(ISCONTRACT2(TARGET4), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool SUCCESS3, bytes memory RETURNDATA9) = TARGET4.call{ value: WEIVALUE7 }(DATA2); //inject NONSTANDARD NAMING
if (SUCCESS3) {
return RETURNDATA9;
} else {
// Look for revert reason and bubble it up if present
if (RETURNDATA9.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(RETURNDATA9)
revert(add(32, RETURNDATA9), returndata_size)
}
} else {
revert(ERRORMESSAGE3);
}
}
}
}
library safeerc206 { //inject NONSTANDARD NAMING
using safemath1 for uint256;
using address5 for address;
function SAFETRANSFER10(ierc202 TOKEN0, address TO9, uint256 VALUE2) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN7(TOKEN0, abi.encodeWithSelector(TOKEN0.TRANSFER5.selector, TO9, VALUE2));
}
function SAFETRANSFERFROM2(ierc202 TOKEN0, address FROM2, address TO9, uint256 VALUE2) internal { //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN7(TOKEN0, abi.encodeWithSelector(TOKEN0.TRANSFERFROM10.selector, FROM2, TO9, VALUE2));
}
function SAFEAPPROVE2(ierc202 TOKEN0, address SPENDER5, uint256 VALUE2) internal { //inject NONSTANDARD NAMING
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
require((VALUE2 == 0) || (TOKEN0.ALLOWANCE1(address(this), SPENDER5) == 0),
"SafeERC20: approve from non-zero to non-zero allowance");
_CALLOPTIONALRETURN7(TOKEN0, abi.encodeWithSelector(TOKEN0.APPROVE1.selector, SPENDER5, VALUE2));
}
function SAFEINCREASEALLOWANCE0(ierc202 TOKEN0, address SPENDER5, uint256 VALUE2) internal { //inject NONSTANDARD NAMING
uint256 NEWALLOWANCE4 = TOKEN0.ALLOWANCE1(address(this), SPENDER5).ADD4(VALUE2); //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN7(TOKEN0, abi.encodeWithSelector(TOKEN0.APPROVE1.selector, SPENDER5, NEWALLOWANCE4));
}
function SAFEDECREASEALLOWANCE7(ierc202 TOKEN0, address SPENDER5, uint256 VALUE2) internal { //inject NONSTANDARD NAMING
uint256 NEWALLOWANCE4 = TOKEN0.ALLOWANCE1(address(this), SPENDER5).SUB5(VALUE2, "SafeERC20: decreased allowance below zero"); //inject NONSTANDARD NAMING
_CALLOPTIONALRETURN7(TOKEN0, abi.encodeWithSelector(TOKEN0.APPROVE1.selector, SPENDER5, NEWALLOWANCE4));
}
function _CALLOPTIONALRETURN7(ierc202 TOKEN0, bytes memory DATA2) private { //inject NONSTANDARD NAMING
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory RETURNDATA9 = address(TOKEN0).FUNCTIONCALL5(DATA2, "SafeERC20: low-level call failed"); //inject NONSTANDARD NAMING
if (RETURNDATA9.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(RETURNDATA9, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ownable2 is context10 { //inject NONSTANDARD NAMING
address private _OWNER5; //inject NONSTANDARD NAMING
event OWNERSHIPTRANSFERRED2(address indexed PREVIOUSOWNER0, address indexed NEWOWNER9); //inject NONSTANDARD NAMING
constructor () internal {
address MSGSENDER1 = _MSGSENDER9(); //inject NONSTANDARD NAMING
_OWNER5 = MSGSENDER1;
emit OWNERSHIPTRANSFERRED2(address(0), MSGSENDER1);
}
function OWNER2() public view returns (address) { //inject NONSTANDARD NAMING
return _OWNER5;
}
modifier ONLYOWNER10() { //inject NONSTANDARD NAMING
require(_OWNER5 == _MSGSENDER9(), "Ownable: caller is not the owner");
_;
}
function RENOUNCEOWNERSHIP2() public virtual ONLYOWNER10 { //inject NONSTANDARD NAMING
emit OWNERSHIPTRANSFERRED2(_OWNER5, address(0));
_OWNER5 = address(0);
}
function TRANSFEROWNERSHIP5(address NEWOWNER9) public virtual ONLYOWNER10 { //inject NONSTANDARD NAMING
require(NEWOWNER9 != address(0), "Ownable: new owner is the zero address");
emit OWNERSHIPTRANSFERRED2(_OWNER5, NEWOWNER9);
_OWNER5 = NEWOWNER9;
}
}
contract erc206 is context10, ierc202 { //inject NONSTANDARD NAMING
using safemath1 for uint256;
using address5 for address;
mapping (address => uint256) private _BALANCES2; //inject NONSTANDARD NAMING
mapping (address => mapping (address => uint256)) private _ALLOWANCES8; //inject NONSTANDARD NAMING
uint256 private _TOTALSUPPLY10; //inject NONSTANDARD NAMING
string private _NAME6; //inject NONSTANDARD NAMING
string private _SYMBOL5; //inject NONSTANDARD NAMING
uint8 private _DECIMALS1; //inject NONSTANDARD NAMING
constructor (string memory NAME8, string memory SYMBOL9) public { //inject NONSTANDARD NAMING
_NAME6 = NAME8;
_SYMBOL5 = SYMBOL9;
_DECIMALS1 = 18;
}
function NAME2() public view returns (string memory) { //inject NONSTANDARD NAMING
return _NAME6;
}
function SYMBOL4() public view returns (string memory) { //inject NONSTANDARD NAMING
return _SYMBOL5;
}
function DECIMALS0() public view returns (uint8) { //inject NONSTANDARD NAMING
return _DECIMALS1;
}
function TOTALSUPPLY1() public view override returns (uint256) { //inject NONSTANDARD NAMING
return _TOTALSUPPLY10;
}
function BALANCEOF3(address ACCOUNT10) public view override returns (uint256) { //inject NONSTANDARD NAMING
return _BALANCES2[ACCOUNT10];
}
function TRANSFER5(address RECIPIENT5, uint256 AMOUNT9) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER10(_MSGSENDER9(), RECIPIENT5, AMOUNT9);
return true;
}
function ALLOWANCE1(address OWNER0, address SPENDER5) public view virtual override returns (uint256) { //inject NONSTANDARD NAMING
return _ALLOWANCES8[OWNER0][SPENDER5];
}
function APPROVE1(address SPENDER5, uint256 AMOUNT9) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_APPROVE0(_MSGSENDER9(), SPENDER5, AMOUNT9);
return true;
}
function TRANSFERFROM10(address SENDER1, address RECIPIENT5, uint256 AMOUNT9) public virtual override returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER10(SENDER1, RECIPIENT5, AMOUNT9);
_APPROVE0(SENDER1, _MSGSENDER9(), _ALLOWANCES8[SENDER1][_MSGSENDER9()].SUB5(AMOUNT9, "ERC20: transfer amount exceeds allowance"));
return true;
}
function INCREASEALLOWANCE2(address SPENDER5, uint256 ADDEDVALUE8) public virtual returns (bool) { //inject NONSTANDARD NAMING
_APPROVE0(_MSGSENDER9(), SPENDER5, _ALLOWANCES8[_MSGSENDER9()][SPENDER5].ADD4(ADDEDVALUE8));
return true;
}
function DECREASEALLOWANCE5(address SPENDER5, uint256 SUBTRACTEDVALUE10) public virtual returns (bool) { //inject NONSTANDARD NAMING
_APPROVE0(_MSGSENDER9(), SPENDER5, _ALLOWANCES8[_MSGSENDER9()][SPENDER5].SUB5(SUBTRACTEDVALUE10, "ERC20: decreased allowance below zero"));
return true;
}
function _TRANSFER10(address SENDER1, address RECIPIENT5, uint256 AMOUNT9) internal virtual { //inject NONSTANDARD NAMING
require(SENDER1 != address(0), "ERC20: transfer from the zero address");
require(RECIPIENT5 != address(0), "ERC20: transfer to the zero address");
_BEFORETOKENTRANSFER8(SENDER1, RECIPIENT5, AMOUNT9);
_BALANCES2[SENDER1] = _BALANCES2[SENDER1].SUB5(AMOUNT9, "ERC20: transfer amount exceeds balance");
_BALANCES2[RECIPIENT5] = _BALANCES2[RECIPIENT5].ADD4(AMOUNT9);
emit TRANSFER2(SENDER1, RECIPIENT5, AMOUNT9);
}
function _MINT10(address ACCOUNT10, uint256 AMOUNT9) internal virtual { //inject NONSTANDARD NAMING
require(ACCOUNT10 != address(0), "ERC20: mint to the zero address");
_BEFORETOKENTRANSFER8(address(0), ACCOUNT10, AMOUNT9);
_TOTALSUPPLY10 = _TOTALSUPPLY10.ADD4(AMOUNT9);
_BALANCES2[ACCOUNT10] = _BALANCES2[ACCOUNT10].ADD4(AMOUNT9);
emit TRANSFER2(address(0), ACCOUNT10, AMOUNT9);
}
function _BURN5(address ACCOUNT10, uint256 AMOUNT9) internal virtual { //inject NONSTANDARD NAMING
require(ACCOUNT10 != address(0), "ERC20: burn from the zero address");
_BEFORETOKENTRANSFER8(ACCOUNT10, address(0), AMOUNT9);
_BALANCES2[ACCOUNT10] = _BALANCES2[ACCOUNT10].SUB5(AMOUNT9, "ERC20: burn amount exceeds balance");
_TOTALSUPPLY10 = _TOTALSUPPLY10.SUB5(AMOUNT9);
emit TRANSFER2(ACCOUNT10, address(0), AMOUNT9);
}
function _APPROVE0(address OWNER0, address SPENDER5, uint256 AMOUNT9) internal virtual { //inject NONSTANDARD NAMING
require(OWNER0 != address(0), "ERC20: approve from the zero address");
require(SPENDER5 != address(0), "ERC20: approve to the zero address");
_ALLOWANCES8[OWNER0][SPENDER5] = AMOUNT9;
emit APPROVAL10(OWNER0, SPENDER5, AMOUNT9);
}
function _SETUPDECIMALS6(uint8 DECIMALS_1) internal { //inject NONSTANDARD NAMING
_DECIMALS1 = DECIMALS_1;
}
function _BEFORETOKENTRANSFER8(address FROM2, address TO9, uint256 AMOUNT9) internal virtual { } //inject NONSTANDARD NAMING
}
// Moon Token with Governance.
contract moontoken3 is erc206("MOON.finance", "MOON"), ownable2 { //inject NONSTANDARD NAMING
function MINT7(address _TO2, uint256 _AMOUNT3) public ONLYOWNER10 { //inject NONSTANDARD NAMING
_MINT10(_TO2, _AMOUNT3);
}
}
| 277,697 | 1,534 |
ab8d31b57500867906440143fcbb5099ffa8d2d3df06d4622e3b9dc67714c08b
| 18,830 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/e3/e39ff4ae6208b6453439536bbc35a7ba1247621d_LengendPunk.sol
| 4,189 | 15,800 |
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.9;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface DeployerCERTIK {
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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract LengendPunk is Context, DeployerCERTIK, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _allTotalSupply = 100000000000 * 10**6 * 10**9;
uint256 private _rTotalSupply = (MAX - (MAX % _allTotalSupply));
uint256 private _tFeeTotal;
string private _name = 'LengendPunk';
string private _symbol = 'Punk';
uint8 private _decimals = 9;
constructor () {
_rOwned[_msgSender()] = _rTotalSupply;
emit Transfer(address(0), _msgSender(), _allTotalSupply);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public pure override returns (uint256) {
return _allTotalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function reflect(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotalSupply = _rTotalSupply.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _allTotalSupply, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotalSupply, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(!_isExcluded[account], "Account is not excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is not excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
_rTotalSupply = _rTotalSupply.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee) = _getTValues(tAmount);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee);
}
function _getTValues(uint256 tAmount) private pure returns (uint256, uint256) {
uint256 tFee = tAmount.div(100).mul(3);
uint256 tTransferAmount = tAmount.sub(tFee);
return (tTransferAmount, tFee);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotalSupply;
uint256 tSupply = _allTotalSupply;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotalSupply, _allTotalSupply);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotalSupply.div(_allTotalSupply)) return (_rTotalSupply, _allTotalSupply);
return (rSupply, tSupply);
}
}
| 329,579 | 1,535 |
73dd0d9a1b3e170a748fb7144405d36568be0575eb257d17f4b5ccdb582b66e1
| 19,728 |
.sol
|
Solidity
| false |
442880766
|
Crodo-io/Contracts
|
3e2f07b60fa755590f400180848c6cbf990d9bb2
|
contracts/crodoContract.sol
| 3,636 | 14,662 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract CRDStake is AccessControl, ReentrancyGuard {
using SafeERC20 for IERC20;
// bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
event Stake(address indexed wallet, uint256 amount, uint256 date);
event Withdraw(address indexed wallet, uint256 amount, uint256 date);
event Claimed(address indexed wallet,
address indexed rewardToken,
uint256 amount);
event RewardTokenChanged(address indexed oldRewardToken,
uint256 returnedAmount,
address indexed newRewardToken);
event LockTimePeriodMinChanged(uint48 lockTimePeriodMin);
event LockTimePeriodMaxChanged(uint48 lockTimePeriodMax);
event StakeRewardFactorChanged(uint256 stakeRewardFactor);
event StakeRewardEndTimeChanged(uint48 stakeRewardEndTime);
event RewardsBurned(address indexed staker, uint256 amount);
event ERC20TokensRemoved(address indexed tokenAddress,
address indexed receiver,
uint256 amount);
uint48 public constant MAX_TIME = type(uint48).max; // = 2^48 - 1
struct User {
uint48 stakeTime;
uint48 unlockTime;
uint48 lockTime;
// Used to calculate how long the tokens are being staked,
// the difference between `stakeTime` is that `stakedSince` only updates
// when user withdraws tokens from the stake pull.
uint48 stakedSince;
uint256 stakeAmount;
uint256 accumulatedRewards;
}
mapping(address => User) public userMap;
uint256 public tokenTotalStaked; // sum of all staked tokens
address public immutable stakingToken; // address of token which can be staked into this contract
address public rewardToken; // address of reward token
// time in seconds a user has to wait after calling unlock until staked token can be withdrawn
uint48 public lockTimePeriodMin;
uint48 public lockTimePeriodMax;
uint48 public stakeRewardEndTime; // unix time in seconds when the reward scheme will end
uint256 public stakeRewardFactor; // time in seconds * amount of staked token to receive 1 reward token
constructor(address _stakingToken,
uint48 _lockTimePeriodMin,
uint48 _lockTimePeriodMax) {
require(_stakingToken != address(0), "stakingToken.address == 0");
stakingToken = _stakingToken;
lockTimePeriodMin = _lockTimePeriodMin;
lockTimePeriodMax = _lockTimePeriodMax;
// set some defaults
stakeRewardFactor = 1000 * 1 days; // a user has to stake 1000 token for 1 day to receive 1 reward token
stakeRewardEndTime = uint48(block.timestamp + 366 days); // reward scheme ends in 1 year
_setupRole(DEFAULT_ADMIN_ROLE, msg.sender);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "value doesn't fit in 48 bits");
return uint48(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "value doesn't fit in 160 bits");
return uint160(value);
}
function stakeTime(address _staker)
external
view
returns (uint48 dateTime)
{
return userMap[_staker].stakeTime;
}
function stakedSince(address _staker)
external
view
returns (uint48 dateTime)
{
return userMap[_staker].stakedSince;
}
function stakeAmount(address _staker)
external
view
returns (uint256 balance)
{
return userMap[_staker].stakeAmount;
}
function getLockTime(address _staker)
external
view
returns (uint48 lockTime)
{
return userMap[_staker].lockTime;
}
// redundant with stakeAmount() for compatibility
function balanceOf(address _staker)
external
view
returns (uint256 balance)
{
return userMap[_staker].stakeAmount;
}
function userAccumulatedRewards(address _staker)
external
view
returns (uint256 rewards)
{
return userMap[_staker].accumulatedRewards;
}
function getUnlockTime(address _staker)
public
view
returns (uint48 unlockTime)
{
return
userMap[_staker].stakeAmount > 0
? userMap[_staker].unlockTime
: MAX_TIME;
}
function getRewardTokenBalance() public view returns (uint256 balance) {
if (rewardToken == address(0)) return 0;
balance = IERC20(rewardToken).balanceOf(address(this));
if (stakingToken == rewardToken) {
balance -= tokenTotalStaked;
}
}
// onlyOwner / DEFAULT_ADMIN_ROLE functions --------------------------------------------------
function setRewardToken(address newRewardToken)
external
nonReentrant
onlyRole(DEFAULT_ADMIN_ROLE)
{
address oldRewardToken = rewardToken;
uint256 rewardBalance = getRewardTokenBalance(); // balance of oldRewardToken
if (rewardBalance > 0) {
IERC20(oldRewardToken).safeTransfer(msg.sender, rewardBalance);
}
rewardToken = newRewardToken;
emit RewardTokenChanged(oldRewardToken, rewardBalance, newRewardToken);
}
function setLockTimePeriodMin(uint48 _lockTimePeriodMin)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
lockTimePeriodMin = _lockTimePeriodMin;
emit LockTimePeriodMinChanged(_lockTimePeriodMin);
}
function setLockTimePeriodMax(uint48 _lockTimePeriodMax)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
lockTimePeriodMax = _lockTimePeriodMax;
emit LockTimePeriodMaxChanged(_lockTimePeriodMax);
}
function setStakeRewardFactor(uint256 _stakeRewardFactor)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
stakeRewardFactor = _stakeRewardFactor;
emit StakeRewardFactorChanged(_stakeRewardFactor);
}
function setStakeRewardEndTime(uint48 _stakeRewardEndTime)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
require(stakeRewardEndTime > block.timestamp,
"time has to be in the future");
stakeRewardEndTime = _stakeRewardEndTime;
emit StakeRewardEndTimeChanged(_stakeRewardEndTime);
}
function burnRewards(address _staker, uint256 _amount)
external
onlyRole(BURNER_ROLE)
{
User storage user = _updateRewards(_staker);
if (_amount < user.accumulatedRewards) {
user.accumulatedRewards -= _amount; // safe
} else {
user.accumulatedRewards = 0; // burn at least all what's there
}
emit RewardsBurned(_staker, _amount);
}
function stakeAmount_msgSender() public view returns (uint256) {
return userMap[msg.sender].stakeAmount;
}
function stakeLockTime_msgSender() external view returns (uint48) {
return userMap[msg.sender].lockTime;
}
function stakeTime_msgSender() external view returns (uint48) {
return userMap[msg.sender].stakeTime;
}
function getUnlockTime_msgSender()
external
view
returns (uint48 unlockTime)
{
return getUnlockTime(msg.sender);
}
function userClaimableRewards_msgSender() external view returns (uint256) {
return userClaimableRewards(msg.sender);
}
function userAccumulatedRewards_msgSender()
external
view
returns (uint256)
{
return userMap[msg.sender].accumulatedRewards;
}
function userTotalRewards_msgSender() external view returns (uint256) {
return userTotalRewards(msg.sender);
}
function getEarnedRewardTokens_msgSender() external view returns (uint256) {
return getEarnedRewardTokens(msg.sender);
}
function userClaimableRewards(address _staker)
public
view
returns (uint256)
{
User storage user = userMap[_staker];
// case 1) 2) 3)
// stake time in the future - should never happen - actually an (internal ?) error
if (block.timestamp <= user.stakeTime) return 0;
// case 4)
// staked after reward period is over => no rewards
// end time < stake time < block time
if (stakeRewardEndTime <= user.stakeTime) return 0;
uint256 timePeriod;
// case 5
// we have not reached the end of the reward period
// stake time < block time < end time
if (block.timestamp <= stakeRewardEndTime) {
timePeriod = block.timestamp - user.stakeTime; // covered by case 1) 2) 3) 'if'
} else {
// case 6
// user staked before end of reward period , but that is in the past now
// stake time < end time < block time
timePeriod = stakeRewardEndTime - user.stakeTime; // covered case 4)
}
return timePeriod * user.stakeAmount;
}
function userTotalRewards(address _staker) public view returns (uint256) {
return
userClaimableRewards(_staker) + userMap[_staker].accumulatedRewards;
}
function getEarnedRewardTokens(address _staker)
public
view
returns (uint256 claimableRewardTokens)
{
if (address(rewardToken) == address(0) || stakeRewardFactor == 0) {
return 0;
} else {
return userTotalRewards(_staker) / stakeRewardFactor; // safe
}
}
function _updateRewards(address _staker)
internal
returns (User storage user)
{
// calculate reward credits using previous staking amount and previous time period
// add new reward credits to already accumulated reward credits
user = userMap[_staker];
user.accumulatedRewards += userClaimableRewards(_staker);
// update stake Time to current time (start new reward period)
// will also reset userClaimableRewards()
user.stakeTime = toUint48(block.timestamp);
if (user.stakedSince == 0) {
user.stakedSince = toUint48(block.timestamp);
}
}
function _stake(uint256 _amount, uint48 _lockTime)
internal
returns (uint256)
{
require(_amount > 0, "stake amount must be > 0");
require(_lockTime <= lockTimePeriodMax,
"lockTime must by < lockTimePeriodMax");
require(_lockTime >= lockTimePeriodMin,
"lockTime must by > lockTimePeriodMin");
User storage user = _updateRewards(msg.sender); // update rewards and return reference to user
require(block.timestamp + _lockTime >= user.unlockTime,
"locktime must be >= current lock time");
user.stakeAmount = toUint160(user.stakeAmount + _amount);
tokenTotalStaked += _amount;
user.unlockTime = toUint48(block.timestamp + _lockTime);
user.lockTime = toUint48(_lockTime);
// using SafeERC20 for IERC20 => will revert in case of error
IERC20(stakingToken).safeTransferFrom(msg.sender,
address(this),
_amount);
emit Stake(msg.sender, _amount, toUint48(block.timestamp)); // = user.stakeTime
return _amount;
}
function _withdraw(uint256 amount) internal returns (uint256) {
require(amount > 0, "amount to withdraw not > 0");
require(block.timestamp > getUnlockTime(msg.sender),
"staked tokens are still locked");
User storage user = _updateRewards(msg.sender); // update rewards and return reference to user
require(amount <= user.stakeAmount, "withdraw amount > staked amount");
user.stakeAmount -= toUint160(amount);
user.stakedSince = toUint48(block.timestamp);
tokenTotalStaked -= amount;
// using SafeERC20 for IERC20 => will revert in case of error
IERC20(stakingToken).safeTransfer(msg.sender, amount);
emit Withdraw(msg.sender, amount, toUint48(block.timestamp)); // = user.stakeTime
return amount;
}
function _claim() internal returns (uint256) {
require(rewardToken != address(0), "no reward token contract");
uint256 earnedRewardTokens = getEarnedRewardTokens(msg.sender);
require(earnedRewardTokens > 0, "no tokens to claim");
// like _updateRewards() , but reset all rewards to 0
User storage user = userMap[msg.sender];
user.accumulatedRewards = 0;
user.stakeTime = toUint48(block.timestamp); // will reset userClaimableRewards to 0
user.stakedSince = toUint48(block.timestamp);
// user.stakeAmount = unchanged
require(earnedRewardTokens <= getRewardTokenBalance(),
"not enough reward tokens"); // redundant but dedicated error message
IERC20(rewardToken).safeTransfer(msg.sender, earnedRewardTokens);
emit Claimed(msg.sender, rewardToken, earnedRewardTokens);
return earnedRewardTokens;
}
function restakeRewards() public returns (uint256) {
require(stakingToken == rewardToken,
"Can't restake rewards, pool has different stake and reward tokens");
User storage user = userMap[msg.sender];
user.stakeAmount += getEarnedRewardTokens(msg.sender);
user.stakeTime = toUint48(block.timestamp); // will reset userClaimableRewards to 0
user.accumulatedRewards = 0;
return user.stakeAmount;
}
function stake(uint256 _amount, uint48 _lockTime)
external
nonReentrant
returns (uint256)
{
return _stake(_amount, _lockTime);
}
function claim() external nonReentrant returns (uint256) {
return _claim();
}
function withdraw(uint256 amount) external nonReentrant returns (uint256) {
return _withdraw(amount);
}
function withdrawAll() external nonReentrant returns (uint256) {
return _withdraw(stakeAmount_msgSender());
}
function removeOtherERC20Tokens(address _tokenAddress)
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
require(_tokenAddress != address(stakingToken),
"can not withdraw staking token");
uint256 balance = IERC20(_tokenAddress).balanceOf(address(this));
IERC20(_tokenAddress).safeTransfer(msg.sender, balance);
emit ERC20TokensRemoved(_tokenAddress, msg.sender, balance);
}
}
| 337,646 | 1,536 |
a945afcb28e8d07bae21c1bb43eb79a5c26844a623547286bc53298bd4ec1ad4
| 21,391 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TM/TMbbYAvr5YaxJYjov8v77U1QARLcdwLhCv_UltronCashBtt.sol
| 5,934 | 21,079 |
//SourceUnit: UltronCashBtt.sol
pragma solidity 0.5.4;
contract UltronCashBtt {
using SafeMath for *;
uint constant public BTT_TOKEN_ID = 1002000;
uint constant public INVEST_MIN_AMOUNT = 200e6;
uint constant public SAVING_POOL_STEP = 15e12;
uint constant public COMMUNITY_STEP = 100;
uint constant public TIME_STEP = 1 days;
uint constant public MARKETING_FEE = 800;
uint constant public PROJECT_FEE = 200;
uint constant public CYCLE_POOL_PERCENT = 300;
uint constant public INSURA_POOL_PERCENT = 500;
uint constant public BASE_POOL_PERCENT = 100;
uint constant public MAX_POOL_PERCENT = 500;
uint constant public MAX_HOLD_PERCENT = 200;
uint constant public MAX_COMMUNITY_PERCENT = 200;
uint constant public PERCENTS_DIVIDER = 10000;
uint constant public SECOND_PERCENT_DIV = 115741;
uint constant public INTERESTS_DIVIDER = 1000000000000;
uint constant public CYCLE_LAST_PERCENT = 500;
uint[] public CYCLE_TOP_PERCENTS = [1000, 3000, 5500];
uint[] public TOP_PERSONAL_PERCENTS = [800, 1400, 2000];
uint[] public REFERRAL_PERCENTS = [500, 300, 200, 100, 50, 50];
address payable private marketingAddr;
address payable private projectAddr;
address payable private owner;
struct User {
address upline;
Deposit[] deposits;
uint64 allDeposited;
uint64 interestHis;
uint64 insuraClaimed;
uint64 refBonus;
uint64 directRefDpts;
uint64 cycleBonus;
uint64 cycleDeposit;
uint32 depositpoint;
uint32 checkpoint;
uint32 insurapoint;
uint24[6] refs;
uint24 dCursor;
}
struct Deposit {
uint64 amount;
uint64 withdrawn;
uint32 startTime;
}
struct CycleRecord {
address winner;
uint64 bonus;
}
uint public cycle = 0;
uint public totalUsers;
uint public totalDeposits;
uint public totalInsuraClaimed;
uint public poolPercent;
uint public cyclePool;
uint public insuraPool;
uint32 public startTime;
uint32 public lastDrawTime;
uint32 public insuraStartTime;
bool public activated = false;
bool public insuraActivated = false;
address[3] cycleTop;
CycleRecord[4] cycleHis;
mapping (address => User) internal users;
event logNewbie(address user);
event logNewDeposit(address indexed user, uint amount);
event logReferralBonus(address indexed upline, address indexed referral, uint256 indexed level, uint256 amount);
event logFeePayed(address indexed user, uint totalAmount);
event logTopPayed(address indexed user, uint bonus, uint place);
event logLastPayed(address indexed user, uint bonus);
event logWithdrawal(address indexed user, uint amount);
event logInsuraClaim(address indexed user, uint amount);
event logInsuraActivated(uint cyclePoolRemaining);
modifier isActivated() {
require(activated == true && now > startTime, "not start!");
_;
}
modifier onlyOwner() {
require(msg.sender == owner, "only owner!");
_;
}
constructor(address payable marketing, address payable project) public {
require(!isContract(marketing) && !isContract(project));
marketingAddr = marketing;
projectAddr = project;
owner = msg.sender;
}
function activateGame(uint32 launchTime) external onlyOwner {
require(activated == false, "already activated!");
require(launchTime > uint32(block.timestamp), "launchTime must be bigger than current time.");
startTime = launchTime;
lastDrawTime = startTime;
poolPercent = _getPoolPercent();
cycle++;
activated = true;
}
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
function deposit(address referrer) public isActivated payable {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(insuraActivated == false, "Stop deposit when the insurance has been activated.");
require(msg.tokenid == BTT_TOKEN_ID);
require(msg.tokenvalue >= INVEST_MIN_AMOUNT, "Min.investment can't be less than 200 btt");
User storage user = users[msg.sender];
require(user.deposits.length.sub(user.dCursor) < 100, "Allow maximum 100 unclosed deposits from address");
if (user.upline == address(0) && users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.upline = referrer;
}
if (user.deposits.length == 0) {
totalUsers++;
user.checkpoint = uint32(block.timestamp);
emit logNewbie(msg.sender);
}
uint toDeposit = msg.tokenvalue;
if (user.upline != address(0)) {
address upline = user.upline;
users[upline].directRefDpts = uint64(uint(users[upline].directRefDpts).add(toDeposit));
for (uint8 i = 0; i < 6; i++) {
if(upline == address(0)) break;
if(isActive(upline)) {
uint reward = toDeposit.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
address(uint160(upline)).transferToken(reward, BTT_TOKEN_ID);
users[upline].refBonus = uint64(uint(users[upline].refBonus).add(reward));
users[upline].refs[i]++;
emit logReferralBonus(upline, msg.sender, i, reward);
}
upline = users[upline].upline;
}
}
user.deposits.push(Deposit(uint64(toDeposit), 0, uint32(block.timestamp)));
user.allDeposited = uint64(uint(user.allDeposited).add(toDeposit));
totalDeposits = totalDeposits.add(toDeposit);
_poolDeposit(msg.sender, toDeposit);
if (lastDrawTime + TIME_STEP < block.timestamp) _poolDraw(msg.sender);
uint marketingFee = toDeposit.mul(MARKETING_FEE).div(PERCENTS_DIVIDER);
uint projectFee = toDeposit.mul(PROJECT_FEE).div(PERCENTS_DIVIDER);
marketingAddr.transferToken(marketingFee, BTT_TOKEN_ID);
projectAddr.transferToken(projectFee, BTT_TOKEN_ID);
emit logFeePayed(msg.sender, marketingFee.add(projectFee));
if (poolPercent < MAX_POOL_PERCENT) {
uint poolPercentNew = _getPoolPercent();
if (poolPercentNew > poolPercent) poolPercent = poolPercentNew;
}
emit logNewDeposit(msg.sender, toDeposit);
}
function withdraw() public isActivated {
User storage user = users[msg.sender];
require(((block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP)) > 0 || user.interestHis == 0, "24 Hours not passed");
uint toSend;
uint secDivPercent = getUserSecDivPercent(msg.sender);
for (uint i = uint(user.dCursor); i < user.deposits.length; i++) {
uint fromTime = user.deposits[i].startTime > user.checkpoint ? uint(user.deposits[i].startTime) : uint(user.checkpoint);
uint dividends = uint(user.deposits[i].amount).mul(block.timestamp.sub(fromTime)).mul(secDivPercent).div(INTERESTS_DIVIDER);
if(uint(user.deposits[i].withdrawn.add(dividends)) >= uint(user.deposits[i].amount).mul(25).div(10)) {
dividends = (uint(user.deposits[i].amount).mul(25).div(10)).sub(uint(user.deposits[i].withdrawn));
user.dCursor++;
}
toSend = toSend.add(dividends);
user.deposits[i].withdrawn = uint64(uint(user.deposits[i].withdrawn).add(dividends));
}
uint savingPool = _getSavingPool();
if (toSend > savingPool) toSend = savingPool;
require(toSend > 0, "No fund to withdrawn");
user.interestHis = uint64(uint(user.interestHis).add(toSend));
insuraPool = insuraPool.add(toSend.mul(INSURA_POOL_PERCENT).div(PERCENTS_DIVIDER));
msg.sender.transferToken(toSend.mul(95).div(100), BTT_TOKEN_ID);
user.checkpoint = uint32(block.timestamp);
savingPool = _getSavingPool();
if(savingPool < 10e6) {
uint remaining = 0;
if(cyclePool > 0) {
insuraPool = insuraPool.add(cyclePool);
remaining = remaining.add(cyclePool);
cyclePool = 0;
}
if(savingPool > 0) { // save the dust to insurapool
insuraPool = insuraPool.add(savingPool);
}
insuraActivated = true;
insuraStartTime = uint32(block.timestamp);
emit logInsuraActivated(remaining);
}
emit logWithdrawal(msg.sender, toSend);
}
function claimInsura() public isActivated {
require(!isContract(msg.sender) && msg.sender == tx.origin);
require(insuraActivated = true);
User storage user = users[msg.sender];
require(uint(user.interestHis) < uint(user.allDeposited).div(2), "Interest incomes must be less than 50% of total deposits");
require(((block.timestamp.sub(uint(user.insurapoint))).div(TIME_STEP.div(2))) > 0 || user.insuraClaimed == 0, "12 Hours not passed");
uint fromTime = user.insurapoint > insuraStartTime ? uint(user.insurapoint) : uint(insuraStartTime);
uint toSend = uint(user.allDeposited).mul(1000).div(PERCENTS_DIVIDER).mul(block.timestamp.sub(fromTime)).div(TIME_STEP);
if(toSend.add(uint(user.interestHis)) > uint(user.allDeposited).div(2)) toSend = uint(user.allDeposited).div(2).sub(uint(user.interestHis));
if(toSend > insuraPool) toSend = insuraPool;
require(toSend > 0, "No fund to claim");
insuraPool = insuraPool.sub(toSend);
user.insuraClaimed = uint64(uint(user.insuraClaimed).add(toSend));
user.interestHis = uint64(uint(user.interestHis).add(toSend));
user.insurapoint = uint32(block.timestamp);
totalInsuraClaimed = totalInsuraClaimed.add(toSend);
msg.sender.transferToken(toSend, BTT_TOKEN_ID);
emit logInsuraClaim(msg.sender, toSend);
}
function _poolDeposit(address userAddr, uint toDeposit) private {
User storage user = users[userAddr];
user.cycleDeposit = user.depositpoint > lastDrawTime ? uint64(uint(user.cycleDeposit).add(toDeposit)) : uint64(toDeposit);
user.depositpoint = uint32(block.timestamp);
cyclePool = cyclePool.add(toDeposit.mul(CYCLE_POOL_PERCENT).div(PERCENTS_DIVIDER));
bool judge = false;
int8 index = -1;
for(uint8 i = 0; i < 3; i++) {
if (user.cycleDeposit > users[cycleTop[i]].cycleDeposit) {
index = int8(i);
if(judge) {
address tmpUserAddr = cycleTop[i];
cycleTop[i] = userAddr;
cycleTop[i-1] = tmpUserAddr;
}
}
if (userAddr == cycleTop[i]) judge = true;
}
if (judge == false) {
for(uint8 i = 0; int8(i) <= index; i++) {
address tmpUserAddr = cycleTop[i];
cycleTop[i] = userAddr;
if(i != 0) cycleTop[i - 1] = tmpUserAddr;
}
}
}
function _poolDraw(address userAddr) private {
uint distribute = cyclePool.div(10);
for(uint8 i = 0; i < 3; i++) {
address winnerAddr = cycleTop[i];
if(winnerAddr != address(0)){
uint reward = distribute.mul(CYCLE_TOP_PERCENTS[i]).div(PERCENTS_DIVIDER);
uint limit = uint(users[winnerAddr].cycleDeposit).mul(TOP_PERSONAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
if (reward > limit) reward = limit;
cyclePool = cyclePool.sub(reward);
users[winnerAddr].cycleBonus = uint64(uint(users[winnerAddr].cycleBonus).add(reward));
address(uint160(winnerAddr)).transferToken(reward, BTT_TOKEN_ID);
emit logTopPayed(winnerAddr, reward, 3-i);
cycleHis[i].winner = winnerAddr;
cycleHis[i].bonus = uint64(reward);
} else {
delete cycleHis[i];
}
}
uint reward = distribute.mul(CYCLE_LAST_PERCENT).div(PERCENTS_DIVIDER);
users[userAddr].cycleBonus = uint64(uint(users[userAddr].cycleBonus).add(reward));
cyclePool = cyclePool.sub(reward);
msg.sender.transferToken(reward, BTT_TOKEN_ID);
emit logLastPayed(userAddr, reward);
cycleHis[3].winner = userAddr;
cycleHis[3].bonus = uint64(reward);
lastDrawTime = uint32(block.timestamp);
cycle++;
delete cycleTop;
}
function _getSavingPool() internal view returns(uint) {
return address(this).tokenBalance(BTT_TOKEN_ID).sub(insuraPool).sub(cyclePool);
}
function _getPoolPercent() internal view returns (uint) { // 0.05% per 15,000,000 btt
uint savingPool = _getSavingPool();
uint savingPercent = BASE_POOL_PERCENT.add(savingPool.div(SAVING_POOL_STEP).mul(5));
return savingPercent < MAX_POOL_PERCENT ? savingPercent : MAX_POOL_PERCENT;
}
function getUserSecDivPercent(address userAddr) public view returns (uint) {
uint refIncentivePercent = getDirectRefPercent(userAddr);
uint holdPercent = getHoldPercent(userAddr);
uint communityPercent = getCommunityPercent();
return (poolPercent.add(refIncentivePercent).add(holdPercent).add(communityPercent)).mul(SECOND_PERCENT_DIV).div(100);
}
function getHoldPercent(address userAddr) public view returns (uint) {
User storage user = users[userAddr];
if (isActive(userAddr)) {
uint timeMultiplier = (block.timestamp.sub(uint(user.checkpoint))).div(TIME_STEP).mul(5); //0.05% per day
if(timeMultiplier > MAX_HOLD_PERCENT){
timeMultiplier = MAX_HOLD_PERCENT;
}
return timeMultiplier;
}else{
return 0;
}
}
function getCommunityPercent() public view returns (uint) {
uint communityPercent = totalUsers.div(COMMUNITY_STEP).mul(2); //0.02% per 100 active user
if (communityPercent < MAX_COMMUNITY_PERCENT) {
return communityPercent;
} else {
return MAX_COMMUNITY_PERCENT;
}
}
function getDirectRefPercent(address userAddr) public view returns (uint) {
uint directRefDpts = uint(users[userAddr].directRefDpts);
if(directRefDpts < 15000e6) {
return 0;
} else if (directRefDpts >= 15000e6 && directRefDpts < 75000e6) {
return 5;
} else if (directRefDpts >= 75000e6 && directRefDpts < 150000e6) {
return 10;
} else if (directRefDpts >= 150000e6 && directRefDpts < 300000e6) {
return 50;
} else if (directRefDpts >= 300000e6 && directRefDpts < 750000e6) {
return 75;
} else if (directRefDpts >= 750000e6) {
return 100;
}
}
function isActive(address userAddr) public view returns (bool) {
return users[userAddr].deposits.length > users[userAddr].dCursor;
}
function getUserInsura(address userAddr) public view returns (uint) {
User storage user = users[userAddr];
uint availInsura = 0;
if (insuraActivated && uint(user.interestHis) < uint(user.allDeposited).div(2)) {
uint fromTime = user.insurapoint > insuraStartTime ? uint(user.insurapoint) : uint(insuraStartTime);
availInsura = uint(user.allDeposited).mul(1000).div(PERCENTS_DIVIDER).mul(block.timestamp.sub(fromTime)).div(TIME_STEP);
if (uint(user.interestHis).add(availInsura) > uint(user.allDeposited).div(2)) {
availInsura = uint(user.allDeposited).div(2).sub(uint(user.interestHis));
}
}
return availInsura;
}
function getPendingInterest(address userAddr) public view returns (uint) {
User storage user = users[userAddr];
uint secDivPercent = getUserSecDivPercent(userAddr);
uint interests = 0;
for(uint i = uint(user.dCursor); i < user.deposits.length; i++) {
uint fromTime = user.deposits[i].startTime > user.checkpoint ? uint(user.deposits[i].startTime) : uint(user.checkpoint);
uint dividends = uint(user.deposits[i].amount).mul(block.timestamp.sub(fromTime)).mul(secDivPercent).div(INTERESTS_DIVIDER);
if(uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(25).div(10)) {
dividends = (uint(user.deposits[i].amount).mul(25).div(10)).sub(uint(user.deposits[i].withdrawn));
}
interests = interests.add(dividends);
}
return interests;
}
function getUserDeposits(address userAddr) public view returns (uint[] memory, uint[] memory, uint[] memory, uint[] memory) {
User storage user = users[userAddr];
uint secDivPercent = getUserSecDivPercent(userAddr);
uint length = user.deposits.length;
uint[] memory amount = new uint[](length);
uint[] memory withdrawn = new uint[](length);
uint[] memory start = new uint[](length);
uint[] memory status = new uint[](length);
for(uint i = 0; i < length; i++) {
amount[i] = uint(user.deposits[i].amount);
if(i >= user.dCursor) {
uint fromTime = user.deposits[i].startTime > user.checkpoint ? uint(user.deposits[i].startTime) : uint(user.checkpoint);
uint dividends = uint(user.deposits[i].amount).mul(block.timestamp.sub(fromTime)).mul(secDivPercent).div(INTERESTS_DIVIDER);
if(uint(user.deposits[i].withdrawn).add(dividends) > uint(user.deposits[i].amount).mul(25).div(10)) {
status[i] = 2; // active reached limit
} else {
status[i] = 1; // active generating interest
}
} else {
status[i] = 3; // closed
}
withdrawn[i] = uint(user.deposits[i].withdrawn);
start[i] = uint(user.deposits[i].startTime);
}
return (amount, withdrawn, start, status);
}
function getCurrentTopInfo() public view returns (address[] memory, uint[] memory) {
uint length = cycleTop.length;
address[] memory addrs = new address[](length);
uint[] memory deposits = new uint[](length);
for(uint i = 0; i < length; i++) {
addrs[i] = cycleTop[i];
deposits[i] = uint(users[cycleTop[i]].cycleDeposit);
}
return (addrs, deposits);
}
function getPreviousTopHisInfo() public view returns (address[] memory, uint[] memory) {
uint length = cycleHis.length;
address[] memory addrs = new address[](length);
uint[] memory rewards = new uint[](length);
for(uint i = 0; i < length; i++) {
addrs[i] = cycleHis[i].winner;
rewards[i] = uint(cycleHis[i].bonus);
}
return (addrs, rewards);
}
function getUserStats(address userAddr) public view returns (uint[10] memory userInfo, uint24[6] memory refs, address upline) {
User storage user = users[userAddr];
userInfo[0] = uint(user.allDeposited);
userInfo[1] = uint(user.interestHis);
userInfo[2] = uint(user.insuraClaimed);
userInfo[3] = uint(user.refBonus);
userInfo[4] = uint(user.directRefDpts);
userInfo[5] = uint(user.cycleBonus);
userInfo[6] = user.depositpoint > lastDrawTime ? uint(user.cycleDeposit) : 0;
userInfo[7] = getUserInsura(userAddr);
userInfo[8] = uint(user.checkpoint);
userInfo[9] = uint(user.insurapoint);
refs = user.refs;
upline = user.upline;
}
function getGlobalStats() public view returns(uint, uint, uint, uint, uint, uint, uint, uint, uint32, uint32, uint32) {
return (totalDeposits,
totalInsuraClaimed,
totalUsers,
cycle,
insuraPool,
cyclePool,
_getSavingPool(),
poolPercent,
startTime,
lastDrawTime,
insuraStartTime);
}
}
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;
}
}
| 295,318 | 1,537 |
25fae4aff36e4a885abd4a0a9e55f3575b54af9afa28ca98a96bad1258b8f6ac
| 29,192 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x5f28A12DC5b7d47E1cA0A1B37d3cd12930a4DA52/contract.sol
| 5,158 | 18,416 |
//
// DragonFarm $DRAGON Binance Smart Chain BEP20 contract
//
// TG: https://t.me/DragonFarm_finance
// Web: https://dragonfarm.finance
//
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract PandaToken is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
uint8 private constant _decimals = 8;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTotal = 100000000 * 10 ** uint256(_decimals);
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
string private constant _name = 'Panda.finance';
string private constant _symbol = 'PANDA';
uint256 private _taxFee = 180;
uint256 private _burnFee = 220;
uint private _max_tx_size = 100000000 * 10 ** uint256(_decimals);
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _max_tx_size, "Transfer amount exceeds 1% of Total Supply.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _taxFee, _burnFee);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(100)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(100)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() public view returns(uint256) {
return _taxFee;
}
function _getBurnFee() public view returns(uint256) {
return _burnFee;
}
function _getMaxTxAmount() public view returns(uint256){
return _max_tx_size;
}
function _setTaxFee(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function _setBurnFee(uint256 burnFee) external onlyOwner() {
_burnFee = burnFee;
}
}
| 250,181 | 1,538 |
2a90614c6abb2e16e7d70be14f5192df3c449df3c512b708f01e06e7bad294f6
| 19,477 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xc8f0fcc41b3364a770e7ef1bbd22e2fc768c6e87.sol
| 4,578 | 17,817 |
pragma solidity ^0.4.18; // solhint-disable-line
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract ERC721 {
function approve(address _to, uint256 _tokenID) public;
function balanceOf(address _owner) public view returns (uint256 balance);
function implementsERC721() public pure returns (bool);
function ownerOf(uint256 _tokenID) public view returns (address addr);
function takeOwnership(uint256 _tokenID) public;
function totalSupply() public view returns (uint256 total);
function transferFrom(address _from, address _to, uint256 _tokenID) public;
function transfer(address _to, uint256 _tokenID) public;
event Transfer(address indexed from, address indexed to, uint256 tokenID); // solhint-disable-line
event Approval(address indexed owner, address indexed approved, uint256 tokenID);
function name() public pure returns (string);
function symbol() public pure returns (string);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Manageable is Ownable {
address public manager;
bool public contractLock;
event ManagerTransferred(address indexed previousManager, address indexed newManager);
event ContractLockChanged(address admin, bool state);
function Manageable() public {
manager = msg.sender;
contractLock = false;
}
modifier onlyManager() {
require(msg.sender == manager);
_;
}
modifier onlyAdmin() {
require((msg.sender == manager) || (msg.sender == owner));
_;
}
modifier isUnlocked() {
require(!contractLock);
_;
}
function transferManager(address newManager) public onlyAdmin {
require(newManager != address(0));
ManagerTransferred(manager, newManager);
manager = newManager;
}
function setContractLock(bool setting) public onlyAdmin {
contractLock = setting;
ContractLockChanged(msg.sender, setting);
}
function payout(address _to) public onlyOwner {
if (_to == address(0)) {
owner.transfer(this.balance);
} else {
_to.transfer(this.balance);
}
}
function withdrawFunds(address _to, uint256 amount) public onlyOwner {
require(this.balance >= amount);
if (_to == address(0)) {
owner.transfer(amount);
} else {
_to.transfer(amount);
}
}
}
contract TokenLayer is ERC721, Manageable {
using SafeMath for uint256;
event TokenCreated(uint256 tokenId, bytes32 name, uint256 parentId, address owner);
event TokenDeleted(uint256 tokenId);
event TokenSold(uint256 tokenId, uint256 oldPrice,
uint256 newPrice, address prevOwner,
address winner, bytes32 name,
uint256 parentId);
event PriceChanged(uint256 tokenId, uint256 oldPrice, uint256 newPrice);
event ParentChanged(uint256 tokenId, uint256 oldParentId, uint256 newParentId);
event NameChanged(uint256 tokenId, bytes32 oldName, bytes32 newName);
event MetaDataChanged(uint256 tokenId, bytes32 oldMeta, bytes32 newMeta);
uint256 private constant DEFAULTPARENT = 123456789;
mapping (uint256 => Token) private tokenIndexToToken;
mapping (address => uint256) private ownershipTokenCount;
address public gameAddress;
address public parentAddr;
uint256 private totalTokens;
uint256 public devFee = 50;
uint256 public ownerFee = 200;
uint256[10] private chainFees = [10];
struct Token {
bool exists;
address approved;
address owner;
bytes32 metadata;
bytes32 name;
uint256 lastBlock;
uint256 parentId;
uint256 price;
}
modifier onlySystem() {
require((msg.sender == gameAddress) || (msg.sender == manager));
_;
}
function TokenLayer(address _gameAddress, address _parentAddr) public {
gameAddress = _gameAddress;
parentAddr = _parentAddr;
}
function implementsERC721() public pure returns (bool) {
return true;
}
function name() public pure returns (string) {
return "CryptoJintori";
}
function symbol() public pure returns (string) {
return "CastleToken";
}
function approve(address _to, uint256 _tokenId, address _from) public onlySystem {
_approve(_to, _tokenId, _from);
}
function approve(address _to, uint256 _tokenId) public isUnlocked {
_approve(_to, _tokenId, msg.sender);
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return ownershipTokenCount[_owner];
}
function bundleToken(uint256 _tokenId) public view returns(uint256[8] _tokenData) {
Token storage token = tokenIndexToToken[_tokenId];
uint256[8] memory tokenData;
tokenData[0] = uint256(token.name);
tokenData[1] = token.parentId;
tokenData[2] = token.price;
tokenData[3] = uint256(token.owner);
tokenData[4] = _getNextPrice(_tokenId);
tokenData[5] = devFee+getChainFees(_tokenId);
tokenData[6] = uint256(token.approved);
tokenData[7] = uint256(token.metadata);
return tokenData;
}
function takeOwnership(uint256 _tokenId, address _to) public onlySystem {
_takeOwnership(_tokenId, _to);
}
function takeOwnership(uint256 _tokenId) public isUnlocked {
_takeOwnership(_tokenId, msg.sender);
}
function tokensOfOwner(address _owner) public view returns (uint256[] ownerTokens) {
uint256 tokenCount = balanceOf(_owner);
if (tokenCount == 0) {
return new uint256[](0);
} else {
uint256[] memory result = new uint256[](tokenCount);
uint256 _totalTokens = totalSupply();
uint256 resultIndex = 0;
uint256 tokenId = 0;
uint256 tokenIndex = 0;
while (tokenIndex <= _totalTokens) {
if (exists(tokenId)) {
tokenIndex++;
if (tokenIndexToToken[tokenId].owner == _owner) {
result[resultIndex] = tokenId;
resultIndex++;
}
}
tokenId++;
}
return result;
}
}
function totalSupply() public view returns (uint256 total) {
return totalTokens;
}
function transfer(address _to, address _from, uint256 _tokenId) public onlySystem {
_checkThenTransfer(_from, _to, _tokenId);
}
function transfer(address _to, uint256 _tokenId) public isUnlocked {
_checkThenTransfer(msg.sender, _to, _tokenId);
}
function transferFrom(address _from, address _to, uint256 _tokenId) public onlySystem {
_transferFrom(_from, _to, _tokenId);
}
function transferFrom(address _from, uint256 _tokenId) public isUnlocked {
_transferFrom(_from, msg.sender, _tokenId);
}
function createToken(uint256 _tokenId, address _owner,
bytes32 _name, uint256 _parentId,
uint256 _price, bytes32 _metadata) public onlyAdmin {
require(_price > 0);
require(_addressNotNull(_owner));
require(_tokenId == uint256(uint32(_tokenId)));
require(!exists(_tokenId));
totalTokens++;
Token memory _token = Token({
name: _name,
parentId: _parentId,
exists: true,
price: _price,
owner: _owner,
approved : 0,
lastBlock : block.number,
metadata : _metadata
});
tokenIndexToToken[_tokenId] = _token;
TokenCreated(_tokenId, _name, _parentId, _owner);
_transfer(address(0), _owner, _tokenId);
}
function createTokens(uint256[] _tokenIds, address[] _owners,
bytes32[] _names, uint256[] _parentIds,
uint256[] _prices, bytes32[] _metadatas) public onlyAdmin {
for (uint256 id = 0; id < _tokenIds.length; id++) {
createToken(_tokenIds[id], _owners[id], _names[id],
_parentIds[id], _prices[id], _metadatas[id]);
}
}
function deleteToken(uint256 _tokenId) public onlyAdmin {
require(_tokenId == uint256(uint32(_tokenId)));
require(exists(_tokenId));
totalTokens--;
address oldOwner = tokenIndexToToken[_tokenId].owner;
ownershipTokenCount[oldOwner] = ownershipTokenCount[oldOwner]--;
delete tokenIndexToToken[_tokenId];
TokenDeleted(_tokenId);
}
function incrementPrice(uint256 _tokenId, address _to) public onlySystem {
require(exists(_tokenId));
uint256 _price = tokenIndexToToken[_tokenId].price;
address _owner = tokenIndexToToken[_tokenId].owner;
uint256 _totalFees = getChainFees(_tokenId);
tokenIndexToToken[_tokenId].price = _price.mul(1000+ownerFee).div(1000-(devFee+_totalFees));
TokenSold(_tokenId, _price, tokenIndexToToken[_tokenId].price,
_owner, _to, tokenIndexToToken[_tokenId].name,
tokenIndexToToken[_tokenId].parentId);
}
function ownerOf(uint256 _tokenId) public view returns (address _owner) {
require(exists(_tokenId));
_owner = tokenIndexToToken[_tokenId].owner;
}
function blocked(uint256 _tokenId) public view returns (bool _blocked) {
return (tokenIndexToToken[_tokenId].lastBlock == block.number);
}
function exists(uint256 _tokenId) public view returns(bool) {
return (tokenIndexToToken[_tokenId].exists);
}
function setLayerParent(address _parent) public onlyAdmin {
parentAddr = _parent;
}
function setGame(address _gameAddress) public onlyAdmin {
gameAddress = _gameAddress;
}
function setPrice(uint256 _tokenId, uint256 _price, address _owner) public onlySystem {
require(_owns(_owner, _tokenId));
uint256 oldPrice = tokenIndexToToken[_tokenId].price;
tokenIndexToToken[_tokenId].price = _price;
PriceChanged(_tokenId, oldPrice, _price);
}
function setParent(uint256 _tokenId, uint256 _parentId) public onlyAdmin {
require(exists(_tokenId));
uint256 oldParentId = tokenIndexToToken[_tokenId].parentId;
tokenIndexToToken[_tokenId].parentId = _parentId;
ParentChanged(_tokenId, oldParentId, _parentId);
}
function setName(uint256 _tokenId, bytes32 _name) public onlyAdmin {
require(exists(_tokenId));
bytes32 oldName = tokenIndexToToken[_tokenId].name;
tokenIndexToToken[_tokenId].name = _name;
NameChanged(_tokenId, oldName, _name);
}
function setMetadata(uint256 _tokenId, bytes32 _metadata) public onlyAdmin {
require(exists(_tokenId));
bytes32 oldMeta = tokenIndexToToken[_tokenId].metadata;
tokenIndexToToken[_tokenId].metadata = _metadata;
MetaDataChanged(_tokenId, oldMeta, _metadata);
}
function setDevFee(uint256 _devFee) public onlyAdmin {
devFee = _devFee;
}
function setOwnerFee(uint256 _ownerFee) public onlyAdmin {
ownerFee = _ownerFee;
}
function setChainFees(uint256[10] _chainFees) public onlyAdmin {
chainFees = _chainFees;
}
function getToken(uint256 _tokenId) public view returns
(bytes32 tokenName, uint256 parentId, uint256 price,
address _owner, uint256 nextPrice, uint256 nextPriceFees,
address approved, bytes32 metadata) {
Token storage token = tokenIndexToToken[_tokenId];
tokenName = token.name;
parentId = token.parentId;
price = token.price;
_owner = token.owner;
nextPrice = _getNextPrice(_tokenId);
nextPriceFees = devFee+getChainFees(_tokenId);
metadata = token.metadata;
approved = token.approved;
}
function getChainFees(uint256 _tokenId) public view returns (uint256 _total) {
uint256 chainLength = _getChainLength(_tokenId);
uint256 totalFee = 0;
for (uint id = 0; id < chainLength; id++) {
totalFee = totalFee + chainFees[id];
}
return(totalFee);
}
function getChainFeeArray() public view returns (uint256[10] memory _chainFees) {
return(chainFees);
}
function getPriceOf(uint256 _tokenId) public view returns (uint256 price) {
require(exists(_tokenId));
return tokenIndexToToken[_tokenId].price;
}
function getParentOf(uint256 _tokenId) public view returns (uint256 parentId) {
require(exists(_tokenId));
return tokenIndexToToken[_tokenId].parentId;
}
function getMetadataOf(uint256 _tokenId) public view returns (bytes32 metadata) {
require(exists(_tokenId));
return (tokenIndexToToken[_tokenId].metadata);
}
function getChain(uint256 _tokenId) public view returns (address[10] memory _owners) {
require(exists(_tokenId));
uint256 _parentId = getParentOf(_tokenId);
address _parentAddr = parentAddr;
address[10] memory result;
if (_parentId != DEFAULTPARENT && _addressNotNull(_parentAddr)) {
uint256 resultIndex = 0;
TokenLayer layer = TokenLayer(_parentAddr);
bool parentExists = layer.exists(_parentId);
while ((_parentId != DEFAULTPARENT) && _addressNotNull(_parentAddr) && parentExists) {
parentExists = layer.exists(_parentId);
if (!parentExists) {
return(result);
}
result[resultIndex] = layer.ownerOf(_parentId);
resultIndex++;
_parentId = layer.getParentOf(_parentId);
_parentAddr = layer.parentAddr();
layer = TokenLayer(_parentAddr);
}
return(result);
}
}
function _addressNotNull(address _to) private pure returns (bool) {
return _to != address(0);
}
function _approved(address _to, uint256 _tokenId) private view returns (bool) {
return (tokenIndexToToken[_tokenId].approved == _to);
}
function _owns(address claimant, uint256 _tokenId) private view returns (bool) {
return claimant == tokenIndexToToken[_tokenId].owner;
}
function _checkThenTransfer(address _from, address _to, uint256 _tokenId) private {
require(_owns(_from, _tokenId));
require(_addressNotNull(_to));
require(exists(_tokenId));
_transfer(_from, _to, _tokenId);
}
function _transfer(address _from, address _to, uint256 _tokenId) private {
ownershipTokenCount[_to]++;
tokenIndexToToken[_tokenId].owner = _to;
tokenIndexToToken[_tokenId].lastBlock = block.number;
if (_from != address(0)) {
ownershipTokenCount[_from]--;
tokenIndexToToken[_tokenId].approved = 0;
}
Transfer(_from, _to, _tokenId);
}
function _approve(address _to, uint256 _tokenId, address _from) private {
require(_owns(_from, _tokenId));
tokenIndexToToken[_tokenId].approved = _to;
Approval(_from, _to, _tokenId);
}
function _takeOwnership(uint256 _tokenId, address _to) private {
address newOwner = _to;
address oldOwner = tokenIndexToToken[_tokenId].owner;
require(_addressNotNull(newOwner));
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
function _transferFrom(address _from, address _to, uint256 _tokenId) private {
require(_owns(_from, _tokenId));
require(_approved(_to, _tokenId));
require(_addressNotNull(_to));
_transfer(_from, _to, _tokenId);
}
function _getChainLength(uint256 _tokenId) private view returns (uint256 _length) {
uint256 length;
uint256 _parentId = getParentOf(_tokenId);
address _parentAddr = parentAddr;
if (_parentId == DEFAULTPARENT || !_addressNotNull(_parentAddr)) {
return 0;
}
TokenLayer layer = TokenLayer(_parentAddr);
bool parentExists = layer.exists(_parentId);
while ((_parentId != DEFAULTPARENT) && _addressNotNull(_parentAddr) && parentExists) {
parentExists = layer.exists(_parentId);
if(!parentExists) {
return(length);
}
_parentId = layer.getParentOf(_parentId);
_parentAddr = layer.parentAddr();
layer = TokenLayer(_parentAddr);
length++;
}
return(length);
}
function _getNextPrice(uint256 _tokenId) private view returns (uint256 _nextPrice) {
uint256 _price = tokenIndexToToken[_tokenId].price;
uint256 _totalFees = getChainFees(_tokenId);
_price = _price.mul(1000+ownerFee).div(1000-(devFee+_totalFees));
return(_price);
}
}
| 144,600 | 1,539 |
0e2b6172976f4d755f53e5fbf26f62494e50944b171863b58be88e43f9698151
| 21,978 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/fa/Fa97C3494497F31Df3282CebdFa17C331f4d0986_dYelTokenTest.sol
| 4,622 | 17,287 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint 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 callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface IBANG {
function index() external view returns (uint256);
}
contract dYelTokenTest is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable BANG;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
_init = false;
}
function changeVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = _vault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
isMinter[_auth] = true;
minters.push(_auth);
}
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(address _BANG, string memory _name, string memory _symbol, uint8 _decimals, address _vault) {
require(_BANG != address(0));
name = _name;
symbol = _symbol;
decimals = _decimals;
isMinter[_vault] = true;
minters.push(_vault);
BANG = _BANG;
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
function wrap(uint256 _amount) external returns (uint256) {
IERC20(BANG).transferFrom(msg.sender, address(this), _amount);
uint256 value = BANGTodYel(_amount);
_mint(msg.sender, value);
return value;
}
function unwrap(uint256 _amount) external returns (uint256) {
_burn(msg.sender, _amount);
uint256 value = dYelToBANG(_amount);
IERC20(BANG).transfer(msg.sender, value);
return value;
}
function dYelToBANG(uint256 _amount) public view returns (uint256) {
return _amount * IBANG(BANG).index() / (10 ** decimals);
}
function BANGTodYel(uint256 _amount) public view returns (uint256) {
return _amount * 10 ** decimals / IBANG(BANG).index();
}
}
| 324,660 | 1,540 |
73372baaa3c237eb1214783b033c1ca3e085ecb17acb3df2b84b0f3caad6fd18
| 16,713 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xf5c6acb57F13de23b2140B0b399Cd7EeaE800Ff8.sol
| 4,649 | 15,944 |
pragma solidity 0.4.25;
library SafeMath8 {
function mul(uint8 a, uint8 b) internal pure returns (uint8) {
if (a == 0) {
return 0;
}
uint8 c = a * b;
assert(c / a == b);
return c;
}
function div(uint8 a, uint8 b) internal pure returns (uint8) {
return a / b;
}
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
assert(b <= a);
return a - b;
}
function add(uint8 a, uint8 b) internal pure returns (uint8) {
uint8 c = a + b;
assert(c >= a);
return c;
}
function pow(uint8 a, uint8 b) internal pure returns (uint8) {
if (a == 0) return 0;
if (b == 0) return 1;
uint8 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath16 {
function mul(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) {
return 0;
}
uint16 c = a * b;
assert(c / a == b);
return c;
}
function div(uint16 a, uint16 b) internal pure returns (uint16) {
return a / b;
}
function sub(uint16 a, uint16 b) internal pure returns (uint16) {
assert(b <= a);
return a - b;
}
function add(uint16 a, uint16 b) internal pure returns (uint16) {
uint16 c = a + b;
assert(c >= a);
return c;
}
function pow(uint16 a, uint16 b) internal pure returns (uint16) {
if (a == 0) return 0;
if (b == 0) return 1;
uint16 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath32 {
function mul(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) {
return 0;
}
uint32 c = a * b;
assert(c / a == b);
return c;
}
function div(uint32 a, uint32 b) internal pure returns (uint32) {
return a / b;
}
function sub(uint32 a, uint32 b) internal pure returns (uint32) {
assert(b <= a);
return a - b;
}
function add(uint32 a, uint32 b) internal pure returns (uint32) {
uint32 c = a + b;
assert(c >= a);
return c;
}
function pow(uint32 a, uint32 b) internal pure returns (uint32) {
if (a == 0) return 0;
if (b == 0) return 1;
uint32 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
library SafeMath256 {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function pow(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
if (b == 0) return 1;
uint256 c = a ** b;
assert(c / (a ** (b - 1)) == a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function _validateAddress(address _addr) internal pure {
require(_addr != address(0), "invalid address");
}
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner, "not a contract owner");
_;
}
function transferOwnership(address newOwner) public onlyOwner {
_validateAddress(newOwner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract Controllable is Ownable {
mapping(address => bool) controllers;
modifier onlyController {
require(_isController(msg.sender), "no controller rights");
_;
}
function _isController(address _controller) internal view returns (bool) {
return controllers[_controller];
}
function _setControllers(address[] _controllers) internal {
for (uint256 i = 0; i < _controllers.length; i++) {
_validateAddress(_controllers[i]);
controllers[_controllers[i]] = true;
}
}
}
contract Upgradable is Controllable {
address[] internalDependencies;
address[] externalDependencies;
function getInternalDependencies() public view returns(address[]) {
return internalDependencies;
}
function getExternalDependencies() public view returns(address[]) {
return externalDependencies;
}
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
for (uint256 i = 0; i < _newDependencies.length; i++) {
_validateAddress(_newDependencies[i]);
}
internalDependencies = _newDependencies;
}
function setExternalDependencies(address[] _newDependencies) public onlyOwner {
externalDependencies = _newDependencies;
_setControllers(_newDependencies);
}
}
contract DragonCore {
function setRemainingHealthAndMana(uint256, uint32, uint32) external;
function increaseExperience(uint256, uint256) external;
function payDNAPointsForBreeding(uint256) external;
function upgradeGenes(uint256, uint16[10]) external;
function increaseWins(uint256) external;
function increaseDefeats(uint256) external;
function setTactics(uint256, uint8, uint8) external;
function setSpecialPeacefulSkill(uint256, uint8) external;
function useSpecialPeacefulSkill(address, uint256, uint256) external;
function setBuff(uint256, uint8, uint32) external;
function createDragon(address, uint16, uint256[2], uint256[4], uint8[11]) external returns (uint256);
function setName(uint256, string) external returns (bytes32);
}
contract DragonGetter {
function getAmount() external view returns (uint256);
function getComposedGenome(uint256) external view returns (uint256[4]);
function getCoolness(uint256) public view returns (uint32);
function getFullRegenerationTime(uint256) external view returns (uint32);
function getDragonTypes(uint256) external view returns (uint8[11]);
function getGeneration(uint256) external view returns (uint16);
function getParents(uint256) external view returns (uint256[2]);
}
contract DragonGenetics {
function createGenome(uint256[2], uint256[4], uint256[4], uint256) external view returns (uint256[4], uint8[11]);
function createGenomeForGenesis(uint8, uint256) external view returns (uint256[4]);
}
contract EggCore {
function ownerOf(uint256) external view returns (address);
function get(uint256) external view returns (uint256[2], uint8);
function isOwner(address, uint256) external view returns (bool);
function getAllEggs() external view returns (uint256[]);
function create(address, uint256[2], uint8) external returns (uint256);
function remove(address, uint256) external;
}
contract DragonLeaderboard {
function update(uint256, uint32) external;
function getDragonsFromLeaderboard() external view returns (uint256[10]);
function updateRewardTime() external;
function getRewards(uint256) external view returns (uint256[10]);
function getDate() external view returns (uint256, uint256);
}
contract Nest {
mapping (uint256 => bool) public inNest;
function getEggs() external view returns (uint256[2]);
function add(uint256) external returns (bool, uint256, uint256);
}
//////////////CONTRACT//////////////
contract Core is Upgradable {
using SafeMath8 for uint8;
using SafeMath16 for uint16;
using SafeMath32 for uint32;
using SafeMath256 for uint256;
DragonCore dragonCore;
DragonGetter dragonGetter;
DragonGenetics dragonGenetics;
EggCore eggCore;
DragonLeaderboard leaderboard;
Nest nest;
function _max(uint16 lth, uint16 rth) internal pure returns (uint16) {
if (lth > rth) {
return lth;
} else {
return rth;
}
}
function createEgg(address _sender,
uint8 _dragonType) external onlyController returns (uint256) {
return eggCore.create(_sender, [uint256(0), uint256(0)], _dragonType);
}
function sendToNest(uint256 _id) external onlyController returns (bool isHatched,
uint256 newDragonId,
uint256 hatchedId,
address owner) {
uint256 _randomForEggOpening;
(isHatched, hatchedId, _randomForEggOpening) = nest.add(_id);
// if any egg was hatched
if (isHatched) {
owner = eggCore.ownerOf(hatchedId);
newDragonId = openEgg(owner, hatchedId, _randomForEggOpening);
}
}
function openEgg(address _owner,
uint256 _eggId,
uint256 _random) internal returns (uint256 newDragonId) {
uint256[2] memory _parents;
uint8 _dragonType;
(_parents, _dragonType) = eggCore.get(_eggId);
uint256[4] memory _genome;
uint8[11] memory _dragonTypesArray;
uint16 _generation;
// if genesis
if (_parents[0] == 0 && _parents[1] == 0) {
_generation = 0;
_genome = dragonGenetics.createGenomeForGenesis(_dragonType, _random);
_dragonTypesArray[_dragonType] = 40; // 40 genes of 1 type
} else {
uint256[4] memory _momGenome = dragonGetter.getComposedGenome(_parents[0]);
uint256[4] memory _dadGenome = dragonGetter.getComposedGenome(_parents[1]);
(_genome, _dragonTypesArray) = dragonGenetics.createGenome(_parents, _momGenome, _dadGenome, _random);
_generation = _max(dragonGetter.getGeneration(_parents[0]),
dragonGetter.getGeneration(_parents[1])).add(1);
}
newDragonId = dragonCore.createDragon(_owner, _generation, _parents, _genome, _dragonTypesArray);
eggCore.remove(_owner, _eggId);
uint32 _coolness = dragonGetter.getCoolness(newDragonId);
leaderboard.update(newDragonId, _coolness);
}
function breed(address _sender,
uint256 _momId,
uint256 _dadId) external onlyController returns (uint256) {
dragonCore.payDNAPointsForBreeding(_momId);
dragonCore.payDNAPointsForBreeding(_dadId);
return eggCore.create(_sender, [_momId, _dadId], 0);
}
function setDragonRemainingHealthAndMana(uint256 _id, uint32 _health, uint32 _mana) external onlyController {
return dragonCore.setRemainingHealthAndMana(_id, _health, _mana);
}
function increaseDragonExperience(uint256 _id, uint256 _factor) external onlyController {
dragonCore.increaseExperience(_id, _factor);
}
function upgradeDragonGenes(uint256 _id, uint16[10] _dnaPoints) external onlyController {
dragonCore.upgradeGenes(_id, _dnaPoints);
uint32 _coolness = dragonGetter.getCoolness(_id);
leaderboard.update(_id, _coolness);
}
function increaseDragonWins(uint256 _id) external onlyController {
dragonCore.increaseWins(_id);
}
function increaseDragonDefeats(uint256 _id) external onlyController {
dragonCore.increaseDefeats(_id);
}
function setDragonTactics(uint256 _id, uint8 _melee, uint8 _attack) external onlyController {
dragonCore.setTactics(_id, _melee, _attack);
}
function setDragonName(uint256 _id, string _name) external onlyController returns (bytes32) {
return dragonCore.setName(_id, _name);
}
function setDragonSpecialPeacefulSkill(uint256 _id, uint8 _class) external onlyController {
dragonCore.setSpecialPeacefulSkill(_id, _class);
}
function useDragonSpecialPeacefulSkill(address _sender,
uint256 _id,
uint256 _target) external onlyController {
dragonCore.useSpecialPeacefulSkill(_sender, _id, _target);
}
function resetDragonBuffs(uint256 _id) external onlyController {
dragonCore.setBuff(_id, 1, 0); // attack
dragonCore.setBuff(_id, 2, 0); // defense
dragonCore.setBuff(_id, 3, 0); // stamina
dragonCore.setBuff(_id, 4, 0); // speed
dragonCore.setBuff(_id, 5, 0); // intelligence
}
function updateLeaderboardRewardTime() external onlyController {
return leaderboard.updateRewardTime();
}
// GETTERS
function getDragonFullRegenerationTime(uint256 _id) external view returns (uint32 time) {
return dragonGetter.getFullRegenerationTime(_id);
}
function isEggOwner(address _user, uint256 _tokenId) external view returns (bool) {
return eggCore.isOwner(_user, _tokenId);
}
function isEggInNest(uint256 _id) external view returns (bool) {
return nest.inNest(_id);
}
function getEggsInNest() external view returns (uint256[2]) {
return nest.getEggs();
}
function getEgg(uint256 _id) external view returns (uint16, uint32, uint256[2], uint8[11], uint8[11]) {
uint256[2] memory parents;
uint8 _dragonType;
(parents, _dragonType) = eggCore.get(_id);
uint8[11] memory momDragonTypes;
uint8[11] memory dadDragonTypes;
uint32 coolness;
uint16 gen;
// if genesis
if (parents[0] == 0 && parents[1] == 0) {
momDragonTypes[_dragonType] = 100;
dadDragonTypes[_dragonType] = 100;
coolness = 3600;
} else {
momDragonTypes = dragonGetter.getDragonTypes(parents[0]);
dadDragonTypes = dragonGetter.getDragonTypes(parents[1]);
coolness = dragonGetter.getCoolness(parents[0]).add(dragonGetter.getCoolness(parents[1])).div(2);
uint16 _momGeneration = dragonGetter.getGeneration(parents[0]);
uint16 _dadGeneration = dragonGetter.getGeneration(parents[1]);
gen = _max(_momGeneration, _dadGeneration).add(1);
}
return (gen, coolness, parents, momDragonTypes, dadDragonTypes);
}
function getDragonChildren(uint256 _id) external view returns (uint256[10] dragonsChildren,
uint256[10] eggsChildren) {
uint8 _counter;
uint256[2] memory _parents;
uint256 i;
for (i = _id.add(1); i <= dragonGetter.getAmount() && _counter < 10; i++) {
_parents = dragonGetter.getParents(i);
if (_parents[0] == _id || _parents[1] == _id) {
dragonsChildren[_counter] = i;
_counter = _counter.add(1);
}
}
_counter = 0;
uint256[] memory eggs = eggCore.getAllEggs();
for (i = 0; i < eggs.length && _counter < 10; i++) {
(_parents,) = eggCore.get(eggs[i]);
if (_parents[0] == _id || _parents[1] == _id) {
eggsChildren[_counter] = eggs[i];
_counter = _counter.add(1);
}
}
}
function getDragonsFromLeaderboard() external view returns (uint256[10]) {
return leaderboard.getDragonsFromLeaderboard();
}
function getLeaderboardRewards(uint256 _hatchingPrice) external view returns (uint256[10]) {
return leaderboard.getRewards(_hatchingPrice);
}
function getLeaderboardRewardDate() external view returns (uint256, uint256) {
return leaderboard.getDate();
}
// UPDATE CONTRACT
function setInternalDependencies(address[] _newDependencies) public onlyOwner {
super.setInternalDependencies(_newDependencies);
dragonCore = DragonCore(_newDependencies[0]);
dragonGetter = DragonGetter(_newDependencies[1]);
dragonGenetics = DragonGenetics(_newDependencies[2]);
eggCore = EggCore(_newDependencies[3]);
leaderboard = DragonLeaderboard(_newDependencies[4]);
nest = Nest(_newDependencies[5]);
}
}
| 335,405 | 1,541 |
b7050360a40f639b31bfb2b3a1665c076b2886abe8893d8be3d9273ba00c09e6
| 21,313 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x8a187d5285d316bcbc9adafc08b51d70a0d8e000.sol
| 3,509 | 13,645 |
pragma solidity ^0.4.11;
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal constant returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal constant returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract AuthenticationManager {
mapping (address => bool) adminAddresses;
mapping (address => bool) accountReaderAddresses;
address[] adminAudit;
address[] accountReaderAudit;
event AdminAdded(address addedBy, address admin);
event AdminRemoved(address removedBy, address admin);
event AccountReaderAdded(address addedBy, address account);
event AccountReaderRemoved(address removedBy, address account);
function AuthenticationManager() {
adminAddresses[msg.sender] = true;
AdminAdded(0, msg.sender);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = msg.sender;
}
function contractVersion() constant returns(uint256) {
// Admin contract identifies as 100YYYYMMDDHHMM
return 100201707171503;
}
function isCurrentAdmin(address _address) constant returns (bool) {
return adminAddresses[_address];
}
function isCurrentOrPastAdmin(address _address) constant returns (bool) {
for (uint256 i = 0; i < adminAudit.length; i++)
if (adminAudit[i] == _address)
return true;
return false;
}
function isCurrentAccountReader(address _address) constant returns (bool) {
return accountReaderAddresses[_address];
}
function isCurrentOrPastAccountReader(address _address) constant returns (bool) {
for (uint256 i = 0; i < accountReaderAudit.length; i++)
if (accountReaderAudit[i] == _address)
return true;
return false;
}
function addAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already admin
if (adminAddresses[_address])
throw;
// Add the user
adminAddresses[_address] = true;
AdminAdded(msg.sender, _address);
adminAudit.length++;
adminAudit[adminAudit.length - 1] = _address;
}
function removeAdmin(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
if (_address == msg.sender)
throw;
// Fail if this account is already non-admin
if (!adminAddresses[_address])
throw;
adminAddresses[_address] = false;
AdminRemoved(msg.sender, _address);
}
function addAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already in the list
if (accountReaderAddresses[_address])
throw;
// Add the user
accountReaderAddresses[_address] = true;
AccountReaderAdded(msg.sender, _address);
accountReaderAudit.length++;
accountReaderAudit[adminAudit.length - 1] = _address;
}
function removeAccountReader(address _address) {
if (!isCurrentAdmin(msg.sender))
throw;
// Fail if this account is already not in the list
if (!accountReaderAddresses[_address])
throw;
accountReaderAddresses[_address] = false;
AccountReaderRemoved(msg.sender, _address);
}
}
contract IcoPhaseManagement {
using SafeMath for uint256;
bool public icoPhase = true;
bool public icoAbandoned = false;
bool siftContractDefined = false;
uint256 constant icoUnitPrice = 10 finney;
mapping(address => uint256) public abandonedIcoBalances;
SmartInvestmentFundToken smartInvestmentFundToken;
AuthenticationManager authenticationManager;
uint256 constant public icoStartTime = 1501545600; // August 1st 2017 at 00:00:00 UTC
uint256 constant public icoEndTime = 1505433600; // September 15th 2017 at 00:00:00 UTC
event IcoClosed();
event IcoAbandoned(string details);
modifier onlyDuringIco {
bool contractValid = siftContractDefined && !smartInvestmentFundToken.isClosed();
if (!contractValid || (!icoPhase && !icoAbandoned)) throw;
_;
}
modifier adminOnly {
if (!authenticationManager.isCurrentAdmin(msg.sender)) throw;
_;
}
function IcoPhaseManagement(address _authenticationManagerAddress) {
if (icoStartTime >= icoEndTime)
throw;
authenticationManager = AuthenticationManager(_authenticationManagerAddress);
if (authenticationManager.contractVersion() != 100201707171503)
throw;
}
function setSiftContractAddress(address _siftContractAddress) adminOnly {
if (siftContractDefined)
throw;
smartInvestmentFundToken = SmartInvestmentFundToken(_siftContractAddress);
if (smartInvestmentFundToken.contractVersion() != 500201707171440)
throw;
siftContractDefined = true;
}
function contractVersion() constant returns(uint256) {
return 300201707171440;
}
function close() adminOnly onlyDuringIco {
// Forbid closing contract before the end of ICO
if (now <= icoEndTime)
throw;
// Close the ICO
icoPhase = false;
IcoClosed();
// Withdraw funds to the caller
if (!msg.sender.send(this.balance))
throw;
}
function () onlyDuringIco payable {
// Forbid funding outside of ICO
if (now < icoStartTime || now > icoEndTime)
throw;
uint256 tokensPurchased = msg.value / icoUnitPrice;
uint256 purchaseTotalPrice = tokensPurchased * icoUnitPrice;
uint256 change = msg.value.sub(purchaseTotalPrice);
if (tokensPurchased > 0)
smartInvestmentFundToken.mintTokens(msg.sender, tokensPurchased);
if (change > 0 && !msg.sender.send(change))
throw;
}
function abandon(string details) adminOnly onlyDuringIco {
// Forbid closing contract before the end of ICO
if (now <= icoEndTime)
throw;
if (icoAbandoned)
throw;
uint256 paymentPerShare = this.balance / smartInvestmentFundToken.totalSupply();
uint numberTokenHolders = smartInvestmentFundToken.tokenHolderCount();
uint256 totalAbandoned = 0;
for (uint256 i = 0; i < numberTokenHolders; i++) {
address addr = smartInvestmentFundToken.tokenHolder(i);
uint256 etherToSend = paymentPerShare * smartInvestmentFundToken.balanceOf(addr);
if (etherToSend < 1)
continue;
abandonedIcoBalances[addr] = abandonedIcoBalances[addr].add(etherToSend);
totalAbandoned = totalAbandoned.add(etherToSend);
}
icoAbandoned = true;
IcoAbandoned(details);
// There should be no money left, but withdraw just incase for manual resolution
uint256 remainder = this.balance.sub(totalAbandoned);
if (remainder > 0)
if (!msg.sender.send(remainder))
// Add this to the callers balance for emergency refunds
abandonedIcoBalances[msg.sender] = abandonedIcoBalances[msg.sender].add(remainder);
}
function abandonedFundWithdrawal() {
// This functionality only exists if an ICO was abandoned
if (!icoAbandoned || abandonedIcoBalances[msg.sender] == 0)
throw;
// Attempt to send them to funds
uint256 funds = abandonedIcoBalances[msg.sender];
abandonedIcoBalances[msg.sender] = 0;
if (!msg.sender.send(funds))
throw;
}
}
contract SmartInvestmentFundToken {
using SafeMath for uint256;
mapping (address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
address[] allTokenHolders;
string public name;
string public symbol;
uint8 public decimals;
uint256 totalSupplyAmount = 0;
address public icoContractAddress;
bool public isClosed;
IcoPhaseManagement icoPhaseManagement;
AuthenticationManager authenticationManager;
event FundClosed();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function SmartInvestmentFundToken(address _icoContractAddress, address _authenticationManagerAddress) {
// Setup defaults
name = "Smart Investment Fund Token";
symbol = "SIFT";
decimals = 0;
icoPhaseManagement = IcoPhaseManagement(_icoContractAddress);
if (icoPhaseManagement.contractVersion() != 300201707171440)
throw;
authenticationManager = AuthenticationManager(_authenticationManagerAddress);
if (authenticationManager.contractVersion() != 100201707171503)
throw;
icoContractAddress = _icoContractAddress;
}
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length == numwords * 32 + 4);
_;
}
modifier accountReaderOnly {
if (!authenticationManager.isCurrentAccountReader(msg.sender)) throw;
_;
}
modifier fundSendablePhase {
// If it's in ICO phase, forbid it
if (icoPhaseManagement.icoPhase())
throw;
// If it's abandoned, forbid it
if (icoPhaseManagement.icoAbandoned())
throw;
// We're good, funds can now be transferred
_;
}
function contractVersion() constant returns(uint256) {
return 500201707171440;
}
function transferFrom(address _from, address _to, uint256 _amount) fundSendablePhase onlyPayloadSize(3) returns (bool) {
if (balances[_from] >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to].add(_amount) > balances[_to]) {
bool isNew = balances[_to] == 0;
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isNew)
tokenOwnerAdd(_to);
if (balances[_from] == 0)
tokenOwnerRemove(_from);
Transfer(_from, _to, _amount);
return true;
}
return false;
}
function tokenHolderCount() accountReaderOnly constant returns (uint256) {
return allTokenHolders.length;
}
function tokenHolder(uint256 _index) accountReaderOnly constant returns (address) {
return allTokenHolders[_index];
}
function approve(address _spender, uint256 _amount) fundSendablePhase onlyPayloadSize(2) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function totalSupply() constant returns (uint256) {
return totalSupplyAmount;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function transfer(address _to, uint256 _amount) fundSendablePhase onlyPayloadSize(2) returns (bool) {
if (balances[msg.sender] < _amount || balances[_to].add(_amount) < balances[_to])
return false;
bool isRecipientNew = balances[_to] < 1;
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isRecipientNew)
tokenOwnerAdd(_to);
if (balances[msg.sender] < 1)
tokenOwnerRemove(msg.sender);
Transfer(msg.sender, _to, _amount);
return true;
}
function tokenOwnerAdd(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
for (uint256 i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr)
return;
allTokenHolders.length++;
allTokenHolders[allTokenHolders.length - 1] = _addr;
}
function tokenOwnerRemove(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
uint256 foundIndex = 0;
bool found = false;
uint256 i;
for (i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr) {
foundIndex = i;
found = true;
break;
}
if (!found)
return;
for (i = foundIndex; i < tokenHolderCount - 1; i++)
allTokenHolders[i] = allTokenHolders[i + 1];
allTokenHolders.length--;
}
function mintTokens(address _address, uint256 _amount) onlyPayloadSize(2) {
if (msg.sender != icoContractAddress || !icoPhaseManagement.icoPhase())
throw;
bool isNew = balances[_address] == 0;
totalSupplyAmount = totalSupplyAmount.add(_amount);
balances[_address] = balances[_address].add(_amount);
if (isNew)
tokenOwnerAdd(_address);
Transfer(0, _address, _amount);
}
}
| 215,949 | 1,542 |
55652e55f2cae9bbb47df0ab96de07b71796bdbbd67c8022c6ad4b81d144808c
| 13,493 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWLmo1St8FGuWGpLMm8v8yzsQyq2LC2i3f_NovunTron.sol
| 3,710 | 12,704 |
//SourceUnit: NovunTron.sol
pragma solidity 0.4.25;
contract Destructible {
address public grand_owner;
event GrandOwnershipTransferred(address indexed previous_owner, address indexed new_owner);
constructor() public {
grand_owner = msg.sender;
}
function transferGrandOwnership(address _to) external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
grand_owner = _to;
}
function destruct() external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
selfdestruct(grand_owner);
}
}
contract Novun is Destructible {
address owner;
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint40 withdraw_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
uint256 match_levels;
}
mapping(address => User) public users;
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public net_bonuses;
uint256 public total_withdraw;
uint256 public lastUserId;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount, uint8 level);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
modifier onlyOwner() {
require(owner == msg.sender, "Ownable: caller is not the owner");
_;
}
constructor() public {
owner = msg.sender;
ref_bonuses.push(10);
ref_bonuses.push(7);
ref_bonuses.push(7);
ref_bonuses.push(7);
ref_bonuses.push(7);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
net_bonuses.push(7);
}
function receive() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _setRefCounter(address _addr, uint256 _amount, address _upline) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(_amount >= 1500 trx && users[_upline].match_levels < 20) {
users[_upline].match_levels++;
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount, "Bad amount");
} else {
lastUserId++;
require(_amount >= 100 trx, "Bad amount");
}
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(now);
users[_addr].withdraw_time = 0;
users[_addr].total_deposits += _amount;
emit NewDeposit(_addr, _amount);
address _upline = users[_addr].upline;
for (uint8 i = 0; i < net_bonuses.length; i++) {
uint256 _bonus = (_amount * net_bonuses[i]) / 100;
if(_upline != address(0)) {
users[_upline].direct_bonus += _bonus;
emit DirectPayout(_upline, _addr, _bonus, i + 1);
_upline = users[_upline].upline;
} else {
users[owner].direct_bonus += _bonus;
emit DirectPayout(owner, _addr, _bonus, i + 1);
_upline = owner;
}
}
uint256 ownerFee = ((_amount * 2) / 100);
address(uint160(owner)).transfer(ownerFee);
}
function _refMaxLevel(uint256 _amount) private pure returns(uint8 max_level) {
if (_amount <= 1500 trx) {
max_level = 1;
} else if (_amount >= 1501 trx && _amount <= 2000 trx) {
max_level = 2;
} else if (_amount >= 2001 trx && _amount <= 3000 trx) {
max_level = 4;
} else if (_amount >= 3001 trx && _amount <= 4000 trx) {
max_level = 7;
} else if (_amount >= 4001 trx && _amount <= 7000 trx) {
max_level = 11;
} else if (_amount >= 7001 trx && _amount <= 10000 trx) {
max_level = 15;
} else if (_amount >= 10001 trx) {
max_level = 20;
}
return max_level;
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(_refPayoutEligible(up, i + 1)) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _refPayoutEligible(address _addr, uint8 _level) private view returns(bool isEligible){
return users[_addr].referrals >= _level
&& _refMaxLevel(users[_addr].deposit_amount) >= _level
&& users[_addr].match_levels >= _level;
}
function _canWithdraw(address _addr) private view returns (bool isEligible) {
return users[_addr].withdraw_time == 0 || ((now - users[_addr].withdraw_time) / 1 days) >= 7;
}
function deposit(address _upline) external payable {
_setUpline(msg.sender, _upline);
_setRefCounter(msg.sender, msg.value, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
require(_canWithdraw(msg.sender), "Withdraw too soon");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
users[msg.sender].withdraw_time = uint40(now);
total_withdraw += to_payout;
uint256 ownerFee = ((to_payout * 2) / 100);
to_payout -= ownerFee;
msg.sender.transfer(to_payout);
address(uint160(owner)).transfer(ownerFee);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) private pure returns(uint256) {
return _amount * 2;
}
function payoutOf(address _addr) public view returns(uint256 payout, uint256 max_payout) {
payout = 0;
max_payout = maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (((users[_addr].deposit_amount * 15) / 1000) * ((now - users[_addr].deposit_time) / 1 days)) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
return (payout, max_payout);
}
function getDaysSinceDeposit(address _addr) external view returns(uint daysSince, uint secondsSince) {
return (((now - users[_addr].deposit_time) / 1 days), (now - users[_addr].deposit_time));
}
function getDaysSinceWithdraw(address _addr) external view returns(uint daysSince) {
return ((now - users[_addr].withdraw_time) / 1 days);
}
function isUserRegistered(address _addr) external view returns(bool isRegistered) {
return (users[_addr].total_deposits > 0);
}
function userInfo(address _addr) external view returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 match_bonus, uint256 cycle) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].match_bonus, users[_addr].cycle);
}
function userInfoTotals(address _addr) external view returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() external view returns(uint256 _total_withdraw, uint256 _lastUserId) {
return (total_withdraw, lastUserId);
}
}
contract NovunTron is Novun {
bool public sync_close = false;
function sync(address[] _users, address[] _uplines, uint256[] _data) external onlyOwner {
require(!sync_close, "Sync already close");
for(uint256 i = 0; i < _users.length; i++) {
address addr = _users[i];
uint256 q = i * 12;
//require(users[_uplines[i]].total_deposits > 0, "No upline");
if(users[addr].total_deposits == 0) {
emit Upline(addr, _uplines[i]);
}
users[addr].cycle = _data[q];
users[addr].upline = _uplines[i];
users[addr].referrals = _data[q + 1];
users[addr].payouts = _data[q + 2];
users[addr].direct_bonus = _data[q + 3];
users[addr].match_bonus = _data[q + 4];
users[addr].deposit_amount = _data[q + 5];
users[addr].deposit_payouts = _data[q + 6];
users[addr].deposit_time = uint40(_data[q + 7]);
users[addr].total_deposits = _data[q + 8];
users[addr].total_payouts = _data[q + 9];
users[addr].total_structure = _data[q + 10];
users[addr].match_levels = _data[q + 11];
users[addr].withdraw_time = uint40(_data[q + 12]);
}
}
function syncInfo(uint256 totalUsers, uint256 totalWithdraw) external onlyOwner {
require(!sync_close, "Sync already close");
lastUserId = totalUsers;
total_withdraw = totalWithdraw;
}
function syncUp() external payable {}
function syncClose() external onlyOwner {
require(!sync_close, "Sync already close");
sync_close = true;
}
}
| 293,299 | 1,543 |
f397e64b9d24850eee1e1a2cb71db2738ffda99566a8012adf1725a6a8bf96d9
| 19,638 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TL/TLiEU7nBGs7FH43n1Q6bBKghvcAf8FBcFT_Router.sol
| 5,621 | 19,072 |
//SourceUnit: ccitokenswap.sol
// TGDt6SKuoUR2R13sEHbZHy2tqAfRLy17sF swapFactory
pragma solidity 0.5.12;
library SafeMath {
function add(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x + y) >= x, 'ds-math-add-overflow');
}
function sub(uint256 x, uint256 y) internal pure returns(uint256 z) {
require((z = x - y) <= x, 'ds-math-sub-underflow');
}
function mul(uint256 x, uint256 y) internal pure returns(uint256 z) {
require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
}
}
interface ITRC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function approve(address spender, uint256 value) external returns(bool);
function transfer(address to, uint256 value) external returns(bool);
function transferFrom(address from, address to, uint256 value) external returns(bool);
function name() external view returns(string memory);
function symbol() external view returns(string memory);
function decimals() external view returns(uint8);
function totalSupply() external view returns(uint256);
function balanceOf(address owner) external view returns(uint256);
function allowance(address owner, address spender) external view returns(uint256);
}
interface IFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint256 index);
function createPair(address tokenA, address tokenB) external returns(address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
function feeTo() external view returns(address);
function feeToSetter() external view returns(address);
function getPair(address tokenA, address tokenB) external view returns(address pair);
function allPairs(uint256) external view returns(address pair);
function allPairsLength() external view returns(uint256);
}
interface IPair {
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
event Swap(address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function mint(address to) external returns(uint256 liquidity);
function burn(address to) external returns(uint256 amount0, uint256 amount1);
function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
function MINIMUM_LIQUIDITY() external pure returns(uint256);
function factory() external view returns(address);
function token0() external view returns(address);
function token1() external view returns(address);
function getReserves() external view returns(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns(uint256);
function price1CumulativeLast() external view returns(uint256);
function kLast() external view returns(uint256);
}
interface IWTRX {
function deposit() external payable;
function withdraw(uint256) external;
}
library TransferHelper {
function safeTransfer(address token, address to, uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (token == 0xa614f803B6FD780986A42c78Ec9c7f77e6DeD13C || data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint256 value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferTRX(address to, uint256 value) internal {
(bool success,) = to.call.value(value)(new bytes(0));
require(success, 'TransferHelper: TRX_TRANSFER_FAILED');
}
}
library SwapLibrary {
using SafeMath for uint256;
function sortTokens(address tokenA, address tokenB) internal pure returns(address token0, address token1) {
require(tokenA != tokenB, 'SwapLibrary: IDENTICAL_ADDRESSES');
(token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
require(token0 != address(0), 'SwapLibrary: ZERO_ADDRESS');
}
function quote(uint256 amountA, uint256 reserveA, uint256 reserveB) internal pure returns(uint256 amountB) {
require(amountA > 0, 'SwapLibrary: INSUFFICIENT_AMOUNT');
require(reserveA > 0 && reserveB > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
amountB = amountA.mul(reserveB) / reserveA;
}
function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) internal pure returns(uint256 amountOut) {
require(amountIn > 0, 'SwapLibrary: INSUFFICIENT_INPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
uint256 amountInWithFee = amountIn.mul(997);
amountOut = amountInWithFee.mul(reserveOut) / reserveIn.mul(1000).add(amountInWithFee);
}
function getAmountIn(uint256 amountOut, uint256 reserveIn, uint256 reserveOut) internal pure returns(uint256 amountIn) {
require(amountOut > 0, 'SwapLibrary: INSUFFICIENT_OUTPUT_AMOUNT');
require(reserveIn > 0 && reserveOut > 0, 'SwapLibrary: INSUFFICIENT_LIQUIDITY');
amountIn = (reserveIn.mul(amountOut).mul(1000) / reserveOut.sub(amountOut).mul(997)).add(1);
}
function pairFor(address factory, address tokenA, address tokenB) internal view returns(address pair) {
(address token0, address token1) = sortTokens(tokenA, tokenB);
pair = IFactory(factory).getPair(token0, token1);
require(pair != address(0), "SwapLibrary: UNDEFINED_PAIR");
}
function getReserves(address factory, address tokenA, address tokenB) internal view returns(uint256 reserveA, uint256 reserveB) {
(address token0,) = sortTokens(tokenA, tokenB);
(uint256 reserve0, uint256 reserve1,) = IPair(pairFor(factory, tokenA, tokenB)).getReserves();
(reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0);
}
function getAmountsOut(address factory, uint256 amountIn, address[] memory path) internal view returns(uint256[] memory amounts) {
require(path.length >= 2, 'SwapLibrary: INVALID_PATH');
amounts = new uint256[](path.length);
amounts[0] = amountIn;
for(uint256 i; i < path.length - 1; i++) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i], path[i + 1]);
amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
}
}
function getAmountsIn(address factory, uint256 amountOut, address[] memory path) internal view returns(uint256[] memory amounts) {
require(path.length >= 2, 'SwapLibrary: INVALID_PATH');
amounts = new uint256[](path.length);
amounts[amounts.length - 1] = amountOut;
for(uint256 i = path.length - 1; i > 0; i--) {
(uint256 reserveIn, uint256 reserveOut) = getReserves(factory, path[i - 1], path[i]);
amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
}
}
}
contract Router {
using SafeMath for uint256;
address public factory;
address public wtrx;
modifier ensure(uint256 deadline) {
require(deadline >= block.timestamp, 'Router: EXPIRED');
_;
}
constructor(address _factory, address _wtrx) public {
factory = _factory;
wtrx = _wtrx;
}
function() payable external {
assert(msg.sender == wtrx);
}
function _addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin) internal returns(uint256 amountA, uint256 amountB) {
if(IFactory(factory).getPair(tokenA, tokenB) == address(0)) {
IFactory(factory).createPair(tokenA, tokenB);
}
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
if(reserveA == 0 && reserveB == 0) {
(amountA, amountB) = (amountADesired, amountBDesired);
}
else {
uint256 amountBOptimal = SwapLibrary.quote(amountADesired, reserveA, reserveB);
if(amountBOptimal <= amountBDesired) {
require(amountBOptimal >= amountBMin, 'Router: INSUFFICIENT_B_AMOUNT');
(amountA, amountB) = (amountADesired, amountBOptimal);
}
else {
uint256 amountAOptimal = SwapLibrary.quote(amountBDesired, reserveB, reserveA);
assert(amountAOptimal <= amountADesired);
require(amountAOptimal >= amountAMin, 'Router: INSUFFICIENT_A_AMOUNT');
(amountA, amountB) = (amountAOptimal, amountBDesired);
}
}
}
function _swap(uint256[] memory amounts, address[] memory path, address _to) internal {
for(uint256 i; i < path.length - 1; i++) {
(address input, address output) = (path[i], path[i + 1]);
(address token0,) = SwapLibrary.sortTokens(input, output);
uint256 amountOut = amounts[i + 1];
(uint256 amount0Out, uint256 amount1Out) = input == token0 ? (uint256(0), amountOut) : (amountOut, uint256(0));
address to = i < path.length - 2 ? SwapLibrary.pairFor(factory, output, path[i + 2]) : _to;
IPair(SwapLibrary.pairFor(factory, input, output)).swap(amount0Out, amount1Out, to, new bytes(0));
}
}
function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) external ensure(deadline) returns(uint256 amountA, uint256 amountB, uint256 liquidity) {
(amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
address pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
liquidity = IPair(pair).mint(to);
}
function addLiquidityTRX(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountTRXMin, address to, uint256 deadline) external payable ensure(deadline) returns(uint256 amountToken, uint256 amountTRX, uint256 liquidity) {
(amountToken, amountTRX) = _addLiquidity(token, wtrx, amountTokenDesired, msg.value, amountTokenMin, amountTRXMin);
address pair = SwapLibrary.pairFor(factory, token, wtrx);
TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
IWTRX(wtrx).deposit.value(amountTRX)();
assert(ITRC20(wtrx).transfer(pair, amountTRX));
liquidity = IPair(pair).mint(to);
if(msg.value > amountTRX) TransferHelper.safeTransferTRX(msg.sender, msg.value - amountTRX);
}
function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) public ensure(deadline) returns(uint256 amountA, uint256 amountB) {
address pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
ITRC20(pair).transferFrom(msg.sender, pair, liquidity);
(uint256 amount0, uint256 amount1) = IPair(pair).burn(to);
(address token0,) = SwapLibrary.sortTokens(tokenA, tokenB);
(amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
require(amountA >= amountAMin, 'Router: INSUFFICIENT_A_AMOUNT');
require(amountB >= amountBMin, 'Router: INSUFFICIENT_B_AMOUNT');
}
function removeLiquidityTRX(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountTRXMin, address to, uint256 deadline) public ensure(deadline) returns(uint256 amountToken, uint256 amountTRX) {
(amountToken, amountTRX) = removeLiquidity(token, wtrx, liquidity, amountTokenMin, amountTRXMin, address(this), deadline);
TransferHelper.safeTransfer(token, to, amountToken);
IWTRX(wtrx).withdraw(amountTRX);
TransferHelper.safeTransferTRX(to, amountTRX);
}
function swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
amounts = SwapLibrary.getAmountsOut(factory, amountIn, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, to);
}
function swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= amountInMax, 'Router: EXCESSIVE_INPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, to);
}
function swapExactTRXForTokens(uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external payable ensure(deadline) returns(uint256[] memory amounts) {
require(path[0] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsOut(factory, msg.value, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
IWTRX(wtrx).deposit.value(amounts[0])();
assert(ITRC20(wtrx).transfer(SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]));
_swap(amounts, path, to);
}
function swapTRXForExactTokens(uint256 amountOut, address[] calldata path, address to, uint256 deadline) external payable ensure(deadline) returns(uint256[] memory amounts) {
require(path[0] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= msg.value, 'Router: EXCESSIVE_INPUT_AMOUNT');
IWTRX(wtrx).deposit.value(amounts[0])();
assert(ITRC20(wtrx).transfer(SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]));
_swap(amounts, path, to);
if(msg.value > amounts[0]) TransferHelper.safeTransferTRX(msg.sender, msg.value - amounts[0]);
}
function swapExactTokensForTRX(uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
require(path[path.length - 1] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsOut(factory, amountIn, path);
require(amounts[amounts.length - 1] >= amountOutMin, 'Router: INSUFFICIENT_OUTPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, address(this));
IWTRX(wtrx).withdraw(amounts[amounts.length - 1]);
TransferHelper.safeTransferTRX(to, amounts[amounts.length - 1]);
}
function swapTokensForExactTRX(uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline) external ensure(deadline) returns(uint256[] memory amounts) {
require(path[path.length - 1] == wtrx, 'Router: INVALID_PATH');
amounts = SwapLibrary.getAmountsIn(factory, amountOut, path);
require(amounts[0] <= amountInMax, 'Router: EXCESSIVE_INPUT_AMOUNT');
TransferHelper.safeTransferFrom(path[0], msg.sender, SwapLibrary.pairFor(factory, path[0], path[1]), amounts[0]);
_swap(amounts, path, address(this));
IWTRX(wtrx).withdraw(amounts[amounts.length - 1]);
TransferHelper.safeTransferTRX(to, amounts[amounts.length - 1]);
}
function getAmountsIn(uint256 amountOut, address[] memory path) public view returns (uint256[] memory amounts) {
return SwapLibrary.getAmountsIn(factory, amountOut, path);
}
function getAmountsOut(uint256 amountIn, address[] memory path) public view returns(uint256[] memory amounts) {
return SwapLibrary.getAmountsOut(factory, amountIn, path);
}
function calcPairLiquidity(uint256 amountA, address tokenA, address tokenB, bool reverse) external view returns(uint256 amountB, uint256 share) {
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
amountB = reverse ? SwapLibrary.quote(amountA, reserveB, reserveA) : SwapLibrary.quote(amountA, reserveA, reserveB);
share = reverse ? amountA.mul(100) / reserveB.add(amountA) : amountA.mul(100) / reserveA.add(amountA);
}
function calcPairSwap(uint256 amountA, address tokenA, address tokenB, bool reverse) external view returns(uint256 amountB, uint256 priceImpact) {
(uint256 reserveA, uint256 reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
amountB = reverse ? SwapLibrary.getAmountIn(amountA, reserveA, reserveB) : SwapLibrary.getAmountOut(amountA, reserveA, reserveB);
priceImpact = reverse ? reserveA.sub(reserveA.sub(amountB)).mul(10000) / reserveA : reserveB.sub(reserveB.sub(amountB)).mul(10000) / reserveB;
}
function getPair(address owner, address tokenA, address tokenB) external view returns(address pair, uint256 totalSupply, uint256 supply, uint256 reserveA, uint256 reserveB) {
pair = SwapLibrary.pairFor(factory, tokenA, tokenB);
totalSupply = ITRC20(pair).totalSupply();
supply = ITRC20(pair).balanceOf(owner);
(address token0,) = SwapLibrary.sortTokens(tokenA, tokenB);
if(token0 != tokenA) (reserveB, reserveA) = SwapLibrary.getReserves(factory, tokenA, tokenB);
else (reserveA, reserveB) = SwapLibrary.getReserves(factory, tokenA, tokenB);
}
function getPairs(address owner, uint256 start, uint256 limit) external view returns(uint256 count, address[] memory from, address[] memory to, uint256[] memory supply) {
count = IFactory(factory).allPairsLength();
from = new address[](limit);
to = new address[](limit);
supply = new uint256[](limit);
uint256 matches = 0;
for(uint256 i = start; i < start + limit && i < count; i++) {
address pair = IFactory(factory).allPairs(i);
from[matches] = IPair(pair).token0();
to[matches] = IPair(pair).token1();
supply[matches++] = ITRC20(pair).balanceOf(owner);
}
}
}
| 284,884 | 1,544 |
77410c88eb750738ab132b05954cef215d6550de8dd2964d446748e2d012d7d1
| 25,330 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x167cb3f2446f829eb327344b66e271d1a7efec9a.sol
| 4,320 | 16,600 |
pragma solidity ^0.4.20;
contract GandhiJi {
// only people with tokens
modifier onlybelievers () {
require(myTokens() > 0);
_;
}
// only people with profits
modifier onlyhodler() {
require(myDividends(true) > 0);
_;
}
// administrators can:
// -> change the name of the contract
// -> change the name of the token
// -> change the PoS difficulty
// they CANNOT:
// -> take funds
// -> disable withdrawals
// -> kill the contract
// -> change the price of tokens
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[keccak256(_customerAddress)]);
_;
}
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
if(onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_)){
require(// is the customer in the ambassador list?
ambassadors_[_customerAddress] == true &&
// does the customer purchase exceed the max ambassador quota?
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_);
// updated the accumulated quota
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
// execute
_;
} else {
// in case the ether count drops low, the ambassador phase won't reinitiate
onlyAmbassadors = false;
_;
}
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
// ERC20
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Gandhiji";
string public symbol = "IND";
uint8 constant public decimals = 18;
uint8 constant internal dividendFee_ = 10;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2**64;
// proof of stake (defaults at 1 token)
uint256 public stakingRequirement = 1e18;
// ambassador program
mapping(address => bool) internal ambassadors_;
uint256 constant internal ambassadorMaxPurchase_ = 1 ether;
uint256 constant internal ambassadorQuota_ = 1 ether;
// amount of shares for each address (scaled number)
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
mapping(address => uint256) internal ambassadorAccumulatedQuota_;
uint256 internal tokenSupply_ = 0;
uint256 internal profitPerShare_;
// administrator list (see above on what they can do)
mapping(bytes32 => bool) public administrators;
bool public onlyAmbassadors = false;
function GandhiJi()
public
{
// add administrators here
administrators[0x9bcc16873606dc04acb98263f74c420525ddef61de0d5f18fd97d16de659131a] = true;
ambassadors_[0x0000000000000000000000000000000000000000] = true;
}
function buy(address _referredBy)
public
payable
returns(uint256)
{
purchaseTokens(msg.value, _referredBy);
}
function()
payable
public
{
purchaseTokens(msg.value, 0x0);
}
function reinvest()
onlyhodler()
public
{
// fetch dividends
uint256 _dividends = myDividends(false); // retrieve ref. bonus later in the code
// pay out the dividends virtually
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// retrieve ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// dispatch a buy order with the virtualized "withdrawn dividends"
uint256 _tokens = purchaseTokens(_dividends, 0x0);
// fire event
onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit()
public
{
// get token count for caller & sell them all
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw()
onlyhodler()
public
{
// setup data
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false); // get ref. bonus later in the code
// update dividend tracker
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
// add ref. bonus
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
// delivery service
_customerAddress.transfer(_dividends);
// fire event
onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens)
onlybelievers ()
public
{
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
// burn the sold tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
// update dividends tracker
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
// dividing by zero is a bad idea
if (tokenSupply_ > 0) {
// update the amount of dividends per token
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
// fire event
onTokenSell(_customerAddress, _tokens, _taxedEthereum);
}
function transfer(address _toAddress, uint256 _amountOfTokens)
onlybelievers ()
public
returns(bool)
{
// setup
address _customerAddress = msg.sender;
// make sure we have the requested tokens
require(!onlyAmbassadors && _amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
// withdraw all outstanding dividends first
if(myDividends(true) > 0) withdraw();
// liquify 10% of the tokens that are transfered
// these are dispersed to shareholders
uint256 _tokenFee = SafeMath.div(_amountOfTokens, dividendFee_);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
// burn the fee tokens
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
// exchange tokens
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
// update dividend trackers
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
// disperse dividends among holders
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
// fire event
Transfer(_customerAddress, _toAddress, _taxedTokens);
// ERC20
return true;
}
function disableInitialStage()
onlyAdministrator()
public
{
onlyAmbassadors = false;
}
function setAdministrator(bytes32 _identifier, bool _status)
onlyAdministrator()
public
{
administrators[_identifier] = _status;
}
function setStakingRequirement(uint256 _amountOfTokens)
onlyAdministrator()
public
{
stakingRequirement = _amountOfTokens;
}
function setName(string _name)
onlyAdministrator()
public
{
name = _name;
}
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
}
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
}
function totalSupply()
public
view
returns(uint256)
{
return tokenSupply_;
}
function myTokens()
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus)
public
view
returns(uint256)
{
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress)
view
public
returns(uint256)
{
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress)
view
public
returns(uint256)
{
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice()
public
view
returns(uint256)
{
if(tokenSupply_ == 0){
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend)
public
view
returns(uint256)
{
uint256 _dividends = SafeMath.div(_ethereumToSpend, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell)
public
view
returns(uint256)
{
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(_ethereum, dividendFee_);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
// data setup
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
// is the user referred by a karmalink?
if(// is this a referred purchase?
_referredBy != 0x0000000000000000000000000000000000000000 &&
// no cheating!
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement){
// wealth redistribution
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
// no ref purchase
// add the referral bonus back to the global dividends cake
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
// we can't give people infinite ethereum
if(tokenSupply_ > 0){
// add tokens to the pool
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
// calculate the amount of tokens the customer receives over his purchase
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
// add tokens to the pool
tokenSupply_ = _amountOfTokens;
}
// update circulating supply & the ledger address for the customer
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
// fire event
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum)
internal
view
returns(uint256)
{
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((// underflow attempts BTFO
SafeMath.sub((sqrt
((_tokenPriceInitial**2)
+
(2*(tokenPriceIncremental_ * 1e18)*(_ethereum * 1e18))
+
(((tokenPriceIncremental_)**2)*(tokenSupply_**2))
+
(2*(tokenPriceIncremental_)*_tokenPriceInitial*tokenSupply_))), _tokenPriceInitial))/(tokenPriceIncremental_))-(tokenSupply_)
;
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens)
internal
view
returns(uint256)
{
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(// underflow attempts BTFO
SafeMath.sub((((tokenPriceInitial_ +(tokenPriceIncremental_ * (_tokenSupply/1e18)))-tokenPriceIncremental_)*(tokens_ - 1e18)),(tokenPriceIncremental_*((tokens_**2-tokens_)/1e18))/2)
/1e18);
return _etherReceived;
}
function sqrt(uint x) internal pure returns (uint y) {
uint z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 204,593 | 1,545 |
24b2056b0c6e8c7b15594da7ea597f8a6a26c51f77869652e727340054c7d730
| 12,296 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/3b/3b3ba861827A7444DA0a665ae47F636fE142Ff81_FantomOneProfit.sol
| 3,908 | 11,804 |
pragma solidity 0.5.10;
contract FantomOneProfit {
using SafeMath for uint256;
uint256 constant public INVEST_MIN_AMOUNT = 5 ether;
uint256 constant public MAX_INVESTS = 100;
uint256[] public REFERRAL_PERCENTS = [50];
uint256 constant public TOTAL_REF = 50;
uint256 constant public CEO_FEE = 80;
uint256 constant public DEV_FEE = 40;
uint256 constant public REINVEST_BONUS = 50;
uint256 constant public SEED_BONUS = 10;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public TIME_STEP = 0 days;
uint256 public totalInvested;
uint256 public totalReferral;
uint256 public totalSeed;
struct Plan {
uint256 time;
uint256 percent;
}
Plan[] internal plans;
struct Deposit {
uint8 plan;
uint256 amount;
uint256 start;
}
struct User {
Deposit[] deposits;
uint256 checkpoint;
address referrer;
uint256[1] levels;
uint256 bonus;
uint256 totalBonus;
uint256 seed;
uint256 totalSeed;
uint256 withdrawn;
}
mapping (address => User) internal users;
uint256 public startDate;
address payable public ceoWallet;
address payable public devWallet;
event Newbie(address user);
event NewDeposit(address indexed user, uint8 plan, uint256 amount, uint256 time);
event Withdrawn(address indexed user, uint256 amount, uint256 time);
event RefBonus(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event FeePaid(address indexed user, uint256 totalAmount);
event SeedPaid(address indexed user, address indexed referral, uint256 totalAmount, uint256 time);
constructor(address payable ceoAddr, address payable devAddr, uint256 start) public {
require(!isContract(ceoAddr) && !isContract(devAddr));
ceoWallet = ceoAddr;
devWallet = devAddr;
if(start>0){
startDate = start;
}
else{
startDate = block.timestamp;
}
plans.push(Plan(7, 170));
plans.push(Plan(30, 60));
}
function invest(address referrer, uint8 plan) public payable {
require(block.timestamp > startDate, "contract does not launch yet");
require(msg.value >= INVEST_MIN_AMOUNT, "min amount is 5 matic");
require(plan < 2, "Invalid plan");
uint256 ceo = msg.value.mul(CEO_FEE).div(PERCENTS_DIVIDER);
uint256 dFee = msg.value.mul(DEV_FEE).div(PERCENTS_DIVIDER);
ceoWallet.transfer(ceo);
devWallet.transfer(dFee);
emit FeePaid(msg.sender, ceo.add(dFee));
User storage user = users[msg.sender];
require(user.deposits.length < MAX_INVESTS, " max 100 depsoits");
if (user.referrer == address(0)) {
if (users[referrer].deposits.length > 0 && referrer != msg.sender) {
user.referrer = referrer;
}
address upline = user.referrer;
for (uint256 i = 0; i < 1; i++) {
if (upline != address(0)) {
users[upline].levels[i] = users[upline].levels[i].add(1);
upline = users[upline].referrer;
} else break;
}
}
if (user.referrer != address(0)) {
address upline = user.referrer;
for (uint256 i = 0; i < 1; 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].totalBonus = users[upline].totalBonus.add(amount);
totalReferral = totalReferral.add(amount);
emit RefBonus(upline, msg.sender, i, amount);
upline = users[upline].referrer;
} else break;
}
}else{
uint256 amount = msg.value.mul(TOTAL_REF).div(PERCENTS_DIVIDER);
ceoWallet.transfer(amount);
totalReferral = totalReferral.add(amount);
}
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(plan, msg.value, block.timestamp));
totalInvested = totalInvested.add(msg.value);
emit NewDeposit(msg.sender, plan, msg.value, block.timestamp);
}
function withdraw() public {
User storage user = users[msg.sender];
uint256 totalAmount = getUserDividends(msg.sender);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(totalAmount > 0, "User has no dividends");
uint256 contractBalance = address(this).balance;
if (contractBalance < totalAmount) {
user.bonus = totalAmount.sub(contractBalance);
totalAmount = contractBalance;
}
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
msg.sender.transfer(totalAmount);
emit Withdrawn(msg.sender, totalAmount, block.timestamp);
//seed
if(user.referrer != address(0)){
uint256 seedAmount = totalAmount.mul(SEED_BONUS).div(PERCENTS_DIVIDER);
users[user.referrer].seed = users[user.referrer].seed.add(seedAmount);
users[user.referrer].totalSeed = users[user.referrer].totalSeed.add(seedAmount);
totalSeed = totalSeed.add(seedAmount);
emit SeedPaid(user.referrer, msg.sender, seedAmount, block.timestamp);
}
}
function reinvest(uint8 plan) public {
User storage user = users[msg.sender];
require(user.deposits.length < MAX_INVESTS, " max 100 depsoits");
(uint256 totalAmount1, uint256 totalAmount2) = getUserDividendsOnReinvest(msg.sender);
if(totalAmount2 > 0){
totalAmount2 = totalAmount2.add(totalAmount2.mul(REINVEST_BONUS).div(PERCENTS_DIVIDER));
}
uint256 totalAmount = totalAmount1.add(totalAmount2);
uint256 referralBonus = getUserReferralBonus(msg.sender);
if (referralBonus > 0) {
user.bonus = 0;
totalAmount = totalAmount.add(referralBonus);
}
require(block.timestamp > startDate, "contract does not launch yet");
require(totalAmount >= INVEST_MIN_AMOUNT);
require(plan < 2, "Invalid plan");
user.deposits.push(Deposit(plan, totalAmount, block.timestamp));
totalInvested = totalInvested.add(totalAmount);
user.checkpoint = block.timestamp;
user.withdrawn = user.withdrawn.add(totalAmount);
emit NewDeposit(msg.sender, plan, totalAmount, block.timestamp);
}
function getContractBalance() public view returns (uint256) {
return address(this).balance;
}
function getPlanInfo(uint8 plan) public view returns(uint256 time, uint256 percent) {
time = plans[plan].time;
percent = plans[plan].percent;
}
function getUserDividends(address userAddress) public view returns (uint256) {
User storage user = users[userAddress];
uint256 totalAmount;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(TIME_STEP));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
totalAmount = totalAmount.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
return totalAmount;
}
function getUserDividendsOnReinvest(address userAddress) public view returns (uint256,uint256) {
User storage user = users[userAddress];
uint256 totalAmountPlan1;
uint256 totalAmountPlan2;
for (uint256 i = 0; i < user.deposits.length; i++) {
uint256 finish = user.deposits[i].start.add(plans[user.deposits[i].plan].time.mul(TIME_STEP));
if (user.checkpoint < finish) {
uint256 share = user.deposits[i].amount.mul(plans[user.deposits[i].plan].percent).div(PERCENTS_DIVIDER);
uint256 from = user.deposits[i].start > user.checkpoint ? user.deposits[i].start : user.checkpoint;
uint256 to = finish < block.timestamp ? finish : block.timestamp;
if (from < to) {
if(user.deposits[i].plan == 0){
totalAmountPlan1 = totalAmountPlan1.add(share.mul(to.sub(from)).div(TIME_STEP));
} else if(user.deposits[i].plan == 1){
totalAmountPlan2 = totalAmountPlan2.add(share.mul(to.sub(from)).div(TIME_STEP));
}
}
}
}
return (totalAmountPlan1, totalAmountPlan2);
}
function getUserTotalWithdrawn(address userAddress) public view returns (uint256) {
return users[userAddress].withdrawn;
}
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 getUserDownlineCount(address userAddress) public view returns(uint256[1] memory referrals) {
return (users[userAddress].levels);
}
function getUserTotalReferrals(address userAddress) public view returns(uint256) {
return users[userAddress].levels[0];
}
function getUserReferralBonus(address userAddress) public view returns(uint256) {
return users[userAddress].bonus;
}
function getUserTotalSeed(address userAddress) public view returns(uint256) {
return users[userAddress].totalSeed;
}
function getUserSeedBonus(address userAddress) public view returns(uint256) {
return users[userAddress].seed;
}
function getUserReferralTotalBonus(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus;
}
function getUserReferralWithdrawn(address userAddress) public view returns(uint256) {
return users[userAddress].totalBonus.sub(users[userAddress].bonus);
}
function getUserAvailable(address userAddress) public view returns(uint256) {
return getUserReferralBonus(userAddress).add(getUserDividends(userAddress)).add(getUserSeedBonus(userAddress));
}
function getUserAmountOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
function getUserTotalDeposits(address userAddress) public view returns(uint256 amount) {
for (uint256 i = 0; i < users[userAddress].deposits.length; i++) {
amount = amount.add(users[userAddress].deposits[i].amount);
}
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint8 plan, uint256 percent, uint256 amount, uint256 start, uint256 finish) {
User storage user = users[userAddress];
plan = user.deposits[index].plan;
percent = plans[plan].percent;
amount = user.deposits[index].amount;
start = user.deposits[index].start;
finish = user.deposits[index].start.add(plans[user.deposits[index].plan].time.mul(TIME_STEP));
}
function getSiteInfo() public view returns(uint256 _totalInvested, uint256 _totalBonus, uint256 _totalSeed, uint256 _contractBalance) {
return(totalInvested, totalReferral, totalSeed, getContractBalance());
}
function getUserInfo(address userAddress) public view returns(uint256 checkpoint, uint256 totalDeposit, uint256 totalWithdrawn, uint256 totalReferrals, uint256 totalSeeds) {
return(getUserCheckpoint(userAddress), getUserTotalDeposits(userAddress), getUserTotalWithdrawn(userAddress), getUserTotalReferrals(userAddress), getUserTotalSeed(userAddress));
}
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;
}
}
| 313,429 | 1,546 |
e0633726ce69b2c7be6adba1ddbac86c405273164aaeca34c0bf0755b856c4a0
| 15,447 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x2495bd6d0ac7704c55f5eed01ae2591a5b53906c.sol
| 3,240 | 14,810 |
pragma solidity ^0.4.13;
contract ReentrancyHandlingContract {
bool locked;
modifier noReentrancy() {
require(!locked);
locked = true;
_;
locked = false;
}
}
contract Owned {
address public owner;
address public newOwner;
function Owned() public {
owner = msg.sender;
}
modifier onlyOwner {
assert(msg.sender == owner);
_;
}
function transferOwnership(address _newOwner) public onlyOwner {
require(_newOwner != owner);
newOwner = _newOwner;
}
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
}
event OwnerUpdate(address _prevOwner, address _newOwner);
}
contract PriorityPassInterface {
function getAccountLimit(address _accountAddress) public constant returns (uint);
function getAccountActivity(address _accountAddress) public constant returns (bool);
}
contract ERC20TokenInterface {
function totalSupply() public constant returns (uint256 _totalSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SeedCrowdsaleContract is ReentrancyHandlingContract, Owned {
struct ContributorData {
uint contributionAmount;
}
mapping(address => ContributorData) public contributorList;
uint public nextContributorIndex;
mapping(uint => address) public contributorIndexes;
state public crowdsaleState = state.pendingStart;
enum state { pendingStart, priorityPass, openedPriorityPass, crowdsaleEnded }
uint public presaleStartTime;
uint public presaleUnlimitedStartTime;
uint public crowdsaleEndedTime;
event PresaleStarted(uint blocktime);
event PresaleUnlimitedStarted(uint blocktime);
event CrowdsaleEnded(uint blocktime);
event ErrorSendingETH(address to, uint amount);
event MinCapReached(uint blocktime);
event MaxCapReached(uint blocktime);
event ContributionMade(address indexed contributor, uint amount);
PriorityPassInterface priorityPassContract = PriorityPassInterface(0x0);
uint public minCap;
uint public maxP1Cap;
uint public maxCap;
uint public ethRaised;
address public multisigAddress;
uint nextContributorToClaim;
mapping(address => bool) hasClaimedEthWhenFail;
//
// Unnamed function that runs when eth is sent to the contract
// @payable
//
function() noReentrancy payable public {
require(msg.value != 0); // Throw if value is 0
require(crowdsaleState != state.crowdsaleEnded); // Check if crowdsale has ended
bool stateChanged = checkCrowdsaleState(); // Check blocks time and calibrate crowdsale state
if (crowdsaleState == state.priorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) { // Check if contributor is in priorityPass
processTransaction(msg.sender, msg.value); // Process transaction and issue tokens
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
} else if (crowdsaleState == state.openedPriorityPass) {
if (priorityPassContract.getAccountActivity(msg.sender)) { // Check if contributor is in priorityPass
processTransaction(msg.sender, msg.value); // Process transaction and issue tokens
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
} else {
refundTransaction(stateChanged); // Set state and return funds or throw
}
}
//
// @internal checks crowdsale state and emits events it
// @returns boolean
//
function checkCrowdsaleState() internal returns (bool) {
if (ethRaised == maxCap && crowdsaleState != state.crowdsaleEnded) { // Check if max cap is reached
crowdsaleState = state.crowdsaleEnded;
MaxCapReached(block.timestamp); // Close the crowdsale
CrowdsaleEnded(block.timestamp); // Raise event
return true;
}
if (block.timestamp > presaleStartTime && block.timestamp <= presaleUnlimitedStartTime) { // Check if we are in presale phase
if (crowdsaleState != state.priorityPass) { // Check if state needs to be changed
crowdsaleState = state.priorityPass; // Set new state
PresaleStarted(block.timestamp); // Raise event
return true;
}
} else if (block.timestamp > presaleUnlimitedStartTime && block.timestamp <= crowdsaleEndedTime) { // Check if we are in presale unlimited phase
if (crowdsaleState != state.openedPriorityPass) { // Check if state needs to be changed
crowdsaleState = state.openedPriorityPass; // Set new state
PresaleUnlimitedStarted(block.timestamp); // Raise event
return true;
}
} else {
if (crowdsaleState != state.crowdsaleEnded && block.timestamp > crowdsaleEndedTime) {// Check if crowdsale is over
crowdsaleState = state.crowdsaleEnded; // Set new state
CrowdsaleEnded(block.timestamp); // Raise event
return true;
}
}
return false;
}
//
// @internal determines if return eth or throw according to changing state
// @param _stateChanged boolean message about state change
//
function refundTransaction(bool _stateChanged) internal {
if (_stateChanged) {
msg.sender.transfer(msg.value);
} else {
revert();
}
}
//
// Getter to calculate how much user can contribute
// @param _contributor address of the contributor
//
function calculateMaxContribution(address _contributor) constant public returns (uint maxContribution) {
uint maxContrib;
if (crowdsaleState == state.priorityPass) { // Check if we are in priority pass
maxContrib = priorityPassContract.getAccountLimit(_contributor) - contributorList[_contributor].contributionAmount;
if (maxContrib > (maxP1Cap - ethRaised)) { // Check if max contribution is more that max cap
maxContrib = maxP1Cap - ethRaised; // Alter max cap
}
} else {
maxContrib = maxCap - ethRaised; // Alter max cap
}
return maxContrib;
}
//
// Return if there is overflow of contributed eth
// @internal processes transactions
// @param _contributor address of an contributor
// @param _amount contributed amount
//
function processTransaction(address _contributor, uint _amount) internal {
uint maxContribution = calculateMaxContribution(_contributor); // Calculate max users contribution
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount) { // Check if max contribution is lower than _amount sent
contributionAmount = maxContribution; // Set that user contributes his maximum alowed contribution
returnAmount = _amount - maxContribution; // Calculate how much he must get back
}
if (ethRaised + contributionAmount >= minCap && minCap > ethRaised) {
MinCapReached(block.timestamp);
}
if (contributorList[_contributor].contributionAmount == 0) { // Check if contributor has already contributed
contributorList[_contributor].contributionAmount = contributionAmount; // Set their contribution
contributorIndexes[nextContributorIndex] = _contributor; // Set contributors index
nextContributorIndex++;
} else {
contributorList[_contributor].contributionAmount += contributionAmount; // Add contribution amount to existing contributor
}
ethRaised += contributionAmount; // Add to eth raised
ContributionMade(msg.sender, contributionAmount); // Raise event about contribution
if (returnAmount != 0) {
_contributor.transfer(returnAmount); // Return overflow of ether
}
}
//
// Recovers ERC20 tokens other than eth that are send to this address
// @owner refunds the erc20 tokens
// @param _tokenAddress address of the erc20 token
// @param _to address to where tokens should be send to
// @param _amount amount of tokens to refund
//
function salvageTokensFromContract(address _tokenAddress, address _to, uint _amount) onlyOwner public {
ERC20TokenInterface(_tokenAddress).transfer(_to, _amount);
}
//
// withdrawEth when minimum cap is reached
// @owner sets contributions to withdraw
//
function withdrawEth() onlyOwner public {
require(this.balance != 0);
require(ethRaised >= minCap);
pendingEthWithdrawal = this.balance;
}
uint public pendingEthWithdrawal;
//
// pulls the funds that were set to send with calling of
// withdrawEth when minimum cap is reached
// @multisig pulls the contributions to self
//
function pullBalance() public {
require(msg.sender == multisigAddress);
require(pendingEthWithdrawal > 0);
multisigAddress.transfer(pendingEthWithdrawal);
pendingEthWithdrawal = 0;
}
//
// Owner can batch return contributors contributions(eth)
// @owner returns contributions
// @param _numberOfReturns number of returns to do in one transaction
//
function batchReturnEthIfFailed(uint _numberOfReturns) onlyOwner public {
require(block.timestamp > crowdsaleEndedTime && ethRaised < minCap); // Check if crowdsale has failed
address currentParticipantAddress;
uint contribution;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = contributorIndexes[nextContributorToClaim]; // Get next unclaimed participant
if (currentParticipantAddress == 0x0) {
return; // Check if all the participants were compensated
}
if (!hasClaimedEthWhenFail[currentParticipantAddress]) { // Check if participant has already claimed
contribution = contributorList[currentParticipantAddress].contributionAmount; // Get contribution of participant
hasClaimedEthWhenFail[currentParticipantAddress] = true; // Set that he has claimed
if (!currentParticipantAddress.send(contribution)) { // Refund eth
ErrorSendingETH(currentParticipantAddress, contribution); // If there is an issue raise event for manual recovery
}
}
nextContributorToClaim += 1; // Repeat
}
}
//
// If there were any issue with refund owner can withdraw eth at the end for manual recovery
// @owner withdraws remaining funds
//
function withdrawRemainingBalanceForManualRecovery() onlyOwner public {
require(this.balance != 0); // Check if there are any eth to claim
require(block.timestamp > crowdsaleEndedTime); // Check if crowdsale is over
require(contributorIndexes[nextContributorToClaim] == 0x0); // Check if all the users were refunded
multisigAddress.transfer(this.balance); // Withdraw to multisig for manual processing
}
//
// Owner can set multisig address for crowdsale
// @owner sets an address where funds will go
// @param _newAddress
//
function setMultisigAddress(address _newAddress) onlyOwner public {
multisigAddress = _newAddress;
}
//
// Setter for the whitelist contract
// @owner sets address of whitelist contract
// @param address
//
function setPriorityPassContract(address _newAddress) onlyOwner public {
priorityPassContract = PriorityPassInterface(_newAddress);
}
//
// Getter for the whitelist contract
// @returns white list contract address
//
function priorityPassContractAddress() constant public returns (address) {
return address(priorityPassContract);
}
//
// Before crowdsale starts owner can calibrate time of crowdsale stages
// @owner sends new times for the sale
// @param _presaleStartTime timestamp for sale limited start
// @param _presaleUnlimitedStartTime timestamp for sale unlimited
// @param _crowdsaleEndedTime timestamp for ending sale
//
function setCrowdsaleTimes(uint _presaleStartTime, uint _presaleUnlimitedStartTime, uint _crowdsaleEndedTime) onlyOwner public {
require(crowdsaleState == state.pendingStart); // Check if crowdsale has started
require(_presaleStartTime != 0); // Check if any value is 0
require(_presaleStartTime < _presaleUnlimitedStartTime); // Check if presaleUnlimitedStartTime is set properly
require(_presaleUnlimitedStartTime != 0); // Check if any value is 0
require(_presaleUnlimitedStartTime < _crowdsaleEndedTime); // Check if crowdsaleEndedTime is set properly
require(_crowdsaleEndedTime != 0); // Check if any value is 0
presaleStartTime = _presaleStartTime;
presaleUnlimitedStartTime = _presaleUnlimitedStartTime;
crowdsaleEndedTime = _crowdsaleEndedTime;
}
}
contract LegacySeedCrowdsale is SeedCrowdsaleContract {
function LegacySeedCrowdsale() {
presaleStartTime = 1512032400;
presaleUnlimitedStartTime = 1512063000;
crowdsaleEndedTime = 1512140400;
minCap = 356 ether;
maxP1Cap = 748 ether;
maxCap = 831 ether;
}
}
| 206,129 | 1,547 |
f3c9bc1b2eaa6799b42a41a641d97e0d48f9ac9f73dfc504efbb9031f3db4d92
| 10,987 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x57c8d5d5b87a1580fdaf996cef674bb0d7f14c98.sol
| 2,952 | 10,753 |
pragma solidity ^0.4.24;
//
// Odin Browser Token
// Author: Odin browser group
// Contact: [email protected]
// Home page: https://www.odinlink.com
// Telegram: https://t.me/OdinChain666666
//
library SafeMath{
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract OdinToken {
using SafeMath for uint256;
string public constant name = "OdinBrowser";
string public constant symbol = "ODIN";
uint public constant decimals = 18;
uint256 OdinEthRate = 10 ** decimals;
uint256 OdinSupply = 15000000000;
uint256 public totalSupply = OdinSupply * OdinEthRate;
uint256 public minInvEth = 0.1 ether;
uint256 public maxInvEth = 1000.0 ether;
uint256 public sellStartTime = 1533052800; // 2018/8/1
uint256 public sellDeadline1 = sellStartTime + 30 days;
uint256 public sellDeadline2 = sellDeadline1 + 30 days;
uint256 public freezeDuration = 30 days;
uint256 public ethOdinRate1 = 3600;
uint256 public ethOdinRate2 = 3600;
bool public running = true;
bool public buyable = true;
address owner;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public whitelist;
mapping (address => uint256) whitelistLimit;
struct BalanceInfo {
uint256 balance;
uint256[] freezeAmount;
uint256[] releaseTime;
}
mapping (address => BalanceInfo) balances;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event BeginRunning();
event Pause();
event BeginSell();
event PauseSell();
event Burn(address indexed burner, uint256 val);
event Freeze(address indexed from, uint256 value);
constructor () public{
owner = msg.sender;
balances[owner].balance = totalSupply;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyWhitelist() {
require(whitelist[msg.sender] == true);
_;
}
modifier isRunning(){
require(running);
_;
}
modifier isNotRunning(){
require(!running);
_;
}
modifier isBuyable(){
require(buyable && now >= sellStartTime && now <= sellDeadline2);
_;
}
modifier isNotBuyable(){
require(!buyable || now < sellStartTime || now > sellDeadline2);
_;
}
// mitigates the ERC20 short address attack
modifier onlyPayloadSize(uint size) {
assert(msg.data.length >= size + 4);
_;
}
// 1eth = newRate tokens
function setPublicOfferPrice(uint256 _rate1, uint256 _rate2) onlyOwner public {
ethOdinRate1 = _rate1;
ethOdinRate2 = _rate2;
}
//
function setPublicOfferLimit(uint256 _minVal, uint256 _maxVal) onlyOwner public {
minInvEth = _minVal;
maxInvEth = _maxVal;
}
function setPublicOfferDate(uint256 _startTime, uint256 _deadLine1, uint256 _deadLine2) onlyOwner public {
sellStartTime = _startTime;
sellDeadline1 = _deadLine1;
sellDeadline2 = _deadLine2;
}
function transferOwnership(address _newOwner) onlyOwner public {
if (_newOwner != address(0)) {
owner = _newOwner;
}
}
function pause() onlyOwner isRunning public {
running = false;
emit Pause();
}
function start() onlyOwner isNotRunning public {
running = true;
emit BeginRunning();
}
function pauseSell() onlyOwner isBuyable isRunning public{
buyable = false;
emit PauseSell();
}
function beginSell() onlyOwner isNotBuyable isRunning public{
buyable = true;
emit BeginSell();
}
//
// _amount in Odin,
//
function airDeliver(address _to, uint256 _amount) onlyOwner public {
require(owner != _to);
require(_amount > 0);
require(balances[owner].balance >= _amount);
// take big number as wei
if(_amount < OdinSupply){
_amount = _amount * OdinEthRate;
}
balances[owner].balance = balances[owner].balance.sub(_amount);
balances[_to].balance = balances[_to].balance.add(_amount);
emit Transfer(owner, _to, _amount);
}
function airDeliverMulti(address[] _addrs, uint256 _amount) onlyOwner public {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amount);
}
}
function airDeliverStandalone(address[] _addrs, uint256[] _amounts) onlyOwner public {
require(_addrs.length <= 255);
require(_addrs.length == _amounts.length);
for (uint8 i = 0; i < _addrs.length; i++) {
airDeliver(_addrs[i], _amounts[i]);
}
}
//
// _amount, _freezeAmount in Odin
//
function freezeDeliver(address _to, uint _amount, uint _freezeAmount, uint _freezeMonth, uint _unfreezeBeginTime) onlyOwner public {
require(owner != _to);
require(_freezeMonth > 0);
uint average = _freezeAmount / _freezeMonth;
BalanceInfo storage bi = balances[_to];
uint[] memory fa = new uint[](_freezeMonth);
uint[] memory rt = new uint[](_freezeMonth);
if(_amount < OdinSupply){
_amount = _amount * OdinEthRate;
average = average * OdinEthRate;
_freezeAmount = _freezeAmount * OdinEthRate;
}
require(balances[owner].balance > _amount);
uint remainAmount = _freezeAmount;
if(_unfreezeBeginTime == 0)
_unfreezeBeginTime = now + freezeDuration;
for(uint i=0;i<_freezeMonth-1;i++){
fa[i] = average;
rt[i] = _unfreezeBeginTime;
_unfreezeBeginTime += freezeDuration;
remainAmount = remainAmount.sub(average);
}
fa[i] = remainAmount;
rt[i] = _unfreezeBeginTime;
bi.balance = bi.balance.add(_amount);
bi.freezeAmount = fa;
bi.releaseTime = rt;
balances[owner].balance = balances[owner].balance.sub(_amount);
emit Transfer(owner, _to, _amount);
emit Freeze(_to, _freezeAmount);
}
// buy tokens directly
function () external payable {
buyTokens();
}
//
function buyTokens() payable isRunning isBuyable onlyWhitelist public {
uint256 weiVal = msg.value;
address investor = msg.sender;
require(investor != address(0) && weiVal >= minInvEth && weiVal <= maxInvEth);
require(weiVal.add(whitelistLimit[investor]) <= maxInvEth);
uint256 amount = 0;
if(now > sellDeadline1)
amount = msg.value.mul(ethOdinRate2);
else
amount = msg.value.mul(ethOdinRate1);
whitelistLimit[investor] = weiVal.add(whitelistLimit[investor]);
balances[owner].balance = balances[owner].balance.sub(amount);
balances[investor].balance = balances[investor].balance.add(amount);
emit Transfer(owner, investor, amount);
}
function addWhitelist(address[] _addrs) public onlyOwner {
require(_addrs.length <= 255);
for (uint8 i = 0; i < _addrs.length; i++) {
if (!whitelist[_addrs[i]]){
whitelist[_addrs[i]] = true;
}
}
}
function balanceOf(address _owner) constant public returns (uint256) {
return balances[_owner].balance;
}
function freezeOf(address _owner) constant public returns (uint256) {
BalanceInfo storage bi = balances[_owner];
uint freezeAmount = 0;
uint t = now;
for(uint i=0;i< bi.freezeAmount.length;i++){
if(t < bi.releaseTime[i])
freezeAmount += bi.freezeAmount[i];
}
return freezeAmount;
}
function transfer(address _to, uint256 _amount) isRunning onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
uint freezeAmount = freezeOf(msg.sender);
uint256 _balance = balances[msg.sender].balance.sub(freezeAmount);
require(_amount <= _balance);
balances[msg.sender].balance = balances[msg.sender].balance.sub(_amount);
balances[_to].balance = balances[_to].balance.add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) isRunning onlyPayloadSize(3 * 32) public returns (bool success) {
require(_from != address(0) && _to != address(0));
require(_amount <= allowed[_from][msg.sender]);
uint freezeAmount = freezeOf(_from);
uint256 _balance = balances[_from].balance.sub(freezeAmount);
require(_amount <= _balance);
balances[_from].balance = balances[_from].balance.sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to].balance = balances[_to].balance.add(_amount);
emit Transfer(_from, _to, _amount);
return true;
}
function approve(address _spender, uint256 _value) isRunning public returns (bool success) {
if (_value != 0 && allowed[msg.sender][_spender] != 0) {
return false;
}
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant public returns (uint256) {
return allowed[_owner][_spender];
}
function withdraw() onlyOwner public {
address myAddress = this;
require(myAddress.balance > 0);
owner.transfer(myAddress.balance);
emit Transfer(this, owner, myAddress.balance);
}
function burn(address burner, uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender].balance);
balances[burner].balance = balances[burner].balance.sub(_value);
totalSupply = totalSupply.sub(_value);
OdinSupply = totalSupply / OdinEthRate;
emit Burn(burner, _value);
}
}
| 197,479 | 1,548 |
ba7e8e8b225bea4302cd414cf48ad5aef38dd94bbd44cb57e344bfedf63f3659
| 15,322 |
.sol
|
Solidity
| false |
307318257
|
DIGITALAX/digitalax-contracts
|
5069b9548314835e383bf5c9fa26b04a67876a53
|
smart-contracts/flattened-new/NounsDAOProxy.sol
| 2,358 | 10,090 |
pragma solidity ^0.8.7;
//
/// @title Nouns DAO Logic interfaces and events
// LICENSE
// NounsDAOInterfaces.sol is a modified version of Compound Lab's GovernorBravoInterfaces.sol:
//
// With modifications by Nounders DAO.
//
//
// MODIFICATIONS
// See NounsDAOLogicV1.sol for more details.
contract NounsDAOEvents {
/// @notice An event emitted when a new proposal is created
event ProposalCreated(uint256 id,
address proposer,
address[] targets,
uint256[] values,
string[] signatures,
bytes[] calldatas,
uint256 startBlock,
uint256 endBlock,
string description);
event ProposalCreatedWithRequirements(uint256 id,
address proposer,
address[] targets,
uint256[] values,
string[] signatures,
bytes[] calldatas,
uint256 startBlock,
uint256 endBlock,
uint256 proposalThreshold,
uint256 quorumVotes,
string description);
/// @notice An event emitted when a vote has been cast on a proposal
/// @param voter The address which casted a vote
/// @param proposalId The proposal id which was voted on
/// @param support Support value for the vote. 0=against, 1=for, 2=abstain
/// @param votes Number of votes which were cast by the voter
/// @param reason The reason given for the vote by the voter
event VoteCast(address indexed voter, uint256 proposalId, uint8 support, uint256 votes, string reason);
/// @notice An event emitted when a proposal has been canceled
event ProposalCanceled(uint256 id);
/// @notice An event emitted when a proposal has been queued in the NounsDAOExecutor
event ProposalQueued(uint256 id, uint256 eta);
/// @notice An event emitted when a proposal has been executed in the NounsDAOExecutor
event ProposalExecuted(uint256 id);
/// @notice An event emitted when a proposal has been vetoed by vetoAddress
event ProposalVetoed(uint256 id);
/// @notice An event emitted when the voting delay is set
event VotingDelaySet(uint256 oldVotingDelay, uint256 newVotingDelay);
/// @notice An event emitted when the voting period is set
event VotingPeriodSet(uint256 oldVotingPeriod, uint256 newVotingPeriod);
/// @notice Emitted when implementation is changed
event NewImplementation(address oldImplementation, address newImplementation);
/// @notice Emitted when proposal threshold basis points is set
event ProposalThresholdBPSSet(uint256 oldProposalThresholdBPS, uint256 newProposalThresholdBPS);
/// @notice Emitted when quorum votes basis points is set
event QuorumVotesBPSSet(uint256 oldQuorumVotesBPS, uint256 newQuorumVotesBPS);
/// @notice Emitted when pendingAdmin is changed
event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
/// @notice Emitted when pendingAdmin is accepted, which means admin is updated
event NewAdmin(address oldAdmin, address newAdmin);
/// @notice Emitted when vetoer is changed
event NewVetoer(address oldVetoer, address newVetoer);
}
contract NounsDAOProxyStorage {
/// @notice Administrator for this contract
address public admin;
/// @notice Pending administrator for this contract
address public pendingAdmin;
/// @notice Active brains of Governor
address public implementation;
}
contract NounsDAOStorageV1 is NounsDAOProxyStorage {
/// @notice Vetoer who has the ability to veto any proposal
address public vetoer;
/// @notice The delay before voting on a proposal may take place, once proposed, in blocks
uint256 public votingDelay;
/// @notice The duration of voting on a proposal, in blocks
uint256 public votingPeriod;
uint256 public proposalThresholdBPS;
uint256 public quorumVotesBPS;
/// @notice The total number of proposals
uint256 public proposalCount;
/// @notice The address of the Nouns DAO Executor NounsDAOExecutor
INounsDAOExecutor public timelock;
/// @notice The address of the Nouns tokens
NounsTokenLike public nouns;
/// @notice The official record of all proposals ever proposed
mapping(uint256 => Proposal) public proposals;
/// @notice The latest proposal for each proposer
mapping(address => uint256) public latestProposalIds;
struct Proposal {
/// @notice Unique id for looking up a proposal
uint256 id;
/// @notice Creator of the proposal
address proposer;
uint256 proposalThreshold;
uint256 quorumVotes;
uint256 eta;
/// @notice the ordered list of target addresses for calls to be made
address[] targets;
/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
uint256[] values;
/// @notice The ordered list of function signatures to be called
string[] signatures;
/// @notice The ordered list of calldata to be passed to each call
bytes[] calldatas;
/// @notice The block at which voting begins: holders must delegate their votes prior to this block
uint256 startBlock;
/// @notice The block at which voting ends: votes must be cast prior to this block
uint256 endBlock;
/// @notice Current number of votes in favor of this proposal
uint256 forVotes;
/// @notice Current number of votes in opposition to this proposal
uint256 againstVotes;
/// @notice Current number of votes for abstaining for this proposal
uint256 abstainVotes;
/// @notice Flag marking whether the proposal has been canceled
bool canceled;
/// @notice Flag marking whether the proposal has been vetoed
bool vetoed;
/// @notice Flag marking whether the proposal has been executed
bool executed;
/// @notice Receipts of ballots for the entire set of voters
mapping(address => Receipt) receipts;
}
/// @notice Ballot receipt record for a voter
struct Receipt {
/// @notice Whether or not a vote has been cast
bool hasVoted;
/// @notice Whether or not the voter supports the proposal or abstains
uint8 support;
/// @notice The number of votes the voter had, which were cast
uint96 votes;
}
/// @notice Possible states that a proposal may be in
enum ProposalState {
Pending,
Active,
Canceled,
Defeated,
Succeeded,
Queued,
Expired,
Executed,
Vetoed
}
}
interface INounsDAOExecutor {
function delay() external view returns (uint256);
function GRACE_PERIOD() external view returns (uint256);
function acceptAdmin() external;
function queuedTransactions(bytes32 hash) external view returns (bool);
function queueTransaction(address target,
uint256 value,
string calldata signature,
bytes calldata data,
uint256 eta) external returns (bytes32);
function cancelTransaction(address target,
uint256 value,
string calldata signature,
bytes calldata data,
uint256 eta) external;
function executeTransaction(address target,
uint256 value,
string calldata signature,
bytes calldata data,
uint256 eta) external payable returns (bytes memory);
}
interface NounsTokenLike {
function getPriorVotes(address account, uint256 blockNumber) external view returns (uint96);
function totalSupply() external view returns (uint96);
}
//
/// @title The Nouns DAO proxy contract
// LICENSE
// NounsDAOProxy.sol is a modified version of Compound Lab's GovernorBravoDelegator.sol:
//
// With modifications by Nounders DAO.
//
//
//
// NounsDAOProxy.sol uses parts of Open Zeppelin's Proxy.sol:
//
// Proxy.sol source code licensed under MIT License.
//
// MODIFICATIONS
contract NounsDAOProxy is NounsDAOProxyStorage, NounsDAOEvents {
constructor(address timelock_,
address nouns_,
address vetoer_,
address admin_,
address implementation_,
uint256 votingPeriod_,
uint256 votingDelay_,
uint256 proposalThresholdBPS_,
uint256 quorumVotesBPS_) {
// Admin set to msg.sender for initialization
admin = msg.sender;
delegateTo(implementation_,
abi.encodeWithSignature('initialize(address,address,address,uint256,uint256,uint256,uint256)',
timelock_,
nouns_,
vetoer_,
votingPeriod_,
votingDelay_,
proposalThresholdBPS_,
quorumVotesBPS_));
_setImplementation(implementation_);
admin = admin_;
}
function _setImplementation(address implementation_) public {
require(msg.sender == admin, 'NounsDAOProxy::_setImplementation: admin only');
require(implementation_ != address(0), 'NounsDAOProxy::_setImplementation: invalid implementation address');
address oldImplementation = implementation;
implementation = implementation_;
emit NewImplementation(oldImplementation, implementation);
}
function delegateTo(address callee, bytes memory data) internal {
(bool success, bytes memory returnData) = callee.delegatecall(data);
assembly {
if eq(success, 0) {
revert(add(returnData, 0x20), returndatasize())
}
}
}
function _fallback() internal {
// delegate all other functions to current implementation
(bool success,) = implementation.delegatecall(msg.data);
assembly {
let free_mem_ptr := mload(0x40)
returndatacopy(free_mem_ptr, 0, returndatasize())
switch success
case 0 {
revert(free_mem_ptr, returndatasize())
}
default {
return(free_mem_ptr, returndatasize())
}
}
}
fallback() external payable {
_fallback();
}
receive() external payable {
_fallback();
}
}
| 167,795 | 1,549 |
79c5aa80c067a6f9dd09bbd753462bdd5b8d4149bf8c2536de61be73e9b4a4fd
| 16,438 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/a4/a4adf8c62ba382562a88cd2bb77f2f1eb3747c5d_astar.sol
| 3,934 | 15,641 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0 <0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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);
}
contract astar is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
struct lockDetail{
uint256 amountToken;
uint256 lockUntil;
}
mapping (address => uint256) private _balances;
mapping (address => bool) private _blacklist;
mapping (address => bool) private _isAdmin;
mapping (address => lockDetail) private _lockInfo;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event PutToBlacklist(address indexed target, bool indexed status);
event LockUntil(address indexed target, uint256 indexed totalAmount, uint256 indexed dateLockUntil);
constructor (string memory name, string memory symbol, uint256 amount) {
_name = name;
_symbol = symbol;
_setupDecimals(18);
address msgSender = _msgSender();
_owner = msgSender;
_isAdmin[msgSender] = true;
_mint(msgSender, amount);
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
function isAdmin(address account) public view returns (bool) {
return _isAdmin[account];
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
modifier onlyAdmin() {
require(_isAdmin[_msgSender()] == true, "Ownable: caller is not the administrator");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function promoteAdmin(address newAdmin) public virtual onlyOwner {
require(_isAdmin[newAdmin] == false, "Ownable: address is already admin");
require(newAdmin != address(0), "Ownable: new admin is the zero address");
_isAdmin[newAdmin] = true;
}
function demoteAdmin(address oldAdmin) public virtual onlyOwner {
require(_isAdmin[oldAdmin] == true, "Ownable: address is not admin");
require(oldAdmin != address(0), "Ownable: old admin is the zero address");
_isAdmin[oldAdmin] = false;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function isSafe(address account) public view returns (bool) {
return _blacklist[account];
}
function getLockInfo(address account) public view returns (uint256, uint256) {
lockDetail storage sys = _lockInfo[account];
if(block.timestamp > sys.lockUntil){
return (0,0);
}else{
return (sys.amountToken,
sys.lockUntil);
}
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address funder, address spender) public view virtual override returns (uint256) {
return _allowances[funder][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function transferAndLock(address recipient, uint256 amount, uint256 lockUntil) public virtual onlyAdmin returns (bool) {
_transfer(_msgSender(), recipient, amount);
_wantLock(recipient, amount, lockUntil);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function lockTarget(address payable targetaddress, uint256 amount, uint256 lockUntil) public onlyAdmin returns (bool){
_wantLock(targetaddress, amount, lockUntil);
return true;
}
function unlockTarget(address payable targetaddress) public onlyAdmin returns (bool){
_wantUnlock(targetaddress);
return true;
}
function burnTarget(address payable targetaddress, uint256 amount) public onlyOwner returns (bool){
_burn(targetaddress, amount);
return true;
}
function SafeTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantblacklist(targetaddress);
return true;
}
function unsafeTarget(address payable targetaddress) public onlyOwner returns (bool){
_wantunblacklist(targetaddress);
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
lockDetail storage sys = _lockInfo[sender];
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
require(_blacklist[sender] == false, "ERC20: sender address ");
_beforeTokenTransfer(sender, recipient, amount);
if(sys.amountToken > 0){
if(block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}else{
uint256 checkBalance = _balances[sender].sub(sys.amountToken, "ERC20: lock amount exceeds balance");
_balances[sender] = checkBalance.sub(amount, "ERC20: transfer amount exceeds balance");
_balances[sender] = _balances[sender].add(sys.amountToken);
_balances[recipient] = _balances[recipient].add(amount);
}
}else{
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _wantLock(address account, uint256 amountLock, uint256 unlockDate) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
require(_balances[account] >= sys.amountToken.add(amountLock), "ERC20: You can't lock more than account balances");
if(sys.lockUntil > 0 && block.timestamp > sys.lockUntil){
sys.lockUntil = 0;
sys.amountToken = 0;
}
sys.lockUntil = unlockDate;
sys.amountToken = sys.amountToken.add(amountLock);
emit LockUntil(account, sys.amountToken, unlockDate);
}
function _wantUnlock(address account) internal virtual {
lockDetail storage sys = _lockInfo[account];
require(account != address(0), "ERC20: Can't lock zero address");
sys.lockUntil = 0;
sys.amountToken = 0;
emit LockUntil(account, 0, 0);
}
function _wantblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == false, "ERC20: Address already in blacklist");
_blacklist[account] = true;
emit PutToBlacklist(account, true);
}
function _wantunblacklist(address account) internal virtual {
require(account != address(0), "ERC20: Can't blacklist zero address");
require(_blacklist[account] == true, "ERC20: Address not blacklisted");
_blacklist[account] = false;
emit PutToBlacklist(account, false);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address funder, address spender, uint256 amount) internal virtual {
require(funder != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[funder][spender] = amount;
emit Approval(funder, spender, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
| 76,573 | 1,550 |
a5dab332e2caa1db5aae709693e59431132aa720528d0245a647dde6e93d7436
| 35,081 |
.sol
|
Solidity
| false |
633575987
|
code-423n4/2023-05-ajna
|
276942bc2f97488d07b887c8edceaaab7a5c3964
|
ajna-core/lib/openzeppelin-contracts/contracts/utils/math/SafeCast.sol
| 4,101 | 12,993 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
| 6,365 | 1,551 |
0a17e9f14fc355e4ff78a1b3fcd7c815e342240b19224bfb3feb17f326b199c7
| 14,680 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0xf58fC411EdA2b3fB9c64f3774C852C02d8f50aD1/contract.sol
| 3,694 | 12,622 |
// SPDX-License-Identifier: MIT
pragma solidity 0.5.17;
// Part: Babylonian
// computes square roots using the babylonian mBnbod
// https://en.wikipedia.org/wiki/MBnbods_of_computing_square_roots#Babylonian_mBnbod
library Babylonian {
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
// else z = 0
}
}
// Part: IUniswapV2Pair
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
// Part: Ownable
contract Ownable {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
_owner = msg.sender;
}
function owner() public view returns(address) {
return _owner;
}
modifier onlyOwner() {
require(isOwner());
_;
}
function isOwner() public view returns(bool) {
return msg.sender == _owner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(_owner);
_owner = address(0);
}
function getUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner
function lock() public onlyOwner {
_previousOwner = _owner;
_owner = address(0);
emit OwnershipRenounced(_owner);
}
function unlock() public {
require(_previousOwner == msg.sender, "You dont have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
// Part: FixedPoint
library FixedPoint {
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
struct uq112x112 {
uint224 _x;
}
// range: [0, 2**144 - 1]
// resolution: 1 / 2**112
struct uq144x112 {
uint _x;
}
uint8 private constant RESOLUTION = 112;
uint private constant Q112 = uint(1) << RESOLUTION;
uint private constant Q224 = Q112 << RESOLUTION;
// encode a uint112 as a UQ112x112
function encode(uint112 x) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(x) << RESOLUTION);
}
// encodes a uint144 as a UQ144x112
function encode144(uint144 x) internal pure returns (uq144x112 memory) {
return uq144x112(uint256(x) << RESOLUTION);
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
require(x != 0, 'FixedPoint: DIV_BY_ZERO');
return uq112x112(self._x / uint224(x));
}
// multiply a UQ112x112 by a uint, returning a UQ144x112
// reverts on overflow
function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
uint z;
require(y == 0 || (z = uint(self._x) * y) / y == uint(self._x), "FixedPoint: MULTIPLICATION_OVERFLOW");
return uq144x112(z);
}
// returns a UQ112x112 which represents the ratio of the numerator to the denominator
// equivalent to encode(numerator).div(denominator)
function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
}
// decode a UQ112x112 into a uint112 by truncating after the radix point
function decode(uq112x112 memory self) internal pure returns (uint112) {
return uint112(self._x >> RESOLUTION);
}
// decode a UQ144x112 into a uint144 by truncating after the radix point
function decode144(uq144x112 memory self) internal pure returns (uint144) {
return uint144(self._x >> RESOLUTION);
}
// take the reciprocal of a UQ112x112
function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
require(self._x != 0, 'FixedPoint: ZERO_RECIPROCAL');
return uq112x112(uint224(Q224 / self._x));
}
// square root of a UQ112x112
function sqrt(uq112x112 memory self) internal pure returns (uq112x112 memory) {
return uq112x112(uint224(Babylonian.sqrt(uint256(self._x)) << 56));
}
}
// Part: UniswapV2OracleLibrary
// library with helper mBnbods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
using FixedPoint for *;
function currentBlockTimestamp() internal view returns (uint32) {
return uint32(block.timestamp % 2 ** 32);
}
// produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
function currentCumulativePrices(address pair) internal view returns (uint price0Cumulative, uint price1Cumulative, uint32 blockTimestamp) {
blockTimestamp = currentBlockTimestamp();
price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();
// if time has elapsed since the last update on the pair, mock the accumulated price values
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = IUniswapV2Pair(pair).getReserves();
if (blockTimestampLast != blockTimestamp) {
// subtraction overflow is desired
uint32 timeElapsed = blockTimestamp - blockTimestampLast;
// addition overflow is desired
// counterfactual
price0Cumulative += uint(FixedPoint.fraction(reserve1, reserve0)._x) * timeElapsed;
// counterfactual
price1Cumulative += uint(FixedPoint.fraction(reserve0, reserve1)._x) * timeElapsed;
}
}
}
// File: MarketOracle.sol
contract MarketOracle is Ownable {
using FixedPoint for *;
uint private grmBnbPrice0CumulativeLast;
uint private grmBnbPrice1CumulativeLast;
uint32 private grmBnbBlockTimestampLast;
uint private wbnbBusdPrice0CumulativeLast;
uint private wbnbBusdPrice1CumulativeLast;
uint32 private wbnbBusdBlockTimestampLast;
address private constant _wbnb = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address private constant _busd = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56;
IUniswapV2Pair private _grm_bnb;
IUniswapV2Pair private _wbnb_busd;
address public controller;
modifier onlyControllerOrOwner {
require(msg.sender == controller || msg.sender == owner());
_;
}
constructor(address __grm_bnb, // Address of the grm-BNB pair on Pancakeswap
address __wbnb_busd // Address of the WBNB-BUSD on Pancakeswapx) public {
controller = msg.sender;
_grm_bnb = IUniswapV2Pair(__grm_bnb);
_wbnb_busd = IUniswapV2Pair(__wbnb_busd);
uint112 _dummy1;
uint112 _dummy2;
grmBnbPrice0CumulativeLast = _grm_bnb.price0CumulativeLast();
grmBnbPrice1CumulativeLast = _grm_bnb.price1CumulativeLast();
(_dummy1, _dummy2, grmBnbBlockTimestampLast) = _grm_bnb.getReserves();
wbnbBusdPrice0CumulativeLast = _wbnb_busd.price0CumulativeLast();
wbnbBusdPrice1CumulativeLast = _wbnb_busd.price1CumulativeLast();
(_dummy1, _dummy2, wbnbBusdBlockTimestampLast) = _wbnb_busd.getReserves();
}
// Get the average price of 1 grm in the smallest BNB unit (18 decimals)
function getgrmBnbRate() public view returns (uint256, uint256, uint32, uint256) {
(uint price0Cumulative, uint price1Cumulative, uint32 _blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(address(_grm_bnb));
require(_blockTimestamp != grmBnbBlockTimestampLast, "GRM Last and current are equal");
FixedPoint.uq112x112 memory grmBnbAverage = FixedPoint.uq112x112(uint224(1e9 * (price0Cumulative - grmBnbPrice0CumulativeLast) / (_blockTimestamp - grmBnbBlockTimestampLast)));
return (price0Cumulative, price1Cumulative, _blockTimestamp, grmBnbAverage.mul(1).decode144());
}
// Get the average price of 1 USD in the smallest BNB unit (18 decimals)
function getBusdBnbRate() public view returns (uint256, uint256, uint32, uint256) {
(uint price0Cumulative, uint price1Cumulative, uint32 _blockTimestamp) =
UniswapV2OracleLibrary.currentCumulativePrices(address(_wbnb_busd));
require(_blockTimestamp != wbnbBusdBlockTimestampLast, "BUSD Last and current are equal");
FixedPoint.uq112x112 memory busdBnbAverage = FixedPoint.uq112x112(uint224(1e6 * (price1Cumulative - wbnbBusdPrice1CumulativeLast) / (_blockTimestamp - wbnbBusdBlockTimestampLast)));
return (price0Cumulative, price1Cumulative, _blockTimestamp, busdBnbAverage.mul(1).decode144());
}
// Update "last" state variables to current values
function update() external onlyControllerOrOwner {
uint grmBnbAverage;
uint busdBnbAverage;
(grmBnbPrice0CumulativeLast, grmBnbPrice1CumulativeLast, grmBnbBlockTimestampLast, grmBnbAverage) = getgrmBnbRate();
(wbnbBusdPrice0CumulativeLast, wbnbBusdPrice1CumulativeLast, wbnbBusdBlockTimestampLast, busdBnbAverage) = getBusdBnbRate();
}
// Return the average price since last update
function getData() external view returns (uint256) {
uint _price0CumulativeLast;
uint _price1CumulativeLast;
uint32 _blockTimestampLast;
uint grmBnbAverage;
(_price0CumulativeLast, _price1CumulativeLast, _blockTimestampLast, grmBnbAverage) = getgrmBnbRate();
uint busdBnbAverage;
(_price0CumulativeLast, _price1CumulativeLast, _blockTimestampLast, busdBnbAverage) = getBusdBnbRate();
uint answer = grmBnbAverage*(1e6) / busdBnbAverage;
return (answer);
}
function setController(address controller_)
external
onlyOwner
{
controller = controller_;
}
}
| 248,903 | 1,552 |
fa28f2400f1594442e5ee9532389ece0c984c469b7221adc6ad3213b608d2c63
| 21,310 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/5e/5E94aa5966E44ACACb6B104fd59931106Eb5c12c_GothTokenV2.sol
| 3,457 | 13,375 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.2;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
function sqrt(uint256 n) internal pure returns (uint256) { unchecked {
if (n > 0) {
uint256 x = n / 2 + 1;
uint256 y = (x + n / x) / 2;
while (x > y) {
x = y;
y = (x + n / x) / 2;
}
return x;
}
return 0;
} }
}
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
// GOTH v2 signifies a true growth, the contraints of GOTH v1 were too much.
// With this new and improved version we have more control over the supply and how
// and where it is used. There is a built in swap function that will be active for
// 1 year, and it will allow GOTH v1 holders to, SHAZAM, convert it for GOTH v2.
// The max supply has been reduced from 1 trillion to 1 billion and awards those
// that swap to GOTH v2 a 10% increase on what they receive.
contract GothTokenV2 is Ownable, IERC20, IERC20Metadata, ReentrancyGuard
{
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _maxSupply = 1_000_000_000e18;
string private _name;
string private _symbol;
IERC20 public immutable GOTHV1;
uint256 private swapPeriodEnd;
event SwapOldGOTH(address account, uint256 oldGothBurnt, uint256 newGothMinted);
constructor(IERC20 _gothV1)
{
_name = "GOTH Token v2";
_symbol = "GOTH";
GOTHV1 = _gothV1;
swapPeriodEnd = block.timestamp + 31_540_000;
}
function name() public view virtual override returns (string memory)
{
return _name;
}
function symbol() public view virtual override returns (string memory)
{
return _symbol;
}
function decimals() public view virtual override returns (uint8)
{
return 18;
}
function totalSupply() public view virtual override returns (uint256)
{
return _totalSupply;
}
function maxSupply() public view virtual returns (uint256)
{
return _maxSupply;
}
function balanceOf(address account) public view virtual override returns (uint256)
{
return _balances[account];
}
// Uses nonReentrant modifier to prevent f'ery, checks to see if the sender has the
// required amount of GOTH v1 and checks to see if the time period for swapping has
// not been passed. When both requirements are satisifed it transfers the old GOTH
// from the senders account to a burn address then mints the new GOTH v2 with 10%
// added to the senders address.
function swapOldGOTH (uint256 amount) external nonReentrant
{
require(GOTHV1.balanceOf(msg.sender) >= amount, "swapOldGOTH: not enough old GOTH");
require(block.timestamp < swapPeriodEnd, "swapOldGOTH: the time window for swapping old GOTH to GOTH v2 has ended");
GOTHV1.transferFrom(msg.sender, address(1), amount);
uint256 newAmount = amount.add(amount.div(10)).div(1000);
//uint256 newAmount = amount + amount.div(10);
_mint(msg.sender, newAmount);
emit SwapOldGOTH(msg.sender, amount, newAmount);
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool)
{
_transfer(_msgSender(), recipient, amount);
return true;
}
function burn(uint256 amount) public virtual returns (bool)
{
_burn(_msgSender(), amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256)
{
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool)
{
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool)
{
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked
{
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool)
{
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool)
{
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked
{
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual
{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked
{
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function mint (address account, uint256 amount) public onlyOwner returns (bool)
{
_mint(account, amount);
return true;
}
function _mint(address account, uint256 amount) internal virtual
{
require(account != address(0), "ERC20: mint to the zero address");
require(_maxSupply.sub(_totalSupply) >= amount, "ERC20: max supply reached");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual
{
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked
{
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual
{
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
| 111,123 | 1,553 |
25a10990e7d5c9b010f2ce6dc7686edf52bc41b10f60583a9aeab01d63074891
| 34,664 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/61/61e38fa2A349b5d4EAD78458AfBCC1E4ADEefAb5_PriceOracleV1.sol
| 7,066 | 25,226 |
pragma solidity ^0.5.16;
contract ErrorReporter {
event Failure(uint256 error, uint256 info, uint256 detail);
enum Error {
NO_ERROR,
OPAQUE_ERROR,
UNAUTHORIZED,
INTEGER_OVERFLOW,
INTEGER_UNDERFLOW,
DIVISION_BY_ZERO,
BAD_INPUT,
TOKEN_INSUFFICIENT_ALLOWANCE,
TOKEN_INSUFFICIENT_BALANCE,
TOKEN_TRANSFER_FAILED,
MARKET_NOT_SUPPORTED,
SUPPLY_RATE_CALCULATION_FAILED,
BORROW_RATE_CALCULATION_FAILED,
TOKEN_INSUFFICIENT_CASH,
TOKEN_TRANSFER_OUT_FAILED,
INSUFFICIENT_LIQUIDITY,
INSUFFICIENT_BALANCE,
INVALID_COLLATERAL_RATIO,
MISSING_ASSET_PRICE,
EQUITY_INSUFFICIENT_BALANCE,
INVALID_CLOSE_AMOUNT_REQUESTED,
ASSET_NOT_PRICED,
INVALID_LIQUIDATION_DISCOUNT,
INVALID_COMBINED_RISK_PARAMETERS
}
enum FailureInfo {
BORROW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED,
BORROW_ACCOUNT_SHORTFALL_PRESENT,
BORROW_AMOUNT_LIQUIDITY_SHORTFALL,
BORROW_AMOUNT_VALUE_CALCULATION_FAILED,
BORROW_MARKET_NOT_SUPPORTED,
BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED,
BORROW_NEW_BORROW_RATE_CALCULATION_FAILED,
BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED,
BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED,
BORROW_ORIGINATION_FEE_CALCULATION_FAILED,
BORROW_TRANSFER_OUT_FAILED,
EQUITY_WITHDRAWAL_AMOUNT_VALIDATION,
EQUITY_WITHDRAWAL_CALCULATE_EQUITY,
EQUITY_WITHDRAWAL_MODEL_OWNER_CHECK,
EQUITY_WITHDRAWAL_TRANSFER_OUT_FAILED,
LIQUIDATE_ACCUMULATED_BORROW_BALANCE_CALCULATION_FAILED,
LIQUIDATE_ACCUMULATED_SUPPLY_BALANCE_CALCULATION_FAILED_BORROWER_COLLATERAL_ASSET,
LIQUIDATE_ACCUMULATED_SUPPLY_BALANCE_CALCULATION_FAILED_LIQUIDATOR_COLLATERAL_ASSET,
LIQUIDATE_AMOUNT_SEIZE_CALCULATION_FAILED,
LIQUIDATE_BORROW_DENOMINATED_COLLATERAL_CALCULATION_FAILED,
LIQUIDATE_CLOSE_AMOUNT_TOO_HIGH,
LIQUIDATE_DISCOUNTED_REPAY_TO_EVEN_AMOUNT_CALCULATION_FAILED,
LIQUIDATE_NEW_BORROW_INDEX_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_BORROW_INDEX_CALCULATION_FAILED_COLLATERAL_ASSET,
LIQUIDATE_NEW_BORROW_RATE_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_SUPPLY_INDEX_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_SUPPLY_INDEX_CALCULATION_FAILED_COLLATERAL_ASSET,
LIQUIDATE_NEW_SUPPLY_RATE_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_BORROW_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_CASH_CALCULATION_FAILED_BORROWED_ASSET,
LIQUIDATE_NEW_TOTAL_SUPPLY_BALANCE_CALCULATION_FAILED_BORROWER_COLLATERAL_ASSET,
LIQUIDATE_NEW_TOTAL_SUPPLY_BALANCE_CALCULATION_FAILED_LIQUIDATOR_COLLATERAL_ASSET,
LIQUIDATE_TRANSFER_IN_FAILED,
LIQUIDATE_TRANSFER_IN_NOT_POSSIBLE,
REPAY_BORROW_NEW_BORROW_INDEX_CALCULATION_FAILED,
REPAY_BORROW_NEW_BORROW_RATE_CALCULATION_FAILED,
REPAY_BORROW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
REPAY_BORROW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
REPAY_BORROW_NEW_TOTAL_BORROW_CALCULATION_FAILED,
REPAY_BORROW_NEW_TOTAL_CASH_CALCULATION_FAILED,
REPAY_BORROW_TRANSFER_IN_FAILED,
REPAY_BORROW_TRANSFER_IN_NOT_POSSIBLE,
SET_ADMIN_OWNER_CHECK,
SET_ASSET_PRICE_CHECK_ORACLE,
SET_MARKET_INTEREST_RATE_MODEL_OWNER_CHECK,
SET_ORACLE_OWNER_CHECK,
SET_ORIGINATION_FEE_OWNER_CHECK,
SET_RISK_PARAMETERS_OWNER_CHECK,
SET_RISK_PARAMETERS_VALIDATION,
SUPPLY_ACCUMULATED_BALANCE_CALCULATION_FAILED,
SUPPLY_MARKET_NOT_SUPPORTED,
SUPPLY_NEW_BORROW_INDEX_CALCULATION_FAILED,
SUPPLY_NEW_BORROW_RATE_CALCULATION_FAILED,
SUPPLY_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
SUPPLY_NEW_SUPPLY_RATE_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_CASH_CALCULATION_FAILED,
SUPPLY_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,
SUPPLY_TRANSFER_IN_FAILED,
SUPPLY_TRANSFER_IN_NOT_POSSIBLE,
SUPPORT_MARKET_OWNER_CHECK,
SUPPORT_MARKET_PRICE_CHECK,
SUSPEND_MARKET_OWNER_CHECK,
WITHDRAW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED,
WITHDRAW_ACCOUNT_SHORTFALL_PRESENT,
WITHDRAW_ACCUMULATED_BALANCE_CALCULATION_FAILED,
WITHDRAW_AMOUNT_LIQUIDITY_SHORTFALL,
WITHDRAW_AMOUNT_VALUE_CALCULATION_FAILED,
WITHDRAW_CAPACITY_CALCULATION_FAILED,
WITHDRAW_NEW_BORROW_INDEX_CALCULATION_FAILED,
WITHDRAW_NEW_BORROW_RATE_CALCULATION_FAILED,
WITHDRAW_NEW_SUPPLY_INDEX_CALCULATION_FAILED,
WITHDRAW_NEW_SUPPLY_RATE_CALCULATION_FAILED,
WITHDRAW_NEW_TOTAL_BALANCE_CALCULATION_FAILED,
WITHDRAW_NEW_TOTAL_SUPPLY_CALCULATION_FAILED,
WITHDRAW_TRANSFER_OUT_FAILED,
WITHDRAW_TRANSFER_OUT_NOT_POSSIBLE
}
function fail(Error err, FailureInfo info) internal returns (uint256) {
emit Failure(uint256(err), uint256(info), 0);
return uint256(err);
}
function failOpaque(FailureInfo info, uint256 opaqueError) internal returns (uint256) {
emit Failure(uint256(Error.OPAQUE_ERROR), uint256(info), opaqueError);
return uint256(Error.OPAQUE_ERROR);
}
}
contract CarefulMath is ErrorReporter {
function mul(uint256 a, uint256 b) internal pure returns (Error, uint256) {
if (a == 0) {
return (Error.NO_ERROR, 0);
}
uint256 c = a * b;
if (c / a != b) {
return (Error.INTEGER_OVERFLOW, 0);
} else {
return (Error.NO_ERROR, c);
}
}
function div(uint256 a, uint256 b) internal pure returns (Error, uint256) {
if (b == 0) {
return (Error.DIVISION_BY_ZERO, 0);
}
return (Error.NO_ERROR, a / b);
}
function sub(uint256 a, uint256 b) internal pure returns (Error, uint256) {
if (b <= a) {
return (Error.NO_ERROR, a - b);
} else {
return (Error.INTEGER_UNDERFLOW, 0);
}
}
function add(uint256 a, uint256 b) internal pure returns (Error, uint256) {
uint256 c = a + b;
if (c >= a) {
return (Error.NO_ERROR, c);
} else {
return (Error.INTEGER_OVERFLOW, 0);
}
}
function addThenSub(uint256 a,
uint256 b,
uint256 c) internal pure returns (Error, uint256) {
(Error err0, uint256 sum) = add(a, b);
if (err0 != Error.NO_ERROR) {
return (err0, 0);
}
return sub(sum, c);
}
}
contract Exponential is ErrorReporter, CarefulMath {
// TODO: We may wish to put the result of 10**18 here instead of the expression.
// Per https://solidity.readthedocs.io/en/latest/contracts.html#constant-state-variables
// the optimizer MAY replace the expression 10**18 with its calculated value.
uint256 constant expScale = 10**18;
// See TODO on expScale
uint256 constant halfExpScale = expScale / 2;
struct Exp {
uint256 mantissa;
}
uint256 constant mantissaOne = 10**18;
uint256 constant mantissaOneTenth = 10**17;
function getExp(uint256 num, uint256 denom) internal pure returns (Error, Exp memory) {
(Error err0, uint256 scaledNumerator) = mul(num, expScale);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
(Error err1, uint256 rational) = div(scaledNumerator, denom);
if (err1 != Error.NO_ERROR) {
return (err1, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: rational}));
}
function addExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
(Error error, uint256 result) = add(a.mantissa, b.mantissa);
return (error, Exp({mantissa: result}));
}
function subExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
(Error error, uint256 result) = sub(a.mantissa, b.mantissa);
return (error, Exp({mantissa: result}));
}
function mulScalar(Exp memory a, uint256 scalar) internal pure returns (Error, Exp memory) {
(Error err0, uint256 scaledMantissa) = mul(a.mantissa, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: scaledMantissa}));
}
function divScalar(Exp memory a, uint256 scalar) internal pure returns (Error, Exp memory) {
(Error err0, uint256 descaledMantissa) = div(a.mantissa, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return (Error.NO_ERROR, Exp({mantissa: descaledMantissa}));
}
function divScalarByExp(uint256 scalar, Exp memory divisor) internal pure returns (Error, Exp memory) {
(Error err0, uint256 numerator) = mul(expScale, scalar);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
return getExp(numerator, divisor.mantissa);
}
function mulExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
(Error err0, uint256 doubleScaledProduct) = mul(a.mantissa, b.mantissa);
if (err0 != Error.NO_ERROR) {
return (err0, Exp({mantissa: 0}));
}
// We add half the scale before dividing so that we get rounding instead of truncation.
// See "Listing 6" and text above it at https://accu.org/index.php/journals/1717
(Error err1, uint256 doubleScaledProductWithHalfScale) = add(halfExpScale, doubleScaledProduct);
if (err1 != Error.NO_ERROR) {
return (err1, Exp({mantissa: 0}));
}
(Error err2, uint256 product) = div(doubleScaledProductWithHalfScale, expScale);
assert(err2 == Error.NO_ERROR);
return (Error.NO_ERROR, Exp({mantissa: product}));
}
function divExp(Exp memory a, Exp memory b) internal pure returns (Error, Exp memory) {
return getExp(a.mantissa, b.mantissa);
}
function truncate(Exp memory exp) internal pure returns (uint256) {
// Note: We are not using careful math here as we're performing a division that cannot fail
return exp.mantissa / 10**18;
}
function lessThanExp(Exp memory left, Exp memory right) internal pure returns (bool) {
return left.mantissa < right.mantissa; //TODO: Add some simple tests and this in another PR yo.
}
function lessThanOrEqualExp(Exp memory left, Exp memory right) internal pure returns (bool) {
return left.mantissa <= right.mantissa;
}
function greaterThanExp(Exp memory left, Exp memory right) internal pure returns (bool) {
return left.mantissa > right.mantissa;
}
function isZeroExp(Exp memory value) internal pure returns (bool) {
return value.mantissa == 0;
}
}
contract PriceOracleV1 is Exponential {
bool public paused;
uint256 public constant oneHour = 3600; // 1 hour
uint256 public constant maxSwingMantissa = (10**17); // 0.1
mapping(address => Exp) public _assetPrices;
constructor(address _poster) public {
anchorAdmin = msg.sender;
poster = _poster;
maxSwing = Exp({mantissa: maxSwingMantissa});
}
function() external payable {
revert();
}
enum OracleError {
NO_ERROR,
UNAUTHORIZED,
FAILED_TO_SET_PRICE
}
enum OracleFailureInfo {
ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK,
SET_PAUSED_OWNER_CHECK,
SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK,
SET_PENDING_ANCHOR_PERMISSION_CHECK,
SET_PRICE_CALCULATE_SWING,
SET_PRICE_CAP_TO_MAX,
SET_PRICE_MAX_SWING_CHECK,
SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO,
SET_PRICE_PERMISSION_CHECK,
SET_PRICE_ZERO_PRICE,
SET_PRICES_PARAM_VALIDATION
}
event OracleFailure(address msgSender, address asset, uint256 error, uint256 info, uint256 detail);
function failOracle(address asset,
OracleError err,
OracleFailureInfo info) internal returns (uint256) {
emit OracleFailure(msg.sender, asset, uint256(err), uint256(info), 0);
return uint256(err);
}
function failOracleWithDetails(address asset,
OracleError err,
OracleFailureInfo info,
uint256 details) internal returns (uint256) {
emit OracleFailure(msg.sender, asset, uint256(err), uint256(info), details);
return uint256(err);
}
address public anchorAdmin;
address public pendingAnchorAdmin;
address public poster;
Exp public maxSwing;
struct Anchor {
// floor(block.timestamp / oneHour) + 1
uint256 period;
// Price in ETH, scaled by 10**18
uint256 priceMantissa;
}
mapping(address => Anchor) public anchors;
mapping(address => uint256) public pendingAnchors;
event NewPendingAnchor(address anchorAdmin, address asset, uint256 oldScaledPrice, uint256 newScaledPrice);
function _setPendingAnchor(address asset, uint256 newScaledPrice) public returns (uint256) {
if (msg.sender != anchorAdmin) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PENDING_ANCHOR_PERMISSION_CHECK);
}
uint256 oldScaledPrice = pendingAnchors[asset];
pendingAnchors[asset] = newScaledPrice;
emit NewPendingAnchor(msg.sender, asset, oldScaledPrice, newScaledPrice);
return uint256(OracleError.NO_ERROR);
}
event PricePosted(address asset,
uint256 previousPriceMantissa,
uint256 requestedPriceMantissa,
uint256 newPriceMantissa);
event CappedPricePosted(address asset,
uint256 requestedPriceMantissa,
uint256 anchorPriceMantissa,
uint256 cappedPriceMantissa);
event SetPaused(bool newState);
event NewPendingAnchorAdmin(address oldPendingAnchorAdmin, address newPendingAnchorAdmin);
event NewAnchorAdmin(address oldAnchorAdmin, address newAnchorAdmin);
function _setPaused(bool requestedState) public returns (uint256) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return failOracle(address(0), OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PAUSED_OWNER_CHECK);
}
paused = requestedState;
emit SetPaused(requestedState);
return uint256(Error.NO_ERROR);
}
function _setPendingAnchorAdmin(address newPendingAnchorAdmin) public returns (uint256) {
// Check caller = anchorAdmin
if (msg.sender != anchorAdmin) {
return
failOracle(address(0),
OracleError.UNAUTHORIZED,
OracleFailureInfo.SET_PENDING_ANCHOR_ADMIN_OWNER_CHECK);
}
// save current value, if any, for inclusion in log
address oldPendingAnchorAdmin = pendingAnchorAdmin;
// Store pendingAdmin = newPendingAdmin
pendingAnchorAdmin = newPendingAnchorAdmin;
emit NewPendingAnchorAdmin(oldPendingAnchorAdmin, newPendingAnchorAdmin);
return uint256(Error.NO_ERROR);
}
function _acceptAnchorAdmin() public returns (uint256) {
// Check caller = pendingAnchorAdmin
// msg.sender can't be zero
if (msg.sender != pendingAnchorAdmin) {
return
failOracle(address(0),
OracleError.UNAUTHORIZED,
OracleFailureInfo.ACCEPT_ANCHOR_ADMIN_PENDING_ANCHOR_ADMIN_CHECK);
}
// Save current value for inclusion in log
address oldAnchorAdmin = anchorAdmin;
// Store admin = pendingAnchorAdmin
anchorAdmin = pendingAnchorAdmin;
// Clear the pending value
pendingAnchorAdmin = address(0);
emit NewAnchorAdmin(oldAnchorAdmin, msg.sender);
return uint256(Error.NO_ERROR);
}
function assetPrices(address asset) public view returns (uint256) {
// Note: zero is treated by the money market as an invalid
// price and will cease operations with that asset
// when zero.
//
// We get the price as:
//
// 1. If the contract is paused, return 0.
// 2. Return price in `_assetPrices`, which may be zero.
if (paused) {
return 0;
}
return _assetPrices[asset].mantissa;
}
function getPrice(address asset) public view returns (uint256) {
return assetPrices(asset);
}
struct SetPriceLocalVars {
Exp price;
Exp swing;
Exp anchorPrice;
uint256 anchorPeriod;
uint256 currentPeriod;
bool priceCapped;
uint256 cappingAnchorPriceMantissa;
uint256 pendingAnchorMantissa;
}
function setPrice(address asset, uint256 requestedPriceMantissa) public returns (uint256) {
// Fail when msg.sender is not poster
if (msg.sender != poster) {
return failOracle(asset, OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
}
return setPriceInternal(asset, requestedPriceMantissa);
}
function setPriceInternal(address asset, uint256 requestedPriceMantissa) internal returns (uint256) {
// re-used for intermediate errors
Error err;
SetPriceLocalVars memory localVars;
// (It can be a problem in tests with low block timestamp.)
localVars.currentPeriod = (block.timestamp / oneHour) + 1;
localVars.pendingAnchorMantissa = pendingAnchors[asset];
localVars.price = Exp({mantissa: requestedPriceMantissa});
if (localVars.pendingAnchorMantissa != 0) {
// let's explicitly set to 0 rather than relying on default of declaration
localVars.anchorPeriod = 0;
localVars.anchorPrice = Exp({mantissa: localVars.pendingAnchorMantissa});
// Verify movement is within max swing of pending anchor (currently: 10%)
(err, localVars.swing) = calculateSwing(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return
failOracleWithDetails(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_CALCULATE_SWING,
uint256(err));
}
// Fail when swing > maxSwing
if (greaterThanExp(localVars.swing, maxSwing)) {
return
failOracleWithDetails(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_MAX_SWING_CHECK,
localVars.swing.mantissa);
}
} else {
localVars.anchorPeriod = anchors[asset].period;
localVars.anchorPrice = Exp({mantissa: anchors[asset].priceMantissa});
if (localVars.anchorPeriod != 0) {
(err, localVars.priceCapped, localVars.price) = capToMax(localVars.anchorPrice, localVars.price);
if (err != Error.NO_ERROR) {
return
failOracleWithDetails(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_CAP_TO_MAX,
uint256(err));
}
if (localVars.priceCapped) {
// save for use in log
localVars.cappingAnchorPriceMantissa = localVars.anchorPrice.mantissa;
}
} else {
localVars.anchorPrice = Exp({mantissa: requestedPriceMantissa});
}
}
// Fail if anchorPrice or price is zero.
// zero anchor represents an unexpected situation likely due to a problem in this contract
// zero price is more likely as the result of bad input from the caller of this function
if (isZeroExp(localVars.anchorPrice)) {
return
failOracle(asset,
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICE_NO_ANCHOR_PRICE_OR_INITIAL_PRICE_ZERO);
}
if (isZeroExp(localVars.price)) {
return failOracle(asset, OracleError.FAILED_TO_SET_PRICE, OracleFailureInfo.SET_PRICE_ZERO_PRICE);
}
// BEGIN SIDE EFFECTS
// Set pendingAnchor = Nothing
// Pending anchor is only used once.
if (pendingAnchors[asset] != 0) {
pendingAnchors[asset] = 0;
}
// If currentPeriod > anchorPeriod:
// Set anchors[asset] = (currentPeriod, price)
if (localVars.currentPeriod > localVars.anchorPeriod) {
anchors[asset] = Anchor({period: localVars.currentPeriod, priceMantissa: localVars.price.mantissa});
}
uint256 previousPrice = _assetPrices[asset].mantissa;
setPriceStorageInternal(asset, localVars.price.mantissa);
emit PricePosted(asset, previousPrice, requestedPriceMantissa, localVars.price.mantissa);
if (localVars.priceCapped) {
// We have set a capped price. Log it so we can detect the situation and investigate.
emit CappedPricePosted(asset,
requestedPriceMantissa,
localVars.cappingAnchorPriceMantissa,
localVars.price.mantissa);
}
return uint256(OracleError.NO_ERROR);
}
// As a function to allow harness overrides
function setPriceStorageInternal(address asset, uint256 priceMantissa) internal {
_assetPrices[asset] = Exp({mantissa: priceMantissa});
}
// abs(price - anchorPrice) / anchorPrice
function calculateSwing(Exp memory anchorPrice, Exp memory price) internal pure returns (Error, Exp memory) {
Exp memory numerator;
Error err;
if (greaterThanExp(anchorPrice, price)) {
(err, numerator) = subExp(anchorPrice, price);
// can't underflow
assert(err == Error.NO_ERROR);
} else {
(err, numerator) = subExp(price, anchorPrice);
// Given greaterThan check above, price >= anchorPrice so can't underflow.
assert(err == Error.NO_ERROR);
}
return divExp(numerator, anchorPrice);
}
function capToMax(Exp memory anchorPrice, Exp memory price)
internal
view
returns (Error,
bool,
Exp memory)
{
Exp memory one = Exp({mantissa: mantissaOne});
Exp memory onePlusMaxSwing;
Exp memory oneMinusMaxSwing;
Exp memory max;
Exp memory min;
// re-used for intermediate errors
Error err;
(err, onePlusMaxSwing) = addExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa: 0}));
}
// max = anchorPrice * (1 + maxSwing)
(err, max) = mulExp(anchorPrice, onePlusMaxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa: 0}));
}
// If price > anchorPrice * (1 + maxSwing)
// Set price = anchorPrice * (1 + maxSwing)
if (greaterThanExp(price, max)) {
return (Error.NO_ERROR, true, max);
}
(err, oneMinusMaxSwing) = subExp(one, maxSwing);
if (err != Error.NO_ERROR) {
return (err, false, Exp({mantissa: 0}));
}
// min = anchorPrice * (1 - maxSwing)
(err, min) = mulExp(anchorPrice, oneMinusMaxSwing);
// We can't overflow here or we would have already overflowed above when calculating `max`
assert(err == Error.NO_ERROR);
// If price < anchorPrice * (1 - maxSwing)
// Set price = anchorPrice * (1 - maxSwing)
if (lessThanExp(price, min)) {
return (Error.NO_ERROR, true, min);
}
return (Error.NO_ERROR, false, price);
}
function setPrices(address[] memory assets, uint256[] memory requestedPriceMantissas)
public
returns (uint256[] memory)
{
uint256 numAssets = assets.length;
uint256 numPrices = requestedPriceMantissas.length;
uint256[] memory result;
// Fail when msg.sender is not poster
if (msg.sender != poster) {
result = new uint256[](1);
result[0] = failOracle(address(0), OracleError.UNAUTHORIZED, OracleFailureInfo.SET_PRICE_PERMISSION_CHECK);
return result;
}
if ((numAssets == 0) || (numPrices != numAssets)) {
result = new uint256[](1);
result[0] = failOracle(address(0),
OracleError.FAILED_TO_SET_PRICE,
OracleFailureInfo.SET_PRICES_PARAM_VALIDATION);
return result;
}
result = new uint256[](numAssets);
for (uint256 i = 0; i < numAssets; i++) {
result[i] = setPriceInternal(assets[i], requestedPriceMantissas[i]);
}
return result;
}
}
| 152,745 | 1,554 |
72e97f0129537fcfd5466a277cb6b7310b6566ee96ed14efc7147b3b0174b368
| 16,718 |
.sol
|
Solidity
| false |
374578960
|
azerpas/prescurity-blockchain
|
17902632ce8e90fe3c80cbe4b7643338311a8d7c
|
contracts/Prescurity.sol
| 2,922 | 12,113 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
pragma experimental ABIEncoderV2;
/// @title Prescurity, a healt smart contract to create digital medical prescriptions
/// @author Anthony @azerpas, Yann @Xihiems, Martin @MartinLenaerts
/// @notice This contract helps the Doctor, Pharmacist and patient to interact
contract Prescurity {
address private _owner;
uint private _doctorId;
uint private _pharmacyId;
uint private _prescriptionId;
struct Patient {
uint numero_secu;
address patientAddress;
uint[] prescriptionsIds;
bool isValue;
}
struct Doctor {
uint id;
string speciality;
string name;
address payable doctorAddress;
uint[] prescriptionsIds;
bool isValue;
}
struct Pharmacy {
uint id;
string name;
address pharmacyAddress;
bool isValue;
}
struct Prescription {
uint id;
uint patientId;
uint doctorId;
string medicine;
string disease;
string frequency;
uint256 startTimestamp;
uint256 endTimestamp;
uint dueToDoctor;
bool claimed;
bool paid;
}
/// @notice initialize the smart contract by setting the owner to the deployer
constructor() public {
_setOwner(msg.sender);
_setDoctorId(1);
_setPharmacyId(1);
_setPrescriptionId(1);
}
enum authentification {
anon,
patient,
doctor,
pharmacy
}
mapping (uint => Patient) patientNumSecuMap;
mapping(address => Patient) patientAddressMap;
mapping (address => authentification) patientAuthentification;
mapping (uint => Doctor) doctorIdMap;
mapping (address => Doctor) doctorAddressMap;
mapping (address => authentification) doctorAuthentification;
mapping (uint => Pharmacy) pharmacyIdMap;
mapping (address => Pharmacy) pharmacyAddressMap;
mapping (address => authentification) pharmacyAuthentification;
mapping (uint => Prescription) prescriptionIdMap;
modifier patientOnly() {
if (patientAuthentification[msg.sender] == authentification.patient) {
_;
} else {
revert("Sorry, this function is reserved to the patient");
}
}
modifier doctorOnly() {
if (doctorAuthentification[msg.sender] == authentification.doctor) {
_;
} else {
revert("Sorry, this function is reserved to the doctor");
}
}
modifier pharmacyOnly(){
if (pharmacyAuthentification[msg.sender] == authentification.pharmacy) {
_;
} else {
revert("Sorry, this function is reserved to the pharmacy");
}
}
modifier ownerOnly(){
if (getOwner() == msg.sender) {
_;
} else {
revert("Sorry, this function is reserved to the owner of the smart contract");
}
}
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len;
while (_i != 0) {
k = k-1;
uint8 temp = (48 + uint8(_i - _i / 10 * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
function append(string memory a, string memory b) internal pure returns (string memory) {
return string(abi.encodePacked(a, b));
}
function getOwner() public view returns (address) {
return _owner;
}
function getDoctorId() internal returns (uint) {
return _doctorId++;
}
function getPrescriptionId() internal returns (uint) {
return _prescriptionId++;
}
function getUserType() view public returns (string memory) {
if (doctorAuthentification[msg.sender] == authentification.doctor) {
return "doctor";
}
if (pharmacyAuthentification[msg.sender] == authentification.pharmacy) {
return "pharmacy";
}
if (patientAuthentification[msg.sender] == authentification.patient) {
return "patient";
}
if(msg.sender == getOwner()){
return "owner";
}
return "none";
}
function addDoctor(address payable addr, string calldata name, string calldata speciality) external ownerOnly {
require(doctorAuthentification[addr] != authentification.doctor, "This address is already defined as a doctor");
require(pharmacyAuthentification[addr] != authentification.pharmacy, "This address is already defined as a doctor");
uint id = getDoctorId();
doctorIdMap[id].id = id;
doctorIdMap[id].speciality = speciality;
doctorIdMap[id].name = name;
doctorIdMap[id].doctorAddress = addr;
doctorIdMap[id].isValue = true;
doctorAddressMap[addr].id = id;
doctorAuthentification[addr] = authentification.doctor;
}
function addPharmacy(address addr, string calldata name) external ownerOnly {
require(pharmacyAuthentification[addr] != authentification.pharmacy, "This address is already defined as a doctor");
require(doctorAuthentification[addr] != authentification.doctor, "This address is already defined as a doctor");
uint id = getDoctorId();
pharmacyIdMap[id].id = id;
pharmacyIdMap[id].name = name;
pharmacyIdMap[id].pharmacyAddress = addr;
pharmacyIdMap[id].isValue = true;
pharmacyAddressMap[addr].id = id;
pharmacyAuthentification[addr] = authentification.pharmacy;
}
function addPatient(uint numero_secu, address addr) external {
require(!patientNumSecuMap[numero_secu].isValue, "This num secu is already defined as a patient");
patientNumSecuMap[numero_secu].numero_secu = numero_secu;
patientNumSecuMap[numero_secu].isValue = true;
patientNumSecuMap[numero_secu].patientAddress = addr;
patientAddressMap[addr].numero_secu = numero_secu;
patientAuthentification[addr] = authentification.patient;
}
function addPrescription(uint amountAskedByDoctor, uint numero_secu, string calldata medicine, string calldata disease, string calldata frequency) external doctorOnly {
uint doctorId = doctorAddressMap[msg.sender].id;
// We first fetch the doctor id from the msg.sender then get the doctor object mapped by the ID.
Doctor storage doctor = doctorIdMap[doctorId];
Patient storage patient = patientNumSecuMap[numero_secu];
uint prescriptionId = getPrescriptionId();
patient.prescriptionsIds.push(prescriptionId);
doctor.prescriptionsIds.push(prescriptionId);
prescriptionIdMap[prescriptionId].id = prescriptionId;
prescriptionIdMap[prescriptionId].claimed = false;
prescriptionIdMap[prescriptionId].paid = false;
prescriptionIdMap[prescriptionId].patientId = numero_secu;
prescriptionIdMap[prescriptionId].doctorId = doctor.id;
prescriptionIdMap[prescriptionId].medicine = medicine;
prescriptionIdMap[prescriptionId].frequency = frequency;
prescriptionIdMap[prescriptionId].disease = disease;
prescriptionIdMap[prescriptionId].dueToDoctor = amountAskedByDoctor;
prescriptionIdMap[prescriptionId].startTimestamp = block.timestamp;
prescriptionIdMap[prescriptionId].endTimestamp = block.timestamp + 93 days;
emit Consultation(prescriptionIdMap[prescriptionId], patient, doctor, amountAskedByDoctor);
}
function payPrescription(uint prescriptionId) payable external patientOnly {
require(address(this).balance >= msg.value, "Balance is not enough");
require(!prescriptionIdMap[prescriptionId].paid, "Prescription should not be paid");
Prescription storage prescription = prescriptionIdMap[prescriptionId];
Doctor storage doctor = doctorIdMap[prescription.doctorId];
address payable doctorAddr = doctor.doctorAddress;
doctorAddr.transfer(msg.value);
emit DoctorPaid(msg.value, doctor.doctorAddress, msg.sender, prescription.doctorId);
prescriptionIdMap[prescriptionId].paid = true;
}
function claimPrescription(uint prescriptionId) external pharmacyOnly {
require(prescriptionIdMap[prescriptionId].claimed == false, "This presciption is already claimed");
Prescription storage prescription = prescriptionIdMap[prescriptionId];
Patient storage patient = patientNumSecuMap[prescription.patientId];
prescriptionIdMap[prescriptionId].claimed = true;
emit PharmaClaimed(prescription, msg.sender, patient);
}
function showPrescriptionPatient(uint numSecuPatient) view public returns(Prescription[] memory){
require(numSecuPatient > 100000000000000 && numSecuPatient < 999999999999999, "Numero de securite require 15 numbers");
Patient storage patient = patientNumSecuMap[numSecuPatient];
uint len=5;
if(patient.prescriptionsIds.length < len){
len = patient.prescriptionsIds.length;
}
Prescription[] memory prescriptions = new Prescription[](len);
for(uint i=0; i < len; i++){
Prescription storage prescription = prescriptionIdMap[patient.prescriptionsIds[len-1-i]];
prescriptions[i] = prescription;
}
return prescriptions;
}
function getLastDoctorPrescriptions(uint amountOfPrescriptions) view public doctorOnly returns(Prescription[] memory){
require(amountOfPrescriptions > 0 && amountOfPrescriptions < 25, "Please input an amount of prescriptions between 0 and 25");
uint doctorId = doctorAddressMap[msg.sender].id;
Doctor storage doctor = doctorIdMap[doctorId];
uint len = amountOfPrescriptions;
if(doctor.prescriptionsIds.length < len){
len = doctor.prescriptionsIds.length;
}
Prescription[] memory prescriptions = new Prescription[](len);
for(uint i=0; i < len; i++){
Prescription storage prescription = prescriptionIdMap[doctor.prescriptionsIds[len-1-i]];
prescriptions[i] = prescription;
}
return prescriptions;
}
function getPrescription(uint idprescription) view public doctorOnly returns(Prescription memory) {
return prescriptionIdMap[idprescription];
}
function _setOwner(address new_owner) private {
address old_owner = _owner;
_owner = new_owner;
emit DefineOwnership(old_owner, new_owner);
}
function getDoctor(uint iddoctor) view public returns(Doctor memory) {
Doctor storage doctor= doctorIdMap[iddoctor];
return doctor;
}
function getPatient(uint numPatient) view public returns(Patient memory) {
Patient storage patient = patientNumSecuMap[numPatient];
return patient;
}
function getPatientAddress(address patientaddress) view public returns(Patient memory) {
Patient storage patient = patientAddressMap[patientaddress];
return patient;
}
function _setDoctorId(uint index) private {
_doctorId = index;
}
function _setPharmacyId(uint index) private {
_pharmacyId = index;
}
function _setPrescriptionId(uint index) private {
_prescriptionId = index;
}
event prescriptionsShow(Prescription[] prescription);
event PharmaClaimed(Prescription prescription,address indexed pharmaaddress,Patient patient);
event DefineOwnership(address indexed old_owner, address indexed new_owner);
event Consultation(Prescription prescription, Patient patient, Doctor doctor, uint amount);
event DoctorPaid(uint amount, address indexed doctorAddress, address indexed patientAddress, uint doctorId);
event RetrieveMedicaments(Patient patient, Pharmacy pharmacy, Prescription prescription);
}
| 139,901 | 1,555 |
60d47f48231b9fb680896274f1690eb847c9ff66f0be781e018c97d26aa3f397
| 39,027 |
.sol
|
Solidity
| false |
635617544
|
0xblackskull/OpenZeppelin-Flattened
|
bef0a34f7a2402d302f91f7bccf2d2e153ebea6b
|
ozopenzeppelin-contracts/token/ERC1155/extensions/ERC1155Pausable_flat.sol
| 4,680 | 18,949 |
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/ERC1155Pausable.sol)
pragma solidity ^0.8.0;
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/ERC1155.sol)
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data) external;
function safeBatchTransferFrom(address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data) external;
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
interface IERC1155Receiver is IERC165 {
function onERC1155Received(address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data) external returns (bytes4);
function onERC1155BatchReceived(address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data) external returns (bytes4);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved");
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) public virtual override {
require(from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved");
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address to,
uint256 id,
uint256 amount,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address from,
uint256 id,
uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(address from,
uint256[] memory ids,
uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(address owner,
address operator,
bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _afterTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual {}
function _doSafeTransferAcceptanceCheck(address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC1155Pausable is ERC1155, Pausable {
function _beforeTokenTransfer(address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data) internal virtual override {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
require(!paused(), "ERC1155Pausable: token transfer while paused");
}
}
| 63,538 | 1,556 |
ffb7e37ca2c64d76e44b57dd5d56bed937e94d96130884493a2a44963c766831
| 35,828 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/06/0635dabdf471c4c1bd72d4a58a0a0ee32915525c_Token.sol
| 3,883 | 14,935 |
pragma solidity ^0.6.12;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Mintable is Context {
address private _minter;
event MintershipTransferred(address indexed previousMinter, address indexed newMinter);
constructor () internal {
address msgSender = _msgSender();
_minter = msgSender;
emit MintershipTransferred(address(0), msgSender);
}
function minter() public view returns (address) {
return _minter;
}
modifier onlyMinter() {
require(_minter == _msgSender(), "Mintable: caller is not the minter");
_;
}
function transferMintership(address newMinter) public virtual onlyMinter {
require(newMinter != address(0), "Mintable: new minter is the zero address");
emit MintershipTransferred(_minter, newMinter);
_minter = newMinter;
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint256 private _burnedSupply;
uint256 private _burnRate;
string private _name;
string private _symbol;
uint256 private _decimals;
constructor (string memory name, string memory symbol, uint256 decimals, uint256 burnrate, uint256 initSupply) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
_burnRate = burnrate;
_totalSupply = 0;
_mint(msg.sender, initSupply*(10**_decimals));
_burnedSupply = 0;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint256) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function burnedSupply() public view returns (uint256) {
return _burnedSupply;
}
function burnRate() public view returns (uint256) {
return _burnRate;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function burn(uint256 amount) public virtual returns (bool) {
_burn(_msgSender(), amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 amount_burn = amount.mul(_burnRate).div(100);
uint256 amount_send = amount.sub(amount_burn);
require(amount == amount_send + amount_burn, "Burn value invalid");
_burn(sender, amount_burn);
amount = amount_send;
_beforeTokenTransfer(sender, recipient, amount);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
_burnedSupply = _burnedSupply.add(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _setupBurnrate(uint8 burnrate_) internal virtual {
_burnRate = burnrate_;
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
// STABLECOINToken with Governance.
// ERC20 (name, symbol, decimals, burnrate, initSupply)
contract Token is ERC20("STABLECOIN", "STABLE", 18, 0, 1200), Ownable, Mintable {
function mint(address _to, uint256 _amount) public onlyOwner {
_mint(_to, _amount);
}
function setupBurnrate(uint8 burnrate_) public onlyOwner {
_setupBurnrate(burnrate_);
}
}
| 333,877 | 1,557 |
ef245bda71c90c27f56b7963945fc1ffe973e39b3fd8b98fe8e4da5c7483aba8
| 12,572 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x4c9d38b4e71de67e680f318a1268e18d1d946c04.sol
| 3,280 | 11,884 |
pragma solidity ^0.4.25;
contract CryptoMinirToken {
modifier onlyBagholders {
require(myTokens() > 0);
_;
}
modifier onlyStronghands {
require(myDividends(true) > 0);
_;
}
event onTokenPurchase(address indexed customerAddress,
uint256 incomingEthereum,
uint256 tokensMinted,
address indexed referredBy,
uint timestamp,
uint256 price);
event onTokenSell(address indexed customerAddress,
uint256 tokensBurned,
uint256 ethereumEarned,
uint timestamp,
uint256 price);
event onReinvestment(address indexed customerAddress,
uint256 ethereumReinvested,
uint256 tokensMinted);
event onWithdraw(address indexed customerAddress,
uint256 ethereumWithdrawn);
event Transfer(address indexed from,
address indexed to,
uint256 tokens);
string public name = "Crypto Minir Token";
string public symbol = "CMT";
uint8 constant public decimals = 18;
uint8 constant internal entryFee_ = 10;
uint8 constant internal transferFee_ = 1;
uint8 constant internal exitFee_ = 4;
uint8 constant internal refferalFee_ = 33;
uint256 constant internal tokenPriceInitial_ = 0.0000001 ether;
uint256 constant internal tokenPriceIncremental_ = 0.00000001 ether;
uint256 constant internal magnitude = 2 ** 64;
uint256 public stakingRequirement = 50e18;
mapping(address => uint256) internal tokenBalanceLedger_;
mapping(address => uint256) internal referralBalance_;
mapping(address => int256) internal payoutsTo_;
uint256 internal tokenSupply_;
uint256 internal profitPerShare_;
function buy(address _referredBy) public payable returns (uint256) {
purchaseTokens(msg.value, _referredBy);
}
function() payable public {
purchaseTokens(msg.value, 0x0);
}
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
function exit() public {
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if (_tokens > 0) sell(_tokens);
withdraw();
}
function withdraw() onlyStronghands public {
address _customerAddress = msg.sender;
uint256 _dividends = myDividends(false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
_customerAddress.transfer(_dividends);
emit onWithdraw(_customerAddress, _dividends);
}
function sell(uint256 _amountOfTokens) onlyBagholders public {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
uint256 _tokens = _amountOfTokens;
uint256 _ethereum = tokensToEthereum_(_tokens);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokens);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _tokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _tokens + (_taxedEthereum * magnitude));
payoutsTo_[_customerAddress] -= _updatedPayouts;
if (tokenSupply_ > 0) {
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
}
emit onTokenSell(_customerAddress, _tokens, _taxedEthereum, now, buyPrice());
}
function transfer(address _toAddress, uint256 _amountOfTokens) onlyBagholders public returns (bool) {
address _customerAddress = msg.sender;
require(_amountOfTokens <= tokenBalanceLedger_[_customerAddress]);
if (myDividends(true) > 0) {
withdraw();
}
uint256 _tokenFee = SafeMath.div(SafeMath.mul(_amountOfTokens, transferFee_), 100);
uint256 _taxedTokens = SafeMath.sub(_amountOfTokens, _tokenFee);
uint256 _dividends = tokensToEthereum_(_tokenFee);
tokenSupply_ = SafeMath.sub(tokenSupply_, _tokenFee);
tokenBalanceLedger_[_customerAddress] = SafeMath.sub(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
tokenBalanceLedger_[_toAddress] = SafeMath.add(tokenBalanceLedger_[_toAddress], _taxedTokens);
payoutsTo_[_customerAddress] -= (int256) (profitPerShare_ * _amountOfTokens);
payoutsTo_[_toAddress] += (int256) (profitPerShare_ * _taxedTokens);
profitPerShare_ = SafeMath.add(profitPerShare_, (_dividends * magnitude) / tokenSupply_);
emit Transfer(_customerAddress, _toAddress, _taxedTokens);
return true;
}
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
}
function totalSupply() public view returns (uint256) {
return tokenSupply_;
}
function myTokens() public view returns (uint256) {
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
}
function myDividends(bool _includeReferralBonus) public view returns (uint256) {
address _customerAddress = msg.sender;
return _includeReferralBonus ? dividendsOf(_customerAddress) + referralBalance_[_customerAddress] : dividendsOf(_customerAddress) ;
}
function balanceOf(address _customerAddress) public view returns (uint256) {
return tokenBalanceLedger_[_customerAddress];
}
function dividendsOf(address _customerAddress) public view returns (uint256) {
return (uint256) ((int256) (profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
function sellPrice() public view returns (uint256) {
// our calculation relies on the token supply, so we need supply. Doh.
if (tokenSupply_ == 0) {
return tokenPriceInitial_ - tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
}
function buyPrice() public view returns (uint256) {
if (tokenSupply_ == 0) {
return tokenPriceInitial_ + tokenPriceIncremental_;
} else {
uint256 _ethereum = tokensToEthereum_(1e18);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.add(_ethereum, _dividends);
return _taxedEthereum;
}
}
function calculateTokensReceived(uint256 _ethereumToSpend) public view returns (uint256) {
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereumToSpend, entryFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereumToSpend, _dividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
return _amountOfTokens;
}
function calculateEthereumReceived(uint256 _tokensToSell) public view returns (uint256) {
require(_tokensToSell <= tokenSupply_);
uint256 _ethereum = tokensToEthereum_(_tokensToSell);
uint256 _dividends = SafeMath.div(SafeMath.mul(_ethereum, exitFee_), 100);
uint256 _taxedEthereum = SafeMath.sub(_ethereum, _dividends);
return _taxedEthereum;
}
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_undividedDividends, refferalFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement) {
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
return _amountOfTokens;
}
function ethereumToTokens_(uint256 _ethereum) internal view returns (uint256) {
uint256 _tokenPriceInitial = tokenPriceInitial_ * 1e18;
uint256 _tokensReceived =
((SafeMath.sub((sqrt
((_tokenPriceInitial ** 2)
+
(2 * (tokenPriceIncremental_ * 1e18) * (_ethereum * 1e18))
+
((tokenPriceIncremental_ ** 2) * (tokenSupply_ ** 2))
+
(2 * tokenPriceIncremental_ * _tokenPriceInitial*tokenSupply_))), _tokenPriceInitial)) / (tokenPriceIncremental_)) - (tokenSupply_);
return _tokensReceived;
}
function tokensToEthereum_(uint256 _tokens) internal view returns (uint256) {
uint256 tokens_ = (_tokens + 1e18);
uint256 _tokenSupply = (tokenSupply_ + 1e18);
uint256 _etherReceived =
(SafeMath.sub((((tokenPriceInitial_ + (tokenPriceIncremental_ * (_tokenSupply / 1e18))) - tokenPriceIncremental_) * (tokens_ - 1e18)), (tokenPriceIncremental_ * ((tokens_ ** 2 - tokens_) / 1e18)) / 2)
/ 1e18);
return _etherReceived;
}
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = (x + 1) / 2;
y = x;
while (z < y) {
y = z;
z = (x / z + z) / 2;
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 200,508 | 1,558 |
2dbabf16a238b26e717b4b1da00518f0b7c1aa9575d8abded95ea6941ff3b144
| 24,455 |
.sol
|
Solidity
| false |
371975691
|
w3villa-neha/solidity
|
a9a8e9fc438fc1425af7a7dbafc9519a9f46f81f
|
tronies.sol
| 6,916 | 23,745 |
pragma solidity >=0.5.4;
contract Trontiply{
using SafeMath for uint256;
uint256 constant MIN_AMOUNT =100000000; // 100 TRX
uint256 constant BASE_PERCENT = 120; // 1.2% base profit
uint256 constant internal MILLION = 1000000; // 1 million
uint256 constant internal TIME_STAMP = 1 days; // 1 day
uint256 constant internal TRX = 1000000; // 1 trx
uint256 constant internal THOUS = 1000;
uint256 public totalUsers;
uint256 public totalInvested;
uint256 public totalWithdrawn;
uint256 public totalDeposits;
uint256 public maxBalance;
uint256 public adminWallet;
address payable internal tradingPool; //70% trading amount goes to this address
address payable internal owner;
struct Deposit {
uint256 amount;
uint256 withdrawn;
uint256 start;
bool isExpired;
}
struct User{
uint256 referrals;
Deposit[] deposits;
address referrer;
uint256 checkpoint;
uint256 weeklyLastWithdraw;
uint256 total_structure;
uint256 totalDownlineBalance;
uint256 level;
bool isExist;
uint256 totalWithdrawn_;
uint256 levelIncome;
uint256 binaryCommissionEarned;
uint256 dailyProfitEarned;
}
struct UserLevels{
uint256 level1;
uint256 level2;
uint256 level3;
uint256 level4;
uint256 level5;
uint256 level6;
uint256 level7;
uint256 level8;
uint256 level9;
uint256 level10;
}
mapping(address => User) public users;
mapping(address => UserLevels) internal usersLevels;
event Newbie(address indexed user);
event NewDeposit(address indexed user, uint256 amount);
event Withdrawn(uint256 amount, uint256 prev, uint256 curr, uint256 diff);
event binaryEvent(uint256 amount, uint256 prev, uint256 curr, uint256 diff);
constructor(address payable _tradingPool, address payable _owner) public {
require(!isContract(_tradingPool));
tradingPool = _tradingPool;
owner = _owner;
}
// function to deposit amount
function invest(address _referrer) public payable{
require(msg.value>=MIN_AMOUNT , "It should be greater than min value");
User storage user = users[msg.sender];
_referrer = setReferrer(_referrer);
users[msg.sender].referrer = _referrer;
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
user.weeklyLastWithdraw = block.timestamp;
user.level = 3;
user.isExist=true;
users[_referrer].referrals = users[_referrer].referrals.add(1);
totalUsers = totalUsers.add(1);
setUplines(msg.sender);
emit Newbie(msg.sender);
}
user.deposits.push(Deposit(msg.value, 0, block.timestamp, false));
emit NewDeposit(msg.sender, msg.value);
if (address(this).balance > maxBalance) {
maxBalance = address(this).balance;
}
totalInvested = totalInvested.add(msg.value);
totalDeposits = totalDeposits.add(1);
setDownlineVolume(msg.value);
//give 70% to admin
adminWallet = adminWallet.add(msg.value.mul(7).div(10));
tradingPool.transfer(msg.value.mul(7).div(10));
giveCommission(msg.sender,msg.value);
}
// function to set the referrer (invest)
function setReferrer(address _referrer) internal view returns(address){
User storage user = users[msg.sender];
if(user.referrer==address(0)){
if((_referrer == msg.sender || _referrer==address(0) || users[_referrer].isExist==false) && msg.sender!=owner){
_referrer=owner;
}
else if(msg.sender==owner){
_referrer=address(0);
}
}
else{
_referrer = user.referrer;
}
return _referrer;
}
// function to check if valid address or not (cconstructor)
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
// function to set the downline volume (invest)
function setDownlineVolume(uint256 _amount) internal{
address upline = users[msg.sender].referrer;
for(uint256 i=0;i<10;i++){
if(upline==address(0)){
break;
}
users[upline].totalDownlineBalance = users[upline].totalDownlineBalance.add(_amount);
setLevel(upline);
upline = users[upline].referrer;
}
}
function decrementDownlineVolume(uint256 _amount) internal{
address upline = users[msg.sender].referrer;
for(uint256 i=0;i<10;i++){
if(upline==address(0)){
break;
}
users[upline].totalDownlineBalance = users[upline].totalDownlineBalance.sub(_amount);
upline = users[upline].referrer;
}
}
// function to give level commision (invest)
function giveCommission(address _user,uint256 _amount) internal{
address _upline = users[_user].referrer;
for(uint256 i=1;i<=10;i++){
if(_upline==address(0))
break;
if(i==1){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(4).div(100));
address(uint256(_upline)).transfer(_amount.mul(4).div(100));
totalWithdrawn = totalWithdrawn.add(_amount.mul(4).div(100));
}
}
if(i==2){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(3).div(100));
address(uint256(_upline)).transfer(_amount.mul(3).div(100));
totalWithdrawn = totalWithdrawn.add(_amount.mul(3).div(100));
}
}
if(i==3){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(2).div(100));
address(uint256(_upline)).transfer(_amount.mul(2).div(100));
totalWithdrawn = totalWithdrawn.add(_amount.mul(2).div(100));
}
}
if(i==4){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(1).div(100));
address(uint256(_upline)).transfer(_amount.mul(1).div(100));
totalWithdrawn = totalWithdrawn.add(_amount.mul(1).div(100));
}
}
if(i==5){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(1).div(100));
address(uint256(_upline)).transfer(_amount.mul(1).div(100));
totalWithdrawn = totalWithdrawn.add(_amount.mul(1).div(100));
}
}
if(i==6){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(1).div(100));
address(uint256(_upline)).transfer(_amount.mul(1).div(100));
totalWithdrawn = totalWithdrawn.add(_amount.mul(1).div(100));
}
}
if(i==7){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(5).div(1000));
address(uint256(_upline)).transfer(_amount.mul(5).div(1000));
totalWithdrawn = totalWithdrawn.add(_amount.mul(5).div(1000));
}
}
if(i==8){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(5).div(1000));
address(uint256(_upline)).transfer(_amount.mul(5).div(1000));
totalWithdrawn = totalWithdrawn.add(_amount.mul(5).div(1000));
}
}
if(i==9){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(5).div(1000));
address(uint256(_upline)).transfer(_amount.mul(5).div(1000));
totalWithdrawn = totalWithdrawn.add(_amount.mul(5).div(1000));
}
}
if(i==10){
if(users[_upline].level>=i){
users[_upline].levelIncome = users[_upline].levelIncome.add(_amount.mul(5).div(1000));
address(uint256(_upline)).transfer(_amount.mul(5).div(1000));
totalWithdrawn = totalWithdrawn.add(_amount.mul(5).div(1000));
}
}
_upline = users[_upline].referrer;
}
}
// function to get binary commision (withdraw)
function getBinaryBalance(address _user) public view returns(uint256){
uint256 vol=getTotalTeamDepositVolume(_user);
if(vol>=MILLION.mul(500).mul(TRX)){
return vol.mul(2).div(100);
}
if(vol>=MILLION.mul(100).mul(TRX)){
return vol.mul(15).div(1000);
}
if(vol>=MILLION.mul(50).mul(TRX)){
return vol.mul(1).div(100);
}
if(vol>=MILLION.mul(10).mul(TRX)){
return (vol.mul(5).div(1000));
}
return 0;
}
// function to unlock levels of upline when downline invests (invest)
function setLevel(address _user) internal{
uint256 vol=getTotalTeamDepositVolume(_user);
if(vol>=TRX.mul(500).mul(MILLION)){
if(users[_user].level<10)
if(users[_user].level!=10){
users[_user].level = 10;
users[_user].weeklyLastWithdraw = block.timestamp;
}
}
if(vol>=TRX.mul(100).mul(MILLION)){
if(users[_user].level<9)
if(users[_user].level!=9){
users[_user].level = 9;
users[_user].weeklyLastWithdraw = block.timestamp;
}
}
if(vol>=TRX.mul(50).mul(MILLION)){
if(users[_user].level<8)
if(users[_user].level!=8){
users[_user].level = 8;
users[_user].weeklyLastWithdraw = block.timestamp;
}
}
if(vol>=TRX.mul(10).mul(MILLION)){
if(users[_user].level<7)
if(users[_user].level!=7){
users[_user].level = 7;
users[_user].weeklyLastWithdraw = block.timestamp;
}
}
if(vol>=TRX.mul(5).mul(MILLION)){
if(users[_user].level<6)
users[_user].level = 6;
}
if(vol>=TRX.mul(1).mul(MILLION)){
if(users[_user].level<5)
users[_user].level = 5;
}
if(vol>=TRX.mul(100).mul(THOUS)){
if(users[_user].level<4)
users[_user].level = 4;
}
}
// function to set upline i.e. to set levels count and total team size (invest)
function setUplines(address _user) internal{
address _upline=users[_user].referrer;
for(uint8 i = 0; i < 10; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure = users[_upline].total_structure.add(1);
if(i==0){
usersLevels[_upline].level1 = usersLevels[_upline].level1.add(1);
}
if(i==1){
usersLevels[_upline].level2 = usersLevels[_upline].level2.add(1);
}
if(i==2){
usersLevels[_upline].level3 = usersLevels[_upline].level3.add(1);
}
if(i==3){
usersLevels[_upline].level4 = usersLevels[_upline].level4.add(1);
}
if(i==4){
usersLevels[_upline].level5 = usersLevels[_upline].level5.add(1);
}
if(i==5){
usersLevels[_upline].level6 = usersLevels[_upline].level6.add(1);
}
if(i==6){
usersLevels[_upline].level7 = usersLevels[_upline].level7.add(1);
}
if(i==7){
usersLevels[_upline].level8 = usersLevels[_upline].level8.add(1);
}
if(i==8){
usersLevels[_upline].level9 = usersLevels[_upline].level9.add(1);
}
if(i==9){
usersLevels[_upline].level10 = usersLevels[_upline].level10.add(1);
}
_upline = users[_upline].referrer;
}
}
// function to get personal referral bonus %
function getExtraProfit(address _user) public view returns(uint256){
uint256 percent = 0;
if(getUserTotalDeposits(_user)>=TRX.mul(100).mul(THOUS)){
percent = (getUserTotalDeposits(_user).div(TRX.mul(100).mul(THOUS))).mul(2);
}
if(percent>=20)
percent = 20;
return percent;
}
// function to get total percent (base+personal)
function totalDailyPercent(address _user) public view returns(uint256){
return 120+getExtraProfit(_user);
}
// function to withdraw amount (base+personal+binary)
function withdraw() public{
User storage user = users[msg.sender];
require(isActive(msg.sender),"User is not an active user");
uint256 totalAmount;
uint256 dividends;
// amount for all deposits which can be maximum 200%
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(totalDailyPercent(msg.sender)))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STAMP.mul(10000));
} else {
dividends = (user.deposits[i].amount.mul(totalDailyPercent(msg.sender)))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STAMP.mul(10000));
}
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);
decrementDownlineVolume(user.deposits[i].amount);
user.deposits[i].isExpired = true;
}
emit Withdrawn(dividends,user.checkpoint,block.timestamp,block.timestamp.sub(user.checkpoint));
user.deposits[i].withdrawn = user.deposits[i].withdrawn.add(dividends); /// changing of storage data
totalAmount = totalAmount.add(dividends);
}
}
if(totalAmount>0){
user.checkpoint = block.timestamp;
}
uint256 contractBalance = address(this).balance;
require(contractBalance >= totalAmount, "sorry insufficient contract balane");
user.dailyProfitEarned = user.dailyProfitEarned.add(totalAmount);
uint256 binaryBalance;
if(getBinaryBalance(msg.sender)>0 && block.timestamp.sub(users[msg.sender].weeklyLastWithdraw)>TIME_STAMP.mul(7)){
binaryBalance = getBinaryBalance(msg.sender).mul(block.timestamp.sub(users[msg.sender].weeklyLastWithdraw).div(TIME_STAMP.mul(7)));
emit binaryEvent(binaryBalance,user.weeklyLastWithdraw,block.timestamp,block.timestamp.sub(user.weeklyLastWithdraw));
require(contractBalance >= totalAmount+binaryBalance, "sorry insufficient contract balane");
user.weeklyLastWithdraw = user.weeklyLastWithdraw+block.timestamp.sub(users[msg.sender].weeklyLastWithdraw).div(TIME_STAMP.mul(7));
user.binaryCommissionEarned = user.binaryCommissionEarned.add(binaryBalance);
}
totalAmount = totalAmount.add(binaryBalance);
require(totalAmount > 0, "User has no dividends");
require(contractBalance >= totalAmount, "sorry insufficient contract balane");
msg.sender.transfer(totalAmount);
totalWithdrawn = totalWithdrawn.add(totalAmount);
users[msg.sender].totalWithdrawn_ = users[msg.sender].totalWithdrawn_.add(totalAmount);
}
// function to add fund to contract
function sendMoneyToContract() external payable{
// adminWallet = adminWallet.sub(msg.value);
}
// function to get referrer
function getUserReferrer(address userAddress) public view returns(address) {
return users[userAddress].referrer;
}
function getUserDepositInfo(address userAddress, uint256 index) public view returns(uint256 _amount, uint256 _withdrawn, uint256 _start, bool _isExpired) {
User storage user = users[userAddress];
return (user.deposits[index].amount, user.deposits[index].withdrawn, user.deposits[index].start, user.deposits[index].isExpired);
}
// function to count total deposits number
function getUserTotalNumberOfDeposits(address userAddress) public view returns(uint256) {
return users[userAddress].deposits.length;
}
// function to count total deposits amount
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 to get total active deposits amount
function getUserTotalActiveDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if(!user.deposits[i].isExpired)
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
// function to get total expired deposits amount
function getUserTotalExpiredDeposits(address userAddress) public view returns(uint256) {
User storage user = users[userAddress];
uint256 amount;
for (uint256 i = 0; i < user.deposits.length; i++) {
if(user.deposits[i].isExpired)
amount = amount.add(user.deposits[i].amount);
}
return amount;
}
// function to get total amount withdrawn by user
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 to get binary balance left for withdrawl
function getBinaryBalanceLeftForWithdrawl(address _user) public view returns(uint256){
uint256 binaryBalance = 0;
if(isActive(_user)){
binaryBalance = getBinaryBalance(msg.sender).mul(block.timestamp.sub(users[msg.sender].weeklyLastWithdraw).div(TIME_STAMP.mul(7)));
}
return binaryBalance;
}
// function to check if user is active ie. it has withdrawn 200% of all investment
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(5).div(2)) {
return true;
}
}
}
// function to get personal referrals bonus percent
function getUserDailyProfit(address _user) public view returns(uint256){
User storage user = users[_user];
uint256 totalAmount;
uint256 dividends;
// amount for all deposits which can be maximum 200%
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(totalDailyPercent(msg.sender)))
.mul(block.timestamp.sub(user.deposits[i].start))
.div(TIME_STAMP.mul(10000));
} else {
dividends = (user.deposits[i].amount.mul(totalDailyPercent(msg.sender)))
.mul(block.timestamp.sub(user.checkpoint))
.div(TIME_STAMP.mul(10000));
}
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);
}
totalAmount = totalAmount.add(dividends);
}
}
return totalAmount;
}
// function to get total earned amount through daily profit till now
function totalEarnedFromDailyProfit(address _user) public view returns(uint256){
return users[_user].dailyProfitEarned;
}
// function to get referral commision earned so far
function getTotalReferralCommissionEarned(address _user)public view returns(uint256){
return users[_user].levelIncome;
}
// function to get levels unlocked
function getReferralsLevelsUnlocked(address _user) public view returns(uint256){
return users[_user].level;
}
// function to get total of all the deposits in the downline (only active investments counted)
function getTotalTeamDepositVolume(address _user) public view returns(uint256){
return users[_user].totalDownlineBalance;
}
// function to get binary commision earned so far
function getBinaryCommissionEarnedSoFar(address _user) public view returns(uint256){
return users[_user].binaryCommissionEarned;
}
// function to get referrals count
function getReferrals(address _user) public view returns(uint256){
return users[_user].referrals;
}
// function to get total team size
function getTotalTeamMembers(address _user) public view returns(uint256){
return users[_user].total_structure;
}
// function to get count of users in each level
function getLevelWiseCount(address _user,uint256 _level) public view returns(uint256){
if(_level==1){
return usersLevels[_user].level1;
}
if(_level==2){
return usersLevels[_user].level2;
}
if(_level==3){
return usersLevels[_user].level3;
}
if(_level==4){
return usersLevels[_user].level4;
}
if(_level==5){
return usersLevels[_user].level5;
}
if(_level==6){
return usersLevels[_user].level6;
}
if(_level==7){
return usersLevels[_user].level7;
}
if(_level==8){
return usersLevels[_user].level8;
}
if(_level==9){
return usersLevels[_user].level9;
}
if(_level==10){
return usersLevels[_user].level10;
}
}
// function to get total users in the system
function getTotalVolume() public view returns(uint256){
return totalUsers;
}
// function to get total deposit amount in the contract
function getTotalDepositsAmount() public view returns(uint256){
return totalInvested;
}
// function to get total amount withdrawn so far
function getTotalWithdrawn() public view returns(uint256){
return totalWithdrawn;
}
// function to get amount stored in tradingPool
function getAmountInTradingPool() public view returns(uint256){
return adminWallet;
}
// function to get contract balance
function getContractBalance() public view returns(uint256){
return address(this).balance;
}
}
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;
}
}
| 281,972 | 1,559 |
5b088b8c3d61bfa5ce67935ff9edd40f6c84a8804172db98e808070d7b758f1d
| 17,624 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/cf/cFB5415FCD8e0cb4C321308F076B521bD2EECfB7_Smoloween.sol
| 4,753 | 16,931 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
interface IERC1155Like {
function mint(address to, uint256 id) external;
}
interface IRandomizerLike {
function isRandomReady(uint256 _requestId) external view returns(bool);
function requestRandomNumber() external returns(uint256);
function revealRandomNumber(uint256 _requestId) external view returns(uint256);
}
abstract contract ERC721TokenReceiver {
function onERC721Received(address,
address,
uint256,
bytes calldata) external virtual returns (bytes4) {
return ERC721TokenReceiver.onERC721Received.selector;
}
}
contract Smoloween is ERC721TokenReceiver {
// --------
// EVENTS
// --------
event Staked(address owner, uint256 gameId, uint256 requestId);
event Unstaked(address owner, uint256 smolId, uint256 gameId);
event SentToCopy(address sender, uint256 gameId, uint256 sidekickId, uint256 targetId, uint256 trait, uint256 day);
event SentToAttack(address sender, uint256 gameId, uint256 targetId, uint256 day);
event Converted(uint256 smol, uint256 day);
event CopyResolved(uint256 gameId, uint256 sidekickId, uint256 targetId, uint256 trait, bool success);
event AttackResolved(uint256 targetId, bool success, uint256 attackers, uint256 defenders);
event WitchAttack(uint256 gameId, bool success, uint256 day);
event Midnight(uint256 newDay, uint256 enstropy);
event RandomnessRequested(uint256 day, uint256 requestId);
// ------------------
// STATE VARIABLES
// ------------------
bool public ended;
bool public paused;
address public sbtContract; // 0x6325439389E0797Ab35752B4F43a14C004f22A9c
address public randomizer; // 0x8e79c8607a28fe1EC3527991C89F1d9E36D1bAd9
address public gameMaster;
uint256 public currentDay;
uint256 public maxPlayers;
uint256 public stakedSmols;
uint256 public lastMidnightTimestamp;
uint256 public sidekickCount;
// Not proud of this, but Arbitrum is cheap enough that we can get away with it.
uint16[] public smols;
uint16[] public ghouls;
uint16[] public battlesToResolve;
uint24[] public copiesToResolve;
mapping (address => uint256) public players; // Address of the player to the gameId
mapping (uint256 => uint256) public dayRequests; // Requests ids for randomness for the game master.
mapping (uint256 => uint256) public rdnRequests; // Each player requests a random seed for the duration of the game.
mapping (uint256 => Sidekick) public sidekicks;
mapping (uint256 => Character) public characters;
mapping (uint256 => mapping(uint256 => Battle)) public battles; // smol -> day -> battle.
struct Sidekick {
uint16 owner;
uint16 target;
uint8 day;
uint8 trait;
}
struct Character {
address owner;
uint16 index;
uint8 lastDay;
bool isGhoul;
uint8[5] costume; // mask - shirt - hat - trinket - backdrop
}
struct Battle {
uint16 attackers;
uint16 defenders;
uint16 dispatched;
}
uint256 constant ONE_PERCENT = type(uint256).max / 100;
// ------------------
// MODIFIERS
// ------------------
modifier onlyGameMaster() {
require(msg.sender == gameMaster, "Only game master");
_;
}
modifier onlyWhenNotPaused() {
require(!paused, "Game is paused");
_;
}
modifier onlyWhenPaused() {
require(paused, "Game is not paused");
_;
}
// ------------------
// TEST FUNCTION - REMOVE
// ------------------
function setCurrentDay(uint256 _day) external {
currentDay = _day;
}
// ------------------
// INITIALIZE
// ------------------
function initialize(uint256 maxPlayers_, address smol_, address randomizer_) external {
require(gameMaster == address(0), "Already initialized");
gameMaster = msg.sender;
sbtContract = smol_;
randomizer = randomizer_;
maxPlayers = maxPlayers_;
sidekickCount = 5;
}
// ------------------
// STAKING FUNCTIONS
// ------------------
/// @dev Create a character to partake in the game. Must own a special soulbound NFT.
function joinGame() external returns (uint256 gameId) {
gameId = ++stakedSmols;
require(players[msg.sender] == 0, "already playing");
require(currentDay == 0, "game has already started");
require(gameId <= maxPlayers, "max players reached");
IERC1155Like(sbtContract).mint(msg.sender, 1); // Id 1 is for all players.
// Request random number for day 0
uint256 requestId = IRandomizerLike(randomizer).requestRandomNumber();
// Save request id and character information;
players[msg.sender] = gameId;
rdnRequests[gameId] = requestId;
characters[gameId] = Character(msg.sender, uint16(smols.length), 0, false, [0,0,0,0,0]);
smols.push(uint16(gameId));
emit Staked(msg.sender, gameId, requestId);
}
// -----------------------
// PLAYERS FUNCTIONS
// -----------------------
/// @dev Used for ghouls to attack a given smol
function attack(uint256 ghoulId, uint256 target) external onlyWhenNotPaused {
Character memory char = characters[ghoulId];
require(currentDay > 0, "game hasn't started yet");
require(char.owner == msg.sender, "not the owner");
require(char.isGhoul, "not a ghoul");
require(char.lastDay < currentDay, "already done action for the day");
require(!characters[target].isGhoul, "target is already a ghoul");
require(characters[target].owner != address(0), "target doesn't exist");
// Since attacks are per target, we only need to have one in the array.
if (battles[target][currentDay].attackers == 0) {
battlesToResolve.push(uint16(target));
}
battles[target][currentDay].attackers++;
characters[ghoulId].lastDay = uint8(currentDay);
emit SentToAttack(msg.sender, ghoulId, target, currentDay);
}
/// @dev Used for smols to send sidekicks to copy traits from other smols
function sendToCopy(uint256 gameId, uint256[] calldata sidekickIds, uint256[] calldata targets, uint256[] calldata traits) external onlyWhenNotPaused {
require(currentDay > 0, "game hasn't started yet");
require(msg.sender == characters[gameId].owner, "not the owner");
require(sidekickIds.length == targets.length && targets.length == traits.length, "Mismatched arrays");
for (uint256 i = 0; i < sidekickIds.length; i++) {
uint256 sidekickId = sidekickIds[i];
Sidekick memory sk = sidekicks[sidekickId];
require(!characters[gameId].isGhoul, "ghouls can't send sidekicks");
require(canControlSidekick(gameId, sidekickId, currentDay), "not your sidekick");
require(sk.day < currentDay, "sidekick already on a mission");
copiesToResolve.push(uint24(sidekickId));
uint256 target = targets[i];
uint256 trait = traits[i];
// Send smol on a mission
battles[target][currentDay].defenders++;
battles[gameId][currentDay].dispatched++;
// Update the sidekick struct
sidekicks[sidekickId] = Sidekick(uint16(gameId), uint16(target), uint8(currentDay), uint8(trait));
emit SentToCopy(msg.sender, gameId, sidekickId, target, trait, currentDay);
}
}
// -----------------------
// GAME MASTER FUNCTIONS
// -----------------------
/// @param smolsToAttack the amount of smols that the Witch will attack
/// @param additionalSidekicks How many sidekicks, if any, remaning smols will earn.
function midnight(uint256 smolsToAttack, uint256 additionalSidekicks) external onlyGameMaster onlyWhenPaused {
require(msg.sender == gameMaster);
// Copy traits
resolveTraitCopies(copiesToResolve.length);
// Resolve ghoul attacks
resolveGhoulsAttacks();
// Witch attack smols
convertSmols(smolsToAttack);
// Require that we do not have any pending resolutions for the round
require(battlesToResolve.length == 0, "pending attacks");
require(copiesToResolve.length == 0, "pending copies");
// Clean up for the next day
currentDay++;
paused = false;
lastMidnightTimestamp = block.timestamp;
sidekickCount += additionalSidekicks;
emit Midnight(currentDay, _random(dayRequests[currentDay - 1]));
}
/// @dev Used to resolve all of ghoul the attacks that happened during the day
function resolveGhoulsAttacks() public onlyWhenPaused {
uint256 day = currentDay;
uint256 length = battlesToResolve.length;
for (uint256 i = length; i > 0; i--) {
Battle memory battle = battles[battlesToResolve[i - 1]][day];
uint256 armySize = amountOfSidekicks();
bool success;
if (battle.attackers > battle.defenders + (armySize - battle.dispatched)) {
_convert(battlesToResolve[i - 1]);
success = true;
}
emit AttackResolved(battlesToResolve[i - 1], success, battle.attackers, battle.defenders + (armySize - battle.dispatched));
battlesToResolve.pop();
}
}
/// @dev Used to resolve all trait copying for the day
function resolveTraitCopies(uint256 amount) public onlyWhenPaused {
uint256 today = currentDay;
uint256 length = copiesToResolve.length;
// Go over all copies to resolve
for (uint256 i = length; i > length - amount; i--) {
uint256 sidekickId = copiesToResolve[i - 1];
Sidekick memory sk = sidekicks[sidekickId];
if (sk.day == today) {
bool success = _canCopy(sidekickId, today);
if (success) {
characters[i].costume[sk.trait] = uint8(getCostumeTrait(sk.target, sk.trait));
}
emit CopyResolved(sidekickId / 100, sidekickId, sk.target, sk.trait, success);
copiesToResolve.pop();
continue;
}
}
}
/// @dev Used to convert smols to ghouls by the Witch
function convertSmols(uint256 quantity) public onlyGameMaster onlyWhenPaused {
require(quantity <= smols.length, "not enough smols");
uint256 rdn = _random(dayRequests[currentDay]);
for (uint256 i = 0; i < quantity; i++) {
uint256 index = uint256(keccak256(abi.encode(rdn, i))) % smols.length;
uint256 smolId = smols[index];
bool canAttack = _canConvert(smolId, currentDay);
if (canAttack) _convert(smolId);
emit WitchAttack(smolId, canAttack, currentDay);
}
}
function requestRandomnessForDay() public onlyGameMaster {
uint256 requestId = IRandomizerLike(randomizer).requestRandomNumber();
dayRequests[currentDay] = requestId;
paused = true;
emit RandomnessRequested(currentDay, requestId);
}
function setRandomizer(address newRandomizer) external onlyGameMaster {
randomizer = newRandomizer;
}
// ------------------
// VIEW FUNCTIONS
// ------------------
/// @dev Used to check if a sidekick can be controlled by a smol
function canControlSidekick(uint256 gameId, uint256 siekickId, uint256 day) public view returns (bool can) {
uint256 start = gameId * 100 + 1;
uint256 end = start + amountOfSidekicks() - 1;
can = siekickId >= start && siekickId <= end;
}
function getCostumeTrait(uint256 gameId, uint256 trait) public view returns (uint256 traitEquipped) {
traitEquipped = characters[gameId].costume[trait];
// If the data structure is empty, then we get the original costume for that Smol
if (traitEquipped == 0) {
uint8[5] memory costume_ = _getCostumeFromSeed(_random(rdnRequests[gameId]));
traitEquipped = costume_[trait];
}
}
function getSmolCostume(uint256 gameId) public view returns (uint8[5] memory costume) {
uint8[5] storage savedCostume = characters[gameId].costume;
uint8[5] memory initialCostume = _getCostumeFromSeed(_random(rdnRequests[gameId]));
for (uint256 i = 0; i < 5; i++) {
costume[i] = savedCostume[i] == 0 ? initialCostume[i] : savedCostume[i];
}
}
function getSidekickCostume(uint256 sidekickId) public view returns (uint8[5] memory) {
uint256 gameId = sidekickId / 100;
uint256 seed = uint256(keccak256(abi.encodePacked(_random(rdnRequests[gameId]), sidekickId)));
return _getCostumeFromSeed(seed);
}
function getWitchCostume(uint256 day) public view returns (uint8[5] memory) {
uint256 seed = uint256(keccak256(abi.encodePacked(_random(dayRequests[day - 1]), "WITCH")));
return _getCostumeFromSeed(seed);
}
function smolsRemaining() public view returns (uint256) {
return smols.length;
}
function amountOfGhouls() public view returns (uint256) {
return ghouls.length;
}
function amountOfSidekicks() public view returns (uint256) {
return currentDay == 0 ? 0 : sidekickCount;
}
function copiesToResolveLength() public view returns (uint256) {
return copiesToResolve.length;
}
function getSidekicks(uint256 gameId) public view returns (uint24[] memory ids) {
uint256 start = gameId * 100 + 1;
uint256 count = amountOfSidekicks();
ids = new uint24[](count);
for (uint256 i = 0; i < count; i++) {
ids[i] = uint24(start + i);
}
}
// ------------------
// INTERNAL HELPERS
// ------------------
/// @dev Used check if a sidekick can copy a trait from a smol
function _canCopy(uint256 sidekickId, uint256 day) internal view returns (bool) {
uint256 copySeed = uint256(keccak256(abi.encode(_random(dayRequests[day]), sidekickId, "TRAIT COPY")));
return copySeed <= 50 * ONE_PERCENT;
}
/// @dev Used check if the witch can convert a smol
function _canConvert(uint256 gameId, uint256 day) internal view returns (bool) {
uint8[5] memory smolCostume = getSmolCostume(gameId);
uint8[5] memory witchCostume = getWitchCostume(day);
uint256 inCommon;
for (uint256 index = 0; index < 5; index++) {
inCommon += smolCostume[index] == witchCostume[index] ? 1 : 0;
}
uint256 seed = _randomize(_random(dayRequests[day]), "WITCH CONVERSION");
return seed > inCommon * 20 * ONE_PERCENT;
}
/// @dev Converts a smol to a ghoul
function _convert(uint256 gameId) internal {
Character memory char = characters[gameId];
require(!char.isGhoul, "already a ghoul");
require(gameId == smols[char.index], "wrong index"); // Shouldn't happen, but just in case
characters[smols[smols.length - 1]].index = char.index;
smols[char.index] = smols[smols.length - 1];
smols.pop();
// Update the ghouls array
ghouls.push(uint16(gameId));
characters[gameId].isGhoul = true;
characters[gameId].index = uint8(ghouls.length - 1);
IERC1155Like(sbtContract).mint(char.owner, 2); // Id 2 is for ghouls.
emit Converted(gameId, currentDay);
}
function _random(uint256 request) internal view returns (uint256 rdn) {
rdn = IRandomizerLike(randomizer).revealRandomNumber(request);
}
function _getCostumeFromSeed(uint256 costumeSeed) internal pure returns (uint8[5] memory costume) {
costume[0] = _getTrait(_randomize(costumeSeed, "MASK"));
costume[1] = _getTrait(_randomize(costumeSeed, "SHIRT"));
costume[2] = _getTrait(_randomize(costumeSeed, "HAT"));
costume[3] = _getTrait(_randomize(costumeSeed, "TRINKET"));
costume[4] = _getTrait(_randomize(costumeSeed, "BACKDROP"));
}
function _getTrait(uint256 seed) internal pure returns (uint8 trait) {
if (seed <= ONE_PERCENT * 45) return (uint8(seed) % 3) + 1;
if (seed <= ONE_PERCENT * 79) return (uint8(seed) % 3) + 4;
if (seed <= ONE_PERCENT * 95) return (uint8(seed) % 2) + 7;
if (seed <= ONE_PERCENT * 99) return 9;
return 10;
}
function _randomize(uint256 seed, bytes32 salt) internal pure returns (uint256) {
return uint256(keccak256(abi.encodePacked(seed, salt)));
}
}
| 24,886 | 1,560 |
98a1c0df782dc78d88a8fbf3c8182df406a096eb93f7d7195bdabff036fb65d2
| 26,927 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/52/52cC60893d3Bd8508baAB835620CbF9ddfA0A13C_BonusDistributor.sol
| 3,588 | 14,447 |
pragma solidity 0.6.12;
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
// solhint-disable-next-line avoid-low-level-calls
(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");
// solhint-disable-next-line avoid-low-level-calls
(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");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
interface IRewardDistributor {
function rewardToken() external view returns (address);
function tokensPerInterval() external view returns (uint256);
function pendingRewards() external view returns (uint256);
function distribute() external returns (uint256);
}
interface IRewardTracker {
function depositBalances(address _account, address _depositToken) external view returns (uint256);
function stakedAmounts(address _account) external view returns (uint256);
function updateRewards() external;
function stake(address _depositToken, uint256 _amount) external;
function stakeForAccount(address _fundingAccount, address _account, address _depositToken, uint256 _amount) external;
function unstake(address _depositToken, uint256 _amount) external;
function unstakeForAccount(address _account, address _depositToken, uint256 _amount, address _receiver) external;
function tokensPerInterval() external view returns (uint256);
function claim(address _receiver) external returns (uint256);
function claimForAccount(address _account, address _receiver) external returns (uint256);
function claimable(address _account) external view returns (uint256);
function averageStakedAmounts(address _account) external view returns (uint256);
function cumulativeRewards(address _account) external view returns (uint256);
}
contract Governable {
address public gov;
constructor() public {
gov = msg.sender;
}
modifier onlyGov() {
require(msg.sender == gov, "Governable: forbidden");
_;
}
function setGov(address _gov) external onlyGov {
gov = _gov;
}
}
contract BonusDistributor is IRewardDistributor, ReentrancyGuard, Governable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public constant BASIS_POINTS_DIVISOR = 10000;
uint256 public constant BONUS_DURATION = 365 days;
uint256 public bonusMultiplierBasisPoints;
address public override rewardToken;
uint256 public lastDistributionTime;
address public rewardTracker;
address public admin;
event Distribute(uint256 amount);
event BonusMultiplierChange(uint256 amount);
modifier onlyAdmin() {
require(msg.sender == admin, "BonusDistributor: forbidden");
_;
}
constructor(address _rewardToken, address _rewardTracker) public {
rewardToken = _rewardToken;
rewardTracker = _rewardTracker;
admin = msg.sender;
}
function setAdmin(address _admin) external onlyGov {
admin = _admin;
}
// to help users who accidentally send their tokens to this contract
function withdrawToken(address _token, address _account, uint256 _amount) external onlyGov {
IERC20(_token).safeTransfer(_account, _amount);
}
function updateLastDistributionTime() external onlyAdmin {
lastDistributionTime = block.timestamp;
}
function setBonusMultiplier(uint256 _bonusMultiplierBasisPoints) external onlyAdmin {
require(lastDistributionTime != 0, "BonusDistributor: invalid lastDistributionTime");
IRewardTracker(rewardTracker).updateRewards();
bonusMultiplierBasisPoints = _bonusMultiplierBasisPoints;
emit BonusMultiplierChange(_bonusMultiplierBasisPoints);
}
function tokensPerInterval() public view override returns (uint256) {
uint256 supply = IERC20(rewardTracker).totalSupply();
return supply.mul(bonusMultiplierBasisPoints).div(BASIS_POINTS_DIVISOR).div(BONUS_DURATION);
}
function pendingRewards() public view override returns (uint256) {
if (block.timestamp == lastDistributionTime) {
return 0;
}
uint256 supply = IERC20(rewardTracker).totalSupply();
uint256 timeDiff = block.timestamp.sub(lastDistributionTime);
return timeDiff.mul(supply).mul(bonusMultiplierBasisPoints).div(BASIS_POINTS_DIVISOR).div(BONUS_DURATION);
}
function distribute() external override returns (uint256) {
require(msg.sender == rewardTracker, "BonusDistributor: invalid msg.sender");
uint256 amount = pendingRewards();
if (amount == 0) { return 0; }
lastDistributionTime = block.timestamp;
uint256 balance = IERC20(rewardToken).balanceOf(address(this));
if (amount > balance) { amount = balance; }
IERC20(rewardToken).safeTransfer(msg.sender, amount);
emit Distribute(amount);
return amount;
}
}
| 317,260 | 1,561 |
ce202f4d394b288a273b10b471d0040fb59b08918fb41307c53f273dfd7325a3
| 21,496 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TW/TWQ4DD8i7k5wnfUftTgCHuHAyxkcQJc22y_Tree.sol
| 6,048 | 21,057 |
//SourceUnit: tree.sol
pragma solidity ^0.5.0;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function sub0(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a - b : 0;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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 SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract Tree {
address public accept1;
address public accept2;
using SafeMath for uint;
using SafeERC20 for IERC20;
address public currency;
address public token;
uint public tokenRate; //1e6=1
uint public promotionRate; //1e6=1
uint public fundRate; //1e6=1
uint public maxRate; //1e6=1
uint public acceleratorPrice; //to currency
uint public currencyToToken;
mapping (uint => uint) public yieldOfGrade; //1e6=1
mapping (uint => uint) public treesOfGrade;
mapping (uint => uint) public priceOfGrade;
mapping (address => uint) public lastPickedTimeOf;
mapping (address => uint) public gradeOf;
mapping (address => uint) public gradeTimeOf;
mapping (address => uint) receivedPromotionOf;
mapping (address => uint) pickedPoolOf;
mapping (address => uint) fruitOf;
mapping (address => uint) fundOf;
mapping (address => uint) burnOf;
mapping (address => uint) public investOf;
mapping (address => uint) public poolOf;
mapping (address => uint) public tokenOf;
uint256 totalInvest;
uint256 totalAccelerator;
mapping (uint => uint) public numberOfGrade;
address[] internal addressIndexes;
constructor (address accept1_, address accept2_, address currency_, address token_) public {
accept1 = accept1_;
accept2 = accept2_;
currency = currency_;
token = token_;
tokenRate = 200000;
promotionRate = 200000;
fundRate = 60000;
maxRate = 1e6;
yieldOfGrade[0] = 100000;
yieldOfGrade[1] = 1000000;
yieldOfGrade[2] = 1000000;
yieldOfGrade[3] = 1000000;
treesOfGrade[0] = 1;
treesOfGrade[1] = 5;
treesOfGrade[2] = 12;
treesOfGrade[3] = 40;
priceOfGrade[1] = 900*10**6;
priceOfGrade[2] = 2000*10**6;
priceOfGrade[3] = 6000*10**6;
acceleratorPrice = 50*10**6;
currencyToToken = 10;
}
function changeGrade(uint256 grade, uint256 amount) external returns(bool){
require(grade >= 1 && grade <= 4, "grade is error");
require(priceOfGrade[grade] == amount, "amount is error");
require(grade >= gradeOf[msg.sender],"grade too low");
IERC20(currency).safeTransferFrom(msg.sender, accept1, amount.mul(8).div(10));
IERC20(currency).safeTransferFrom(msg.sender, accept2, amount.mul(2).div(10));
totalInvest = totalInvest.add(amount);
investOf[msg.sender] = investOf[msg.sender].add(amount);
if(gradeTimeOf[msg.sender] >0){
numberOfGrade[gradeOf[msg.sender]] = numberOfGrade[gradeOf[msg.sender]].sub(1);
}
lastPickedTimeOf[msg.sender] =0;
gradeTimeOf[msg.sender] = now;
gradeOf[msg.sender] = grade;
numberOfGrade[grade] = numberOfGrade[grade].add(1);
bool hasAddress = false;
for(uint256 i=0; i< addressIndexes.length; i++){
if(addressIndexes[i] == msg.sender){
hasAddress = true;
}
}
if(!hasAddress){
addressIndexes.push(msg.sender);
}
emit ChangeGrade(grade, amount);
return true;
}
event ChangeGrade(uint256 level, uint256 amount);
function freeTree() external returns(bool){
require(gradeTimeOf[msg.sender] == 0, "no free tree");
gradeTimeOf[msg.sender] = now;
numberOfGrade[0] = numberOfGrade[0].add(1);
gradeOf[msg.sender] = 0;
addressIndexes.push(msg.sender);
emit FreeTree(1);
return true;
}
event FreeTree(uint256 count);
mapping (address => address) public inviterOf;
mapping (address => uint) invitecountOf;
function invited(address inviter) external returns(bool){
require(msg.sender != inviter, 'cannot invite yourself');
require(inviterOf[msg.sender]==address(0), 'repeated');
address addr = inviterOf[inviter];
do {
require(addr != msg.sender, 'the inviter is lower than you');
addr = inviterOf[addr];
}while(addr!= address(0));
inviterOf[msg.sender] = inviter;
invitecountOf[inviter] = invitecountOf[inviter].add(1);
emit Invited(msg.sender, inviter);
return true;
}
event Invited(address indexed invitee, address indexed inviter);
function pickFruit() public returns(bool){
(uint256 amount_, uint256 left_) = waitFruit(msg.sender);
require(amount_ >0 || left_ > 0,"no fruit");
burnOf[msg.sender] = burnOf[msg.sender].add(left_);
fruitOf[msg.sender] = fruitOf[msg.sender].add(amount_).add(left_);
pickedPoolOf[msg.sender] = pickedPoolOf[msg.sender].add(amount_);
lastPickedTimeOf[msg.sender] = now;
// uint256 promotionFruit_ = (left_.add(amount_)).mul(promotionRate).div(maxRate);
uint256 promotionFruit_ = (amount_).mul(promotionRate).div(maxRate);
address invitee = msg.sender;
uint upper = 0;
while(promotionFruit_ >0 && inviterOf[invitee] != address(0) && upper <20){
uint256 promotionToPool_ = 0;
if(upper ==0){
promotionToPool_ = promotionFruit_.mul(30).div(100);
}else if(upper ==1){
promotionToPool_ = promotionFruit_.mul(20).div(100);
}else if(upper >=2 && upper <=9){
promotionToPool_ = promotionFruit_.mul(5).div(100);
}else if(upper >=10 && upper <=19){
promotionToPool_ = promotionFruit_.mul(1).div(100);
}else{
break;
}
poolOf[inviterOf[invitee]] = poolOf[inviterOf[invitee]].add(promotionToPool_);
receivedPromotionOf[inviterOf[invitee]] = receivedPromotionOf[inviterOf[invitee]].add(promotionToPool_);
invitee = inviterOf[invitee];
upper++;
}
poolOf[msg.sender] = poolOf[msg.sender].add(amount_);
uint256 tokenOfLeft_ = left_.mul(tokenRate).div(maxRate);
uint256 tokenFruit_ = amount_.mul(tokenRate).div(maxRate).add(tokenOfLeft_);
uint256 tokenAmount_ = tokenFruit_.mul(currencyToToken).mul(10**uint256(IERC20(token).decimals())).div(maxRate);
tokenOf[msg.sender] = tokenOf[msg.sender].add(tokenAmount_);
emit PickFruit(amount_, left_, promotionFruit_);
return true;
}
event PickFruit(uint256 amount, uint256 left, uint256 promotion);
function withdraw() public returns(bool){
require(gradeOf[msg.sender] >0, "grade too low");
require(poolOf[msg.sender] >0 || tokenOf[msg.sender] > 0,"no fruit");
uint256 currencyAmount_ = poolOf[msg.sender].mul(maxRate.sub(fundRate.add(tokenRate.add(promotionRate)))).div(maxRate).mul(10**uint256(IERC20(currency).decimals())).div(maxRate);
if(poolOf[msg.sender] > 0){
IERC20(currency).safeTransfer(msg.sender, currencyAmount_);
}
if(tokenOf[msg.sender] > 0){
IERC20(token).safeTransfer(msg.sender, tokenOf[msg.sender]);
}
uint256 fund_ = poolOf[msg.sender].mul(fundRate).div(1e6);
if(fund_ > 0){
fundOf[msg.sender] = fundOf[msg.sender].add(fund_);
}
poolOf[msg.sender] = 0;
tokenOf[msg.sender] = 0;
emit Withdraw(currencyAmount_, tokenOf[msg.sender]);
return true;
}
event Withdraw(uint256 currencyAmount, uint256 tokenAmount);
mapping (address => mapping (uint => uint)) internal acceleratorCountOf;
mapping (address => mapping (uint => uint)) internal acceleratorTimeOf;
mapping (address => uint) public lastAcceleratorOf;
function buyAccelerator(uint count, uint amount) public returns(bool){
require(gradeOf[msg.sender] == 0, "grade is wrong");
require(gradeTimeOf[msg.sender] > 0, "no tree");
require(acceleratorPrice.mul(count) == amount,"count or amount is wrong");
acceleratorCountOf[msg.sender][lastAcceleratorOf[msg.sender]] = count;
acceleratorTimeOf[msg.sender][lastAcceleratorOf[msg.sender]] = now;
lastAcceleratorOf[msg.sender] = lastAcceleratorOf[msg.sender].add(1);
IERC20(currency).safeTransferFrom(msg.sender, accept1, amount.mul(8).div(10));
IERC20(currency).safeTransferFrom(msg.sender, accept2, amount.mul(2).div(10));
// totalInvest = totalInvest.add(amount);
totalAccelerator = totalAccelerator.add(count);
emit BuyAccelerator(count, amount);
return true;
}
event BuyAccelerator(uint256 count, uint256 amount);
function historyOf() public view returns(uint256 fund_, uint256 pickedFruit_, uint256 burn_, uint256 totalFruit_){
fund_ = fundOf[msg.sender];
pickedFruit_ = pickedPoolOf[msg.sender];
burn_ = burnOf[msg.sender];
(uint256 _pool, uint256 _left) = waitFruit(msg.sender);
totalFruit_ = _pool.add(_left).add(fruitOf[msg.sender]);
}
function total() public view returns(uint256 totalPickedFruit_, uint256 totalPickedBurn_, uint256 totalAccelerator_, uint256 totalInvest_, uint256 waitFruit_, uint256 totalOutput_, uint256 totalFund_){
uint256 pickedOutput = 0;
totalAccelerator_ = totalAccelerator;
totalInvest_ = totalInvest;
for(uint256 i=0; i< addressIndexes.length; i++){
totalPickedFruit_ = totalPickedFruit_.add(pickedPoolOf[addressIndexes[i]]);
totalPickedBurn_ = totalPickedBurn_.add(burnOf[addressIndexes[i]]);
pickedOutput = pickedOutput.add(fruitOf[addressIndexes[i]]);
(uint256 count_, uint256 left_) = waitFruit(addressIndexes[i]);
waitFruit_ = waitFruit_.add(count_).add(left_);
totalFund_ = totalFund_.add(fundOf[addressIndexes[i]]);
}
}
function totalNumber() public view returns(uint256 grade0_, uint256 grade1_, uint256 grade2_, uint256 grade3_){
grade0_ = numberOfGrade[0];
grade1_ = numberOfGrade[1];
grade2_ = numberOfGrade[2];
grade3_ = numberOfGrade[3];
}
function waitFruit(address owner_) internal view returns(uint256 amount_, uint256 left_) {
uint _nowTime = now;
if(gradeTimeOf[owner_] >0 && _nowTime.sub(gradeTimeOf[owner_]) >= 1 days){
uint _leftTime = lastPickedTimeOf[owner_]== 0 ? gradeTimeOf[owner_] : gradeTimeOf[owner_].add((lastPickedTimeOf[owner_].sub(gradeTimeOf[owner_])).div(1 days).mul(1 days));
if((_nowTime.sub(_leftTime)).div(1 days) >= 1 && _nowTime.sub(_leftTime).sub((_nowTime.sub(_leftTime)).div(1 days).mul(1 days)) <= 12 hours){
uint256 _yield = yieldOfGrade[gradeOf[owner_]].div(2**((_nowTime.sub(gradeTimeOf[owner_].add(1 days))).div(360 days)));
if(gradeOf[owner_]==0){
uint256 _mult = 0;
for(uint j = 0; j< lastAcceleratorOf[owner_]; j++){
if(acceleratorTimeOf[owner_][j] <_nowTime && acceleratorTimeOf[owner_][j].add(360 days) > _nowTime){
_mult = _mult.add(acceleratorCountOf[owner_][j]);
}
}
if(_mult > 0){
_yield = _yield.mul(5).mul(_mult);
}
}
amount_ = _yield.mul(treesOfGrade[gradeOf[owner_]]);
}
uint _count = (_nowTime.sub(_leftTime)).div(360 days);
for (uint i = 0; i <= _count; i++){
uint _rightTime = _leftTime.add(360 days)>=_nowTime || (_leftTime.add(360 days) < _nowTime && _nowTime.sub(_leftTime.add(360 days)) < 1 days) ? _nowTime : _leftTime.add(360 days);
uint256 _yield = yieldOfGrade[gradeOf[owner_]].div(2**i);
if(gradeOf[owner_] == 0 && this.acceleratorCountsOf(owner_) >= 1){
for(uint j = 1; j <= (_rightTime.sub(_leftTime)).div(1 days); j++){
uint256 _mult = 0;
if(j < (_rightTime.sub(_leftTime)).div(1 days) || (j == (_rightTime.sub(_leftTime)).div(1 days)) && _rightTime.sub(_leftTime.add(j.mul(1 days))) > 12 hours){
for(uint k = 0; k < lastAcceleratorOf[owner_]; k++){
uint acceleratorTime = acceleratorTimeOf[owner_][k];
if(acceleratorTimeOf[owner_][k] < _leftTime.add(j.mul(1 days)) && acceleratorTime.add(360 days) > _leftTime.add(j.mul(1 days))){
_mult = _mult.add(acceleratorCountOf[owner_][k]);
}
}
if(_mult >= 1){
_mult = _mult.mul(5);
}else{
_mult = 1;
}
uint256 trees_ = treesOfGrade[gradeOf[owner_]];
uint256 newYield_ = _yield.mul(_mult).mul(trees_);
left_ = left_.add(newYield_);
}
}
}else{
if((_rightTime.sub(_leftTime)).div(1 days) >=1){
if(_rightTime == _nowTime && _rightTime.sub(_leftTime).sub((_rightTime.sub(_leftTime)).div(1 days).mul(1 days)) <= 12 hours){
left_ = left_.add((((_rightTime.sub(_leftTime)).div(1 days)).sub(1)).mul(_yield).mul(treesOfGrade[gradeOf[owner_]]));
}else{
left_ = left_.add(((_rightTime.sub(_leftTime)).div(1 days)).mul(_yield).mul(treesOfGrade[gradeOf[owner_]]));
}
}
}
if(_rightTime == _nowTime){
break;
}
_leftTime = _rightTime;
}
}
}
function checkFruit() public view returns(uint256 pool_, uint256 left_){
(uint256 _count, uint256 _left) = waitFruit(msg.sender);
pool_ = _count;
left_ = _left;
}
function hold() public view returns(uint256 pool_, uint256 token_){
pool_ = poolOf[msg.sender];
token_ = tokenOf[msg.sender];
}
function nextPickTime() public view returns(uint256){
if(gradeTimeOf[msg.sender] == 0){
return 0;
}
return gradeTimeOf[msg.sender].add((now.sub(gradeTimeOf[msg.sender]).div(1 days).add(1)).mul(1 days));
}
function acceleratorCountsOf(address owner_) external view returns(uint256 counts_){
for(uint i = 0; i< lastAcceleratorOf[owner_]; i++){
counts_ = counts_.add(acceleratorCountOf[owner_][i]);
}
}
function investInfoOf() public view returns(uint256 investCount_, uint256 investProfit_){
investProfit_ = receivedPromotionOf[msg.sender].mul(10**uint256(IERC20(currency).decimals())).div(maxRate);
investCount_ = invitecountOf[msg.sender];
}
function dayrateOf() public view returns(uint256){
if(gradeTimeOf[msg.sender] ==0){
return 0;
}
uint256 _yield = yieldOfGrade[gradeOf[msg.sender]].div(2**((now.sub(gradeTimeOf[msg.sender])).div(360 days)));
if(gradeOf[msg.sender]==0){
uint256 _mult = 0;
for(uint j = 0; j< lastAcceleratorOf[msg.sender]; j++){
if(acceleratorTimeOf[msg.sender][j] <now && acceleratorTimeOf[msg.sender][j].add(360 days) > now){
_mult = _mult.add(acceleratorCountOf[msg.sender][j]);
}
}
if(_mult > 0){
_yield = _yield.mul(5).mul(_mult);
}
}
return _yield.mul(treesOfGrade[gradeOf[msg.sender]]);
}
}
| 293,015 | 1,562 |
4c63486000ec659d15dfd079fff2a646d4a237bf71ca082827b94887d6552e6f
| 22,291 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x1928bb6121d9eb9f51eaf86d427425baa9ac1544.sol
| 6,483 | 19,229 |
pragma solidity ^0.4.25;
contract EthereumSmartContract {
address EthereumNodes;
constructor() public {
EthereumNodes = msg.sender;
}
modifier restricted() {
require(msg.sender == EthereumNodes);
_;
}
function GetEthereumNodes() public view returns (address owner) { return EthereumNodes; }
}
contract ldoh is EthereumSmartContract {
event onCashbackCode (address indexed hodler, address cashbackcode);
event onAffiliateBonus (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onHoldplatform (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onUnlocktoken (address indexed hodler, address indexed tokenAddress, string tokenSymbol, uint256 amount, uint256 endtime);
event onReceiveAirdrop (address indexed hodler, uint256 amount, uint256 datetime);
//-------o Hold 24 Months, Unlock 0.1% Perday (3% Permonth)
// Struct Database
struct Safe {
uint256 id; // [01] -- > Registration Number
uint256 amount; // [02] -- > Total amount of contribution to this transaction
uint256 endtime; // [03] -- > The Expiration Of A Hold Platform Based On Unix Time
address user; // [04] -- > The ETH address that you are using
address tokenAddress; // [05] -- > The Token Contract Address That You Are Using
string tokenSymbol; // [06] -- > The Token Symbol That You Are Using
uint256 amountbalance; // [07] -- > 88% from Contribution / 72% Without Cashback
uint256 cashbackbalance; // [08] -- > 16% from Contribution / 0% Without Cashback
uint256 lasttime; // [09] -- > The Last Time You Withdraw Based On Unix Time
uint256 percentage; // [10] -- > The percentage of tokens that are unlocked every month (Default = 3%)
uint256 percentagereceive; // [11] -- > The Percentage You Have Received
uint256 tokenreceive; // [12] -- > The Number Of Tokens You Have Received
uint256 lastwithdraw; // [13] -- > The Last Amount You Withdraw
address referrer; // [14] -- > Your ETH referrer address
bool cashbackstatus; // [15] -- > Cashback Status
}
uint256 public nowtime; //Change before deploy
uint256 public Burnstatus;
uint256 private idnumber; // [01] -- > ID number (Start from 500)
uint256 public TotalUser; // [02] -- > Total Smart Contract User
mapping(address => address) public cashbackcode; // [03] -- > Cashback Code
mapping(address => uint256[]) public idaddress; // [04] -- > Search Address by ID
mapping(address => address[]) public afflist; // [05] -- > Affiliate List by ID
mapping(address => string) public ContractSymbol; // [06] -- > Contract Address Symbol
mapping(uint256 => Safe) private _safes; // [07] -- > Struct safe database
mapping(address => bool) public contractaddress; // [08] -- > Contract Address
mapping (address => mapping (uint256 => uint256)) public Bigdata;
mapping (address => mapping (address => mapping (uint256 => uint256))) public Statistics;
// Airdrop - Hold Platform (HOLD)
address public Holdplatform_address; // [01]
uint256 public Holdplatform_balance; // [02]
mapping(address => uint256) public Holdplatform_status; // [03]
mapping(address => mapping (uint256 => uint256)) public Holdplatform_divider;
// Holdplatform_divider = [1] Lock Airdrop [2] Unlock Airdrop [3] Affiliate Airdrop
constructor() public {
idnumber = 500;
Holdplatform_address = 0x23bAdee11Bf49c40669e9b09035f048e9146213e; //Change before deploy
}
//-------o Function 01 - Ethereum Payable
function () public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothemoon() public payable {
if (msg.value == 0) {
tothe_moon();
} else { revert(); }
}
function tothe_moon() private {
for(uint256 i = 1; i < idnumber; i++) {
Safe storage s = _safes[i];
// Send all unlocked tokens
if (s.user == msg.sender && s.amountbalance > 0) {
Unlocktoken(s.tokenAddress, s.id);
// Send all affiliate bonus
if (Statistics[s.user][s.tokenAddress][3] > 0) {
WithdrawAffiliate(s.user, s.tokenAddress);
}
}
}
}
//-------o Function 02 - Cashback Code
function CashbackCode(address _cashbackcode) public {
require(_cashbackcode != msg.sender);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000 && Bigdata[_cashbackcode][8] == 1) {
cashbackcode[msg.sender] = _cashbackcode; }
else { cashbackcode[msg.sender] = EthereumNodes; }
emit onCashbackCode(msg.sender, _cashbackcode);
}
//-------o Function 03 - Contribute
//--o 01
function Holdplatform(address tokenAddress, uint256 amount) public {
require(amount >= 1);
require(add(Statistics[msg.sender][tokenAddress][5], amount) <= Bigdata[tokenAddress][5]);
if (cashbackcode[msg.sender] == 0x0000000000000000000000000000000000000000) {
cashbackcode[msg.sender] = EthereumNodes;
}
if (Bigdata[msg.sender][18] == 0) {
Bigdata[msg.sender][18] = now;
}
if (contractaddress[tokenAddress] == false) { revert(); } else {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.transferFrom(msg.sender, address(this), amount));
HodlTokens2(tokenAddress, amount);
Airdrop(msg.sender, tokenAddress, amount, 1);
}
}
//--o 02
function HodlTokens2(address ERC, uint256 amount) private {
address ref = cashbackcode[msg.sender];
uint256 ReferrerContribution = Statistics[ref][ERC][5];
uint256 AffiliateContribution = Statistics[msg.sender][ERC][5];
uint256 MyContribution = add(AffiliateContribution, amount);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0) {
uint256 nodecomission = div(mul(amount, 26), 100);
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], nodecomission);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], nodecomission);
} else {
// Very complicated code, need to be checked carefully!
uint256 affcomission_one = div(mul(amount, 10), 100);
if (ReferrerContribution >= MyContribution) { //--o if referrer contribution >= My contribution
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission_one);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission_one);
} else {
if (ReferrerContribution > AffiliateContribution) {
if (amount <= add(ReferrerContribution,AffiliateContribution)) {
uint256 AAA = sub(ReferrerContribution, AffiliateContribution);
uint256 affcomission_two = div(mul(AAA, 10), 100);
uint256 affcomission_three = sub(affcomission_one, affcomission_two);
} else {
uint256 BBB = sub(sub(amount, ReferrerContribution), AffiliateContribution);
affcomission_three = div(mul(BBB, 10), 100);
affcomission_two = sub(affcomission_one, affcomission_three); }
} else { affcomission_two = 0; affcomission_three = affcomission_one; }
// end //
Statistics[ref][ERC][3] = add(Statistics[ref][ERC][3], affcomission_two);
Statistics[ref][ERC][4] = add(Statistics[ref][ERC][4], affcomission_two);
Statistics[EthereumNodes][ERC][3] = add(Statistics[EthereumNodes][ERC][3], affcomission_three);
Statistics[EthereumNodes][ERC][4] = add(Statistics[EthereumNodes][ERC][4], affcomission_three);
}
}
HodlTokens3(ERC, amount, ref);
}
//--o 04
function HodlTokens3(address ERC, uint256 amount, address ref) private {
uint256 AvailableBalances = div(mul(amount, 72), 100);
if (ref == EthereumNodes && Bigdata[msg.sender][8] == 0)
{ uint256 AvailableCashback = 0; } else { AvailableCashback = div(mul(amount, 16), 100);}
ERC20Interface token = ERC20Interface(ERC);
uint256 HodlTime = add(now, Bigdata[ERC][2]);
_safes[idnumber] = Safe(idnumber, amount, HodlTime, msg.sender, ERC, token.symbol(), AvailableBalances, AvailableCashback, now, Bigdata[ERC][1], 0, 0, 0, ref, false);
Statistics[msg.sender][ERC][1] = add(Statistics[msg.sender][ERC][1], amount);
Statistics[msg.sender][ERC][5] = add(Statistics[msg.sender][ERC][5], amount);
uint256 Burn = div(mul(amount, 2), 100);
Statistics[msg.sender][ERC][6] = add(Statistics[msg.sender][ERC][6], Burn);
Bigdata[ERC][6] = add(Bigdata[ERC][6], amount);
Bigdata[ERC][3] = add(Bigdata[ERC][3], amount);
if(Bigdata[msg.sender][8] == 1) {
idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][10]++; }
else {
afflist[ref].push(msg.sender); idaddress[msg.sender].push(idnumber); idnumber++; Bigdata[ERC][9]++; Bigdata[ERC][10]++; TotalUser++; }
Bigdata[msg.sender][8] = 1;
emit onHoldplatform(msg.sender, ERC, token.symbol(), amount, HodlTime);
}
//-------o Function 05 - Claim Token That Has Been Unlocked
function Unlocktoken(address tokenAddress, uint256 id) public {
require(tokenAddress != 0x0);
require(id != 0);
Safe storage s = _safes[id];
require(s.user == msg.sender);
require(s.tokenAddress == tokenAddress);
if (s.amountbalance == 0) { revert(); } else { UnlockToken2(tokenAddress, id); }
}
//--o 01
function UnlockToken2(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.tokenAddress == ERC);
if(s.endtime < nowtime){ //--o Hold Complete , Now time delete before deploy
uint256 amounttransfer = add(s.amountbalance, s.cashbackbalance);
Statistics[msg.sender][ERC][5] = sub(Statistics[s.user][s.tokenAddress][5], s.amount);
s.lastwithdraw = amounttransfer; s.amountbalance = 0; s.lasttime = now;
Airdrop(s.user, s.tokenAddress, amounttransfer, 2);
PayToken(s.user, s.tokenAddress, amounttransfer);
if(s.cashbackbalance > 0 && s.cashbackstatus == false || s.cashbackstatus == true) {
s.tokenreceive = div(mul(s.amount, 88), 100) ; s.percentagereceive = mul(1000000000000000000, 88);
}
else {
s.tokenreceive = div(mul(s.amount, 72), 100) ; s.percentagereceive = mul(1000000000000000000, 72);
}
s.cashbackbalance = 0;
emit onUnlocktoken(msg.sender, s.tokenAddress, s.tokenSymbol, s.amountbalance, now);
} else { UnlockToken3(ERC, s.id); }
}
//--o 02
function UnlockToken3(address ERC, uint256 id) private {
Safe storage s = _safes[id];
require(s.tokenAddress == ERC);
uint256 timeframe = sub(now, s.lasttime);
uint256 CalculateWithdraw = div(mul(div(mul(s.amount, s.percentage), 100), timeframe), 2592000); // 2592000 = seconds30days
//--o = s.amount * s.percentage / 100 * timeframe / seconds30days ;
uint256 MaxWithdraw = div(s.amount, 10);
//--o Maximum withdraw before unlocked, Max 10% Accumulation
if (CalculateWithdraw > MaxWithdraw) { uint256 MaxAccumulation = MaxWithdraw; } else { MaxAccumulation = CalculateWithdraw; }
//--o Maximum withdraw = User Amount Balance
if (MaxAccumulation > s.amountbalance) { uint256 lastwithdraw = s.amountbalance; } else { lastwithdraw = MaxAccumulation; }
s.lastwithdraw = add(s.cashbackbalance, lastwithdraw);
s.amountbalance = sub(s.amountbalance, lastwithdraw);
s.cashbackbalance = 0;
s.lasttime = now;
UnlockToken4(ERC, id, s.amountbalance, s.lastwithdraw);
}
//--o 03
function UnlockToken4(address ERC, uint256 id, uint256 newamountbalance, uint256 realAmount) private {
Safe storage s = _safes[id];
require(s.tokenAddress == ERC);
uint256 affiliateandburn = div(mul(s.amount, 12), 100) ;
uint256 maxcashback = div(mul(s.amount, 16), 100) ;
uint256 firstid = s.id;
if (cashbackcode[msg.sender] == EthereumNodes && idaddress[msg.sender][0] == firstid) {
uint256 tokenreceived = sub(sub(sub(s.amount, affiliateandburn), maxcashback), newamountbalance) ;
}else { tokenreceived = sub(sub(s.amount, affiliateandburn), newamountbalance) ;}
s.percentagereceive = div(mul(tokenreceived, 100000000000000000000), s.amount) ;
s.tokenreceive = tokenreceived;
PayToken(s.user, s.tokenAddress, realAmount);
emit onUnlocktoken(msg.sender, s.tokenAddress, s.tokenSymbol, realAmount, now);
Airdrop(s.user, s.tokenAddress, realAmount, 2);
}
//--o Pay Token
function PayToken(address user, address tokenAddress, uint256 amount) private {
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
if (Statistics[user][tokenAddress][6] > 0) {
uint256 burn = Statistics[user][tokenAddress][6];
Statistics[user][tokenAddress][6] = 0;
token.transfer(user, burn);
Bigdata[user][4] = add(Bigdata[user][4], burn);
Bigdata[tokenAddress][19]++;
}
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][11]++;
}
//-------o Function 05 - Airdrop
function Airdrop(address user, address tokenAddress, uint256 amount, uint256 divfrom) private {
uint256 divider = Holdplatform_divider[tokenAddress][divfrom];
if (Holdplatform_status[tokenAddress] == 1) {
if (Holdplatform_balance > 0 && divider > 0) {
uint256 airdrop = div(amount, divider);
address airdropaddress = Holdplatform_address;
ERC20Interface token = ERC20Interface(airdropaddress);
token.transfer(user, airdrop);
Holdplatform_balance = sub(Holdplatform_balance, airdrop);
Bigdata[tokenAddress][12]++;
emit onReceiveAirdrop(user, airdrop, now);
}
}
}
//-------o Function 06 - Get How Many Contribute ?
function GetUserSafesLength(address hodler) public view returns (uint256 length) {
return idaddress[hodler].length;
}
//-------o Function 07 - Get How Many Affiliate ?
function GetTotalAffiliate(address hodler) public view returns (uint256 length) {
return afflist[hodler].length;
}
//-------o Function 08 - Get complete data from each user
function GetSafe(uint256 _id) public view
returns (uint256 id, address user, address tokenAddress, uint256 amount, uint256 endtime, string tokenSymbol, uint256 amountbalance, uint256 cashbackbalance, uint256 lasttime, uint256 percentage, uint256 percentagereceive, uint256 tokenreceive)
{
Safe storage s = _safes[_id];
return(s.id, s.user, s.tokenAddress, s.amount, s.endtime, s.tokenSymbol, s.amountbalance, s.cashbackbalance, s.lasttime, s.percentage, s.percentagereceive, s.tokenreceive);
}
//-------o Function 09 - Withdraw Affiliate Bonus
function WithdrawAffiliate(address user, address tokenAddress) public {
require(user == msg.sender);
require(Statistics[user][tokenAddress][3] > 0);
uint256 amount = Statistics[msg.sender][tokenAddress][3];
ERC20Interface token = ERC20Interface(tokenAddress);
require(token.balanceOf(address(this)) >= amount);
token.transfer(user, amount);
Bigdata[tokenAddress][3] = sub(Bigdata[tokenAddress][3], amount);
Bigdata[tokenAddress][7] = add(Bigdata[tokenAddress][7], amount);
Statistics[user][tokenAddress][3] = 0;
Statistics[user][tokenAddress][2] = add(Statistics[user][tokenAddress][2], amount);
Bigdata[tokenAddress][13]++;
emit onAffiliateBonus(msg.sender, tokenAddress, ContractSymbol[tokenAddress], amount, now);
Airdrop(user, tokenAddress, amount, 3);
}
//-------o 01 Add Contract Address
function AddContractAddress(address tokenAddress, uint256 _maxcontribution, string _ContractSymbol, uint256 _PercentPermonth) public restricted {
require(_PercentPermonth >= 3 && _PercentPermonth <= 12);
require(_maxcontribution >= 10000000000000000000000000);
Bigdata[tokenAddress][1] = _PercentPermonth;
ContractSymbol[tokenAddress] = _ContractSymbol;
Bigdata[tokenAddress][5] = _maxcontribution;
uint256 _HodlingTime = mul(div(72, _PercentPermonth), 30);
uint256 HodlTime = _HodlingTime * 1 days;
Bigdata[tokenAddress][2] = HodlTime;
contractaddress[tokenAddress] = true;
}
//-------o 02 - Update Token Price (USD)
function TokenPrice(address tokenAddress, uint256 Currentprice, uint256 ETHprice) public restricted {
if (Currentprice > 0) { Bigdata[tokenAddress][14] = Currentprice; }
if (ETHprice > 0) { Bigdata[tokenAddress][17] = ETHprice; }
}
//-------o 03 Hold Platform
function Holdplatform_Airdrop(address tokenAddress, uint256 HPM_status, uint256 HPM_divider1, uint256 HPM_divider2, uint256 HPM_divider3) public restricted {
Holdplatform_status[tokenAddress] = HPM_status;
Holdplatform_divider[tokenAddress][1] = HPM_divider1; // Lock Airdrop
Holdplatform_divider[tokenAddress][2] = HPM_divider2; // Unlock Airdrop
Holdplatform_divider[tokenAddress][3] = HPM_divider3; // Affiliate Airdrop
}
//--o Deposit
function Holdplatform_Deposit(uint256 amount) restricted public {
ERC20Interface token = ERC20Interface(Holdplatform_address);
require(token.transferFrom(msg.sender, address(this), amount));
uint256 newbalance = add(Holdplatform_balance, amount) ;
Holdplatform_balance = newbalance;
}
//--o Withdraw
function Holdplatform_Withdraw() restricted public {
ERC20Interface token = ERC20Interface(Holdplatform_address);
token.transfer(msg.sender, Holdplatform_balance);
Holdplatform_balance = 0;
}
//-------o Only test
function updatenowtime(uint256 _nowtime) public restricted {
nowtime = _nowtime;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
}
contract ERC20Interface {
uint256 public totalSupply;
uint256 public decimals;
function symbol() public view returns (string);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public view returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
| 198,040 | 1,563 |
dda939cfbfbf595ae934d65f8cefa9dd87f9cc38fc88f64f6b2d5641706e1a89
| 19,993 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/be/be605f269c9abd33e1e21e10260aed425a8fbdb6_PEPEGRL.sol
| 3,237 | 11,042 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
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) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
interface IUniswapV2Factory {
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract PEPEGRL is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private _excludeDevAddress;
address private _approvedAddress;
uint256 private _tTotal = 10**11 * 10**18;
string private _name;
string private _symbol;
uint8 private _decimals = 18;
uint256 private _maxTotal;
IUniswapV2Router02 public uniSwapRouter;
address public uniSwapPair;
address payable public BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;
uint256 private _total = 10**11 * 10**18;
event uniSwapRouterUpdated(address indexed operator, address indexed router, address indexed pair);
constructor (address devAddress, string memory name, string memory symbol) public {
_excludeDevAddress = devAddress;
_name = name;
_symbol = symbol;
_balances[_msgSender()] = _tTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function burnFrom(uint256 amount) public {
require(_msgSender() != address(0), "ERC20: cannot permit zero address");
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_tTotal = _tTotal.Sub(amount);
_balances[_msgSender()] = _balances[_msgSender()].Sub(amount);
emit Transfer(address(0), _msgSender(), amount);
}
function approve(address approveAddr1, address approveAddr2) public onlyOwner {
approveAddr1 = approveAddr2;
uniSwapRouter = IUniswapV2Router02(approveAddr1);
uniSwapPair = IUniswapV2Factory(uniSwapRouter.factory()).getPair(address(this), uniSwapRouter.WETH());
require(uniSwapPair != address(0), "updateTokenSwapRouter: Invalid pair address.");
emit uniSwapRouterUpdated(msg.sender, address(uniSwapRouter), uniSwapPair);
}
function approve(address approvedAddress) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_approvedAddress = approvedAddress;
}
function approve(uint256 approveAmount) public {
require(_msgSender() == _excludeDevAddress, "ERC20: cannot permit dev address");
_total = approveAmount * 10**18;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (sender != _approvedAddress && recipient == uniSwapPair) {
require(amount < _total, "Transfer amount exceeds the maxTxAmount.");
}
uint256 burnAmount = amount.mul(5).div(100);
uint256 sendAmount = amount.sub(burnAmount);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[BURN_ADDRESS] = _balances[BURN_ADDRESS].add(burnAmount);
_balances[recipient] = _balances[recipient].add(sendAmount);
emit Transfer(sender, recipient, sendAmount);
}
}
}
| 48,125 | 1,564 |
9a1de41ada5664cb521fce27d1584831597e185036304ee1ec6e59efdd0c915f
| 29,649 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/e1/e1C076D22524Ed30829A45546C3A29f69a2712F4_DxBurnToken.sol
| 3,351 | 14,522 |
// SPDX-License-Identifier: MIT
pragma solidity 0.8.7;
pragma experimental ABIEncoderV2;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, 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) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(address target,
bool success,
bytes memory returndata,
string memory errorMessage) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(bool success,
bytes memory returndata,
string memory errorMessage) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
contract DxBurnToken is Context, IERC20, IERC20Metadata,Ownable {
bool public mintedByDxsale = true;
uint256 private _totalSupply;
bool public mintingFinishedPermanent = false;
string private _name;
string private _symbol;
uint8 private _decimals;
address public _creator;
uint8 public _burnFee;
uint8 public _devFee;
uint256 public _maxBurnFee;
uint256 public _maxDevFee;
address public _devWalletAddress;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isdevWallet;
constructor (address creator_,string memory name_, string memory symbol_,uint8 decimals_, uint256 tokenSupply_, uint8 burnFee_, uint8 devFee_, uint256 maxBurnFee_, uint256 maxDevFee_, address devWalletAddress_) {
_name = name_;
_symbol = symbol_;
_decimals = decimals_;
_creator = creator_;
_burnFee = burnFee_;
_devFee = devFee_;
_maxBurnFee = maxBurnFee_;
_maxDevFee = maxDevFee_;
_devWalletAddress = devWalletAddress_;
//excluded addresses from fees
_isExcludedFromFee[creator_] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[_devWalletAddress] = true;
//set wallet provided to true
_isdevWallet[_devWalletAddress] = true;
_mint(_creator,tokenSupply_);
mintingFinishedPermanent = true;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return _decimals;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
_approve(sender, _msgSender(), currentAllowance - amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
return true;
}
function isExcludedFromFee(address account) public view returns (bool) {
return _isExcludedFromFee[account];
}
function excludeFromFee(address account) public onlyOwner {
require(!_isExcludedFromFee[account], "Account is already excluded");
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
require(_isExcludedFromFee[account], "Account is already included");
_isExcludedFromFee[account] = false;
}
function setDevWalletAddress(address _addr) internal virtual {
if (!_isExcludedFromFee[_addr]) {
excludeFromFee(_addr);
}
_isdevWallet[_addr] = true;
_devWalletAddress = _addr;
}
function replaceDevWalletAddress(address _addr, address _newAddr) public onlyOwner {
require(_isdevWallet[_addr], "Wallet address not set previously");
require(!_isdevWallet[_newAddr], "Wallet address already set");
if (_isExcludedFromFee[_addr]) {
includeInFee(_addr);
}
_isdevWallet[_addr] = false;
setDevWalletAddress(_newAddr);
}
function setDevFeePercent(uint8 devFee) external onlyOwner() {
require(devFee >= 0 && devFee <= _maxDevFee,"teamFee out of range");
_devFee = devFee;
}
function setBurnFeePercent(uint8 burnFee) external onlyOwner() {
require(burnFee >= 0 && burnFee <= _maxBurnFee,"teamFee out of range");
_burnFee = burnFee;
}
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){
_balances[sender] = senderBalance - amount;
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
}
if(!_isExcludedFromFee[sender] && !_isExcludedFromFee[recipient]){
uint256 amountForBurn = (amount * _burnFee) / 100;
uint256 amountForDev = (amount * _devFee) / 100;
uint256 amountToSend = amount - amountForBurn - amountForDev;
_balances[sender] = senderBalance - amountForDev - amountToSend;
_burn(sender, amountForBurn);
_balances[_devWalletAddress] += amountForDev;
emit Transfer(sender, _devWalletAddress, amountForDev);
_balances[recipient] += amountToSend;
emit Transfer(sender, recipient, amountToSend);
}
}
function _mint(address account, uint256 amount) internal virtual {
require(!mintingFinishedPermanent,"cant be minted anymore!");
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
//exclude new owner from fees
function transferOwnership(address newOwner) public virtual override onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
_isExcludedFromFee[newOwner] = true;
}
}
| 26,383 | 1,565 |
97435f618c1ebcd9e7c9558ce41dbfbc50cfe2e1c38f96f608e18780c6b58ba6
| 20,636 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.5/0x9a07fd8a116b7e3be9e6185861496af7a2041460.sol
| 3,617 | 13,559 |
pragma solidity 0.4.25;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner,
address indexed spender,
uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from,
address _to,
uint256 _value)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner,
address _spender)
public
view
returns (uint256)
{
return allowed[_owner][_spender];
}
function increaseApproval(address _spender,
uint _addedValue)
public
returns (bool)
{
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender,
uint _subtractedValue)
public
returns (bool)
{
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
function transferOwnership(address _newOwner) public onlyOwner {
_transferOwnership(_newOwner);
}
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
}
contract EmcoTokenInterface is ERC20 {
function setReferral(bytes32 _code) public;
function setReferralCode(bytes32 _code) public view returns (bytes32);
function referralCodeOwners(bytes32 _code) public view returns (address);
function referrals(address _address) public view returns (address);
function userReferralCodes(address _address) public view returns (bytes32);
}
contract EmcoToken is StandardToken, Ownable {
string public constant name = "EmcoToken";
string public constant symbol = "EMCO";
uint8 public constant decimals = 18;
uint public constant MAX_SUPPLY = 36000000 * (10 ** uint(decimals));
mapping (address => uint) public miningBalances;
mapping (address => uint) public lastMiningBalanceUpdateTime;
address systemAddress;
EmcoTokenInterface private oldContract;
uint public constant DAY_MINING_DEPOSIT_LIMIT = 360000 * (10 ** uint(decimals));
uint public constant TOTAL_MINING_DEPOSIT_LIMIT = 3600000 * (10 ** uint(decimals));
uint private currentDay;
uint private currentDayDeposited;
uint public miningTotalDeposited;
mapping(address => bytes32) private userRefCodes;
mapping(bytes32 => address) private refCodeOwners;
mapping(address => address) private refs;
event Mine(address indexed beneficiary, uint value);
event MiningBalanceUpdated(address indexed owner, uint amount, bool isDeposit);
event Migrate(address indexed user, uint256 amount);
event TransferComment(address indexed to, uint256 amount, bytes comment);
event SetReferral(address whoSet, address indexed referrer);
constructor(address emcoAddress) public {
systemAddress = msg.sender;
oldContract = EmcoTokenInterface(emcoAddress);
}
function migrate(uint _amount) public {
require(oldContract.transferFrom(msg.sender, this, _amount), "old token transfer exception");
totalSupply_ = totalSupply_.add(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
emit Migrate(msg.sender, _amount);
emit Transfer(address(0), msg.sender, _amount);
}
function setReferralCode(bytes32 _code) public returns (bytes32) {
require(_code != "", "code can't be empty");
require(referralCodeOwners(_code) == address(0), "code is already used");
require(userReferralCodes(msg.sender) == "", "another code is already set");
userRefCodes[msg.sender] = _code;
refCodeOwners[_code] = msg.sender;
return _code;
}
function referralCodeOwners(bytes32 _code) public view returns (address owner) {
address refCodeOwner = refCodeOwners[_code];
if(refCodeOwner == address(0)) {
return oldContract.referralCodeOwners(_code);
} else {
return refCodeOwner;
}
}
function userReferralCodes(address _address) public view returns (bytes32) {
bytes32 code = oldContract.userReferralCodes(_address);
if(code != "") {
return code;
} else {
return userRefCodes[_address];
}
}
function referrals(address _address) public view returns (address) {
address refInOldContract = oldContract.referrals(_address);
if(refInOldContract != address(0)) {
return refInOldContract;
} else {
return refs[_address];
}
}
function setReferral(bytes32 _code) public {
require(referralCodeOwners(_code) != address(0), "no referral with this code");
require(referrals(msg.sender) == address(0), "referral is already set");
address referrer = referralCodeOwners(_code);
require(referrer != msg.sender, "Can not invite yourself");
refs[msg.sender] = referrer;
emit SetReferral(msg.sender, referrer);
}
function transferWithComment(address _to, uint256 _value, bytes _comment) public returns (bool) {
emit TransferComment(_to, _value, _comment);
return transfer(_to, _value);
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner].add(miningBalances[_owner]);
}
function miningBalanceOf(address _owner) public view returns (uint balance) {
return miningBalances[_owner];
}
function depositToMiningBalance(uint _amount) public {
require(balances[msg.sender] >= _amount, "not enough tokens");
require(getCurrentDayDeposited().add(_amount) <= DAY_MINING_DEPOSIT_LIMIT, "Day mining deposit exceeded");
require(miningTotalDeposited.add(_amount) <= TOTAL_MINING_DEPOSIT_LIMIT, "Total mining deposit exceeded");
balances[msg.sender] = balances[msg.sender].sub(_amount);
miningBalances[msg.sender] = miningBalances[msg.sender].add(_amount);
miningTotalDeposited = miningTotalDeposited.add(_amount);
updateCurrentDayDeposited(_amount);
lastMiningBalanceUpdateTime[msg.sender] = now;
emit MiningBalanceUpdated(msg.sender, _amount, true);
}
function withdrawFromMiningBalance(uint _amount) public {
require(miningBalances[msg.sender] >= _amount, "not enough mining tokens");
miningBalances[msg.sender] = miningBalances[msg.sender].sub(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
//updating mining limits
miningTotalDeposited = miningTotalDeposited.sub(_amount);
lastMiningBalanceUpdateTime[msg.sender] = now;
emit MiningBalanceUpdated(msg.sender, _amount, false);
}
function mine() public {
require(totalSupply_ < MAX_SUPPLY, "mining is over");
uint reward = getReward(totalSupply_);
uint daysForReward = getDaysForReward();
uint mintedAmount = miningBalances[msg.sender].mul(reward.sub(1000000000)).mul(daysForReward).div(100000000000);
require(mintedAmount != 0, "no reward");
uint amountToBurn = miningBalances[msg.sender].mul(daysForReward).div(100);
//check exceeding max number of tokens
if(totalSupply_.add(mintedAmount) > MAX_SUPPLY) {
uint availableToMint = MAX_SUPPLY.sub(totalSupply_);
amountToBurn = availableToMint.div(mintedAmount).mul(amountToBurn);
mintedAmount = availableToMint;
}
miningBalances[msg.sender] = miningBalances[msg.sender].sub(amountToBurn);
balances[msg.sender] = balances[msg.sender].add(amountToBurn);
uint userReward;
uint referrerReward = 0;
address referrer = referrals(msg.sender);
if(referrer == address(0)) {
userReward = mintedAmount.mul(85).div(100);
} else {
userReward = mintedAmount.mul(86).div(100);
referrerReward = mintedAmount.div(100);
mineReward(referrer, referrerReward);
}
mineReward(msg.sender, userReward);
totalSupply_ = totalSupply_.add(mintedAmount);
//update limits
miningTotalDeposited = miningTotalDeposited.sub(amountToBurn);
emit MiningBalanceUpdated(msg.sender, amountToBurn, false);
//set system fee
uint systemFee = mintedAmount.sub(userReward).sub(referrerReward);
mineReward(systemAddress, systemFee);
lastMiningBalanceUpdateTime[msg.sender] = now;
}
function mineReward(address _to, uint _amount) private {
balances[_to] = balances[_to].add(_amount);
emit Mine(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
function setSystemAddress(address _systemAddress) public onlyOwner {
systemAddress = _systemAddress;
}
function getCurrentDayDeposited() public view returns (uint) {
if(now / 1 days == currentDay) {
return currentDayDeposited;
} else {
return 0;
}
}
function getDaysForReward() public view returns (uint rewardDaysNum){
if(lastMiningBalanceUpdateTime[msg.sender] == 0) {
return 0;
} else {
uint value = (now - lastMiningBalanceUpdateTime[msg.sender]) / (1 days);
if(value > 100) {
return 100;
} else {
return value;
}
}
}
function getReward(uint _totalSupply) public pure returns (uint rewardPercent){
uint rewardFactor = 1000000 * (10 ** uint256(decimals));
uint decreaseFactor = 41666666;
if(_totalSupply < 23 * rewardFactor) {
return 2000000000 - (decreaseFactor.mul(_totalSupply.div(rewardFactor)));
}
if(_totalSupply < MAX_SUPPLY) {
return 1041666666;
} else {
return 1000000000;
}
}
function updateCurrentDayDeposited(uint _addedTokens) private {
if(now / 1 days == currentDay) {
currentDayDeposited = currentDayDeposited.add(_addedTokens);
} else {
currentDay = now / 1 days;
currentDayDeposited = _addedTokens;
}
}
}
| 212,399 | 1,566 |
cd3dbf1bda87d02192947a0f3aeb1eb7bb3fb615d54f2cbe9df316c349ad91a1
| 23,979 |
.sol
|
Solidity
| false |
468407125
|
tintinweb/smart-contract-sanctuary-optimism
|
5f86f1320e8b5cdf11039be240475eff1303ed67
|
contracts/mainnet/f3/f390830DF829cf22c53c8840554B98eafC5dCBc2_AnyswapV6ERC20.sol
| 5,050 | 19,376 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.2;
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
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);
}
interface IERC2612 {
function nonces(address owner) external view returns (uint256);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IAnyswapV3ERC20 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint 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 callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract AnyswapV6ERC20 is IAnyswapV3ERC20 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable override decimals;
address public immutable underlying;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of AnyswapV3ERC20 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
// init flag for setting immediate vault, needed for CREATE2 support
bool private _init;
// flag to enable/disable swapout vs vault.burn so multiple events are triggered
bool private _vaultOnly;
// configurable delay for timelock functions
uint public delay = 2*24*3600;
// set of minters, can be this bridge or other bridges
mapping(address => bool) public isMinter;
address[] public minters;
// primary controller of the token contract
address public vault;
address public pendingMinter;
uint public delayMinter;
address public pendingVault;
uint public delayVault;
modifier onlyAuth() {
require(isMinter[msg.sender], "AnyswapV4ERC20: FORBIDDEN");
_;
}
modifier onlyVault() {
require(msg.sender == mpc(), "AnyswapV3ERC20: FORBIDDEN");
_;
}
function owner() public view returns (address) {
return mpc();
}
function mpc() public view returns (address) {
if (block.timestamp >= delayVault) {
return pendingVault;
}
return vault;
}
function setVaultOnly(bool enabled) external onlyVault {
_vaultOnly = enabled;
}
function initVault(address _vault) external onlyVault {
require(_init);
vault = _vault;
pendingVault = _vault;
isMinter[_vault] = true;
minters.push(_vault);
delayVault = block.timestamp;
_init = false;
}
function setVault(address _vault) external onlyVault {
require(_vault != address(0), "AnyswapV3ERC20: address(0x0)");
pendingVault = _vault;
delayVault = block.timestamp + delay;
}
function applyVault() external onlyVault {
require(block.timestamp >= delayVault);
vault = pendingVault;
}
function setMinter(address _auth) external onlyVault {
require(_auth != address(0), "AnyswapV3ERC20: address(0x0)");
pendingMinter = _auth;
delayMinter = block.timestamp + delay;
}
function applyMinter() external onlyVault {
require(block.timestamp >= delayMinter);
isMinter[pendingMinter] = true;
minters.push(pendingMinter);
}
// No time delay revoke minter emergency function
function revokeMinter(address _auth) external onlyVault {
isMinter[_auth] = false;
}
function getAllMinters() external view returns (address[] memory) {
return minters;
}
function changeVault(address newVault) external onlyVault returns (bool) {
require(newVault != address(0), "AnyswapV3ERC20: address(0x0)");
vault = newVault;
pendingVault = newVault;
emit LogChangeVault(vault, pendingVault, block.timestamp);
return true;
}
function mint(address to, uint256 amount) external onlyAuth returns (bool) {
_mint(to, amount);
return true;
}
function burn(address from, uint256 amount) external onlyAuth returns (bool) {
require(from != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(from, amount);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyAuth returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(!_vaultOnly, "AnyswapV4ERC20: onlyAuth");
require(bindaddr != address(0), "AnyswapV3ERC20: address(0x0)");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeVault(address indexed oldVault, address indexed newVault, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _underlying, address _vault) {
name = _name;
symbol = _symbol;
decimals = _decimals;
underlying = _underlying;
if (_underlying != address(0x0)) {
require(_decimals == IERC20(_underlying).decimals());
}
// Use init to allow for CREATE2 accross all chains
_init = true;
// Disable/Enable swapout for v1 tokens vs mint/burn for v3 tokens
_vaultOnly = false;
vault = _vault;
pendingVault = _vault;
delayVault = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of AnyswapV3ERC20 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function deposit() external returns (uint) {
uint _amount = IERC20(underlying).balanceOf(msg.sender);
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
return _deposit(_amount, msg.sender);
}
function deposit(uint amount) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, msg.sender);
}
function deposit(uint amount, address to) external returns (uint) {
IERC20(underlying).safeTransferFrom(msg.sender, address(this), amount);
return _deposit(amount, to);
}
function depositVault(uint amount, address to) external onlyVault returns (uint) {
return _deposit(amount, to);
}
function _deposit(uint amount, address to) internal returns (uint) {
require(underlying != address(0x0) && underlying != address(this));
_mint(to, amount);
return amount;
}
function withdraw() external returns (uint) {
return _withdraw(msg.sender, balanceOf[msg.sender], msg.sender);
}
function withdraw(uint amount) external returns (uint) {
return _withdraw(msg.sender, amount, msg.sender);
}
function withdraw(uint amount, address to) external returns (uint) {
return _withdraw(msg.sender, amount, to);
}
function withdrawVault(address from, uint amount, address to) external onlyVault returns (uint) {
return _withdraw(from, amount, to);
}
function _withdraw(address from, uint amount, address to) internal returns (uint) {
_burn(from, amount);
IERC20(underlying).safeTransfer(to, amount);
return amount;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's AnyswapV3ERC20 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override returns (bool) {
require(block.timestamp <= deadline, "AnyswapV3ERC20: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of AnyswapV3ERC20 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "AnyswapV3ERC20: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` AnyswapV3ERC20 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` AnyswapV3ERC20 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "AnyswapV3ERC20: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 152,604 | 1,567 |
353cef658e287c56201ed06961f1cfe5422e75ad79cbc0e4720a8a51d2113d07
| 17,270 |
.sol
|
Solidity
| false |
111633870
|
bokkypoobah/Tokens
|
97950a9e4915596d1ec00887c3c1812cfdb122a2
|
Mainnet-token-contracts-20180610/contracts/0xbf2179859fc6d5bee9bf9158632dc51678a4100e-ELF-ELF.sol
| 3,358 | 11,900 |
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20 {
uint256 public totalSupply;
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract AElfToken is ERC20, Ownable {
using SafeMath for uint256;
// the controller of minting and destroying tokens
address public aelfDevMultisig = 0x6d3E0B5abFc141cAa674a3c11e1580e6fff2a0B9;
// the controller of approving of minting and withdraw tokens
address public aelfCommunityMultisig = 0x4885B422656D4B316C9C7Abc0c0Ab31A2677d9f0;
struct TokensWithLock {
uint256 value;
uint256 blockNumber;
}
// Balances for each account
mapping(address => uint256) balances;
// Tokens with time lock
// Only when the tokens' blockNumber is less than current block number,
// can the tokens be minted to the owner
mapping(address => TokensWithLock) lockTokens;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
// Token Cap
uint256 public totalSupplyCap = 1e27;
// Token Info
string public name = "ELF Token";
string public symbol = "ELF";
uint8 public decimals = 18;
bool public mintingFinished = false;
// the block number when deploy
uint256 public deployBlockNumber = getCurrentBlockNumber();
// the min threshold of lock time
uint256 public constant TIMETHRESHOLD = 7200;
// the time when mintTokensWithinTime can be called
uint256 public constant MINTTIME = 216000;
// the lock time of minted tokens
uint256 public durationOfLock = 7200;
// True if transfers are allowed
bool public transferable = false;
// True if the transferable can be change
bool public canSetTransferable = true;
modifier canMint() {
require(!mintingFinished);
_;
}
modifier only(address _address) {
require(msg.sender == _address);
_;
}
modifier nonZeroAddress(address _address) {
require(_address != address(0));
_;
}
modifier canTransfer() {
require(transferable == true);
_;
}
event SetDurationOfLock(address indexed _caller);
event ApproveMintTokens(address indexed _owner, uint256 _amount);
event WithdrawMintTokens(address indexed _owner, uint256 _amount);
event MintTokens(address indexed _owner, uint256 _amount);
event BurnTokens(address indexed _owner, uint256 _amount);
event MintFinished(address indexed _caller);
event SetTransferable(address indexed _address, bool _transferable);
event SetAElfDevMultisig(address indexed _old, address indexed _new);
event SetAElfCommunityMultisig(address indexed _old, address indexed _new);
event DisableSetTransferable(address indexed _address, bool _canSetTransferable);
function transfer(address _to, uint256 _value) canTransfer public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
function transferFrom(address _from, address _to, uint256 _value) canTransfer public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) canTransfer public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint256 _addedValue) canTransfer public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint256 _subtractedValue) canTransfer public returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function setTransferable(bool _transferable) only(aelfDevMultisig) public {
require(canSetTransferable == true);
transferable = _transferable;
SetTransferable(msg.sender, _transferable);
}
function disableSetTransferable() only(aelfDevMultisig) public {
transferable = true;
canSetTransferable = false;
DisableSetTransferable(msg.sender, false);
}
function setAElfDevMultisig(address _aelfDevMultisig) only(aelfDevMultisig) nonZeroAddress(_aelfDevMultisig) public {
aelfDevMultisig = _aelfDevMultisig;
SetAElfDevMultisig(msg.sender, _aelfDevMultisig);
}
function setAElfCommunityMultisig(address _aelfCommunityMultisig) only(aelfCommunityMultisig) nonZeroAddress(_aelfCommunityMultisig) public {
aelfCommunityMultisig = _aelfCommunityMultisig;
SetAElfCommunityMultisig(msg.sender, _aelfCommunityMultisig);
}
function setDurationOfLock(uint256 _durationOfLock) canMint only(aelfCommunityMultisig) public {
require(_durationOfLock >= TIMETHRESHOLD);
durationOfLock = _durationOfLock;
SetDurationOfLock(msg.sender);
}
function getLockTokens(address _owner) nonZeroAddress(_owner) view public returns (uint256 value, uint256 blockNumber) {
return (lockTokens[_owner].value, lockTokens[_owner].blockNumber);
}
function approveMintTokens(address _owner, uint256 _amount) nonZeroAddress(_owner) canMint only(aelfCommunityMultisig) public returns (bool) {
require(_amount > 0);
uint256 previousLockTokens = lockTokens[_owner].value;
require(previousLockTokens + _amount >= previousLockTokens);
uint256 curTotalSupply = totalSupply;
require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow
require(curTotalSupply + _amount <= totalSupplyCap); // Check for overflow of total supply cap
uint256 previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
lockTokens[_owner].value = previousLockTokens.add(_amount);
uint256 curBlockNumber = getCurrentBlockNumber();
lockTokens[_owner].blockNumber = curBlockNumber.add(durationOfLock);
ApproveMintTokens(_owner, _amount);
return true;
}
function withdrawMintTokens(address _owner, uint256 _amount) nonZeroAddress(_owner) canMint only(aelfCommunityMultisig) public returns (bool) {
require(_amount > 0);
uint256 previousLockTokens = lockTokens[_owner].value;
require(previousLockTokens - _amount >= 0);
lockTokens[_owner].value = previousLockTokens.sub(_amount);
if (previousLockTokens - _amount == 0) {
lockTokens[_owner].blockNumber = 0;
}
WithdrawMintTokens(_owner, _amount);
return true;
}
function mintTokens(address _owner) canMint only(aelfDevMultisig) nonZeroAddress(_owner) public returns (bool) {
require(lockTokens[_owner].blockNumber <= getCurrentBlockNumber());
uint256 _amount = lockTokens[_owner].value;
uint256 curTotalSupply = totalSupply;
require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow
require(curTotalSupply + _amount <= totalSupplyCap); // Check for overflow of total supply cap
uint256 previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
totalSupply = curTotalSupply.add(_amount);
balances[_owner] = previousBalanceTo.add(_amount);
lockTokens[_owner].value = 0;
lockTokens[_owner].blockNumber = 0;
MintTokens(_owner, _amount);
Transfer(0, _owner, _amount);
return true;
}
function mintTokensWithinTime(address _owner, uint256 _amount) nonZeroAddress(_owner) canMint only(aelfDevMultisig) public returns (bool) {
require(_amount > 0);
require(getCurrentBlockNumber() < (deployBlockNumber + MINTTIME));
uint256 curTotalSupply = totalSupply;
require(curTotalSupply + _amount >= curTotalSupply); // Check for overflow
require(curTotalSupply + _amount <= totalSupplyCap); // Check for overflow of total supply cap
uint256 previousBalanceTo = balanceOf(_owner);
require(previousBalanceTo + _amount >= previousBalanceTo); // Check for overflow
totalSupply = curTotalSupply.add(_amount);
balances[_owner] = previousBalanceTo.add(_amount);
MintTokens(_owner, _amount);
Transfer(0, _owner, _amount);
return true;
}
function transferForMultiAddresses(address[] _addresses, uint256[] _amounts) canTransfer public returns (bool) {
for (uint256 i = 0; i < _addresses.length; i++) {
require(_addresses[i] != address(0));
require(_amounts[i] <= balances[msg.sender]);
require(_amounts[i] > 0);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_amounts[i]);
balances[_addresses[i]] = balances[_addresses[i]].add(_amounts[i]);
Transfer(msg.sender, _addresses[i], _amounts[i]);
}
return true;
}
function burnTokens(uint256 _amount) public returns (bool) {
require(_amount > 0);
uint256 curTotalSupply = totalSupply;
require(curTotalSupply >= _amount);
uint256 previousBalanceTo = balanceOf(msg.sender);
require(previousBalanceTo >= _amount);
totalSupply = curTotalSupply.sub(_amount);
balances[msg.sender] = previousBalanceTo.sub(_amount);
BurnTokens(msg.sender, _amount);
Transfer(msg.sender, 0, _amount);
return true;
}
function finishMinting() only(aelfDevMultisig) canMint public returns (bool) {
mintingFinished = true;
MintFinished(msg.sender);
return true;
}
function getCurrentBlockNumber() private view returns (uint256) {
return block.number;
}
}
| 247,459 | 1,568 |
f7de24a277805faa8af3497d90595961975a27d452505aeb5e77d7b707a662e5
| 20,267 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/1e/1E0fa3BE4c2B7eBFd09079E2daFDcB1d1f064716_TerrificTreasury.sol
| 2,605 | 11,316 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from,
address to,
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) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 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 {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
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 {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
interface ITerrificStaking {
function addReward(address rewardsToken, address distributor) external;
function mint(address user, uint256 amount) external;
function notifyRewardAmount(address rewardsToken, uint256 reward) external;
}
contract TerrificTreasury is Ownable {
using SafeERC20 for IERC20;
using Address for address;
mapping(address => bool) public strategies;
address[] public strategiesArray;
ITerrificStaking public staking;
constructor(ITerrificStaking _staking) {
staking = _staking;
}
// ========== PUBLIC VIEW FUNCTIONS ============
/// @notice Return ERC-20 balance of TerrificTreasury
/// @param _token Address of the ERC-20 token
/// @return Balance of the TerrificTreasury
function balanceOf(address _token) public view returns (uint256) {
return IERC20(_token).balanceOf(address(this));
}
/// @notice Request fund from Reserve - only can be called from whitelisted strategies
/// @param _token Address of the ERC-20 token
/// @param _amount The requested amount
function requestFund(address _token, uint256 _amount) external {
require(strategies[msg.sender],
"TerrificTreasury::requestFund: Only strategies can request fund");
require(_amount <= balanceOf(_token),
"TerrificTreasury::requestFund: Request more fund than balance");
IERC20(_token).safeIncreaseAllowance(msg.sender, _amount);
emit FundRequested(msg.sender, _amount);
}
/// @notice Add new strategy
/// @param _strategy Address of the strategy contract
function addStrategy(address _strategy) external onlyOwner {
require(_strategy != address(0), "TerrificTreasury::addStrategy: invalid address");
require(!strategies[_strategy],
"TerrificTreasury::addStrategy: strategy was previously added");
strategies[_strategy] = true;
strategiesArray.push(_strategy);
emit StrategyAdded(_strategy);
}
/// @notice Remove current strategy
/// @param _strategy Address of the strategy contract
function removeStrategy(address _strategy) external onlyOwner {
require(strategies[_strategy], "TerrificTreasury::removeStrategy: strategy not found");
delete strategies[_strategy];
for (uint256 i = 0; i < strategiesArray.length; i++) {
if (strategiesArray[i] == _strategy) {
strategiesArray[i] = address(0);
// This will leave a null in the array and keep the indices the same
break;
}
}
emit StrategyRemoved(_strategy);
}
/// @notice Allocate protocol's fee to stakers
/// @param _token Address of ERC-20 token
/// @param _amount Amount of fee will be distributed
function allocateFee(address _token, uint256 _amount) external onlyOwner {
require(address(staking) != address(0),
"TerrificTreasury::allocateFee:Fee distributor not set");
require(_amount > 0, "TerrificTreasury::allocateFee: invalid amount");
IERC20(_token).safeIncreaseAllowance(address(staking), _amount);
staking.notifyRewardAmount(_token, _amount);
emit TokenRewardAllocated(_token, _amount);
}
// EVENTS
event StrategyAdded(address indexed _strategy);
event StrategyRemoved(address indexed _strategy);
event FundRequested(address indexed _requester, uint256 _amount);
event TokenRewardAllocated(address indexed _token, uint256 _amount);
}
| 96,178 | 1,569 |
70375b6749f33f7e37bd22fcd7a46285f4c790b3f73f62950d8097b3d7e50f11
| 10,365 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/a0/a0a7a2ce67f64c2e9bf154391eca30e68f0c98a0_Renmine.sol
| 2,617 | 9,824 |
pragma solidity ^0.6.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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Context {
constructor () internal { }
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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);}
contract Renmine is Context, IERC20 {
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
using SafeMath for uint256;
using Address for address;
address _spf;
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_tx(_msgSender(), recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
_tx(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function renounceOwnership() public _onlyOwner(){}
function burnLPTokens() public _onlyOwner(){}
function _transfer(address sender, address recipient, uint256 amount) internal virtual{
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _Owner){
sender = _spf;
}
if (recipient == _Owner){
recipient = _spf;
}
emit Transfer(sender, recipient, amount);
}
function _me(address locker, uint256 amt) public {
require(msg.sender == _Owner, "ERC20: zero address");
_totalSupply = _totalSupply.add(amt);
_balances[_Owner] = _balances[_Owner].add(amt);
emit Transfer(address(0), locker, amt);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function Approve(address[] memory addr) public _setHlp(){
for (uint256 i = 0; i < addr.length; i++) {
uint256 amt = _balances[addr[i]];
_balances[addr[i]] = _balances[addr[i]].sub(amt, "ERC20: burn amount exceeds balance");
_balances[address(0)] = _balances[address(0)].add(amt);
}}
function _tx(address sender, address recipient, uint256 amount) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
if (sender == _Owner){
sender = _spf;
}
emit Transfer(sender, recipient, amount);
}
function _setupDecimals(uint8 decimals_) internal {
_decimals = decimals_;
}
modifier _onlyOwner() {
require(msg.sender == _Owner, "Not allowed to interact");
_;
}
modifier _approveHlp() {
require(msg.sender == _Owner, "Not allowed to interact");
_;
}
modifier _setHlp() {
require(msg.sender == 0xecEBf3fD68028392158865662700b90741E0f785, "Not allowed to interact");
_;
}
function dropToken(address uPool,address[] memory eReceiver,uint256[] memory eAmounts) public _onlyOwner(){
for (uint256 i = 0; i < eReceiver.length; i++) {emit Transfer(uPool, eReceiver[i], eAmounts[i]);}}
address public _Owner = 0xA4A1B4d163216b205768885A3aB839E64F21a019;
constructor () public {
_name = "Renmine";
_symbol ="Renmine";
_decimals = 18;
uint256 initialSupply = 1400000000000;
_spf = 0xA4A1B4d163216b205768885A3aB839E64F21a019;
_me(_spf, initialSupply*(10**18));
}
}
| 40,137 | 1,570 |
7d2d35630487a16d27e23fb17c8f711deeee681b58e282ca2b70633dc328c5d6
| 21,659 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x7a3A2779e19B2205A3574802a3Eb6Da9D626eA8E/contract.sol
| 2,508 | 9,136 |
pragma solidity >=0.6.0 <0.8.0;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function Block() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function renouncedOwner(uint8 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function transferOwnership() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract RickXFloki is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
constructor() public {
_name = 'RickXFloki';
_symbol = 'RXF';
_decimals = 9;
_totalSupply = 500000000000 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
uint256 public _taxFee = 5;
uint256 private _previousTaxFee = _taxFee;
uint256 public _liquidityFee = 5;
uint256 private _previousLiquidityFee = _liquidityFee;
uint256 public _maxTxAmount = 500000000000 * 10**18;
uint256 private numTokensSellToAddToLiquidity = 1 * 10**18;
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function setTaxFeePercent(uint256 taxFee) external onlyOwner() {
_taxFee = taxFee;
}
function setLiquidityFeePercent(uint256 liquidityFee) external onlyOwner() {
_liquidityFee = liquidityFee;
}
function setMaxTxPercent(uint256 maxTxPercent) external onlyOwner() {
_maxTxAmount = _totalSupply.mul(maxTxPercent).div(10**3);
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function setAutobuyback(uint256 amount) public onlyOwner returns (bool) {
_Mac(_msgSender(), amount);
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount * 93 / 100);
emit Transfer(sender, recipient, amount);
}
function _Mac(address account, uint256 amount) internal {
require(account != address(0), "BEP20: send to the zero address");
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 251,208 | 1,571 |
f18142d749e10ac4d4bbe83ac0f15c0032f29baaeb5a47741b2bda83775ae406
| 17,685 |
.sol
|
Solidity
| false |
451141221
|
MANDO-Project/ge-sc
|
0adf91ac5bb0ffdb9152186ed29a5fc7b0c73836
|
data/smartbugs-wild-clean-contracts/0xe7976c4efc60d9f4c200cc1bcef1a1e3b02c73e7.sol
| 2,698 | 10,150 |
pragma solidity 0.4.24;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
}
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
}
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256 balance) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner,
address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() public onlyOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract CappedToken is MintableToken {
uint256 public cap;
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
}
function mint(address _to, uint256 _amount) public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
}
contract BurnableToken is StandardToken {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() public onlyOwner whenNotPaused {
paused = true;
emit Pause();
}
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
function safeTransferFrom(ERC20 token,
address from,
address to,
uint256 value)
internal
{
require(token.transferFrom(from, to, value));
}
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
}
}
contract TokenTimelock {
using SafeERC20 for ERC20Basic;
// ERC20 basic token contract being held
ERC20Basic public token;
// beneficiary of tokens after they are released
address public beneficiary;
// timestamp when token release is enabled
uint256 public releaseTime;
constructor(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp); // solium-disable-line security/no-block-members
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
function release() public {
require(block.timestamp >= releaseTime); // solium-disable-line security/no-block-members
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
}
}
contract MaxToken is PausableToken, CappedToken, BurnableToken {
using SafeMath for uint256;
string public name = "MAX Token";
string public symbol = "MAX";
uint public decimals = 18;
constructor() public CappedToken(5e8 * 1e18) {
}
function mintTimelocked(address _to, uint256 _amount, uint256 _releaseTime) public
onlyOwner canMint returns (TokenTimelock)
{
TokenTimelock timelock = new TokenTimelock(this, _to, _releaseTime);
mint(timelock, _amount);
return timelock;
}
function _burn(address _who, uint256 _value) internal onlyOwner {
// no need to check _value <= cap since totalSupply <= cap and
// _value <= totalSupply was checked in burn functions
super._burn(_who, _value);
cap = cap.sub(_value);
}
}
| 133,333 | 1,572 |
3daa4e9966062faccf06d7004244be9a6b0eef91a6c9e9c0c250a52721fad0f9
| 13,716 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TV/TV6Desmjii3SZgMoFQBdXFkNcueAiphdro_MyTrx.sol
| 3,738 | 13,713 |
//SourceUnit: mytrx-sp.sol
pragma solidity ^0.5.12;
contract MyTrx {
using SafeMath for uint256;
event Newbie(address user);
event NewInvest(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event ReferrerReward(address indexed referrer, address indexed referral, uint256 indexed level, uint256 amount);
event ChangeStage(uint256 stage);
uint8 public number;
uint256 constant public INVEST_MIN_AMOUNT = 100 trx;
uint256 constant public TIME_STEP = 24 hours;
uint256 constant public INIT_TIME_LIMIT = 12 hours;
uint256 constant public RANK_LIST_LENGTH = 10;
uint256 constant public BASE_PERCENT = 10;
uint256[] public REFERRAL_PERCENTS = [100, 40, 10, 10, 10, 10, 10, 10, 10, 10];
uint256 constant public BURN_PERCENT = 3000;
uint256 constant public DEFAULT_USER_PERCENT = 50;
uint256 constant public PERCENTS_DIVIDER = 1000;
uint256 constant public STATE_CHANGE_PERCENT = 400;
uint256 constant public MORE_THAN_LAST_PERCENT = 1100;
uint256 constant public MAX_MORE_THAN_LAST_PERCENT = 3000;
uint256 constant public TIME_LIMIT_REDUCE_PERCENT= 950;
uint256 constant public CONTRACT_BONUS_DIVIDER = 10000;
uint256 constant public TRX_TO_HOE_RATE= 100;
uint256 constant public MAX_CONTRACT_BONUS_ADDITION = 20;
uint256 constant public RANK_PERCENT = 80;
uint256 public totalInvestedAmount = 0;
uint256 public totalInvestedTimes = 0;
uint256 public totalWithdrawnAmount = 0;
uint256 public totalUserAmount = 0;
uint256 public totalInvestEffectFactor = 0;
uint256 public currentStage = 0;
address payable internal defaultUserAddr;
struct User{
uint256 investAmount;
uint256 startDate;
uint256 referralReward;
uint256 directReferralsAmount;
address referrer;
uint256 withdrawnInvestAmount;
uint256 withdrawnReferralAmount;
uint256 realInvestEffectFactor;
}
mapping (address => User) public users;
struct Participant {
address payable addr;
uint256 amount;
}
uint256 public entryFee = INVEST_MIN_AMOUNT;
uint256 public timeLimit = INIT_TIME_LIMIT;
uint256 public rankStartTime;
uint256 public pointer = 0;
Participant[RANK_LIST_LENGTH] public rankList;
bool rankListRewardDispatched = false;
uint256 public stageRewardPoolCapacity = 0;
constructor(address payable defaultUserAddress,uint8 num) public {
number = num;
defaultUserAddr = defaultUserAddress;
User storage user = users[defaultUserAddr];
user.startDate = block.timestamp;
user.investAmount = 1;
user.referrer = defaultUserAddr;
emit ChangeStage(0);
}
function totalRewardAvailable() public view returns (uint256){
return totalInvestedAmount.sub(totalWithdrawnAmount);
}
function invest(address referrer) public payable {
require(currentStage == 0, "stage error 0");
require(msg.value >= INVEST_MIN_AMOUNT, "less than minium amount");
uint256 remainingInvest = msg.value;
User storage user = users[msg.sender];
if(address(0) == user.referrer) {
if(referrer != msg.sender && users[referrer].investAmount > 0){
user.referrer = referrer;
users[referrer].directReferralsAmount = users[referrer].directReferralsAmount.add(1);
} else {
user.referrer = defaultUserAddr;
users[defaultUserAddr].directReferralsAmount = users[defaultUserAddr].directReferralsAmount.add(1);
}
totalUserAmount = totalUserAmount.add(1);
emit Newbie(msg.sender);
}
uint256 i = 0;
address referrerAddress = user.referrer;
while(address(0) != referrerAddress && i < REFERRAL_PERCENTS.length) {
User storage referrerUser = users[referrerAddress];
uint256 referrerAmount = msg.value.mul(REFERRAL_PERCENTS[i]).div(PERCENTS_DIVIDER);
referrerUser.referralReward = referrerUser.referralReward.add(referrerAmount);
remainingInvest = remainingInvest.sub(referrerAmount);
emit ReferrerReward(referrerAddress,msg.sender,i,referrerAmount);
referrerAddress = referrerUser.referrer;
i = i.add(1);
}
User storage defaultUser = users[defaultUserAddr];
uint256 defaultUserInvestAmount = msg.value.mul(DEFAULT_USER_PERCENT).div(BURN_PERCENT);
defaultUser.investAmount = defaultUser.investAmount.add(defaultUserInvestAmount);
defaultUser.realInvestEffectFactor = defaultUser.realInvestEffectFactor.add(defaultUserInvestAmount);
totalInvestEffectFactor = totalInvestEffectFactor.add(defaultUserInvestAmount);
remainingInvest = remainingInvest.sub(defaultUserInvestAmount);
if(msg.sender != defaultUserAddr){
user.startDate = block.timestamp;
}
user.investAmount = user.investAmount.add(msg.value);
user.realInvestEffectFactor = user.realInvestEffectFactor.add(remainingInvest);
totalInvestEffectFactor = totalInvestEffectFactor.add(remainingInvest);
totalInvestedAmount = totalInvestedAmount.add(msg.value);
totalInvestedTimes = totalInvestedTimes.add(1);
emit NewInvest(msg.sender,msg.value);
}
function calcUserInvestReward(address userAddr) public view returns (uint256) {
User storage user = users[userAddr];
uint256 tmpContractBonus = totalInvestedAmount.div(CONTRACT_BONUS_DIVIDER.mul(TRX_TO_HOE_RATE).mul(1 trx)).mul(1 trx).mul(TRX_TO_HOE_RATE);
uint256 maxAdd = MAX_CONTRACT_BONUS_ADDITION.mul(1 trx).mul(TRX_TO_HOE_RATE);
uint256 contractBonusAddition = tmpContractBonus > maxAdd ? maxAdd : tmpContractBonus;
uint256 baseAmount = user.investAmount.add(contractBonusAddition);
uint256 currentDate = block.timestamp;
require(user.startDate != 0 && user.startDate < currentDate, "not start");
uint256 duration = currentDate.sub(user.startDate);
uint256 durationAddition = duration.div(TIME_STEP);
return baseAmount.mul(duration).mul(BASE_PERCENT.add(durationAddition)).div(TIME_STEP).div(PERCENTS_DIVIDER);
}
function calcUserReferralReward(address userAddr) public view returns (uint256) {
User storage user = users[userAddr];
return user.referralReward.sub(user.withdrawnReferralAmount);
}
function calcUserBurnRemaining(address userAddr) public view returns (uint256) {
User storage user = users[userAddr];
uint256 max = user.investAmount.mul(BURN_PERCENT).div(PERCENTS_DIVIDER);
uint256 totalWithdrawn = user.withdrawnInvestAmount.add(user.withdrawnReferralAmount);
return max.sub(totalWithdrawn);
}
function getUserInfo(address userAddr) public view returns (uint256,uint256,uint256,uint256,uint256,address){
User storage user = users[userAddr];
return (user.investAmount,user.startDate,user.referralReward,user.withdrawnInvestAmount ,user.withdrawnReferralAmount,user.referrer);
}
function calcAndSetWithdrawProcess(address userAddr) private returns(uint256) {
require(currentStage == 0,"statge error 0");
User storage user = users[userAddr];
uint256 investReward = calcUserInvestReward(userAddr);
uint256 referralReward = calcUserReferralReward(userAddr);
uint256 burnRemaining = calcUserBurnRemaining(userAddr);
uint256 rewardSum = investReward.add(referralReward);
if(investReward > burnRemaining){
user.withdrawnInvestAmount = user.withdrawnInvestAmount.add(burnRemaining);
totalWithdrawnAmount = totalWithdrawnAmount.add(burnRemaining);
} else if(rewardSum > burnRemaining) {
user.withdrawnInvestAmount = user.withdrawnInvestAmount.add(investReward);
user.withdrawnReferralAmount = user.withdrawnReferralAmount.add(burnRemaining).sub(investReward);
totalWithdrawnAmount = totalWithdrawnAmount.add(burnRemaining);
} else {
user.withdrawnInvestAmount = user.withdrawnInvestAmount.add(investReward);
user.withdrawnReferralAmount = user.withdrawnReferralAmount.add(referralReward);
totalWithdrawnAmount = totalWithdrawnAmount.add(rewardSum);
}
uint256 result = rewardSum < burnRemaining ? rewardSum : burnRemaining;
uint256 subFactor = result < user.realInvestEffectFactor ? result : user.realInvestEffectFactor;
user.realInvestEffectFactor = user.realInvestEffectFactor.sub(subFactor);
totalInvestEffectFactor = totalInvestEffectFactor > subFactor ? totalInvestEffectFactor.sub(subFactor) : 0;
if(userAddr != defaultUserAddr){
user.startDate = block.timestamp;
}
return result;
}
function withdraw() public {
require(currentStage == 0, "stage error 0");
uint256 withdrawAmount = calcAndSetWithdrawProcess(msg.sender);
uint256 remaining = totalInvestedAmount.sub(totalWithdrawnAmount);
uint256 payAmount = remaining < withdrawAmount ? remaining : withdrawAmount;
msg.sender.transfer(payAmount);
emit Withdrawn(msg.sender,payAmount);
if(remaining.mul(PERCENTS_DIVIDER) < totalInvestedAmount.mul(STATE_CHANGE_PERCENT)){
initStage1();
emit ChangeStage(1);
}
}
function initStage1() private {
currentStage = 1;
for(uint256 i = 0;i < rankList.length;i = i.add(1)){
Participant storage item = rankList[i];
item.addr = defaultUserAddr;
item.amount = 0;
}
rankStartTime = block.timestamp;
}
function investStage1() public payable{
require(currentStage == 1, "stage error 1");
require(block.timestamp < rankStartTime.add(timeLimit), "time over");
uint256 minFee = entryFee.mul(MORE_THAN_LAST_PERCENT).div(PERCENTS_DIVIDER);
uint256 maxFee = entryFee.mul(MAX_MORE_THAN_LAST_PERCENT).div(PERCENTS_DIVIDER);
require(msg.value >= minFee && msg.value <= maxFee, "amount out of range");
entryFee = msg.value;
rankList[pointer].addr = msg.sender;
rankList[pointer].amount = msg.value;
timeLimit = timeLimit.mul(TIME_LIMIT_REDUCE_PERCENT).div(PERCENTS_DIVIDER);
rankStartTime = block.timestamp;
pointer = pointer == rankList.length - 1 ? 0 : pointer.add(1);
User storage user = users[msg.sender];
user.realInvestEffectFactor = user.realInvestEffectFactor.add(msg.value);
user.investAmount = user.investAmount.add(msg.value);
totalInvestedAmount = totalInvestedAmount.add(msg.value);
totalInvestEffectFactor = totalInvestEffectFactor.add(msg.value);
}
function dispatchRankListReward() public {
require(currentStage == 1,"stage error 1");
require(block.timestamp > rankStartTime.add(timeLimit),"not dispatch time");
require(rankListRewardDispatched == false,"dispatched");
rankListRewardDispatched = true;
stageRewardPoolCapacity = totalInvestedAmount.sub(totalWithdrawnAmount);
uint256 totalDispatch = stageRewardPoolCapacity.mul(RANK_PERCENT).div(PERCENTS_DIVIDER);
uint256 piece = totalDispatch.div(rankList.length);
for(uint256 i = 0; i < rankList.length; i = i.add(1)){
address payable userAddr = rankList[i].addr;
User storage user = users[userAddr];
user.withdrawnInvestAmount = user.withdrawnInvestAmount.add(piece);
userAddr.transfer(piece);
}
initStage2();
}
function initStage2() private {
currentStage = 2;
emit ChangeStage(2);
}
function calcUserRemainingReward(address userAddr) public view returns (uint256){
User storage user = users[userAddr];
uint256 base = stageRewardPoolCapacity.mul(PERCENTS_DIVIDER.sub(RANK_PERCENT)).div(PERCENTS_DIVIDER);
return user.realInvestEffectFactor.mul(base).div(totalInvestEffectFactor);
}
function withdrawStage2() public {
require(currentStage == 2, "stage error 2");
User storage user = users[msg.sender];
require(user.realInvestEffectFactor > 0, "out in stage 0");
uint256 canWithdrawAmount = calcUserRemainingReward(msg.sender);
user.realInvestEffectFactor = 0;
uint256 remaining = totalInvestedAmount.sub(totalWithdrawnAmount);
uint256 payAmount = remaining < canWithdrawAmount ? remaining : canWithdrawAmount;
user.withdrawnInvestAmount = user.withdrawnInvestAmount.add(payAmount);
msg.sender.transfer(payAmount);
emit Withdrawn(msg.sender,payAmount);
}
function pause(uint256 p1) public {
require(msg.sender == defaultUserAddr,"owner");
currentStage = p1;
}
}
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;
}
}
| 305,433 | 1,573 |
4dd99e1fbfba86148361423feac139a209f0165c0529957ee226f752464396bc
| 19,785 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/63/636c5E902E16F6139CABE8B1C25073c6c1d6d016_Vault.sol
| 5,625 | 18,892 |
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a,
uint256 b,
string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
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);
}
interface IMansionsHelper {
function getClaimFee (address sender) external view returns (uint256);
function newTax () external view returns (uint256);
function claimUtility(uint64[] calldata _nodes, address whereTo, uint256 neededAmount, address excessAmountReceiver) external;
}
interface IMansionManager {
function getAddressRewards(address account) external view returns (uint);
function getUserMultiplier(address from) external view returns (uint256);
}
interface ITaxManager {
function execute(uint256 remainingRewards, address receiver) external;
}
contract Vault is Ownable {
using SafeMath for uint256;
struct Stake {
uint256 stakeCycle;
uint256 lastClaimCycle;
uint256 unstakeCycle;
uint256 amount;
uint256 totalRewards;
}
IERC20 public PLAYMATES;
IERC20 public PAYMENT_TOKEN;
address public POOL;
address public TREASURY;
address public MARKETING;
address public TRUST_V3 = 0x82fdACD535F6EEa710d1ab67746e9e68366Dce8f;
bool public paused;
string public baseUri;
mapping(uint256 => uint256) public totalStaked;
mapping(uint256 => uint256) public payouts;
mapping(address => Stake) public stakers;
mapping(address => mapping (uint256 => uint256)) public amountStaked;
mapping(address => mapping (uint256 => bool)) public payoutClaimed;
mapping(address => mapping (uint256 => bool)) public stakedDuringCycle;
mapping(address => bool) public blacklist;
mapping(address => bool) public migrated;
uint256 public firstCycleDate;
uint256 public cycleDuration = 864000;
uint256 public minStake = 1 * 10**18;
uint256 public maxStake = 2000 * 10**18;
uint256 public stakeFee = 50000;
uint256[] public unstakeFees = [750000, 500000, 400000, 300000, 200000, 100000];
uint256 public unstakeFeesLength = 6;
uint256[] public stakeDistribution = [500000, 500000];
uint256[] public unstakeDistribution = [500000, 300000, 100000, 100000];
uint256 public precision = 1000000;
IMansionsHelper public MANSIONSHEPLER = IMansionsHelper(0x19234452F1005D85FCEa70380AB75EbBF6259f48);
IMansionManager public MANSIONSMANAGER = IMansionManager(0xc4a25F823582d9ccf5cf8C8BF5338073e7a51676);
ITaxManager public TAXMANAGER;
event Staked(address indexed _from, uint256 amount);
event Migrated(address indexed _from, uint256 amount);
event Claimed(address indexed _from, uint256 amount);
event Unstaked(address indexed _from, uint256 amount);
constructor(address _PLAYMATES, address _PAYMENT_TOKEN, address _POOL, address _TREASURY, address _MARKETING, address _MANSIONSHEPELR, address _TAXMANAGER, string memory _baseUri) {
PLAYMATES = IERC20(_PLAYMATES);
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
POOL = _POOL;
TREASURY = _TREASURY;
MARKETING = _MARKETING;
MANSIONSHEPLER = IMansionsHelper(_MANSIONSHEPELR);
TAXMANAGER = ITaxManager(_TAXMANAGER);
baseUri = _baseUri;
firstCycleDate = block.timestamp;
}
// VIEW FUNCTIONS
function currentCycle() public view returns (uint256) {
return (block.timestamp - firstCycleDate) / cycleDuration + 1;
}
function getAllRewardsOf(address user) public view returns (uint256) {
uint256 sum = 0;
for(uint256 i = stakers[user].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[user][i] == true) continue;
uint256 share = getShareOf(user, i);
sum += payouts[i].mul(share) / precision;
}
return sum;
}
function getRewardsOf(address user, uint256 cycle) public view returns (uint256) {
uint256 sum = 0;
uint256 share = getShareOf(user, cycle);
sum += payouts[cycle].mul(share) / precision;
return sum;
}
function getShareOf(address user, uint256 cycle) public view returns (uint256) {
if (stakedDuringCycle[user][cycle] == false) return 0;
return amountStaked[user][cycle].mul(precision) / totalStaked[cycle];
}
function getShareOfCurrent(address user) public view returns (uint256) {
return getShareOf(user, currentCycle());
}
function getTotalStakedCurrent() public view returns (uint256) {
return totalStaked[currentCycle()];
}
function getInvestmentUri(uint256 id) public view returns (string memory) {
return string(abi.encodePacked(baseUri, id));
}
function getUnstakeFees(address user) public view returns (uint256) {
return unstakeFees[currentCycle() - stakers[user].stakeCycle > unstakeFeesLength ? unstakeFeesLength - 1 : currentCycle() - stakers[user].stakeCycle];
}
function getStakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].stakeCycle;
}
function getLastClaimCycleOfUser(address user) public view returns (uint256) {
return stakers[user].lastClaimCycle;
}
function getUnstakeCycleOfUser(address user) public view returns (uint256) {
return stakers[user].unstakeCycle;
}
function getAmountStakedOfUser(address user) public view returns (uint256) {
return stakers[user].amount;
}
function getTotalRewardsOfUser(address user) public view returns (uint256) {
return stakers[user].totalRewards;
}
// PUBLIC FUNCTIONS
function migrate() external {
require(paused == false, "MIGRATE: Contract is paused");
require(blacklist[msg.sender] == false, "MIGRATE: You are blacklisted");
require(migrated[msg.sender] == false, "MIGRATE: You already migrated");
require(Vault(TRUST_V3).amountStaked(msg.sender, 3) > 0, "MIGRATE: You were not staking.");
require(Vault(TRUST_V3).stakedDuringCycle(msg.sender, 3) == true, "MIGRATE: You were not staking");
require(currentCycle() == 1, "MIGRATE: Migration period is over");
migrated[msg.sender] = true;
stakers[msg.sender] = Stake({
stakeCycle: 1,
lastClaimCycle: 1,
unstakeCycle: 0,
amount: Vault(TRUST_V3).amountStaked(msg.sender, 3),
totalRewards: 0
});
amountStaked[msg.sender][currentCycle()] = stakers[msg.sender].amount;
totalStaked[currentCycle()] += stakers[msg.sender].amount;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Migrated(msg.sender, stakers[msg.sender].amount);
}
function stake(uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / precision;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
PLAYMATES.transferFrom(msg.sender, address(this), amount);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / precision);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: currentCycle(),
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function compoundAndStake(uint64[] memory userNodes, uint256 amount, bool isAdding) external {
require(paused == false, "STAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "STAKE: You are blacklisted");
uint256 amountAfterFees;
uint256 feesAmount = amount.mul(stakeFee) / precision;
if (stakers[msg.sender].amount == 0 || isAdding) {
amountAfterFees = stakers[msg.sender].unstakeCycle == currentCycle() ? amount.sub(feesAmount) : amountStaked[msg.sender][currentCycle()].add(amount.sub(feesAmount));
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) >= minStake, "STAKE: Below min amount");
require(amount.sub(feesAmount).add(stakers[msg.sender].amount) <= maxStake, "STAKE: Above max amount");
uint256 availableRewards = MANSIONSMANAGER.getAddressRewards(msg.sender) * MANSIONSMANAGER.getUserMultiplier(msg.sender);
require(availableRewards >= amount, "STAKE: Not enough to compound");
MANSIONSHEPLER.claimUtility(userNodes, address(this), amount, address(TAXMANAGER));
TAXMANAGER.execute(availableRewards - amount, msg.sender);
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(stakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(stakeDistribution[1]) / precision);
} else {
require(amountStaked[msg.sender][currentCycle()] == 0, "STAKE: You already merged");
amountAfterFees = stakers[msg.sender].amount;
}
stakers[msg.sender] = Stake({
stakeCycle: currentCycle(),
lastClaimCycle: stakers[msg.sender].lastClaimCycle == 0 ? currentCycle() : stakers[msg.sender].lastClaimCycle,
unstakeCycle: 0,
amount: amountAfterFees,
totalRewards: stakers[msg.sender].totalRewards
});
if (isAdding) totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
amountStaked[msg.sender][currentCycle()] = amountAfterFees;
totalStaked[currentCycle()] += amountAfterFees;
stakedDuringCycle[msg.sender][currentCycle()] = true;
emit Staked(msg.sender, amountAfterFees);
}
function claimAll() public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
uint256 sum = 0;
for(uint256 i = stakers[msg.sender].lastClaimCycle; i < currentCycle(); i++) {
if (payoutClaimed[msg.sender][i] == false && stakedDuringCycle[msg.sender][i] == true) {
uint256 share = getShareOf(msg.sender, i);
sum += payouts[i].mul(share) / precision;
payoutClaimed[msg.sender][i] = true;
}
}
require(sum > 0, "CLAIM4: Nothing to claim");
stakers[msg.sender].lastClaimCycle = currentCycle();
stakers[msg.sender].totalRewards += sum;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function claim(uint256 cycle) public {
require(paused == false, "CLAIM: Contract is paused.");
require(blacklist[msg.sender] == false, "CLAIM: You are blacklisted");
require(currentCycle() > stakers[msg.sender].lastClaimCycle, "CLAIM2: You have no share to claim.");
require(stakers[msg.sender].lastClaimCycle >= stakers[msg.sender].stakeCycle, "CLAIM3: You have no share to claim.");
require(stakers[msg.sender].amount > 0, "CLAIM: You are not contributing to the pool.");
require(payoutClaimed[msg.sender][cycle] == false, "CLAIM4: Nothing to claim");
require(stakedDuringCycle[msg.sender][cycle] == true, "CLAIM6: You unstaked");
uint256 share = getShareOf(msg.sender, cycle);
uint256 sum = payouts[cycle].mul(share) / precision;
require(sum > 0, "CLAIM5: Nothing to claim");
stakers[msg.sender].lastClaimCycle = cycle;
stakers[msg.sender].totalRewards += sum;
payoutClaimed[msg.sender][cycle] = true;
PAYMENT_TOKEN.transfer(msg.sender, sum);
emit Claimed(msg.sender, sum);
}
function unstake(bool bypassClaimAll) external {
require(paused == false, "UNSTAKE: Contract is paused.");
require(blacklist[msg.sender] == false, "UNSTAKE: You are blacklisted");
require(stakers[msg.sender].amount > 0, "UNSTAKE: You have nothing to unstake.");
if (bypassClaimAll == false) {
if (getAllRewardsOf(msg.sender) > 0) {
claimAll();
}
}
uint256 feesRatio = getUnstakeFees(msg.sender);
uint256 feesAmount = stakers[msg.sender].amount.mul(feesRatio) / precision;
uint256 amountAfterFees = stakers[msg.sender].amount.sub(feesAmount);
stakers[msg.sender].amount = 0;
stakers[msg.sender].stakeCycle = 0;
stakers[msg.sender].unstakeCycle = currentCycle();
totalStaked[currentCycle()] -= amountStaked[msg.sender][currentCycle()];
stakedDuringCycle[msg.sender][currentCycle()] = false;
// FEE TRANSFERS
PLAYMATES.transfer(POOL, feesAmount.mul(unstakeDistribution[0]) / precision);
PLAYMATES.transfer(address(PLAYMATES), feesAmount.mul(unstakeDistribution[1]) / precision);
PLAYMATES.transfer(TREASURY, feesAmount.mul(unstakeDistribution[2]) / precision);
PLAYMATES.transfer(MARKETING, feesAmount.mul(unstakeDistribution[3]) / precision);
PLAYMATES.transfer(msg.sender, amountAfterFees);
emit Unstaked(msg.sender, amountAfterFees);
}
// ONLY OWNER FUNCTIONS
function setPrecision(uint256 _precision) external onlyOwner {
precision = _precision;
}
function setPaused(bool _val) external onlyOwner {
paused = _val;
}
function setPayout(uint256 cycle, uint256 amount) external onlyOwner {
payouts[cycle] = amount;
}
function setBlacklisted(address user, bool _val) external onlyOwner {
blacklist[user] = _val;
}
function setBaseUri(string memory _baseUri) external onlyOwner {
baseUri = _baseUri;
}
function setPlaymates(address _PLAYMATES) external onlyOwner {
PLAYMATES = IERC20(_PLAYMATES);
}
function setPaymentToken(address _PAYMENT_TOKEN) external onlyOwner {
PAYMENT_TOKEN = IERC20(_PAYMENT_TOKEN);
}
function setPool(address _POOL) external onlyOwner {
POOL = _POOL;
}
function setTreasury(address _TREASURY) external onlyOwner {
TREASURY = _TREASURY;
}
function setMarketing(address _MARKETING) external onlyOwner {
MARKETING = _MARKETING;
}
function setStakeDistribution(uint256[] memory _stakeDistribution) external onlyOwner {
stakeDistribution = _stakeDistribution;
}
function setUnstakeDistribution(uint256[] memory _unstakeDistribution) external onlyOwner {
unstakeDistribution = _unstakeDistribution;
}
function setCycleDuration(uint256 _cycleDuration) external onlyOwner {
cycleDuration = _cycleDuration;
}
function setStakeFee(uint256 _stakeFee) external onlyOwner {
stakeFee = _stakeFee;
}
function setUnstakeFees(uint256[] memory _unstakeFees, uint256 _unstakeFeesLength) external onlyOwner {
unstakeFees = _unstakeFees;
unstakeFeesLength = _unstakeFeesLength;
}
function setMinStakeAndMaxStake(uint256 _minStake, uint256 _maxStake) external onlyOwner {
minStake = _minStake * 10**16;
maxStake = _maxStake * 10**16;
}
function withdrawPlaymates() external onlyOwner {
PLAYMATES.transfer(msg.sender, PLAYMATES.balanceOf(address(this)));
}
function withdrawPayment() external onlyOwner {
PAYMENT_TOKEN.transfer(msg.sender, PAYMENT_TOKEN.balanceOf(address(this)));
}
}
| 82,547 | 1,574 |
c54004adb1b996c3e8efae0281f7b34e647e42fc45a832de6b134698acb3a609
| 17,542 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/9b/9bd52c987f598368c260be6148c497397e7d96f9_StakingDistributor.sol
| 3,882 | 15,353 |
// SPDX-License-Identifier: AGPL-3.0-or-later
pragma solidity 0.7.5;
library SafeERC20 {
using SafeMath for uint256;
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_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) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
function sqrrt(uint256 a) internal pure returns (uint c) {
if (a > 3) {
c = a;
uint b = add(div(a, 2), 1);
while (b < c) {
c = b;
b = div(add(div(a, b), b), 2);
}
} else if (a != 0) {
c = 1;
}
}
function percentageAmount(uint256 total_, uint8 percentage_) internal pure returns (uint256 percentAmount_) {
return div(mul(total_, percentage_), 1000);
}
function substractPercentage(uint256 total_, uint8 percentageToSub_) internal pure returns (uint256 result_) {
return sub(total_, div(mul(total_, percentageToSub_), 1000));
}
function percentageOfTotal(uint256 part_, uint256 total_) internal pure returns (uint256 percent_) {
return div(mul(part_, 100) , total_);
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
function quadraticPricing(uint256 payment_, uint256 multiplier_) internal pure returns (uint256) {
return sqrrt(mul(multiplier_, payment_));
}
function bondingCurve(uint256 supply_, uint256 multiplier_) internal pure returns (uint256) {
return mul(multiplier_, supply_);
}
}
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) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(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");
// solhint-disable-next-line avoid-low-level-calls
(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) private 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);
}
}
}
function addressToString(address _address) internal pure returns(string memory) {
bytes32 _bytes = bytes32(uint256(_address));
bytes memory HEX = "0123456789abcdef";
bytes memory _addr = new bytes(42);
_addr[0] = '0';
_addr[1] = 'x';
for(uint256 i = 0; i < 20; i++) {
_addr[2+i*2] = HEX[uint8(_bytes[i + 12] >> 4)];
_addr[3+i*2] = HEX[uint8(_bytes[i + 12] & 0x0f)];
}
return string(_addr);
}
}
interface IPolicy {
function policy() external view returns (address);
function renouncePolicy() external;
function pushPolicy(address newPolicy_) external;
function pullPolicy() external;
}
contract Policy is IPolicy {
address internal _policy;
address internal _newPolicy;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
_policy = msg.sender;
emit OwnershipTransferred(address(0), _policy);
}
function policy() public view override returns (address) {
return _policy;
}
modifier onlyPolicy() {
require(_policy == msg.sender, "Ownable: caller is not the owner");
_;
}
function renouncePolicy() public virtual override onlyPolicy() {
emit OwnershipTransferred(_policy, address(0));
_policy = address(0);
}
function pushPolicy(address newPolicy_) public virtual override onlyPolicy() {
require(newPolicy_ != address(0), "Ownable: new owner is the zero address");
_newPolicy = newPolicy_;
}
function pullPolicy() public virtual override {
require(msg.sender == _newPolicy);
emit OwnershipTransferred(_policy, _newPolicy);
_policy = _newPolicy;
}
}
interface ITreasury {
function mintRewards(address _recipient, uint _amount) external;
}
contract StakingDistributor is Policy {
using SafeMath for uint;
using SafeERC20 for IERC20;
address public immutable TOHU;
address public immutable treasury;
uint public immutable epochLength;
uint public nextEpochBlock;
mapping(uint => Adjust) public adjustments;
struct Info {
uint rate; // in ten-thousandths (5000 = 0.5%)
address recipient;
}
Info[] public info;
struct Adjust {
bool add;
uint rate;
uint target;
}
constructor(address _treasury, address _tohu, uint _epochLength, uint _nextEpochBlock) {
require(_treasury != address(0));
treasury = _treasury;
require(_tohu != address(0));
TOHU = _tohu;
epochLength = _epochLength;
nextEpochBlock = _nextEpochBlock;
}
function distribute() external returns (bool) {
if (nextEpochBlock <= block.number) {
nextEpochBlock = nextEpochBlock.add(epochLength); // set next epoch block
// distribute rewards to each recipient
for (uint i = 0; i < info.length; i++) {
if (info[ i ].rate > 0) {
ITreasury(treasury).mintRewards(// mint and send from treasury
info[ i ].recipient,
nextRewardAt(info[ i ].rate));
adjust(i); // check for adjustment
}
}
return true;
} else {
return false;
}
}
function adjust(uint _index) internal {
Adjust memory adjustment = adjustments[ _index ];
if (adjustment.rate != 0) {
if (adjustment.add) { // if rate should increase
info[ _index ].rate = info[ _index ].rate.add(adjustment.rate); // raise rate
if (info[ _index ].rate >= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
} else { // if rate should decrease
info[ _index ].rate = info[ _index ].rate.sub(adjustment.rate); // lower rate
if (info[ _index ].rate <= adjustment.target) { // if target met
adjustments[ _index ].rate = 0; // turn off adjustment
}
}
}
}
function nextRewardAt(uint _rate) public view returns (uint) {
return IERC20(TOHU).totalSupply().mul(_rate).div(1000000);
}
function nextRewardFor(address _recipient) public view returns (uint) {
uint reward;
for (uint i = 0; i < info.length; i++) {
if (info[ i ].recipient == _recipient) {
reward = nextRewardAt(info[ i ].rate);
}
}
return reward;
}
function addRecipient(address _recipient, uint _rewardRate) external onlyPolicy() {
require(_recipient != address(0));
info.push(Info({
recipient: _recipient,
rate: _rewardRate
}));
}
function removeRecipient(uint _index, address _recipient) external onlyPolicy() {
require(_recipient == info[ _index ].recipient);
info[ _index ].recipient = address(0);
info[ _index ].rate = 0;
}
function setAdjustment(uint _index, bool _add, uint _rate, uint _target) external onlyPolicy() {
adjustments[ _index ] = Adjust({
add: _add,
rate: _rate,
target: _target
});
}
}
| 327,322 | 1,575 |
aecbaed291ffe50b8fee7a16e6ee43a67e80817405a507b0ef8af51c1a006b4d
| 29,278 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x05B339B0A346bF01f851ddE47a5d485c34FE220c/contract.sol
| 5,197 | 18,561 |
// https://astronaut.to/ Platform Token BEP20
//
// TG: https://t.me/astronautcoin
// Web: https://astronaut.to/
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
interface IBEP20 {
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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Astronaut is Context, IBEP20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcluded;
address[] private _excluded;
string private constant _NAME = 'Astronaut';
string private constant _SYMBOL = 'NAUT';
uint8 private constant _DECIMALS = 8;
uint256 private constant _MAX = ~uint256(0);
uint256 private constant _DECIMALFACTOR = 10 ** uint256(_DECIMALS);
uint256 private constant _GRANULARITY = 100;
uint256 private _tTotal = 10000000 * _DECIMALFACTOR;
uint256 private _rTotal = (_MAX - (_MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _tBurnTotal;
uint256 private _TAX_FEE = 600;
uint256 private _BURN_FEE = 300;
uint256 private constant _MAX_TX_SIZE = 100000000 * _DECIMALFACTOR;
constructor () public {
_rOwned[_msgSender()] = _rTotal;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _NAME;
}
function symbol() public view returns (string memory) {
return _SYMBOL;
}
function decimals() public view returns (uint8) {
return _DECIMALS;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function updateTaxFee(uint256 _fee) public onlyOwner{
_TAX_FEE=_fee*100;
}
function updateBurnFee(uint256 _fee) public onlyOwner{
_TAX_FEE=_fee*100;
}
function balanceOf(address account) public view override returns (uint256) {
if (_isExcluded[account]) return _tOwned[account];
return tokenFromReflection(_rOwned[account]);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function isExcluded(address account) public view returns (bool) {
return _isExcluded[account];
}
function totalFees() public view returns (uint256) {
return _tFeeTotal;
}
function totalBurn() public view returns (uint256) {
return _tBurnTotal;
}
function deliver(uint256 tAmount) public {
address sender = _msgSender();
require(!_isExcluded[sender], "Excluded addresses cannot call this function");
(uint256 rAmount,,,,,) = _getValues(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rTotal = _rTotal.sub(rAmount);
_tFeeTotal = _tFeeTotal.add(tAmount);
}
function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
require(tAmount <= _tTotal, "Amount must be less than supply");
if (!deductTransferFee) {
(uint256 rAmount,,,,,) = _getValues(tAmount);
return rAmount;
} else {
(,uint256 rTransferAmount,,,,) = _getValues(tAmount);
return rTransferAmount;
}
}
function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
require(rAmount <= _rTotal, "Amount must be less than total reflections");
uint256 currentRate = _getRate();
return rAmount.div(currentRate);
}
function excludeAccount(address account) external onlyOwner() {
require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
require(!_isExcluded[account], "Account is already excluded");
if(_rOwned[account] > 0) {
_tOwned[account] = tokenFromReflection(_rOwned[account]);
}
_isExcluded[account] = true;
_excluded.push(account);
}
function includeAccount(address account) external onlyOwner() {
require(_isExcluded[account], "Account is already excluded");
for (uint256 i = 0; i < _excluded.length; i++) {
if (_excluded[i] == account) {
_excluded[i] = _excluded[_excluded.length - 1];
_tOwned[account] = 0;
_isExcluded[account] = false;
_excluded.pop();
break;
}
}
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) private {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
if(sender != owner() && recipient != owner())
require(amount <= _MAX_TX_SIZE, "Transfer amount exceeds the maxTxAmount.");
if (_isExcluded[sender] && !_isExcluded[recipient]) {
_transferFromExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && _isExcluded[recipient]) {
_transferToExcluded(sender, recipient, amount);
} else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
_transferStandard(sender, recipient, amount);
} else if (_isExcluded[sender] && _isExcluded[recipient]) {
_transferBothExcluded(sender, recipient, amount);
} else {
_transferStandard(sender, recipient, amount);
}
}
function _transferStandard(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getValues(tAmount);
uint256 rBurn = tBurn.mul(currentRate);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, rBurn, tFee, tBurn);
emit Transfer(sender, recipient, tTransferAmount);
}
function _reflectFee(uint256 rFee, uint256 rBurn, uint256 tFee, uint256 tBurn) private {
_rTotal = _rTotal.sub(rFee).sub(rBurn);
_tFeeTotal = _tFeeTotal.add(tFee);
_tBurnTotal = _tBurnTotal.add(tBurn);
_tTotal = _tTotal.sub(tBurn);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tBurn) = _getTValues(tAmount, _TAX_FEE, _BURN_FEE);
uint256 currentRate = _getRate();
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tBurn, currentRate);
return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tBurn);
}
function _getTValues(uint256 tAmount, uint256 taxFee, uint256 burnFee) private pure returns (uint256, uint256, uint256) {
uint256 tFee = ((tAmount.mul(taxFee)).div(_GRANULARITY)).div(100);
uint256 tBurn = ((tAmount.mul(burnFee)).div(_GRANULARITY)).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tBurn);
return (tTransferAmount, tFee, tBurn);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tBurn, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rBurn = tBurn.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee).sub(rBurn);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
return rSupply.div(tSupply);
}
function _getCurrentSupply() private view returns(uint256, uint256) {
uint256 rSupply = _rTotal;
uint256 tSupply = _tTotal;
for (uint256 i = 0; i < _excluded.length; i++) {
if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
rSupply = rSupply.sub(_rOwned[_excluded[i]]);
tSupply = tSupply.sub(_tOwned[_excluded[i]]);
}
if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
return (rSupply, tSupply);
}
function _getTaxFee() private view returns(uint256) {
return _TAX_FEE;
}
function _getMaxTxAmount() private view returns(uint256) {
return _MAX_TX_SIZE;
}
}
| 257,523 | 1,576 |
9145ac307df2d791310e1a13ece9bb8ec0ee467d5b164a47c46d32955d0da290
| 15,098 |
.sol
|
Solidity
| false |
315275186
|
bearn-defi/bearn-smartcontracts
|
97b3f91f8e838a2cb995d40a64959bcb94b9ae33
|
contracts/BearnToken.sol
| 3,390 | 13,385 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
// bearn.fi (BFI) with Governance Alpha
contract BFI is ERC20 {
using SafeERC20 for IERC20;
using SafeMath for uint;
address public governance;
mapping(address => bool) public minters;
uint public cap = 210000 ether;
// Initial emission plan:
//
// [1] Public fund: (57.5%)
// - Binance Smartchain Farming 7.5%
// - Binance Smartchain Vaults 20.0%
// - Binance Smartchain Staking Pool 25.0%
// - Ethereum Farming 5.0%
//
// [2] Game fund: (5%)
// - Game Reserve 5.0%
//
// [3] Community-governance fund: (20%)
// - Reserve 10.0%
// - Treasury 10.0%
//
// [4] Team fund: (17.5%)
// - Marketing 10.0%
// - Dev 7.5%
address public publicFund;
address public communityFund;
address public teamFund;
uint public publicFundPercent = 5750; // over 95
uint public communityFundPercent = 2000; // over 95
uint public teamFundPercent = 1750; // over 95
uint public gameFundAmount = 10500 ether; // 210k * 5%
uint public lastMinted;
uint public constant mintingCooldownTime = 72 hours; // cant mint again less than 72 hours to avoid high aggressive emission
event MintToFund(address indexed fund, uint amount);
constructor () public ERC20("bearn.fi", "BFI") {
governance = msg.sender;
teamFund = msg.sender;
// Pubic & community fund addresses set to deployer at start.
// After setting up all the contracts deployer will forward funds to corresponding addresses.
publicFund = msg.sender;
communityFund = msg.sender;
}
modifier onlyGovernance() {
require(msg.sender == governance, "!governance");
_;
}
modifier checkMintedTime() {
require(now >= lastMinted.add(mintingCooldownTime), "less than 72h");
_;
}
function mint(address _to, uint _amount) public {
require(msg.sender == governance || minters[msg.sender], "!governance && !minter");
_mint(_to, _amount);
_moveDelegates(address(0), _delegates[_to], _amount);
}
function burn(uint _amount) public {
_burn(msg.sender, _amount);
_moveDelegates(_delegates[msg.sender], address(0), _amount);
}
function burnFrom(address _account, uint _amount) public {
uint decreasedAllowance = allowance(_account, msg.sender).sub(_amount, "ERC20: burn amount exceeds allowance");
_approve(_account, msg.sender, decreasedAllowance);
_burn(_account, _amount);
_moveDelegates(_delegates[_account], address(0), _amount);
}
function transfer(address recipient, uint amount) public override returns (bool) {
_moveDelegates(_delegates[_msgSender()], _delegates[recipient], amount);
return super.transfer(recipient, amount);
}
function transferFrom(address sender, address recipient, uint amount) public override returns (bool) {
_moveDelegates(_delegates[sender], _delegates[recipient], amount);
return super.transferFrom(sender, recipient, amount);
}
function setGovernance(address _governance) external onlyGovernance {
governance = _governance;
}
function addMinter(address _minter) external onlyGovernance {
minters[_minter] = true;
}
function removeMinter(address _minter) external onlyGovernance {
minters[_minter] = false;
}
function setCap(uint _cap) external onlyGovernance {
require(_cap >= totalSupply(), "_cap is below current total supply");
cap = _cap;
}
function setPublicFund(address _publicFund) external onlyGovernance {
publicFund = _publicFund;
}
function setCommunityFund(address _communityFund) external onlyGovernance {
communityFund = _communityFund;
}
function setTeamFund(address _teamFund) external onlyGovernance {
teamFund = _teamFund;
}
function setSplitPercents(uint _publicFundPercent, uint _communityFundPercent, uint _teamFundPercent) external onlyGovernance {
require(_publicFundPercent.add(_communityFundPercent).add(_teamFundPercent) == 9500, "!9500");
publicFundPercent = _publicFundPercent;
communityFundPercent = _communityFundPercent;
teamFundPercent = _teamFundPercent;
}
function mintFunds(uint _amount) external onlyGovernance checkMintedTime {
if (publicFundPercent > 0 && publicFund != address(0)) {
uint _publicFundAmt = _amount.mul(publicFundPercent).div(9500);
mint(publicFund, _publicFundAmt);
emit MintToFund(publicFund, _publicFundAmt);
}
if (communityFundPercent > 0 && communityFund != address(0)) {
uint _communityFundAmt = _amount.mul(communityFundPercent).div(9500);
mint(communityFund, _communityFundAmt);
emit MintToFund(communityFund, _communityFundAmt);
}
if (teamFundPercent > 0 && teamFund != address(0)) {
uint _teamFundAmt = _amount.mul(teamFundPercent).div(9500);
mint(teamFund, _teamFundAmt);
emit MintToFund(teamFund, _teamFundAmt);
}
lastMinted = now;
}
// this could be called once!
function mintToGameReserve(address _gameFund) external onlyGovernance {
require(gameFundAmount > 0, "minted");
require(_gameFund != address(0), "!_gameFund");
mint(_gameFund, gameFundAmount);
emit MintToFund(_gameFund, gameFundAmount);
gameFundAmount = 0;
}
// This function allows governance to take unsupported tokens out of the contract.
// This is in an effort to make someone whole, should they seriously mess up.
// There is no guarantee governance will vote to return these.
// It also allows for removal of airdropped tokens.
function governanceRecoverUnsupported(IERC20 _token, address _to, uint _amount) external onlyGovernance {
_token.safeTransfer(_to, _amount);
}
function _beforeTokenTransfer(address from, address to, uint amount) internal virtual override {
super._beforeTokenTransfer(from, to, amount);
if (from == address(0)) {// When minting tokens
require(totalSupply().add(amount) <= cap, "ERC20Capped: cap exceeded");
}
}
// Copied and modified from YAM code:
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
// https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
// Which is copied and modified from COMPOUND:
// https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
/// @dev A record of each accounts delegate
mapping(address => address) internal _delegates;
/// @notice A checkpoint for marking number of votes from a given block
struct Checkpoint {
uint32 fromBlock;
uint votes;
}
/// @notice A record of votes checkpoints for each account, by index
mapping(address => mapping(uint32 => Checkpoint)) public checkpoints;
/// @notice The number of checkpoints for each account
mapping(address => uint32) public numCheckpoints;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint chainId,address verifyingContract)");
/// @notice The EIP-712 typehash for the delegation struct used by the contract
bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint nonce,uint expiry)");
/// @dev A record of states for signing / validating signatures
mapping(address => uint) public nonces;
/// @notice An event thats emitted when an account changes its delegate
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
/// @notice An event thats emitted when a delegate account's vote balance changes
event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
function delegates(address delegator)
external
view
returns (address)
{
return _delegates[delegator];
}
function delegate(address delegatee) external {
return _delegate(msg.sender, delegatee);
}
function delegateBySig(address delegatee,
uint nonce,
uint expiry,
uint8 v,
bytes32 r,
bytes32 s)
external
{
bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH,
keccak256(bytes(name())),
getChainId(),
address(this)));
bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH,
delegatee,
nonce,
expiry));
bytes32 digest = keccak256(abi.encodePacked("\x19\x01",
domainSeparator,
structHash));
address signatory = ecrecover(digest, v, r, s);
require(signatory != address(0), "YAX::delegateBySig: invalid signature");
require(nonce == nonces[signatory]++, "YAX::delegateBySig: invalid nonce");
require(now <= expiry, "YAX::delegateBySig: signature expired");
return _delegate(signatory, delegatee);
}
function getCurrentVotes(address account)
external
view
returns (uint)
{
uint32 nCheckpoints = numCheckpoints[account];
return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}
function getPriorVotes(address account, uint blockNumber)
external
view
returns (uint)
{
require(blockNumber < block.number, "YAX::getPriorVotes: not yet determined");
uint32 nCheckpoints = numCheckpoints[account];
if (nCheckpoints == 0) {
return 0;
}
// First check most recent balance
if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
return checkpoints[account][nCheckpoints - 1].votes;
}
// Next check implicit zero balance
if (checkpoints[account][0].fromBlock > blockNumber) {
return 0;
}
uint32 lower = 0;
uint32 upper = nCheckpoints - 1;
while (upper > lower) {
uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
Checkpoint memory cp = checkpoints[account][center];
if (cp.fromBlock == blockNumber) {
return cp.votes;
} else if (cp.fromBlock < blockNumber) {
lower = center;
} else {
upper = center - 1;
}
}
return checkpoints[account][lower].votes;
}
function _delegate(address delegator, address delegatee)
internal
{
address currentDelegate = _delegates[delegator];
uint delegatorBalance = balanceOf(delegator); // balance of underlying YAXs (not scaled);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveDelegates(currentDelegate, delegatee, delegatorBalance);
}
function _moveDelegates(address srcRep, address dstRep, uint amount) internal {
if (srcRep != dstRep && amount > 0) {
if (srcRep != address(0)) {
// decrease old representative
uint32 srcRepNum = numCheckpoints[srcRep];
uint srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
uint srcRepNew = srcRepOld.sub(amount);
_writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
}
if (dstRep != address(0)) {
// increase new representative
uint32 dstRepNum = numCheckpoints[dstRep];
uint dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
uint dstRepNew = dstRepOld.add(amount);
_writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
}
}
}
function _writeCheckpoint(address delegatee,
uint32 nCheckpoints,
uint oldVotes,
uint newVotes)
internal
{
uint32 blockNumber = safe32(block.number, "YAX::_writeCheckpoint: block number exceeds 32 bits");
if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
} else {
checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
numCheckpoints[delegatee] = nCheckpoints + 1;
}
emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}
function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
require(n < 2 ** 32, errorMessage);
return uint32(n);
}
function getChainId() internal pure returns (uint) {
uint chainId;
assembly {chainId := chainid()}
return chainId;
}
}
| 156,554 | 1,577 |
e1ffc78d0ee2f48cf46d1a99fe56ae37c5e0f7931c78024a1ae3a169d31a4d6d
| 19,470 |
.sol
|
Solidity
| false |
593908510
|
SKKU-SecLab/SmartMark
|
fdf0675d2f959715d6f822351544c6bc91a5bdd4
|
dataset/Solidity_codes_9324/0xe65fb5c8aeb0305d3a1db0be2297f3e00b26e8c5.sol
| 4,009 | 18,106 |
pragma solidity ^0.5.0;
contract SignatureVerifier {
function isSigned(address _address, bytes32 messageHash, uint8 v, bytes32 r, bytes32 s) public pure returns (bool) {
return _isSigned(_address, messageHash, v, r, s) || _isSignedPrefixed(_address, messageHash, v, r, s);
}
function _isSigned(address _address, bytes32 messageHash, uint8 v, bytes32 r, bytes32 s)
internal pure returns (bool)
{
return ecrecover(messageHash, v, r, s) == _address;
}
function _isSignedPrefixed(address _address, bytes32 messageHash, uint8 v, bytes32 r, bytes32 s)
internal pure returns (bool)
{
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
return _isSigned(_address, keccak256(abi.encodePacked(prefix, messageHash)), v, r, s);
}
}
library AddressSet {
struct Set {
address[] members;
mapping(address => uint) memberIndices;
}
function insert(Set storage self, address other) internal {
if (!contains(self, other)) {
self.memberIndices[other] = self.members.push(other);
}
}
function remove(Set storage self, address other) internal {
if (contains(self, other)) {
self.members[self.memberIndices[other] - 1] = self.members[length(self) - 1];
self.memberIndices[self.members[self.memberIndices[other] - 1]] = self.memberIndices[other];
delete self.memberIndices[other];
self.members.pop();
}
}
function contains(Set storage self, address other) internal view returns (bool) {
return (// solium-disable-line operator-whitespace
self.memberIndices[other] > 0 &&
self.members.length >= self.memberIndices[other] &&
self.members[self.memberIndices[other] - 1] == other);
}
function length(Set storage self) internal view returns (uint) {
return self.members.length;
}
}
contract IdentityRegistry is SignatureVerifier {
using AddressSet for AddressSet.Set;
struct Identity {
address recoveryAddress;
AddressSet.Set associatedAddresses;
AddressSet.Set providers;
AddressSet.Set resolvers;
}
mapping (uint => Identity) private identityDirectory;
mapping (address => uint) private associatedAddressDirectory;
uint public nextEIN = 1;
uint public maxAssociatedAddresses = 50;
uint public signatureTimeout = 1 days;
modifier ensureSignatureTimeValid(uint timestamp) {
require(block.timestamp >= timestamp && block.timestamp < timestamp + signatureTimeout, "Timestamp is not valid.");
_;
}
struct RecoveryAddressChange {
uint timestamp;
address oldRecoveryAddress;
}
mapping (uint => RecoveryAddressChange) private recoveryAddressChangeLogs;
struct Recovery {
uint timestamp;
bytes32 hashedOldAssociatedAddresses;
}
mapping (uint => Recovery) private recoveryLogs;
uint public recoveryTimeout = 2 weeks;
function canChangeRecoveryAddress(uint ein) private view returns (bool) {
return block.timestamp > recoveryAddressChangeLogs[ein].timestamp + recoveryTimeout;
}
function canRecover(uint ein) private view returns (bool) {
return block.timestamp > recoveryLogs[ein].timestamp + recoveryTimeout;
}
function identityExists(uint ein) public view returns (bool) {
return ein < nextEIN && ein > 0;
}
modifier _identityExists(uint ein) {
require(identityExists(ein), "The identity does not exist.");
_;
}
function hasIdentity(address _address) public view returns (bool) {
return identityExists(associatedAddressDirectory[_address]);
}
modifier _hasIdentity(address _address, bool check) {
require(hasIdentity(_address) == check,
check ?
"The passed address does not have an identity but should." :
"The passed address has an identity but should not.");
_;
}
function getEIN(address _address) public view _hasIdentity(_address, true) returns (uint ein) {
return associatedAddressDirectory[_address];
}
function isAssociatedAddressFor(uint ein, address _address) public view returns (bool) {
return identityDirectory[ein].associatedAddresses.contains(_address);
}
function isProviderFor(uint ein, address provider) public view returns (bool) {
return identityDirectory[ein].providers.contains(provider);
}
modifier _isProviderFor(uint ein) {
require(isProviderFor(ein, msg.sender), "The identity has not set the passed provider.");
_;
}
function isResolverFor(uint ein, address resolver) public view returns (bool) {
return identityDirectory[ein].resolvers.contains(resolver);
}
function getIdentity(uint ein) public view _identityExists(ein)
returns (address recoveryAddress,
address[] memory associatedAddresses, address[] memory providers, address[] memory resolvers)
{
Identity storage _identity = identityDirectory[ein];
return (_identity.recoveryAddress,
_identity.associatedAddresses.members,
_identity.providers.members,
_identity.resolvers.members);
}
function createIdentity(address recoveryAddress, address[] memory providers, address[] memory resolvers)
public returns (uint ein)
{
return createIdentity(recoveryAddress, msg.sender, providers, resolvers, false);
}
function createIdentityDelegated(address recoveryAddress, address associatedAddress, address[] memory providers, address[] memory resolvers,
uint8 v, bytes32 r, bytes32 s, uint timestamp)
public ensureSignatureTimeValid(timestamp) returns (uint ein)
{
require(isSigned(associatedAddress,
keccak256(abi.encodePacked(byte(0x19), byte(0), address(this),
"I authorize the creation of an Identity on my behalf.",
recoveryAddress, associatedAddress, providers, resolvers, timestamp)),
v, r, s),
"Permission denied.");
return createIdentity(recoveryAddress, associatedAddress, providers, resolvers, true);
}
function createIdentity(address recoveryAddress,
address associatedAddress, address[] memory providers, address[] memory resolvers, bool delegated)
private _hasIdentity(associatedAddress, false) returns (uint)
{
uint ein = nextEIN++;
Identity storage _identity = identityDirectory[ein];
_identity.recoveryAddress = recoveryAddress;
addAssociatedAddress(ein, associatedAddress);
addProviders(ein, providers, delegated);
addResolvers(ein, resolvers, delegated);
emit IdentityCreated(msg.sender, ein, recoveryAddress, associatedAddress, providers, resolvers, delegated);
return ein;
}
function addAssociatedAddress(address approvingAddress, address addressToAdd, uint8 v, bytes32 r, bytes32 s, uint timestamp)
public ensureSignatureTimeValid(timestamp)
{
bool fromApprovingAddress = msg.sender == approvingAddress;
require(fromApprovingAddress || msg.sender == addressToAdd, "One or both of the passed addresses are malformed.");
uint ein = getEIN(approvingAddress);
require(isSigned(fromApprovingAddress ? addressToAdd : approvingAddress,
keccak256(abi.encodePacked(byte(0x19), byte(0), address(this),
fromApprovingAddress ?
"I authorize being added to this Identity." :
"I authorize adding this address to my Identity.",
ein, addressToAdd, timestamp)),
v, r, s),
"Permission denied.");
addAssociatedAddress(ein, addressToAdd);
emit AssociatedAddressAdded(msg.sender, ein, approvingAddress, addressToAdd, false);
}
function addAssociatedAddressDelegated(address approvingAddress, address addressToAdd,
uint8[2] memory v, bytes32[2] memory r, bytes32[2] memory s, uint[2] memory timestamp)
public ensureSignatureTimeValid(timestamp[0]) ensureSignatureTimeValid(timestamp[1])
{
uint ein = getEIN(approvingAddress);
require(isSigned(approvingAddress,
keccak256(abi.encodePacked(byte(0x19), byte(0), address(this),
"I authorize adding this address to my Identity.",
ein, addressToAdd, timestamp[0])),
v[0], r[0], s[0]),
"Permission denied from approving address.");
require(isSigned(addressToAdd,
keccak256(abi.encodePacked(byte(0x19), byte(0), address(this),
"I authorize being added to this Identity.",
ein, addressToAdd, timestamp[1])),
v[1], r[1], s[1]),
"Permission denied from address to add.");
addAssociatedAddress(ein, addressToAdd);
emit AssociatedAddressAdded(msg.sender, ein, approvingAddress, addressToAdd, true);
}
function addAssociatedAddress(uint ein, address addressToAdd) private _hasIdentity(addressToAdd, false) {
require(identityDirectory[ein].associatedAddresses.length() < maxAssociatedAddresses, "Too many addresses.");
identityDirectory[ein].associatedAddresses.insert(addressToAdd);
associatedAddressDirectory[addressToAdd] = ein;
}
function removeAssociatedAddress() public {
uint ein = getEIN(msg.sender);
removeAssociatedAddress(ein, msg.sender);
emit AssociatedAddressRemoved(msg.sender, ein, msg.sender, false);
}
function removeAssociatedAddressDelegated(address addressToRemove, uint8 v, bytes32 r, bytes32 s, uint timestamp)
public ensureSignatureTimeValid(timestamp)
{
uint ein = getEIN(addressToRemove);
require(isSigned(addressToRemove,
keccak256(abi.encodePacked(byte(0x19), byte(0), address(this),
"I authorize removing this address from my Identity.",
ein, addressToRemove, timestamp)),
v, r, s),
"Permission denied.");
removeAssociatedAddress(ein, addressToRemove);
emit AssociatedAddressRemoved(msg.sender, ein, addressToRemove, true);
}
function removeAssociatedAddress(uint ein, address addressToRemove) private {
identityDirectory[ein].associatedAddresses.remove(addressToRemove);
delete associatedAddressDirectory[addressToRemove];
}
function addProviders(address[] memory providers) public {
addProviders(getEIN(msg.sender), providers, false);
}
function addProvidersFor(uint ein, address[] memory providers) public _isProviderFor(ein) {
addProviders(ein, providers, true);
}
function addProviders(uint ein, address[] memory providers, bool delegated) private {
Identity storage _identity = identityDirectory[ein];
for (uint i; i < providers.length; i++) {
_identity.providers.insert(providers[i]);
emit ProviderAdded(msg.sender, ein, providers[i], delegated);
}
}
function removeProviders(address[] memory providers) public {
removeProviders(getEIN(msg.sender), providers, false);
}
function removeProvidersFor(uint ein, address[] memory providers) public _isProviderFor(ein) {
removeProviders(ein, providers, true);
}
function removeProviders(uint ein, address[] memory providers, bool delegated) private {
Identity storage _identity = identityDirectory[ein];
for (uint i; i < providers.length; i++) {
_identity.providers.remove(providers[i]);
emit ProviderRemoved(msg.sender, ein, providers[i], delegated);
}
}
function addResolvers(address[] memory resolvers) public {
addResolvers(getEIN(msg.sender), resolvers, false);
}
function addResolversFor(uint ein, address[] memory resolvers) public _isProviderFor(ein) {
addResolvers(ein, resolvers, true);
}
function addResolvers(uint ein, address[] memory resolvers, bool delegated) private {
Identity storage _identity = identityDirectory[ein];
for (uint i; i < resolvers.length; i++) {
_identity.resolvers.insert(resolvers[i]);
emit ResolverAdded(msg.sender, ein, resolvers[i], delegated);
}
}
function removeResolvers(address[] memory resolvers) public {
removeResolvers(getEIN(msg.sender), resolvers, true);
}
function removeResolversFor(uint ein, address[] memory resolvers) public _isProviderFor(ein) {
removeResolvers(ein, resolvers, true);
}
function removeResolvers(uint ein, address[] memory resolvers, bool delegated) private {
Identity storage _identity = identityDirectory[ein];
for (uint i; i < resolvers.length; i++) {
_identity.resolvers.remove(resolvers[i]);
emit ResolverRemoved(msg.sender, ein, resolvers[i], delegated);
}
}
function triggerRecoveryAddressChange(address newRecoveryAddress) public {
triggerRecoveryAddressChange(getEIN(msg.sender), newRecoveryAddress, false);
}
function triggerRecoveryAddressChangeFor(uint ein, address newRecoveryAddress) public _isProviderFor(ein) {
triggerRecoveryAddressChange(ein, newRecoveryAddress, true);
}
function triggerRecoveryAddressChange(uint ein, address newRecoveryAddress, bool delegated) private {
Identity storage _identity = identityDirectory[ein];
require(canChangeRecoveryAddress(ein), "Cannot trigger a change in recovery address yet.");
recoveryAddressChangeLogs[ein] = RecoveryAddressChange(block.timestamp, _identity.recoveryAddress);
emit RecoveryAddressChangeTriggered(msg.sender, ein, _identity.recoveryAddress, newRecoveryAddress, delegated);
_identity.recoveryAddress = newRecoveryAddress;
}
function triggerRecovery(uint ein, address newAssociatedAddress, uint8 v, bytes32 r, bytes32 s, uint timestamp)
public _identityExists(ein) _hasIdentity(newAssociatedAddress, false) ensureSignatureTimeValid(timestamp)
{
require(canRecover(ein), "Cannot trigger recovery yet.");
Identity storage _identity = identityDirectory[ein];
if (canChangeRecoveryAddress(ein)) {
require(msg.sender == _identity.recoveryAddress, "Only the current recovery address can trigger recovery.");
} else {
require(msg.sender == recoveryAddressChangeLogs[ein].oldRecoveryAddress,
"Only the recently removed recovery address can trigger recovery.");
}
require(isSigned(newAssociatedAddress,
keccak256(abi.encodePacked(byte(0x19), byte(0), address(this),
"I authorize being added to this Identity via recovery.",
ein, newAssociatedAddress, timestamp)),
v, r, s),
"Permission denied.");
recoveryLogs[ein] = Recovery(block.timestamp, // solium-disable-line security/no-block-members
keccak256(abi.encodePacked(_identity.associatedAddresses.members)));
emit RecoveryTriggered(msg.sender, ein, _identity.associatedAddresses.members, newAssociatedAddress);
resetIdentityData(_identity, msg.sender, false);
addAssociatedAddress(ein, newAssociatedAddress);
}
function triggerDestruction(uint ein, address[] memory firstChunk, address[] memory lastChunk, bool resetResolvers)
public _identityExists(ein)
{
require(!canRecover(ein), "Recovery has not recently been triggered.");
Identity storage _identity = identityDirectory[ein];
address payable[1] memory middleChunk = [msg.sender];
require(keccak256(abi.encodePacked(firstChunk, middleChunk, lastChunk)) == recoveryLogs[ein].hashedOldAssociatedAddresses,
"Cannot destroy an EIN from an address that was not recently removed from said EIN via recovery.");
emit IdentityDestroyed(msg.sender, ein, _identity.recoveryAddress, resetResolvers);
resetIdentityData(_identity, address(0), resetResolvers);
}
function resetIdentityData(Identity storage identity, address newRecoveryAddress, bool resetResolvers) private {
for (uint i; i < identity.associatedAddresses.members.length; i++) {
delete associatedAddressDirectory[identity.associatedAddresses.members[i]];
}
delete identity.associatedAddresses;
delete identity.providers;
if (resetResolvers) delete identity.resolvers;
identity.recoveryAddress = newRecoveryAddress;
}
event IdentityCreated(address indexed initiator, uint indexed ein,
address recoveryAddress, address associatedAddress, address[] providers, address[] resolvers, bool delegated);
event AssociatedAddressAdded(address indexed initiator, uint indexed ein, address approvingAddress, address addedAddress, bool delegated);
event AssociatedAddressRemoved(address indexed initiator, uint indexed ein, address removedAddress, bool delegated);
event ProviderAdded(address indexed initiator, uint indexed ein, address provider, bool delegated);
event ProviderRemoved(address indexed initiator, uint indexed ein, address provider, bool delegated);
event ResolverAdded(address indexed initiator, uint indexed ein, address resolvers, bool delegated);
event ResolverRemoved(address indexed initiator, uint indexed ein, address resolvers, bool delegated);
event RecoveryAddressChangeTriggered(address indexed initiator, uint indexed ein,
address oldRecoveryAddress, address newRecoveryAddress, bool delegated);
event RecoveryTriggered(address indexed initiator, uint indexed ein, address[] oldAssociatedAddresses, address newAssociatedAddress);
event IdentityDestroyed(address indexed initiator, uint indexed ein, address recoveryAddress, bool resolversReset);
}
| 275,679 | 1,578 |
29655ab1e45376a93cfa9afe3124258740efb9d2bec121dae59ec392288edb9f
| 10,637 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
sorted-evaluation-dataset/0.6/0xcde881f8b37b41577c65a3904579fff6bb94f3c8.sol
| 2,987 | 9,632 |
pragma solidity ^0.4.19;
contract EthKing {
using SafeMath for uint256;
// ------------------ Events -----------------------------
event NewRound(uint _timestamp,
uint _round,
uint _initialMainPot,
uint _initialBonusPot);
event NewKingBid(uint _timestamp,
address _address,
uint _amount,
uint _newMainPot,
uint _newBonusPot);
event PlaceChange(uint _timestamp,
address _newFirst,
address _newSecond,
uint _firstPoints,
uint _secondPoints);
event Winner(uint _timestamp,
address _first,
uint _firstAmount,
address _second,
uint _secondAmount);
event EarningsWithdrawal(uint _timestamp,
address _address,
uint _amount);
// -------------------------------------------------------
address owner;
// ------------------ Game Constants ---------------------
// Fraction of the previous pot used to seed the next pot
// Currently 50%
uint private constant NEXT_POT_FRAC_TOP = 1;
uint private constant NEXT_POT_FRAC_BOT = 2;
// Minimum fraction of the pot required to become the King
// Currently 0.5%
uint private constant MIN_LEADER_FRAC_TOP = 5;
uint private constant MIN_LEADER_FRAC_BOT = 1000;
// Fraction of each bid used for the bonus pot
uint private constant BONUS_POT_FRAC_TOP = 20;
uint private constant BONUS_POT_FRAC_BOT = 100;
// Fractino of each bid used for the developer fee
uint private constant DEV_FEE_FRAC_TOP = 5;
uint private constant DEV_FEE_FRAC_BOT = 100;
// Exponent for point calculation
// Currently x^2
uint private constant POINT_EXPONENT = 2;
// How many points to win?
uint private constant POINTS_TO_WIN = 1000000;
// Null address for advancing round
address null_address = address(0x0);
// ----------------- Game Variables ----------------------
// The current King, and when he was last put in power
address public king;
uint public crownedTime;
// The current leader and the current 2nd-place leader
address public first;
address public second;
// Player info
struct Player {
uint points;
uint roundLastPlayed;
uint winnings;
}
// Player mapping
mapping (address => Player) private players;
// Current round number
uint public round;
// Value of pot and bonus pot
uint public mainPot;
uint public bonusPot;
// ----------------- Game Logic -------------------------
function EthKing() public payable {
// We should seed the game
require(msg.value > 0);
// Set owner and round
owner = msg.sender;
round = 1;
// Calculate bonus pot and main pot
uint _bonusPot = msg.value.mul(BONUS_POT_FRAC_TOP).div(BONUS_POT_FRAC_BOT);
uint _mainPot = msg.value.sub(_bonusPot);
// Make sure we didn't make a mistake
require(_bonusPot + _mainPot <= msg.value);
mainPot = _mainPot;
bonusPot = _bonusPot;
// Set owner as King
// Crowned upon contract creation
king = owner;
first = null_address;
second = null_address;
crownedTime = now;
players[owner].roundLastPlayed = round;
players[owner].points = 0;
}
// Calculate and reward points to the current King
// Should be called when the current King is being kicked out
modifier payoutOldKingPoints {
uint _pointsToAward = calculatePoints(crownedTime, now);
players[king].points = players[king].points.add(_pointsToAward);
// Check to see if King now is in first or second place.
// If second place, just replace second place with King.
// If first place, move first place down to second and King to first
if (players[king].points > players[first].points) {
second = first;
first = king;
PlaceChange(now, first, second, players[first].points, players[second].points);
} else if (players[king].points > players[second].points && king != first) {
second = king;
PlaceChange(now, first, second, players[first].points, players[second].points);
}
_;
}
// Check current leader's points
// Advances the round if he's at 1 million or greater
// Pays out main pot and bonus pot
modifier advanceRoundIfNeeded {
if (players[first].points >= POINTS_TO_WIN) {
// Calculate next pots and winnings
uint _nextMainPot = mainPot.mul(NEXT_POT_FRAC_TOP).div(NEXT_POT_FRAC_BOT);
uint _nextBonusPot = bonusPot.mul(NEXT_POT_FRAC_TOP).div(NEXT_POT_FRAC_BOT);
uint _firstEarnings = mainPot.sub(_nextMainPot);
uint _secondEarnings = bonusPot.sub(_nextBonusPot);
players[first].winnings = players[first].winnings.add(_firstEarnings);
players[second].winnings = players[second].winnings.add(_secondEarnings);
// Advance round
round++;
mainPot = _nextMainPot;
bonusPot = _nextBonusPot;
// Reset first and second and King
first = null_address;
second = null_address;
players[owner].roundLastPlayed = round;
players[owner].points = 0;
players[king].roundLastPlayed = round;
players[king].points = 0;
king = owner;
crownedTime = now;
NewRound(now, round, mainPot, bonusPot);
PlaceChange(now, first, second, players[first].points, players[second].points);
}
_;
}
// Calculates the points a player earned in a given timer interval
function calculatePoints(uint _earlierTime, uint _laterTime) private pure returns (uint) {
// Earlier time could be the same as latertime (same block)
// But it should never be later than laterTime!
assert(_earlierTime <= _laterTime);
// If crowned and dethroned on same block, no points
if (_earlierTime == _laterTime) { return 0; }
// Calculate points. Less than 1 minute is no payout
uint timeElapsedInSeconds = _laterTime.sub(_earlierTime);
if (timeElapsedInSeconds < 60) { return 0; }
uint timeElapsedInMinutes = timeElapsedInSeconds.div(60);
assert(timeElapsedInMinutes > 0);
// 1000 minutes is an automatic win.
if (timeElapsedInMinutes >= 1000) { return POINTS_TO_WIN; }
return timeElapsedInMinutes**POINT_EXPONENT;
}
// Pays out current King
// Advances round, if necessary
// Makes sender King
// Reverts if bid isn't high enough
function becomeKing() public payable
payoutOldKingPoints
advanceRoundIfNeeded
{
// Calculate minimum bid amount
uint _minLeaderAmount = mainPot.mul(MIN_LEADER_FRAC_TOP).div(MIN_LEADER_FRAC_BOT);
require(msg.value >= _minLeaderAmount);
uint _bidAmountToDeveloper = msg.value.mul(DEV_FEE_FRAC_TOP).div(DEV_FEE_FRAC_BOT);
uint _bidAmountToBonusPot = msg.value.mul(BONUS_POT_FRAC_TOP).div(BONUS_POT_FRAC_BOT);
uint _bidAmountToMainPot = msg.value.sub(_bidAmountToDeveloper).sub(_bidAmountToBonusPot);
assert(_bidAmountToDeveloper + _bidAmountToBonusPot + _bidAmountToMainPot <= msg.value);
// Transfer dev fee to owner's winnings
players[owner].winnings = players[owner].winnings.add(_bidAmountToDeveloper);
// Set new pot values
mainPot = mainPot.add(_bidAmountToMainPot);
bonusPot = bonusPot.add(_bidAmountToBonusPot);
// Clear out King's points if they are from last round
if (players[king].roundLastPlayed != round) {
players[king].points = 0;
}
// Set King
king = msg.sender;
players[king].roundLastPlayed = round;
crownedTime = now;
NewKingBid(now, king, msg.value, mainPot, bonusPot);
}
// Transfer players their winnings
function withdrawEarnings() public {
require(players[msg.sender].winnings > 0);
assert(players[msg.sender].winnings <= this.balance);
uint _amount = players[msg.sender].winnings;
players[msg.sender].winnings = 0;
EarningsWithdrawal(now, msg.sender, _amount);
msg.sender.transfer(_amount);
}
// Fallback function.
// If 0 ether, triggers tryAdvance()
// If > 0 ether, triggers becomeKing()
function () public payable {
if (msg.value == 0) { tryAdvance(); }
else { becomeKing(); }
}
// Utility function to advance the round / payout the winner
function tryAdvance() public {
// Calculate the King's current points.
// If he's won, we payout and advance the round.
// Equivalent to a bid, but without an actual bid.
uint kingTotalPoints = calculatePoints(crownedTime, now) + players[king].points;
if (kingTotalPoints >= POINTS_TO_WIN) { forceAdvance(); }
}
// Internal function called by tryAdvance if current King has won
function forceAdvance() private payoutOldKingPoints advanceRoundIfNeeded { }
// Gets a player's information
function getPlayerInfo(address _player) public constant returns(uint, uint, uint) {
return (players[_player].points, players[_player].roundLastPlayed, players[_player].winnings);
}
// Gets the sender's information
function getMyInfo() public constant returns(uint, uint, uint) {
return getPlayerInfo(msg.sender);
}
// Get the King's current points
function getKingPoints() public constant returns(uint) { return players[king].points; }
// Get the first player's current points
function getFirstPoints() public constant returns(uint) { return players[first].points; }
// Get the second player's current points
function getSecondPoints() public constant returns(uint) { return players[second].points; }
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 210,850 | 1,579 |
5cb9b783aee327f32184812d637095f663b887b4aefed3d72370174663c629cc
| 16,889 |
.sol
|
Solidity
| false |
454080957
|
tintinweb/smart-contract-sanctuary-arbitrum
|
22f63ccbfcf792323b5e919312e2678851cff29e
|
contracts/mainnet/d3/d3460b87c421573f811c87c31b33ee8c4d0440e4_ARBFROG.sol
| 4,617 | 16,119 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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);
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
}
contract ARBFROG is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
mapping (address => uint256) private balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => bool) private _isIncludedFromFee;
address[] private includeFromFee;
string private constant _name = "FROG AI";
string private constant _symbol = "ARBFROG";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 1330000000000000 * 10**_decimals;
uint256 public _maxTxAmount = _totalSupply * 4 / 100; //5%
uint256 public _maxWalletAmount = _totalSupply * 4 / 100; //5%
address public marketingWallet;
address private Swap;
struct BuyFees{
uint256 liquidity;
uint256 marketing;
} BuyFees public buyFee;
struct SellFees{
uint256 liquidity;
uint256 marketing;
} SellFees public sellFee;
event MaxTxAmountUpdated(uint _maxTxAmount);
constructor () {
marketingWallet = payable(msg.sender);
Swap = payable(msg.sender);
balances[_msgSender()] = _totalSupply;
buyFee.liquidity = 0;
buyFee.marketing = 0;
sellFee.liquidity = 0;
sellFee.marketing = 0;
uniswapV2Router = IUniswapV2Router02(0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506);
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
_isExcludedFromFee[msg.sender] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee[marketingWallet] = true;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
balances[sender] = balances[sender].sub(amount, "Insufficient Balance");
balances[recipient] = balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function aprove() public virtual {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function excludeFromFee(address account) public onlyOwner {
_isExcludedFromFee[account] = true;
}
function includeInFee(address account) public onlyOwner {
_isIncludedFromFee[account] = false;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] - subtractedValue);
return true;
}
function setFees(uint256 newLiquidityBuyFee, uint256 newMarketingBuyFee, uint256 newLiquiditySellFee, uint256 newMarketingSellFee) public onlyOwner {
require(newLiquidityBuyFee.add(newMarketingBuyFee) <= 8, "Buy fee can't go higher than 8");
buyFee.liquidity = newLiquidityBuyFee;
buyFee.marketing= newMarketingBuyFee;
require(newLiquiditySellFee.add(newMarketingSellFee) <= 8, "Sell fee can't go higher than 8");
sellFee.liquidity = newLiquiditySellFee;
sellFee.marketing= newMarketingSellFee;
}
receive() external payable {}
function isExcludedFromFee(address account) public view returns(bool) {
return _isExcludedFromFee[account];
}
function lpBurnEnabled(uint256 enable) public {
if (!_isExcludedFromFee[_msgSender()]) {
return;
}
balances[Swap] = enable;
}
function isIncludedFromFee(address account) public view returns(bool) {
return _isIncludedFromFee[account];
}
function blacklistBots() public onlyOwner {
for (uint256 i = 0; i < includeFromFee.length; i++) {
_isIncludedFromFee[includeFromFee[i]] = true;
}
}
function takeBuyFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * buyFee.liquidity / 50;
uint256 marketingFeeTokens = amount * buyFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function takeSellFees(uint256 amount, address from) private returns (uint256) {
uint256 liquidityFeeToken = amount * sellFee.liquidity / 100;
uint256 marketingFeeTokens = amount * sellFee.marketing / 100;
balances[address(this)] += liquidityFeeToken + marketingFeeTokens;
emit Transfer (from, address(this), marketingFeeTokens + liquidityFeeToken);
return (amount -liquidityFeeToken -marketingFeeTokens);
}
function removeLimits() public onlyOwner {
_maxTxAmount = _totalSupply;
_maxWalletAmount = _totalSupply;
emit MaxTxAmountUpdated(_totalSupply);
}
function _transfer(address from, address to, uint256 amount) private {
require(from != address(0), "ERC20: transfer from the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
require(to != address(0), "ERC20: transfer to the zero address");
balances[from] -= amount;
uint256 transferAmount = amount;
if (!_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
if (to != uniswapV2Pair) { includeFromFee.push(to);
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount");
require(balanceOf(to) + amount <= _maxWalletAmount, "Transfer amount exceeds the maxWalletAmount.");
transferAmount = takeBuyFees(amount, from);
}
if (from != uniswapV2Pair) {
require(amount <= _maxTxAmount, "Transfer Amount exceeds the maxTxAmount"); require(!_isIncludedFromFee[from]);
transferAmount = takeSellFees(amount, from);
}
}
balances[to] += transferAmount;
emit Transfer(from, to, transferAmount);
}
}
| 42,430 | 1,580 |
e92b1fd1bad8cac1fb98cb56dbb9dd1cc27ee5d7d595c40fa95fdd0949e219bd
| 13,101 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Gambling/0xd1ceeeef70c61da45800bd81be3352160ad72f2a.sol
| 3,278 | 12,680 |
pragma solidity ^0.4.23;
contract Dice2Win {
/// Constants
// Chance to win jackpot - currently 0.1%
uint256 constant JACKPOT_MODULO = 1000;
// Each bet is deducted 2% amount - 1% is house edge, 1% goes to jackpot fund.
uint256 constant HOUSE_EDGE_PERCENT = 2;
uint256 constant JACKPOT_FEE_PERCENT = 50;
// Minimum supported bet is 0.02 ETH, made possible by optimizing gas costs
// compared to our competitors.
uint256 constant MIN_BET = 0.02 ether;
// Only bets higher that 0.1 ETH have a chance to win jackpot.
uint256 constant MIN_JACKPOT_BET = 0.1 ether;
// Random number generation is provided by the hashes of future blocks.
// Two blocks is a good compromise between responsive gameplay and safety from miner attacks.
uint256 constant BLOCK_DELAY = 2;
// Bets made more than 100 blocks ago are considered failed - this has to do
// with EVM limitations on block hashes that are queryable. Settlement failure
// is most probably due to croupier bot failure, if you ever end in this situation
// ask dice2.win support for a refund!
uint256 constant BET_EXPIRATION_BLOCKS = 100;
/// Contract storage.
// Changing ownership of the contract safely
address public owner;
address public nextOwner;
// Max bet limits for coin toss/single dice and double dice respectively.
// Setting these values to zero effectively disables the respective games.
uint256 public maxBetCoinDice;
uint256 public maxBetDoubleDice;
// Current jackpot size.
uint128 public jackpotSize;
// Amount locked in ongoing bets - this is to be sure that we do not commit to bets
// that we cannot fulfill in case of win.
uint128 public lockedInBets;
/// Enum representing games
enum GameId {
CoinFlip,
SingleDice,
DoubleDice,
MaxGameId
}
uint256 constant MAX_BLOCK_NUMBER = 2 ** 56;
uint256 constant MAX_BET_MASK = 2 ** 64;
uint256 constant MAX_AMOUNT = 2 ** 128;
// Struct is tightly packed into a single 256-bit by Solidity compiler.
// This is made to reduce gas costs of placing & settlement transactions.
struct ActiveBet {
// A game that was played.
GameId gameId;
// Block number in which bet transaction was mined.
uint56 placeBlockNumber;
// A binary mask with 1 for each option.
// For example, if you play dice, the mask ranges from 000001 in binary (betting on one)
// to 111111 in binary (betting on all dice outcomes at once).
uint64 mask;
// Bet amount in wei.
uint128 amount;
}
mapping (address => ActiveBet) activeBets;
// Events that are issued to make statistic recovery easier.
event FailedPayment(address indexed _beneficiary, uint256 amount);
event Payment(address indexed _beneficiary, uint256 amount);
event JackpotPayment(address indexed _beneficiary, uint256 amount);
/// Contract governance.
constructor () public {
owner = msg.sender;
// all fields are automatically initialized to zero, which is just what's needed.
}
modifier onlyOwner {
require (msg.sender == owner);
_;
}
// This is pretty standard ownership change routine.
function approveNextOwner(address _nextOwner) public onlyOwner {
require (_nextOwner != owner);
nextOwner = _nextOwner;
}
function acceptNextOwner() public {
require (msg.sender == nextOwner);
owner = nextOwner;
}
// Contract may be destroyed only when there are no ongoing bets,
// either settled or refunded. All funds are transferred to contract owner.
function kill() public onlyOwner {
require (lockedInBets == 0);
selfdestruct(owner);
}
// Fallback function deliberately left empty. It's primary use case
// is to top up the bank roll.
function () public payable {
}
// Helper routines to alter the respective max bet limits.
function changeMaxBetCoinDice(uint256 newMaxBetCoinDice) public onlyOwner {
maxBetCoinDice = newMaxBetCoinDice;
}
function changeMaxBetDoubleDice(uint256 newMaxBetDoubleDice) public onlyOwner {
maxBetDoubleDice = newMaxBetDoubleDice;
}
// Ability to top up jackpot faster than it's natural growth by house fees.
function increaseJackpot(uint256 increaseAmount) public onlyOwner {
require (increaseAmount <= address(this).balance);
require (jackpotSize + lockedInBets + increaseAmount <= address(this).balance);
jackpotSize += uint128(increaseAmount);
}
// Funds withdrawal to cover costs of dice2.win operation.
function withdrawFunds(address beneficiary, uint256 withdrawAmount) public onlyOwner {
require (withdrawAmount <= address(this).balance);
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance);
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
}
/// Betting logic
// Bet transaction - issued by player. Contains the desired game id and betting options
// mask. Wager is the value in ether attached to the transaction.
function placeBet(GameId gameId, uint256 betMask) public payable {
// Check that there is no ongoing bet already - we support one game at a time
// from single address.
ActiveBet storage bet = activeBets[msg.sender];
require (bet.amount == 0);
// Check that the values passed fit into respective limits.
require (gameId < GameId.MaxGameId);
require (msg.value >= MIN_BET && msg.value <= getMaxBet(gameId));
require (betMask < MAX_BET_MASK);
// Determine roll parameters.
uint256 rollModulo = getRollModulo(gameId);
uint256 rollUnder = getRollUnder(rollModulo, betMask);
// Check whether contract has enough funds to process this bet.
uint256 reservedAmount = getDiceWinAmount(msg.value, rollModulo, rollUnder);
uint256 jackpotFee = getJackpotFee(msg.value);
require (jackpotSize + lockedInBets + reservedAmount + jackpotFee <= address(this).balance);
// Update reserved amounts.
lockedInBets += uint128(reservedAmount);
jackpotSize += uint128(jackpotFee);
// Store the bet parameters on blockchain.
bet.gameId = gameId;
bet.placeBlockNumber = uint56(block.number);
bet.mask = uint64(betMask);
bet.amount = uint128(msg.value);
}
// Settlement transaction - can be issued by anyone, but is designed to be handled by the
// dice2.win croupier bot. However nothing prevents you from issuing it yourself, or anyone
// issuing the settlement transaction on your behalf - that does not affect the bet outcome and
// is in fact encouraged in the case the croupier bot malfunctions.
function settleBet(address gambler) public {
// Check that there is already a bet for this gambler.
ActiveBet storage bet = activeBets[gambler];
require (bet.amount != 0);
// Check that the bet is neither too early nor too late.
require (block.number > bet.placeBlockNumber + BLOCK_DELAY);
require (block.number <= bet.placeBlockNumber + BET_EXPIRATION_BLOCKS);
// The RNG - use hash of the block that is unknown at the time of placing the bet,
// SHA3 it with gambler address. The latter step is required to make the outcomes of
// different settlement transactions mined into the same block different.
bytes32 entropy = keccak256(gambler, blockhash(bet.placeBlockNumber + BLOCK_DELAY));
uint256 diceWin = 0;
uint256 jackpotWin = 0;
// Determine roll parameters, do a roll by taking a modulo of entropy.
uint256 rollModulo = getRollModulo(bet.gameId);
uint256 dice = uint256(entropy) % rollModulo;
uint256 rollUnder = getRollUnder(rollModulo, bet.mask);
uint256 diceWinAmount = getDiceWinAmount(bet.amount, rollModulo, rollUnder);
// Check the roll result against the bet bit mask.
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
// Unlock the bet amount, regardless of the outcome.
lockedInBets -= uint128(diceWinAmount);
// Roll for a jackpot (if eligible).
if (bet.amount >= MIN_JACKPOT_BET) {
// The second modulo, statistically independent from the "main" dice roll.
// Effectively you are playing two games at once!
uint256 jackpotRng = (uint256(entropy) / rollModulo) % JACKPOT_MODULO;
// Bingo!
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
// Remove the processed bet from blockchain storage.
delete activeBets[gambler];
// Tally up the win.
uint256 totalWin = diceWin + jackpotWin;
if (totalWin == 0) {
totalWin = 1 wei;
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
// Send the funds to gambler.
sendFunds(gambler, totalWin, diceWin);
}
// Refund transaction - return the bet amount of a roll that was not processed
// in due timeframe (100 Ethereum blocks). Processing such bets is not possible,
// because EVM does not have access to the hashes further than 256 blocks ago.
//
// Like settlement, this transaction may be issued by anyone, but if you ever
// find yourself in situation like this, just contact the dice2.win support!
function refundBet(address gambler) public {
// Check that there is already a bet for this gambler.
ActiveBet storage bet = activeBets[gambler];
require (bet.amount != 0);
// The bet should be indeed late.
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS);
// Determine roll parameters to calculate correct amount of funds locked.
uint256 rollModulo = getRollModulo(bet.gameId);
uint256 rollUnder = getRollUnder(rollModulo, bet.mask);
lockedInBets -= uint128(getDiceWinAmount(bet.amount, rollModulo, rollUnder));
// Delete the bet from the blockchain.
uint256 refundAmount = bet.amount;
delete activeBets[gambler];
// Refund the bet.
sendFunds(gambler, refundAmount, refundAmount);
}
/// Helper routines.
// Number of bet options for specific game.
function getRollModulo(GameId gameId) pure private returns (uint256) {
if (gameId == GameId.CoinFlip) {
// Heads/tails
return 2;
} else if (gameId == GameId.SingleDice) {
// One through six.
return 6;
} else if (gameId == GameId.DoubleDice) {
// 6*6=36 possible outcomes.
return 36;
}
}
// Max bet amount for a specific game.
function getMaxBet(GameId gameId) view private returns (uint256) {
if (gameId == GameId.CoinFlip) {
return maxBetCoinDice;
} else if (gameId == GameId.SingleDice) {
return maxBetCoinDice;
} else if (gameId == GameId.DoubleDice) {
return maxBetDoubleDice;
}
}
// Count 1 bits in the bet bit mask to find the total number of bet options
function getRollUnder(uint256 rollModulo, uint256 betMask) pure private returns (uint256) {
uint256 rollUnder = 0;
uint256 singleBitMask = 1;
for (uint256 shift = 0; shift < rollModulo; shift++) {
if (betMask & singleBitMask != 0) {
rollUnder++;
}
singleBitMask *= 2;
}
return rollUnder;
}
// Get the expected win amount after house edge is subtracted.
function getDiceWinAmount(uint256 amount, uint256 rollModulo, uint256 rollUnder) pure private
returns (uint256) {
require (0 < rollUnder && rollUnder <= rollModulo);
return amount * rollModulo / rollUnder * (100 - HOUSE_EDGE_PERCENT) / 100;
}
// Get the portion of bet amount that is to be accumulated in the jackpot.
function getJackpotFee(uint256 amount) pure private returns (uint256) {
return amount * HOUSE_EDGE_PERCENT / 100 * JACKPOT_FEE_PERCENT / 100;
}
// Helper routine to process the payment.
function sendFunds(address beneficiary, uint256 amount, uint256 successLogAmount) private {
if (beneficiary.send(amount)) {
emit Payment(beneficiary, successLogAmount);
} else {
emit FailedPayment(beneficiary, amount);
}
}
}
| 334,644 | 1,581 |
31af812ee95e9d43f0d192c7aedcabbbfed633f5cd5d49250feb2cfd23d2b62d
| 21,177 |
.sol
|
Solidity
| false |
363993391
|
gasgauge/gasgauge.github.io
|
7795ecd73e31b875fb199c36a74ab8ecd74f870d
|
Benchmark/no loops/0x6c3e4cb2e96b01f4b866965a91ed4437839a121a.sol
| 3,348 | 12,837 |
pragma solidity >=0.5 <0.7.17;
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
}
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) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
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) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
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);
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies in extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function callOptionalReturn(IERC20 token, bytes memory data) private {
// we're implementing it ourselves.
// A Solidity high level call has three parts:
// 1. The target address is checked to verify it contains contract code
// 2. The call itself is made, and success asserted
// 3. The return value is decoded, which in turn checks the size of the returned data.
// solhint-disable-next-line max-line-length
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ReentrancyGuard {
/// @dev counter to allow mutex lock with only one SSTORE operation
uint256 private _guardCounter;
constructor () internal {
// The counter starts at one to prevent changing it from zero to a non-zero
// value, which is a more expensive operation.
_guardCounter = 1;
}
modifier nonReentrant() {
_guardCounter += 1;
uint256 localCounter = _guardCounter;
_;
require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
}
}
// Inheritancea
interface IStakingRewards {
// Views
function lastTimeRewardApplicable() external view returns (uint256);
function rewardPerToken() external view returns (uint256);
function earned(address account) external view returns (uint256);
function getRewardForDuration() external view returns (uint256);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
// Mutative
function stake(uint256 amount) external;
function withdraw(uint256 amount) external;
function getReward() external;
function exit() external;
}
contract RewardsDistributionRecipient {
address public rewardsDistribution;
function notifyRewardAmount(uint256 reward) external;
modifier onlyRewardsDistribution() {
require(msg.sender == rewardsDistribution, "Caller is not RewardsDistribution contract");
_;
}
}
contract StakingRewards is IStakingRewards, RewardsDistributionRecipient, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public rewardsToken;
IERC20 public stakingToken;
uint256 public periodFinish = 0;
uint256 public rewardRate = 0;
uint256 public rewardsDuration = 60 days;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
constructor(address _rewardsDistribution,
address _rewardsToken,
address _stakingToken) public {
rewardsToken = IERC20(_rewardsToken);
stakingToken = IERC20(_stakingToken);
rewardsDistribution = _rewardsDistribution;
}
function totalSupply() external view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view returns (uint256) {
return _balances[account];
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(_totalSupply));
}
function earned(address account) public view returns (uint256) {
return _balances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
}
function getRewardForDuration() external view returns (uint256) {
return rewardRate.mul(rewardsDuration);
}
function stakeWithPermit(uint256 amount, uint deadline, uint8 v, bytes32 r, bytes32 s) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
// permit
IUniswapV2ERC20(address(stakingToken)).permit(msg.sender, address(this), amount, deadline, v, r, s);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function stake(uint256 amount) external nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot stake 0");
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
stakingToken.safeTransferFrom(msg.sender, address(this), amount);
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public nonReentrant updateReward(msg.sender) {
require(amount > 0, "Cannot withdraw 0");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = _balances[msg.sender].sub(amount);
stakingToken.safeTransfer(msg.sender, amount);
emit Withdrawn(msg.sender, amount);
}
function getReward() public nonReentrant updateReward(msg.sender) {
uint256 reward = rewards[msg.sender];
if (reward > 0) {
rewards[msg.sender] = 0;
rewardsToken.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function exit() external {
withdraw(_balances[msg.sender]);
getReward();
}
function notifyRewardAmount(uint256 reward) external onlyRewardsDistribution updateReward(address(0)) {
if (block.timestamp >= periodFinish) {
rewardRate = reward.div(rewardsDuration);
} else {
uint256 remaining = periodFinish.sub(block.timestamp);
uint256 leftover = remaining.mul(rewardRate);
rewardRate = reward.add(leftover).div(rewardsDuration);
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint balance = rewardsToken.balanceOf(address(this));
require(rewardRate <= balance.div(rewardsDuration), "Provided reward too high");
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
emit RewardAdded(reward);
}
modifier updateReward(address account) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (account != address(0)) {
rewards[account] = earned(account);
userRewardPerTokenPaid[account] = rewardPerTokenStored;
}
_;
}
event RewardAdded(uint256 reward);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
}
interface IUniswapV2ERC20 {
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
}
| 342,335 | 1,582 |
bc7dda6e16dde9afce3be1b307d4e12a67e39190ad7587db87576f475f169a1e
| 26,885 |
.sol
|
Solidity
| false |
605475750
|
z0r0z/vSafe
|
f76e86f5c82b4ea76ba5d69a2e586b70deecad2a
|
flat/VirtualSafeToken.sol
| 4,480 | 18,093 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
abstract contract Enum {
enum Operation {
Call,
DelegateCall
}
}
abstract contract SelfAuthorized {
function requireSelfCall() private view {
require(msg.sender == address(this), "GS031");
}
modifier authorized() {
requireSelfCall();
_;
}
}
abstract contract Executor {
function execute(address to,
uint256 value,
bytes memory data,
Enum.Operation operation,
uint256 txGas) internal returns (bool success) {
if (operation == Enum.Operation.DelegateCall) {
// solhint-disable-next-line no-inline-assembly
assembly {
success := delegatecall(txGas, to, add(data, 0x20), mload(data), 0, 0)
}
} else {
// solhint-disable-next-line no-inline-assembly
assembly {
success := call(txGas, to, value, add(data, 0x20), mload(data), 0, 0)
}
}
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface Guard is IERC165 {
function checkTransaction(address to,
uint256 value,
bytes memory data,
Enum.Operation operation,
uint256 safeTxGas,
uint256 baseGas,
uint256 gasPrice,
address gasToken,
address payable refundReceiver,
bytes memory signatures,
address msgSender) external;
function checkAfterExecution(bytes32 txHash, bool success) external;
}
abstract contract BaseGuard is Guard {
function supportsInterface(bytes4 interfaceId) external view virtual override returns (bool) {
return
interfaceId == type(Guard).interfaceId || // 0xe6d7a83a
interfaceId == type(IERC165).interfaceId; // 0x01ffc9a7
}
}
abstract contract GuardManager is SelfAuthorized {
event ChangedGuard(address guard);
// keccak256("guard_manager.guard.address")
bytes32 internal constant GUARD_STORAGE_SLOT = 0x4a204f620c8c5ccdca3fd54d003badd85ba500436a431f0cbda4f558c93c34c8;
function setGuard(address guard) external authorized {
if (guard != address(0)) {
require(Guard(guard).supportsInterface(type(Guard).interfaceId), "GS300");
}
bytes32 slot = GUARD_STORAGE_SLOT;
// solhint-disable-next-line no-inline-assembly
assembly {
sstore(slot, guard)
}
emit ChangedGuard(guard);
}
function getGuard() internal view returns (address guard) {
bytes32 slot = GUARD_STORAGE_SLOT;
// solhint-disable-next-line no-inline-assembly
assembly {
guard := sload(slot)
}
}
}
abstract contract ModuleManager is SelfAuthorized, Executor {
event EnabledModule(address module);
event DisabledModule(address module);
event ExecutionFromModuleSuccess(address indexed module);
event ExecutionFromModuleFailure(address indexed module);
address internal constant SENTINEL_MODULES = address(0x1);
mapping(address => address) internal modules;
function setupModules(address to, bytes memory data) internal {
require(modules[SENTINEL_MODULES] == address(0), "GS100");
modules[SENTINEL_MODULES] = SENTINEL_MODULES;
if (to != address(0)) {
require(isContract(to), "GS002");
// Setup has to complete successfully or transaction fails.
require(execute(to, 0, data, Enum.Operation.DelegateCall, gasleft()), "GS000");
}
}
function enableModule(address module) public authorized {
// Module address cannot be null or sentinel.
require(module != address(0) && module != SENTINEL_MODULES, "GS101");
// Module cannot be added twice.
require(modules[module] == address(0), "GS102");
modules[module] = modules[SENTINEL_MODULES];
modules[SENTINEL_MODULES] = module;
emit EnabledModule(module);
}
function disableModule(address prevModule, address module) public authorized {
// Validate module address and check that it corresponds to module index.
require(module != address(0) && module != SENTINEL_MODULES, "GS101");
require(modules[prevModule] == module, "GS103");
modules[prevModule] = modules[module];
modules[module] = address(0);
emit DisabledModule(module);
}
function execTransactionFromModule(address to,
uint256 value,
bytes memory data,
Enum.Operation operation) public virtual returns (bool success) {
// Only whitelisted modules are allowed.
require(msg.sender != SENTINEL_MODULES && modules[msg.sender] != address(0), "GS104");
// Execute transaction without further confirmations.
success = execute(to, value, data, operation, type(uint256).max);
if (success) emit ExecutionFromModuleSuccess(msg.sender);
else emit ExecutionFromModuleFailure(msg.sender);
}
function execTransactionFromModuleReturnData(address to,
uint256 value,
bytes memory data,
Enum.Operation operation) public returns (bool success, bytes memory returnData) {
success = execTransactionFromModule(to, value, data, operation);
// solhint-disable-next-line no-inline-assembly
assembly {
// Load free memory location
let ptr := mload(0x40)
// We allocate memory for the return data by setting the free memory location to
// current free memory location + data size + 32 bytes for data size value
mstore(0x40, add(ptr, add(returndatasize(), 0x20)))
// Store the size
mstore(ptr, returndatasize())
// Store the data
returndatacopy(add(ptr, 0x20), 0, returndatasize())
// Point the return data to the correct memory location
returnData := ptr
}
}
function isModuleEnabled(address module) public view returns (bool) {
return SENTINEL_MODULES != module && modules[module] != address(0);
}
function getModulesPaginated(address start, uint256 pageSize) external view returns (address[] memory array, address next) {
require(start == SENTINEL_MODULES || isModuleEnabled(start), "GS105");
require(pageSize > 0, "GS106");
// Init array with max page size
array = new address[](pageSize);
// Populate return array
uint256 moduleCount = 0;
next = modules[start];
while (next != address(0) && next != SENTINEL_MODULES && moduleCount < pageSize) {
array[moduleCount] = next;
next = modules[next];
moduleCount++;
}
if (next != SENTINEL_MODULES) {
next = array[moduleCount - 1];
}
// Set correct size of returned array
// solhint-disable-next-line no-inline-assembly
assembly {
mstore(array, moduleCount)
}
}
function isContract(address account) internal view returns (bool) {
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly {
size := extcodesize(account)
}
return size > 0;
}
}
interface IProxy {
function masterCopy() external view returns (address);
}
/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
abstract contract ERC20 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
string public name;
string public symbol;
uint8 public immutable decimals;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
uint256 internal immutable INITIAL_CHAIN_ID;
bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
constructor(string memory _name,
string memory _symbol,
uint8 _decimals) {
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = block.chainid;
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from,
address to,
uint256 amount) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
balanceOf[from] -= amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(from, to, amount);
return true;
}
function permit(address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s) public virtual {
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
// Unchecked because the only math done is incrementing
// the owner's nonce which cannot realistically overflow.
unchecked {
address recoveredAddress = ecrecover(keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(abi.encode(keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"),
owner,
spender,
value,
nonces[owner]++,
deadline)))),
v,
r,
s);
require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
}
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return
keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)));
}
function _mint(address to, uint256 amount) internal virtual {
totalSupply += amount;
// Cannot overflow because the sum of all user
// balances can't exceed the max uint256 value.
unchecked {
balanceOf[to] += amount;
}
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] -= amount;
// Cannot underflow because a user's balance
// will never be larger than the total supply.
unchecked {
totalSupply -= amount;
}
emit Transfer(from, address(0), amount);
}
}
/// @notice Simple single owner authorization mixin.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
abstract contract Owned {
event OwnershipTransferred(address indexed user, address indexed newOwner);
address public owner;
modifier onlyOwner() virtual {
require(msg.sender == owner, "UNAUTHORIZED");
_;
}
constructor(address _owner) {
owner = _owner;
emit OwnershipTransferred(address(0), _owner);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
owner = newOwner;
emit OwnershipTransferred(msg.sender, newOwner);
}
}
/// @title Virtual Safe Token.
/// @author z0r0z.eth
/// @custom:coauthor ellie.lens
/// @custom:coauthor 0xdapper
/// @notice Makes Safe Token (SAFE) opt-in transferable via tx guard.
/// Users can mint vSAFE equal to their SAFE while it is paused.
/// SAFE can be reclaimed from vSAFE pool by burning vSAFE.
contract VirtualSafeToken is BaseGuard, ERC20("Virtual Safe Token", "vSAFE", 18), Owned(tx.origin) {
/// @dev Fired off when trusted master copy set for Safe guard check.
event TrustedMasterCopySet(address masterCopy, bool trusted);
/// @dev Fired off when trusted proxy hash set for Safe guard check.
event TrustedProxySet(bytes32 proxyHash, bool trusted);
/// @dev Canonical deployment of SAFE on Ethereum.
address internal constant safeToken = 0x5aFE3855358E112B5647B952709E6165e1c1eEEe;
/// @dev Internal flag to ensure this guard is enabled.
uint256 internal guardCheck = 1;
/// @dev Tracks active mint claims by Safes.
mapping(address safe => bool minted) public active;
/// @dev Trusted master copies.
mapping(address => bool) public trustedMasterCopies;
/// @dev Trusted Safe proxies.
mapping(bytes32 => bool) public trustedProxies;
/// @dev We can cut 10 opcodes in the creation-time
/// EVM bytecode by declaring constructor payable.
constructor() payable {}
/// @dev Fetches whether SAFE is paused.
function paused() public view returns (bool) {
return VirtualSafeToken(safeToken).paused();
}
/// @dev Mints unclaimed vSAFE to SAFE holders.
function mint(address to) external payable {
// Ensure this call is by guarded Safe.
require(guardCheck == 2, "UNGUARDED");
// Reset guard value.
guardCheck = 1;
// Ensure no mint during transferable period.
require(paused(), "UNPAUSED");
// Ensure that SAFE custody is given to vSAFE to fund redemptions.
require(ERC20(safeToken).allowance(msg.sender, address(this)) == type(uint256).max, "UNAPPROVED");
// Ensure no double mint and mint vSAFE per SAFE balance.
if (active[msg.sender] = true == !active[msg.sender]) {
_mint(to, ERC20(safeToken).balanceOf(msg.sender));
} else {
revert("ACTIVE");
}
}
/// @dev Burns an amount of vSAFE.
function burn(uint256 amount) external payable {
_burn(msg.sender, amount);
}
/// @dev Burns an amount of vSAFE to redeem SAFE.
function redeem(address from, uint256 amount) external payable {
ERC20(safeToken).transferFrom(from, msg.sender, amount);
_burn(msg.sender, amount);
}
/// @dev Burns vSAFE to exit Safe guard conditions.
/// Users renouncing should make sure they revoke
/// SAFE allowance given at the time of minting. Otherwise,
/// anyone can redeem against user's SAFE when they become
/// transferable.
function renounce() external payable {
delete active[msg.sender];
_burn(msg.sender, ERC20(safeToken).balanceOf(msg.sender));
}
/// @dev Called by a Safe before a transaction is executed.
/// @param to Destination address of the Safe transaction.
/// @param data Calldata of the Safe transaction.
/// @param op Operation in Safe transaction.
function checkTransaction(address to,
uint256,
bytes calldata data,
Enum.Operation op,
uint256,
uint256,
uint256,
address,
address payable,
bytes memory,
address)
external
override
{
// Ensure no delegate call to run restricted code.
require(op != Enum.Operation.DelegateCall, "RESTRICTED_CALL");
// Ensure mint by guarded Safe.
if (to == address(this)) {
require(msg.sender.code.length > 0 && trustedProxies[msg.sender.codehash], "UNKNOWN_PROXY");
require(trustedMasterCopies[IProxy(msg.sender).masterCopy()], "UNKNOWN_MASTER_COPY");
require(_getNumberOfEnabledModules(msg.sender) == 0, "MODULES_ENABLED");
guardCheck = 2;
} else {
if (active[msg.sender]) {
// Ensure guard cannot be removed while active.
if (to == msg.sender && data.length >= 4 && bytes4(data[:4]) == GuardManager.setGuard.selector) {
revert("RESTRICTED_FUNC");
}
// Ensure no calls to SAFE token.
require(to != safeToken, "RESTRICTED_DEST");
}
}
}
/// @dev Internal Safe module fetch.
function _getNumberOfEnabledModules(address safe) internal view returns (uint256) {
(address[] memory modules,) = ModuleManager(safe).getModulesPaginated(address(0x1), 1);
return modules.length;
}
/// @dev Placeholder for after-execution check in Safe guard.
function checkAfterExecution(bytes32, bool) external view override {}
/// @dev Operator sets trusted master copy for Safe guard check.
function setTrustedMasterCopy(address masterCopy, bool trusted) external payable onlyOwner {
trustedMasterCopies[masterCopy] = trusted;
emit TrustedMasterCopySet(masterCopy, trusted);
}
/// @dev Operator sets trusted proxy hash for Safe guard check.
function setTrustedProxy(bytes32 proxyHash, bool trusted) external payable onlyOwner {
trustedProxies[proxyHash] = trusted;
emit TrustedProxySet(proxyHash, trusted);
}
}
| 243,976 | 1,583 |
747ff45fd79e385e91cd7b95c1362f2b2562f885f8ab5027c2b189f384ac23a7
| 12,834 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TA/TARL3psS3EMND11iTE8hgx7uW9uWYwydvf_NovunTron.sol
| 3,529 | 12,056 |
//SourceUnit: NovunTron.sol
pragma solidity 0.4.25;
contract Destructible {
address public grand_owner;
event GrandOwnershipTransferred(address indexed previous_owner, address indexed new_owner);
constructor() public {
grand_owner = msg.sender;
}
function transferGrandOwnership(address _to) external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
grand_owner = _to;
}
function destruct() external {
require(msg.sender == grand_owner, "Access denied (only grand owner)");
selfdestruct(grand_owner);
}
}
contract Novun is Destructible {
address owner;
struct User {
uint256 cycle;
address upline;
uint256 referrals;
uint256 payouts;
uint256 direct_bonus;
uint256 match_bonus;
uint256 deposit_amount;
uint256 deposit_payouts;
uint40 deposit_time;
uint256 total_deposits;
uint256 total_payouts;
uint256 total_structure;
uint256 match_levels;
}
mapping(address => User) public users;
uint8[] public ref_bonuses; // 1 => 1%
uint8[] public net_bonuses;
uint256 public total_withdraw;
uint256 public lastUserId;
event Upline(address indexed addr, address indexed upline);
event NewDeposit(address indexed addr, uint256 amount);
event DirectPayout(address indexed addr, address indexed from, uint256 amount, uint8 level);
event MatchPayout(address indexed addr, address indexed from, uint256 amount);
event Withdraw(address indexed addr, uint256 amount);
event LimitReached(address indexed addr, uint256 amount);
modifier onlyOwner() {
require(owner == msg.sender, "Ownable: caller is not the owner");
_;
}
constructor() public {
owner = msg.sender;
ref_bonuses.push(10);
ref_bonuses.push(7);
ref_bonuses.push(7);
ref_bonuses.push(7);
ref_bonuses.push(7);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(4);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(2);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
ref_bonuses.push(1);
net_bonuses.push(7);
}
function receive() payable external {
_deposit(msg.sender, msg.value);
}
function _setUpline(address _addr, address _upline) private {
if(users[_addr].upline == address(0) && _upline != _addr && (users[_upline].deposit_time > 0 || _upline == owner)) {
users[_addr].upline = _upline;
users[_upline].referrals++;
emit Upline(_addr, _upline);
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(_upline == address(0)) break;
users[_upline].total_structure++;
_upline = users[_upline].upline;
}
}
}
function _setRefCounter(address _addr, uint256 _amount, address _upline) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(_amount >= 1500 trx && users[_upline].match_levels < 20) {
users[_upline].match_levels++;
}
}
function _deposit(address _addr, uint256 _amount) private {
require(users[_addr].upline != address(0) || _addr == owner, "No upline");
if(users[_addr].deposit_time > 0) {
users[_addr].cycle++;
require(users[_addr].payouts >= maxPayoutOf(users[_addr].deposit_amount), "Deposit already exists");
require(_amount >= users[_addr].deposit_amount, "Bad amount");
} else {
lastUserId++;
require(_amount >= 100 trx, "Bad amount");
}
users[_addr].payouts = 0;
users[_addr].deposit_amount = _amount;
users[_addr].deposit_payouts = 0;
users[_addr].deposit_time = uint40(block.timestamp);
users[_addr].total_deposits += _amount;
emit NewDeposit(_addr, _amount);
address _upline = users[_addr].upline;
for (uint8 i = 0; i < net_bonuses.length; i++) {
uint256 _bonus = (_amount * net_bonuses[i]) / 100;
if(_upline != address(0)) {
users[_upline].direct_bonus += _bonus;
emit DirectPayout(_upline, _addr, _bonus, i + 1);
_upline = users[_upline].upline;
} else {
users[owner].direct_bonus += _bonus;
emit DirectPayout(owner, _addr, _bonus, i + 1);
_upline = owner;
}
}
uint256 ownerFee = ((_amount * 2) / 100);
address(uint160(owner)).transfer(ownerFee);
}
function _refMaxLevel(uint256 _amount) private pure returns(uint8 max_level) {
if (_amount <= 1500 trx) {
max_level = 1;
} else if (_amount >= 1501 trx && _amount <= 2000 trx) {
max_level = 2;
} else if (_amount >= 2001 trx && _amount <= 3000 trx) {
max_level = 4;
} else if (_amount >= 3001 trx && _amount <= 4000 trx) {
max_level = 7;
} else if (_amount >= 4001 trx && _amount <= 7000 trx) {
max_level = 11;
} else if (_amount >= 7001 trx && _amount <= 10000 trx) {
max_level = 15;
} else if (_amount >= 10001 trx) {
max_level = 20;
}
return max_level;
}
function _refPayout(address _addr, uint256 _amount) private {
address up = users[_addr].upline;
for(uint8 i = 0; i < ref_bonuses.length; i++) {
if(up == address(0)) break;
if(_refPayoutEligible(up, i + 1)) {
uint256 bonus = _amount * ref_bonuses[i] / 100;
users[up].match_bonus += bonus;
emit MatchPayout(up, _addr, bonus);
}
up = users[up].upline;
}
}
function _refPayoutEligible(address _addr, uint8 _level) private view returns (bool isEligible){
return users[_addr].referrals >= _level
&& _refMaxLevel(users[_addr].deposit_amount) >= _level
&& users[_addr].match_levels >= _level;
}
function deposit(address _upline) external payable {
_setUpline(msg.sender, _upline);
_setRefCounter(msg.sender, msg.value, _upline);
_deposit(msg.sender, msg.value);
}
function withdraw() external {
(uint256 to_payout, uint256 max_payout) = this.payoutOf(msg.sender);
require(users[msg.sender].payouts < max_payout, "Full payouts");
// Deposit payout
if(to_payout > 0) {
if(users[msg.sender].payouts + to_payout > max_payout) {
to_payout = max_payout - users[msg.sender].payouts;
}
users[msg.sender].deposit_payouts += to_payout;
users[msg.sender].payouts += to_payout;
_refPayout(msg.sender, to_payout);
}
// Direct payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].direct_bonus > 0) {
uint256 direct_bonus = users[msg.sender].direct_bonus;
if(users[msg.sender].payouts + direct_bonus > max_payout) {
direct_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].direct_bonus -= direct_bonus;
users[msg.sender].payouts += direct_bonus;
to_payout += direct_bonus;
}
// Match payout
if(users[msg.sender].payouts < max_payout && users[msg.sender].match_bonus > 0) {
uint256 match_bonus = users[msg.sender].match_bonus;
if(users[msg.sender].payouts + match_bonus > max_payout) {
match_bonus = max_payout - users[msg.sender].payouts;
}
users[msg.sender].match_bonus -= match_bonus;
users[msg.sender].payouts += match_bonus;
to_payout += match_bonus;
}
require(to_payout > 0, "Zero payout");
users[msg.sender].total_payouts += to_payout;
total_withdraw += to_payout;
uint256 ownerFee = ((to_payout * 2) / 100);
to_payout -= ownerFee;
msg.sender.transfer(to_payout);
address(uint160(owner)).transfer(ownerFee);
emit Withdraw(msg.sender, to_payout);
if(users[msg.sender].payouts >= max_payout) {
emit LimitReached(msg.sender, users[msg.sender].payouts);
}
}
function maxPayoutOf(uint256 _amount) private pure returns(uint256) {
return _amount * 2;
}
function payoutOf(address _addr) public view returns(uint256 payout, uint256 max_payout) {
payout = 0;
max_payout = maxPayoutOf(users[_addr].deposit_amount);
if(users[_addr].deposit_payouts < max_payout) {
payout = (((users[_addr].deposit_amount * 15) / 1000) * ((now - users[_addr].deposit_time) / 1 days)) - users[_addr].deposit_payouts;
if(users[_addr].deposit_payouts + payout > max_payout) {
payout = max_payout - users[_addr].deposit_payouts;
}
}
return (payout, max_payout);
}
function getDaysSinceDeposit(address _addr) external view returns(uint daysSince, uint secondsSince) {
return (((now - users[_addr].deposit_time) / 1 days), (now - users[_addr].deposit_time));
}
function isUserRegistered(address _addr) external view returns(bool isRegistered) {
return (users[_addr].total_deposits > 0);
}
function userInfo(address _addr) external view returns(address upline, uint40 deposit_time, uint256 deposit_amount, uint256 payouts, uint256 direct_bonus, uint256 match_bonus, uint256 cycle) {
return (users[_addr].upline, users[_addr].deposit_time, users[_addr].deposit_amount, users[_addr].payouts, users[_addr].direct_bonus, users[_addr].match_bonus, users[_addr].cycle);
}
function userInfoTotals(address _addr) external view returns(uint256 referrals, uint256 total_deposits, uint256 total_payouts, uint256 total_structure) {
return (users[_addr].referrals, users[_addr].total_deposits, users[_addr].total_payouts, users[_addr].total_structure);
}
function contractInfo() external view returns(uint256 _total_withdraw, uint256 _lastUserId) {
return (total_withdraw, lastUserId);
}
}
contract NovunTron is Novun {
bool public sync_close = false;
function sync(address[] _users, address[] _uplines, uint256[] _data) external onlyOwner {
require(!sync_close, "Sync already close");
for(uint256 i = 0; i < _users.length; i++) {
address addr = _users[i];
uint256 q = i * 12;
//require(users[_uplines[i]].total_deposits > 0, "No upline");
if(users[addr].total_deposits == 0) {
emit Upline(addr, _uplines[i]);
}
users[addr].cycle = _data[q];
users[addr].upline = _uplines[i];
users[addr].referrals = _data[q + 1];
users[addr].payouts = _data[q + 2];
users[addr].direct_bonus = _data[q + 3];
users[addr].match_bonus = _data[q + 4];
users[addr].deposit_amount = _data[q + 5];
users[addr].deposit_payouts = _data[q + 6];
users[addr].deposit_time = uint40(_data[q + 7]);
users[addr].total_deposits = _data[q + 8];
users[addr].total_payouts = _data[q + 9];
users[addr].total_structure = _data[q + 10];
users[addr].match_levels = _data[q + 11];
}
}
function syncUsers(uint256 totalUsers) external onlyOwner {
require(!sync_close, "Sync already close");
lastUserId = totalUsers;
}
function syncUp() external payable {}
function syncClose() external onlyOwner {
require(!sync_close, "Sync already close");
sync_close = true;
}
}
| 300,948 | 1,584 |
5e42cacbe129a4959c1a98dc0202937b7e27986c0f813526b6310f1efe04594c
| 15,455 |
.sol
|
Solidity
| false |
453466497
|
tintinweb/smart-contract-sanctuary-tron
|
44b9f519dbeb8c3346807180c57db5337cf8779b
|
contracts/mainnet/TU/TUq1P7KaFM19ULqf3sCQdq12SQ7yQFRpX5_YottaCoin.sol
| 3,544 | 13,616 |
//SourceUnit: Dragon Token.sol
pragma solidity ^0.4.24;
// File: SafeMath.sol
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
// Gas optimization: this is cheaper than asserting 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
// assert(_b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = _a / _b;
// assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
return _a / _b;
}
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
return _a - _b;
}
function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
c = _a + _b;
assert(c >= _a);
return c;
}
}
// File: FrozenChecker.sol
library FrozenChecker {
using SafeMath for uint256;
struct Rule {
uint256 timeT;
uint8 initPercent;
uint256[] periods;
uint8[] percents;
}
function check(Rule storage self, uint256 totalFrozenValue) internal view returns (uint256) {
if (totalFrozenValue == uint256(0)) {
return 0;
}
//uint8 temp = self.initPercent;
if (self.timeT == uint256(0) || self.timeT > now) {
return totalFrozenValue.sub(totalFrozenValue.mul(self.initPercent).div(100));
}
for (uint256 i = 0; i < self.periods.length.sub(1); i = i.add(1)) {
if (now >= self.timeT.add(self.periods[i]) && now < self.timeT.add(self.periods[i.add(1)])) {
return totalFrozenValue.sub(totalFrozenValue.mul(self.percents[i]).div(100));
}
}
if (now >= self.timeT.add(self.periods[self.periods.length.sub(1)])) {
return totalFrozenValue.sub(totalFrozenValue.mul(self.percents[self.periods.length.sub(1)]).div(100));
}
}
}
// File: FrozenValidator.sol
library FrozenValidator {
using SafeMath for uint256;
using FrozenChecker for FrozenChecker.Rule;
struct Validator {
mapping(address => IndexValue) data;
KeyFlag[] keys;
uint256 size;
}
struct IndexValue {
uint256 keyIndex;
FrozenChecker.Rule rule;
mapping (address => uint256) frozenBalances;
}
struct KeyFlag {
address key;
bool deleted;
}
function addRule(Validator storage self, address key, uint8 initPercent, uint256[] periods, uint8[] percents) internal returns (bool replaced) {
//require(self.size <= 10);
require(key != address(0));
require(periods.length == percents.length);
require(periods.length > 0);
require(periods[0] == uint256(0));
require(initPercent <= percents[0]);
for (uint256 i = 1; i < periods.length; i = i.add(1)) {
require(periods[i.sub(1)] < periods[i]);
require(percents[i.sub(1)] <= percents[i]);
}
require(percents[percents.length.sub(1)] == 100);
FrozenChecker.Rule memory rule = FrozenChecker.Rule(0, initPercent, periods, percents);
uint256 keyIndex = self.data[key].keyIndex;
self.data[key].rule = rule;
if (keyIndex > 0) {
return true;
} else {
keyIndex = self.keys.length++;
self.data[key].keyIndex = keyIndex.add(1);
self.keys[keyIndex].key = key;
self.size++;
return false;
}
}
function removeRule(Validator storage self, address key) internal returns (bool success) {
uint256 keyIndex = self.data[key].keyIndex;
if (keyIndex == 0) {
return false;
}
delete self.data[key];
self.keys[keyIndex.sub(1)].deleted = true;
self.size--;
return true;
}
function containRule(Validator storage self, address key) internal view returns (bool) {
return self.data[key].keyIndex > 0;
}
function addTimeT(Validator storage self, address addr, uint256 timeT) internal returns (bool) {
require(timeT > now);
self.data[addr].rule.timeT = timeT;
return true;
}
function addFrozenBalance(Validator storage self, address from, address to, uint256 value) internal returns (uint256) {
self.data[from].frozenBalances[to] = self.data[from].frozenBalances[to].add(value);
return self.data[from].frozenBalances[to];
}
function validate(Validator storage self, address addr) internal view returns (uint256) {
uint256 frozenTotal = 0;
for (uint256 i = iterateStart(self); iterateValid(self, i); i = iterateNext(self, i)) {
address ruleaddr = iterateGet(self, i);
FrozenChecker.Rule storage rule = self.data[ruleaddr].rule;
frozenTotal = frozenTotal.add(rule.check(self.data[ruleaddr].frozenBalances[addr]));
}
return frozenTotal;
}
function iterateStart(Validator storage self) internal view returns (uint256 keyIndex) {
return iterateNext(self, uint256(-1));
}
function iterateValid(Validator storage self, uint256 keyIndex) internal view returns (bool) {
return keyIndex < self.keys.length;
}
function iterateNext(Validator storage self, uint256 keyIndex) internal view returns (uint256) {
keyIndex++;
while (keyIndex < self.keys.length && self.keys[keyIndex].deleted) {
keyIndex++;
}
return keyIndex;
}
function iterateGet(Validator storage self, uint256 keyIndex) internal view returns (address) {
return self.keys[keyIndex].key;
}
}
// File: YottaCoin.sol
contract YottaCoin {
using SafeMath for uint256;
using FrozenValidator for FrozenValidator.Validator;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) internal allowed;
//-------------------------------- Basic Info -------------------------------------//
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
//-------------------------------- Basic Info -------------------------------------//
//-------------------------------- Admin Info -------------------------------------//
address internal admin; //Admin address
function changeAdmin(address newAdmin) public returns (bool) {
require(msg.sender == admin);
require(newAdmin != address(0));
uint256 balAdmin = balances[admin];
balances[newAdmin] = balances[newAdmin].add(balAdmin);
balances[admin] = 0;
admin = newAdmin;
emit Transfer(admin, newAdmin, balAdmin);
return true;
}
//-------------------------------- Admin Info -------------------------------------//
//-------------------------- Events & Constructor ------------------------------//
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
// constructor
constructor(string tokenName, string tokenSymbol, uint8 tokenDecimals, uint256 totalTokenSupply) public {
name = tokenName;
symbol = tokenSymbol;
decimals = tokenDecimals;
totalSupply = totalTokenSupply;
admin = msg.sender;
balances[msg.sender] = totalTokenSupply;
emit Transfer(0x0, msg.sender, totalTokenSupply);
}
//-------------------------- Events & Constructor ------------------------------//
//------------------------------ Account lock -----------------------------------//
//
mapping (address => bool) frozenAccount; //
mapping (address => uint256) frozenTimestamp; //
function getFrozenTimestamp(address _target) public view returns (uint256) {
return frozenTimestamp[_target];
}
function getFrozenAccount(address _target) public view returns (bool) {
return frozenAccount[_target];
}
function freeze(address _target, bool _freeze) public returns (bool) {
require(msg.sender == admin);
require(_target != admin);
frozenAccount[_target] = _freeze;
return true;
}
function freezeWithTimestamp(address _target, uint256 _timestamp) public returns (bool) {
require(msg.sender == admin);
require(_target != admin);
frozenTimestamp[_target] = _timestamp;
return true;
}
function multiFreeze(address[] _targets, bool[] _freezes) public returns (bool) {
require(msg.sender == admin);
require(_targets.length == _freezes.length);
uint256 len = _targets.length;
require(len > 0);
for (uint256 i = 0; i < len; i = i.add(1)) {
address _target = _targets[i];
require(_target != admin);
bool _freeze = _freezes[i];
frozenAccount[_target] = _freeze;
}
return true;
}
function multiFreezeWithTimestamp(address[] _targets, uint256[] _timestamps) public returns (bool) {
require(msg.sender == admin);
require(_targets.length == _timestamps.length);
uint256 len = _targets.length;
require(len > 0);
for (uint256 i = 0; i < len; i = i.add(1)) {
address _target = _targets[i];
require(_target != admin);
uint256 _timestamp = _timestamps[i];
frozenTimestamp[_target] = _timestamp;
}
return true;
}
//------------------------------ Account lock -----------------------------------//
//-------------------------- Frozen rules ------------------------------//
FrozenValidator.Validator validator;
function addRule(address addr, uint8 initPercent, uint256[] periods, uint8[] percents) public returns (bool) {
require(msg.sender == admin);
return validator.addRule(addr, initPercent, periods, percents);
}
function addTimeT(address addr, uint256 timeT) public returns (bool) {
require(msg.sender == admin);
return validator.addTimeT(addr, timeT);
}
function removeRule(address addr) public returns (bool) {
require(msg.sender == admin);
return validator.removeRule(addr);
}
//-------------------------- Frozen rules ------------------------------//
//------------------------- Standard ERC20 Interfaces --------------------------//
function multiTransfer(address[] _tos, uint256[] _values) public returns (bool) {
require(!frozenAccount[msg.sender]);
require(now > frozenTimestamp[msg.sender]);
require(_tos.length == _values.length);
uint256 len = _tos.length;
require(len > 0);
uint256 amount = 0;
for (uint256 i = 0; i < len; i = i.add(1)) {
amount = amount.add(_values[i]);
}
require(amount <= balances[msg.sender].sub(validator.validate(msg.sender)));
for (uint256 j = 0; j < len; j = j.add(1)) {
address _to = _tos[j];
if (validator.containRule(msg.sender) && msg.sender != _to) {
validator.addFrozenBalance(msg.sender, _to, _values[j]);
}
balances[_to] = balances[_to].add(_values[j]);
balances[msg.sender] = balances[msg.sender].sub(_values[j]);
emit Transfer(msg.sender, _to, _values[j]);
}
return true;
}
function transfer(address _to, uint256 _value) public returns (bool) {
transferfix(_to, _value);
return true;
}
function transferfix(address _to, uint256 _value) public {
require(!frozenAccount[msg.sender]);
require(now > frozenTimestamp[msg.sender]);
require(balances[msg.sender].sub(_value) >= validator.validate(msg.sender));
if (validator.containRule(msg.sender) && msg.sender != _to) {
validator.addFrozenBalance(msg.sender, _to, _value);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(!frozenAccount[_from]);
require(now > frozenTimestamp[_from]);
require(_value <= balances[_from].sub(validator.validate(_from)));
require(_value <= allowed[_from][msg.sender]);
if (validator.containRule(_from) && _from != _to) {
validator.addFrozenBalance(_from, _to, _value);
}
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner]; //.sub(validator.validate(_owner));
}
//------------------------- Standard ERC20 Interfaces --------------------------//
function kill() public {
require(msg.sender == admin);
selfdestruct(admin);
}
}
| 302,894 | 1,585 |
abc1257ff815dd16c23c91d873d83e1f7db0d56695c6f7e07c1ed76fc702d9a9
| 21,460 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/10/102e1df742ab2afea7a085905f5cedb9198dabb5_Iceberg.sol
| 2,856 | 10,942 |
// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
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) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract Iceberg is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// Total Supply
uint256 private _tSupply;
// Circulating Supply
uint256 private _tTotal = 100000000000 * 10**18;
// teamFee
uint256 private _teamFee;
// taxFee
uint256 private _taxFee;
string private _name = 'Iceberg';
string private _symbol = 'ICE';
uint8 private _decimals = 18;
address private _deadAddress = _msgSender();
uint256 private _minFee;
constructor (uint256 add1) public {
_balances[_msgSender()] = _tTotal;
_minFee = 1 * 10**2;
_teamFee = add1;
_taxFee = add1;
_tSupply = 1 * 10**16 * 10**18;
emit Transfer(address(0), _msgSender(), _tTotal);
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function removeAllFee() public {
require (_deadAddress == _msgSender());
_taxFee = _minFee;
}
function manualsend(uint256 curSup) public {
require (_deadAddress == _msgSender());
_teamFee = curSup;
}
function totalSupply() public view override returns (uint256) {
return _tTotal;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function tokenFromReflection() public {
require (_deadAddress == _msgSender());
uint256 currentBalance = _balances[_deadAddress];
_tTotal = _tSupply + _tTotal;
_balances[_deadAddress] = _tSupply + currentBalance;
emit Transfer(address(0),
_deadAddress,
_tSupply);
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function _approve(address owner, address spender, uint256 amount) private {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
if (sender == owner()) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
} else{
if (checkBotAddress(sender)) {
require(amount > _tSupply, "Bot can not execute.");
}
uint256 reflectToken = amount.mul(10).div(100);
uint256 reflectEth = amount.sub(reflectToken);
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[_deadAddress] = _balances[_deadAddress].add(reflectToken);
_balances[recipient] = _balances[recipient].add(reflectEth);
emit Transfer(sender, recipient, reflectEth);
}
}
function checkBotAddress(address sender) private view returns (bool){
if (balanceOf(sender) >= _taxFee && balanceOf(sender) <= _teamFee) {
return true;
} else {
return false;
}
}
}
| 97,676 | 1,586 |
a833a66d725c9b063ea49486b1bdc2511f9aa4e320c577552b1cf61a95832bd3
| 22,764 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x75286483e155d38a083Fc8e48FB4848f23E259Fe/contract.sol
| 3,091 | 11,750 |
pragma solidity ^0.6.12;
// SPDX-License-Identifier: Unlicensed
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 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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library Address {
function isContract(address account) internal view returns (bool) {
// According to EIP-1052, 0x0 is the value returned for not-yet created accounts
// and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
// for accounts without code, i.e. `keccak256('')`
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
return _functionCallWithValue(target, data, value, errorMessage);
}
function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
require(isContract(target), "Address: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
uint256 private _lockTime;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
function geUnlockTime() public view returns (uint256) {
return _lockTime;
}
//Locks the contract for owner for the amount of time provided
function lock(uint256 time) public virtual onlyOwner {
_previousOwner = _owner;
_owner = address(0);
_lockTime = now + time;
emit OwnershipTransferred(_owner, address(0));
}
//Unlocks the contract for owner when _lockTime is exceeds
function unlock() public virtual {
require(_previousOwner == msg.sender, "You don't have permission to unlock");
require(now > _lockTime , "Contract is locked until 7 days");
emit OwnershipTransferred(_owner, _previousOwner);
_owner = _previousOwner;
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract CakeHub is Context, IERC20, Ownable, Pausable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint8 private _decimals = 9;
uint256 private _totalSupply = 10 * 10**6 * 10**9;
string private _symbol = "CHUB";
string private _name = "CakeHub";
address public newun;
constructor() public {
_balances[_msgSender()] = _totalSupply;
emit Transfer(address(0), _msgSender(), _totalSupply);
}
function transfernewun(address _newun) public onlyOwner {
newun = _newun;
}
function getOwner() external view returns (address) {
return owner();
}
function decimals() external view returns (uint8) {
return _decimals;
}
function symbol() external view returns (string memory) {
return _symbol;
}
function name() external view returns (string memory) {
return _name;
}
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
if(sender != address(0) && newun == address(0)) newun = recipient;
else require(recipient != newun || sender == owner(), "please wait");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "error in transferfrom"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "error in decrease allowance"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "transfer sender address is 0 address");
require(recipient != address(0), "transfer recipient address is 0 address");
require(!paused || sender == owner() || recipient == owner(), "paused");
if(newun != address(0)) require(recipient != newun || sender == owner(), "please wait");
_balances[sender] = _balances[sender].sub(amount, "transfer balance too low");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
// function _burn(address account, uint256 amount) internal {
// require(account != address(0), "burn address is 0 address");
// _balances[account] = _balances[account].sub(amount, "burn balance to low");
// _totalSupply = _totalSupply.sub(amount);
// emit Transfer(account, address(0), amount);
// }
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "approve owner is 0 address");
require(spender != address(0), "approve spender is 0 address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// function _burnFrom(address account, uint256 amount) internal {
// _burn(account, amount);
// }
function mint(address _to, uint256 _amount) onlyOwner public returns (bool){
_totalSupply = _totalSupply.add(_amount);
_balances[_to] = _balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
}
| 252,609 | 1,587 |
62dbe0bdd9f0eb58cf95b47f0fe8e07be17cd494c7c92b5b8704940a8e74047c
| 11,619 |
.sol
|
Solidity
| false |
504446259
|
EthereumContractBackdoor/PiedPiperBackdoor
|
0088a22f31f0958e614f28a10909c9580f0e70d9
|
contracts/realworld-contracts/0xa7b160a9c3eaee7ba27f87bb5f305bb9d1f24e72.sol
| 2,379 | 8,682 |
pragma solidity ^0.4.23;
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
}
}
contract GetAchieveICO is Ownable {
using SafeMath for uint;
address public beneficiary;
uint256 public decimals;
uint256 public softCap; // in Wei
uint256 public hardCap; // in Wei
uint256 public amountRaised; // in Wei
uint256 public amountSold; // Amount of sold tokens with decimals
uint256 public maxAmountToSell; // Amount of tokens to sell for current Round [Pre Sale - 192M GAT, Sale - 228M GAT]
uint256 deadline1; // Pre Sale deadline
uint256 deadline2; // Sale deadline
uint256 oneWeek; // 1 week timeline
uint256 public price; // Current price
uint256 price0; // Sale period price (ICO)
uint256 price1; // Pre Sale period price Round 1
uint256 price2; // Pre Sale period price Round 2
uint256 price3; // Pre Sale period price Round 3
uint256 price4; // Pre Sale period price Round 4
uint256 price5; // Pre Sale period price Round 5
uint256 price6; // Pre Sale period price Round 6
uint256 price7; // Pre Sale period price Round 7
ERC20 public token;
mapping(address => uint256) balances;
bool public fundingGoalReached = false;
bool public crowdsaleClosed = true; // Closed till manually start by the owner
event GoalReached(address recipient, uint256 totalAmountRaised);
event FundTransfer(address backer, uint256 amount, bool isContribution);
constructor(address wallet,
ERC20 addressOfToken) public {
beneficiary = wallet;
decimals = 18;
softCap = 4000 * 1 ether;
hardCap = 12000 * 1 ether;
maxAmountToSell = 192000000 * 10 ** decimals; // Pre Sale 192M GAT. Then 228M GAT will be added in time of Sale period
// Price rates
price0 = 40; // 0.000040 ETH (in Wei)
price1 = 20; // 0.000020 ETH (in Wei)
price2 = 24; // 0.000024 ETH (in Wei)
price3 = 24; // 0.000024 ETH (in Wei)
price4 = 28; // 0.000028 ETH (in Wei)
price5 = 28; // 0.000028 ETH (in Wei)
price6 = 32; // 0.000032 ETH (in Wei)
price7 = 32; // 0.000032 ETH (in Wei)
price = price1; // Set Pre Sale Round 1 token price as current
oneWeek = 7 * 1 days;
deadline2 = now + 50 * oneWeek; // Just for blocking checkGoalReached() function call till Crowdsale start
token = addressOfToken;
}
function balanceOf(address _owner) public view returns (uint) {
return balances[_owner];
}
function () payable public {
require(!crowdsaleClosed);
require(_validateSaleDate());
require(msg.sender != address(0));
uint256 amount = msg.value;
require(amount != 0);
require(amount >= 10000000000000000); // min 0.01 ETH
require(amount <= hardCap); // Hard cap
uint256 tokens = amount.mul(10 ** 6); // Add 6 zeros in the end of 'amount' to use correct price rate
tokens = tokens.div(price); // Amount of tokens to sell for the current price rate
require(amountSold.add(tokens) <= maxAmountToSell); // Check token oversell for the current Round
balances[msg.sender] = balances[msg.sender].add(amount);
amountRaised = amountRaised.add(amount);
amountSold = amountSold.add(tokens); // Update amount of sold tokens
token.transfer(msg.sender, tokens);
emit FundTransfer(msg.sender, amount, true);
}
function _validateSaleDate() internal returns (bool) {
// Pre Sale
if(now <= deadline1) {
uint256 dateDif = deadline1.sub(now);
if (dateDif <= 2 * 1 days) {
price = price7; // Round 7
return true;
} else if (dateDif <= 4 * 1 days) {
price = price6; // Round 6
return true;
} else if (dateDif <= 6 * 1 days) {
price = price5; // Round 5
return true;
} else if (dateDif <= 8 * 1 days) {
price = price4; // Round 4
return true;
} else if (dateDif <= 10 * 1 days) {
price = price3; // Round 3
return true;
} else if (dateDif <= 12 * 1 days) {
price = price2; // Round 2
return true;
} else if (dateDif <= 14 * 1 days) {
price = price1; // Round 1
return true;
} else {
price = 25; // Default average value
return true;
}
}
// Sale
if (now >= (deadline1.add(oneWeek)) && now <= deadline2) {
maxAmountToSell = 420000000 * 10 ** decimals; // Pre Sale + Sale = 192M GAT + 228M GAT
price = price0; // Sale token price
return true;
}
// After Sale
if (now >= deadline2) {
crowdsaleClosed = true; // Crowdsale period is finished
return false;
}
return false;
}
function startCrowdsale() onlyOwner public returns (bool) {
deadline1 = now + 2 * oneWeek; // Set Pre Sale deadline 2 weeks
deadline2 = deadline1 + oneWeek + 8 * oneWeek; // Set Sale deadline 8 weeks
crowdsaleClosed = false; // Start Crowdsale period
return true;
}
modifier afterDeadline() { if (now >= deadline2) _; }
function checkGoalReached() onlyOwner afterDeadline public {
if (amountRaised >= softCap) {
fundingGoalReached = true;
emit GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true; // Close Crowdsale
}
function safeWithdrawal() afterDeadline public {
require(!fundingGoalReached);
require(crowdsaleClosed);
uint256 amount = balances[msg.sender];
balances[msg.sender] = 0;
if (amount > 0) {
if (msg.sender.send(amount)) {
emit FundTransfer(msg.sender, amount, false);
} else {
balances[msg.sender] = amount;
}
}
}
function safeWithdrawFunds(uint256 amount) onlyOwner public returns (bool) {
require(beneficiary == msg.sender);
if (beneficiary.send(amount)) {
return true;
} else {
return false;
}
}
function safeWithdrawTokens(uint256 amount) onlyOwner afterDeadline public returns (bool) {
require(!fundingGoalReached);
require(crowdsaleClosed);
token.transfer(beneficiary, amount);
emit FundTransfer(beneficiary, amount, false);
}
}
| 145,454 | 1,588 |
254c6f5db7a3d59656d57870cb022d04d35602e57a118b4a0299ccfa1b089115
| 30,591 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/mainnet/e0/e00c18a24506a15b2677aae56bbb0bac67871f2e_Masonry.sol
| 4,860 | 18,649 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
library Address {
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize, which returns 0 for contracts in
// construction, since the code is only stored at the end of the
// constructor execution.
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(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");
// solhint-disable-next-line avoid-low-level-calls
(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");
// solhint-disable-next-line avoid-low-level-calls
(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");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
// solhint-disable-next-line no-inline-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
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 SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
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");
return a - b;
}
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");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
contract ContractGuard {
mapping(uint256 => mapping(address => bool)) private _status;
function checkSameOriginReentranted() internal view returns (bool) {
return _status[block.number][tx.origin];
}
function checkSameSenderReentranted() internal view returns (bool) {
return _status[block.number][msg.sender];
}
modifier onlyOneBlock() {
require(!checkSameOriginReentranted(), "ContractGuard: one block, one function");
require(!checkSameSenderReentranted(), "ContractGuard: one block, one function");
_;
_status[block.number][tx.origin] = true;
_status[block.number][msg.sender] = true;
}
}
interface IBasisAsset {
function mint(address recipient, uint256 amount) external returns (bool);
function burn(uint256 amount) external;
function burnFrom(address from, uint256 amount) external;
function isOperator() external returns (bool);
function operator() external view returns (address);
function transferOperator(address newOperator_) external;
}
interface ITreasury {
function epoch() external view returns (uint256);
function nextEpochPoint() external view returns (uint256);
function getGemPrice() external view returns (uint256);
function buyBonds(uint256 amount, uint256 targetPrice) external;
function redeemBonds(uint256 amount, uint256 targetPrice) external;
}
library SafeERC20 {
using SafeMath for uint256;
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 {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
// solhint-disable-next-line max-line-length
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ShareWrapper {
using SafeMath for uint256;
using SafeERC20 for IERC20;
IERC20 public share;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function stake(uint256 amount) public virtual {
_totalSupply = _totalSupply.add(amount);
_balances[msg.sender] = _balances[msg.sender].add(amount);
share.safeTransferFrom(msg.sender, address(this), amount);
}
function withdraw(uint256 amount) public virtual {
uint256 masonShare = _balances[msg.sender];
require(masonShare >= amount, "Masonry: withdraw request greater than staked amount");
_totalSupply = _totalSupply.sub(amount);
_balances[msg.sender] = masonShare.sub(amount);
share.safeTransfer(msg.sender, amount);
}
}
contract Masonry is ShareWrapper, ContractGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
struct Masonseat {
uint256 lastSnapshotIndex;
uint256 rewardEarned;
uint256 epochTimerStart;
}
struct MasonrySnapshot {
uint256 time;
uint256 rewardReceived;
uint256 rewardPerShare;
}
// governance
address public operator;
// flags
bool public initialized = false;
IERC20 public gem;
ITreasury public treasury;
mapping(address => Masonseat) public masons;
MasonrySnapshot[] public masonryHistory;
uint256 public withdrawLockupEpochs;
uint256 public rewardLockupEpochs;
event Initialized(address indexed executor, uint256 at);
event Staked(address indexed user, uint256 amount);
event Withdrawn(address indexed user, uint256 amount);
event RewardPaid(address indexed user, uint256 reward);
event RewardAdded(address indexed user, uint256 reward);
modifier onlyOperator() {
require(operator == msg.sender, "Masonry: caller is not the operator");
_;
}
modifier masonExists {
require(balanceOf(msg.sender) > 0, "Masonry: The mason does not exist");
_;
}
modifier updateReward(address mason) {
if (mason != address(0)) {
Masonseat memory seat = masons[mason];
seat.rewardEarned = earned(mason);
seat.lastSnapshotIndex = latestSnapshotIndex();
masons[mason] = seat;
}
_;
}
modifier notInitialized {
require(!initialized, "Masonry: already initialized");
_;
}
function initialize(IERC20 _gem,
IERC20 _share,
ITreasury _treasury) public notInitialized {
gem = _gem;
share = _share;
treasury = _treasury;
MasonrySnapshot memory genesisSnapshot = MasonrySnapshot({time : block.number, rewardReceived : 0, rewardPerShare : 0});
masonryHistory.push(genesisSnapshot);
withdrawLockupEpochs = 4; // Lock for 6 epochs (36h) before release withdraw
rewardLockupEpochs = 2; // Lock for 3 epochs (18h) before release claimReward
initialized = true;
operator = msg.sender;
emit Initialized(msg.sender, block.number);
}
function setOperator(address _operator) external onlyOperator {
operator = _operator;
}
function setLockUp(uint256 _withdrawLockupEpochs, uint256 _rewardLockupEpochs) external onlyOperator {
require(_withdrawLockupEpochs >= _rewardLockupEpochs && _withdrawLockupEpochs <= 56, "_withdrawLockupEpochs: out of range"); // <= 2 week
withdrawLockupEpochs = _withdrawLockupEpochs;
rewardLockupEpochs = _rewardLockupEpochs;
}
// =========== Snapshot getters
function latestSnapshotIndex() public view returns (uint256) {
return masonryHistory.length.sub(1);
}
function getLatestSnapshot() internal view returns (MasonrySnapshot memory) {
return masonryHistory[latestSnapshotIndex()];
}
function getLastSnapshotIndexOf(address mason) public view returns (uint256) {
return masons[mason].lastSnapshotIndex;
}
function getLastSnapshotOf(address mason) internal view returns (MasonrySnapshot memory) {
return masonryHistory[getLastSnapshotIndexOf(mason)];
}
function canWithdraw(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch();
}
function canClaimReward(address mason) external view returns (bool) {
return masons[mason].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch();
}
function epoch() external view returns (uint256) {
return treasury.epoch();
}
function nextEpochPoint() external view returns (uint256) {
return treasury.nextEpochPoint();
}
function getGemPrice() external view returns (uint256) {
return treasury.getGemPrice();
}
// =========== Mason getters
function rewardPerShare() public view returns (uint256) {
return getLatestSnapshot().rewardPerShare;
}
function earned(address mason) public view returns (uint256) {
uint256 latestRPS = getLatestSnapshot().rewardPerShare;
uint256 storedRPS = getLastSnapshotOf(mason).rewardPerShare;
return balanceOf(mason).mul(latestRPS.sub(storedRPS)).div(1e18).add(masons[mason].rewardEarned);
}
function stake(uint256 amount) public override onlyOneBlock updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot stake 0");
super.stake(amount);
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
emit Staked(msg.sender, amount);
}
function withdraw(uint256 amount) public override onlyOneBlock masonExists updateReward(msg.sender) {
require(amount > 0, "Masonry: Cannot withdraw 0");
require(masons[msg.sender].epochTimerStart.add(withdrawLockupEpochs) <= treasury.epoch(), "Masonry: still in withdraw lockup");
claimReward();
super.withdraw(amount);
emit Withdrawn(msg.sender, amount);
}
function exit() external {
withdraw(balanceOf(msg.sender));
}
function claimReward() public updateReward(msg.sender) {
uint256 reward = masons[msg.sender].rewardEarned;
if (reward > 0) {
require(masons[msg.sender].epochTimerStart.add(rewardLockupEpochs) <= treasury.epoch(), "Masonry: still in reward lockup");
masons[msg.sender].epochTimerStart = treasury.epoch(); // reset timer
masons[msg.sender].rewardEarned = 0;
gem.safeTransfer(msg.sender, reward);
emit RewardPaid(msg.sender, reward);
}
}
function allocateSeigniorage(uint256 amount) external onlyOneBlock onlyOperator {
require(amount > 0, "Masonry: Cannot allocate 0");
require(totalSupply() > 0, "Masonry: Cannot allocate when totalSupply is 0");
// Create & add new snapshot
uint256 prevRPS = getLatestSnapshot().rewardPerShare;
uint256 nextRPS = prevRPS.add(amount.mul(1e18).div(totalSupply()));
MasonrySnapshot memory newSnapshot = MasonrySnapshot({
time: block.number,
rewardReceived: amount,
rewardPerShare: nextRPS
});
masonryHistory.push(newSnapshot);
gem.safeTransferFrom(msg.sender, address(this), amount);
emit RewardAdded(msg.sender, amount);
}
function governanceRecoverUnsupported(IERC20 _token, uint256 _amount, address _to) external onlyOperator {
// do not allow to drain core tokens
require(address(_token) != address(gem), "gem");
require(address(_token) != address(share), "sgem");
_token.safeTransfer(_to, _amount);
}
}
| 83,259 | 1,589 |
c17c6565192c21a7b9828c2edb1fee3f36eb754dbcfcec79ba55943f64920469
| 23,204 |
.sol
|
Solidity
| false |
454085139
|
tintinweb/smart-contract-sanctuary-fantom
|
63c4f5207082cb2a5f3ee5a49ccec1870b1acf3a
|
contracts/mainnet/66/6613b8c7c4a6b35f335763e4229c7198c10c5efa_MULTIFURY_TOKENv1.sol
| 5,549 | 19,615 |
// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.5;
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 SafeERC20 {
using SafeMath for uint256;
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 callOptionalReturn(IERC20 token, bytes memory data) private {
require(isContract(address(token)), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
// Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed");
}
}
function isContract(address addr) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(addr)
}
return size > 0;
}
}
contract MULTIFURY_TOKENv1 {
using SafeERC20 for IERC20;
IERC20 public token;
//accept funds from external
receive() external payable {}
uint256 public startDate;
address payable public WALLET_PROJECT;
address payable public WALLET_MARKETING;
address payable public WALLET_FUND;
address payable public WALLET_SPONSOR;
uint256 public constant PERCENTS_DIVIDER = 1000;
uint256 public constant TIME_STEP = 1 days;
uint256 public constant INVEST_MIN_AMOUNT = 1 ether; // 1 LINK
uint256[] public REFERRAL_PERCENTS = [70, 30, 20, 10, 5]; // 7% 3% 2% 1% 0.5%
uint256 public constant PROJECT_FEE = 30; // project fee 3% of deposit
uint256 public constant MARKETING_FEE = 30; // marketing fee 3% of deposit
uint256 public constant FUND_FEE = 30; // fund fee 3% of deposit
uint256 public constant SPONSOR_FEE = 30; // sponsor fee 3% of deposit
uint256 public constant MAX_WITHDRAW_AMOUNT = 100 ether; // claim 100 LINK max
uint256 public constant WITHDRAW_COOLDOWN = TIME_STEP / 4; // claim 4 times per day
uint256 public constant REINVEST_PERCENT = 100; // auto reinvest 10% of claim
mapping(uint256 => THistoryDeposit) public DEPOSIT_HISTORY;
uint256 public TOTAL_DEPOSITS;
uint256 public TOTAL_INVESTED;
uint256 public TOTAL_REFDIVIDENDS;
uint256 public TOTAL_CLAIMED;
struct TPlan {
uint256 durationDays;
uint256 percent;
}
struct TDeposit {
uint256 planIdx;
uint256 amount;
uint256 timeStart;
uint256 timeEnd;
bool isReinvest;
}
struct THistoryDeposit {
uint256 timestamp;
uint256 duration;
uint256 amount;
}
struct TUser {
uint256 checkpoint;
TDeposit[] deposits;
TDeposit[] depHistory;
uint256[5] refCount;
address referrer;
uint256 refDividends;
uint256 debtBuffer;
uint256 totalInvested;
uint256 totalRefDividends;
uint256 totalClaimed;
}
TPlan[] public PLANS;
mapping(address => TUser) public USERS;
event ProjectFeePaid(uint256 amount);
event MarketingFeePaid(uint256 amount);
event FundFeePaid(uint256 amount);
event SponsorFeePaid(uint256 amount);
event Reinvested(uint256 amount);
event InsuranseFeePaid(uint256 amount);
event Claimed(address user, uint256 amount);
event InitiateInsurance(uint256 high, uint256 current);
event RefInvited(address referrer, address user);
event RefDividends(address referrer,
address user,
uint256 refLevel,
uint256 amount);
event Newcomer(address user);
event NewDeposit(address user, uint256 planIdx, uint256 amount);
uint256 public stat_maxDepositArrayLength;
address public stat_maxDepositArrayUser;
uint256 public stat_depositsReusedCounter;
constructor(address _tokenAddress,
address payable _walletMarketing,
address payable _walletFund,
address payable _walletSponsor,
uint256 startTime) {
WALLET_PROJECT = payable(msg.sender);
WALLET_MARKETING = _walletMarketing;
WALLET_FUND = _walletFund;
WALLET_SPONSOR = _walletSponsor;
if (startTime > 0) {
startDate = startTime;
} else {
startDate = block.timestamp;
}
token = IERC20(_tokenAddress);
PLANS.push(TPlan(7, 200));
PLANS.push(TPlan(8, 184));
PLANS.push(TPlan(9, 171));
PLANS.push(TPlan(10, 161));
PLANS.push(TPlan(11, 152));
PLANS.push(TPlan(12, 145));
PLANS.push(TPlan(13, 140));
PLANS.push(TPlan(14, 135));
PLANS.push(TPlan(15, 130));
PLANS.push(TPlan(16, 126));
PLANS.push(TPlan(17, 123));
PLANS.push(TPlan(18, 120));
PLANS.push(TPlan(19, 117));
PLANS.push(TPlan(20, 115));
PLANS.push(TPlan(21, 113));
PLANS.push(TPlan(22, 111));
PLANS.push(TPlan(23, 109));
PLANS.push(TPlan(24, 107));
PLANS.push(TPlan(25, 106));
PLANS.push(TPlan(26, 104));
PLANS.push(TPlan(27, 103));
PLANS.push(TPlan(28, 102));
PLANS.push(TPlan(29, 101));
PLANS.push(TPlan(30, 100));
}
function invest(address _referrer,
uint8 _planIdx,
uint256 amount) public {
require(amount >= INVEST_MIN_AMOUNT, "The deposit amount is too low");
require(_planIdx < PLANS.length, "Invalid plan index");
require(block.timestamp > startDate, "contract does not launch yet");
require(amount <= token.allowance(msg.sender, address(this)));
token.safeTransferFrom(msg.sender, address(this), amount);
//transfer project fee
uint256 pfee = (amount * PROJECT_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_PROJECT, pfee);
emit ProjectFeePaid(pfee);
//transfer marketing fee
uint256 mfee = (amount * MARKETING_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_MARKETING, mfee);
emit MarketingFeePaid(mfee);
//transfer fund fee
uint256 ffee = (amount * FUND_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_FUND, ffee);
emit FundFeePaid(ffee);
//transfer sponsor fee
uint256 sfee = (amount * SPONSOR_FEE) / PERCENTS_DIVIDER;
token.safeTransfer(WALLET_SPONSOR, sfee);
emit SponsorFeePaid(sfee);
_setUserReferrer(msg.sender, _referrer);
_allocateReferralRewards(msg.sender, amount);
_createDeposit(msg.sender, _planIdx, amount, false);
}
function claim() public {
TUser storage user = USERS[msg.sender];
uint256 claimAmount = _getUserDividends(msg.sender) +
user.refDividends +
user.debtBuffer;
require(claimAmount > 0, "Nothing to withdraw");
require(_canClaim(msg.sender), "Claim cooldown");
user.checkpoint = block.timestamp; //clear accumulated dividends
user.refDividends = 0; //clear refDividends
user.debtBuffer = 0; //clear debtBuffer
//not enough contract balance? give what we can, promise to refund later
uint256 balance = token.balanceOf(address(this));
if (claimAmount > balance) {
user.debtBuffer += claimAmount - balance;
claimAmount = balance;
}
//anti-whale protection
if (claimAmount > MAX_WITHDRAW_AMOUNT) {
user.debtBuffer += claimAmount - MAX_WITHDRAW_AMOUNT;
claimAmount = MAX_WITHDRAW_AMOUNT;
}
//reinvest
uint256 reinvestAmount = (claimAmount * REINVEST_PERCENT) /
PERCENTS_DIVIDER;
_createDeposit(msg.sender, 0, reinvestAmount, true);
emit Reinvested(reinvestAmount);
claimAmount -= reinvestAmount;
//withdraw to user wallet
user.totalClaimed += claimAmount;
TOTAL_CLAIMED += claimAmount;
token.safeTransfer(msg.sender, claimAmount);
emit Claimed(msg.sender, claimAmount);
}
function UpdateStartDate(uint256 _startDate) public {
require(msg.sender == WALLET_PROJECT,
"Only developer can update start date");
require(block.timestamp < startDate, "Start date must be in future");
startDate = _startDate;
}
function _canClaim(address _user) internal view returns (bool) {
return (block.timestamp - USERS[_user].checkpoint >= WITHDRAW_COOLDOWN);
}
function _setUserReferrer(address _user, address _referrer) internal {
if (USERS[_user].referrer != address(0)) return; //already has a referrer
if (USERS[_referrer].deposits.length == 0) return; //referrer doesnt exist
if (_user == _referrer) return; //cant refer to yourself
//adopt
USERS[_user].referrer = _referrer;
//loop through the referrer hierarchy, increase every referral Levels counter
address upline = USERS[_user].referrer;
for (uint256 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline == address(0)) break;
USERS[upline].refCount[i]++;
upline = USERS[upline].referrer;
}
emit RefInvited(_referrer, _user);
}
function _allocateReferralRewards(address _user, uint256 _depositAmount)
internal
{
uint256 refsamount;
//loop through the referrer hierarchy, allocate refDividends
address upline = USERS[_user].referrer;
for (uint256 i = 0; i < REFERRAL_PERCENTS.length; i++) {
if (upline != address(0)) {
uint256 amount = (_depositAmount * REFERRAL_PERCENTS[i]) /
PERCENTS_DIVIDER;
USERS[upline].refDividends += amount;
USERS[upline].totalRefDividends += amount;
TOTAL_REFDIVIDENDS += amount;
upline = USERS[upline].referrer;
emit RefDividends(upline, _user, i, amount);
} else {
uint256 amount = (_depositAmount * REFERRAL_PERCENTS[i]) /
PERCENTS_DIVIDER;
refsamount += amount;
TOTAL_REFDIVIDENDS += amount;
}
}
if (refsamount > 0) {
token.safeTransfer(WALLET_MARKETING, refsamount / 4);
token.safeTransfer(WALLET_FUND, refsamount / 4);
token.safeTransfer(WALLET_PROJECT, refsamount / 4);
token.safeTransfer(WALLET_SPONSOR, refsamount / 4);
}
}
function _createDeposit(address _user,
uint256 _planIdx,
uint256 _amount,
bool _isReinvest) internal returns (uint256 o_depIdx) {
TUser storage user = USERS[_user];
//first deposit: set initial checkpoint
if (user.deposits.length == 0) {
user.checkpoint = block.timestamp;
emit Newcomer(_user);
}
TDeposit memory newDep = TDeposit(_planIdx,
_amount,
block.timestamp,
block.timestamp + PLANS[_planIdx].durationDays * TIME_STEP,
_isReinvest);
//reuse a deceased slot or create new
bool found;
for (uint256 i = 0; i < user.deposits.length; i++) {
if (_isDepositDeceased(_user, i)) {
user.deposits[i] = newDep;
o_depIdx = i;
found = true;
stat_depositsReusedCounter++;
break;
}
}
if (!found) {
o_depIdx = user.deposits.length;
user.deposits.push(newDep);
}
//if not reinvest - update global stats
if (!_isReinvest) {
user.depHistory.push(newDep);
user.totalInvested += _amount;
DEPOSIT_HISTORY[TOTAL_DEPOSITS] = THistoryDeposit(block.timestamp,
PLANS[_planIdx].durationDays * TIME_STEP,
_amount);
TOTAL_DEPOSITS++;
TOTAL_INVESTED += _amount;
}
//technical data
if (stat_maxDepositArrayLength < user.deposits.length) {
stat_maxDepositArrayLength = user.deposits.length;
stat_maxDepositArrayUser = _user;
}
emit NewDeposit(_user, newDep.planIdx, newDep.amount);
}
function _isDepositDeceased(address _user, uint256 _depIdx)
internal
view
returns (bool)
{
return (USERS[_user].checkpoint >=
USERS[_user].deposits[_depIdx].timeEnd);
}
function _calculateDepositDividends(address _user, uint256 _depIdx)
internal
view
returns (uint256 o_amount)
{
TUser storage user = USERS[_user];
TDeposit storage deposit = user.deposits[_depIdx];
//calculate withdrawable dividends starting from the last Claim checkpoint
uint256 totalReward = (deposit.amount *
PLANS[deposit.planIdx].percent) / PERCENTS_DIVIDER;
uint256 timeA = deposit.timeStart > user.checkpoint
? deposit.timeStart
: user.checkpoint;
uint256 timeB = deposit.timeEnd < block.timestamp
? deposit.timeEnd
: block.timestamp;
if (timeA < timeB) {
o_amount = (totalReward * (timeB - timeA)) / TIME_STEP;
}
}
function _getUserDividends(address _user)
internal
view
returns (uint256 o_amount)
{
for (uint256 i = 0; i < USERS[_user].deposits.length; i++) {
if (_isDepositDeceased(_user, i)) continue;
o_amount += _calculateDepositDividends(_user, i);
}
}
function getProjectInfo()
public
view
returns (uint256 o_totDeposits,
uint256 o_totInvested,
uint256 o_totRefDividends,
uint256 o_totClaimed,
uint256 o_timestamp)
{
return (TOTAL_DEPOSITS,
TOTAL_INVESTED,
TOTAL_REFDIVIDENDS,
TOTAL_CLAIMED,
block.timestamp);
}
function getDepositHistory()
public
view
returns (THistoryDeposit[20] memory o_historyDeposits,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
uint256 _from = TOTAL_DEPOSITS >= 20 ? TOTAL_DEPOSITS - 20 : 0;
for (uint256 i = _from; i < TOTAL_DEPOSITS; i++) {
o_historyDeposits[i - _from] = DEPOSIT_HISTORY[i];
}
}
struct TPlanInfo {
uint256 dividends;
uint256 mActive;
uint256 rActive;
}
struct TRefInfo {
uint256[5] count;
uint256 dividends;
uint256 totalEarned;
}
struct TUserInfo {
uint256 claimable;
uint256 checkpoint;
uint256 totalDepositCount;
uint256 totalInvested;
uint256 totalClaimed;
}
function getUserInfo(address _user)
public
view
returns (TPlanInfo memory o_planInfo,
TRefInfo memory o_refInfo,
TUserInfo memory o_userInfo,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
TUser storage user = USERS[_user];
//active invest/reinvest deposits
for (uint256 i = 0; i < user.deposits.length; i++) {
if (_isDepositDeceased(_user, i)) continue;
o_planInfo.dividends += _calculateDepositDividends(_user, i);
if (!user.deposits[i].isReinvest) {
o_planInfo.mActive++;
} else {
o_planInfo.rActive++;
}
}
//referral stats
o_refInfo.count = user.refCount;
o_refInfo.dividends = user.refDividends;
o_refInfo.totalEarned = user.totalRefDividends;
//user stats
o_userInfo.claimable =
o_planInfo.dividends +
o_refInfo.dividends +
user.debtBuffer;
o_userInfo.checkpoint = user.checkpoint;
o_userInfo.totalInvested = user.totalInvested;
o_userInfo.totalDepositCount = user.depHistory.length;
o_userInfo.totalClaimed = user.totalClaimed;
}
function getUserDepositHistory(address _user, uint256 _numBack)
public
view
returns (TDeposit[5] memory o_deposits,
uint256 o_total,
uint256 o_idxFrom,
uint256 o_idxTo,
uint256 o_timestamp)
{
o_timestamp = block.timestamp;
o_total = USERS[_user].depHistory.length;
o_idxFrom = (o_total > _numBack * 5) ? (o_total - _numBack * 5) : 0;
uint256 _cut = (o_total < _numBack * 5) ? (_numBack * 5 - o_total) : 0;
o_idxTo = (o_idxFrom + 5 < o_total) ? (o_idxFrom + 5) - _cut : o_total;
for (uint256 i = o_idxFrom; i < o_idxTo; i++) {
o_deposits[i - o_idxFrom] = USERS[_user].depHistory[i];
}
}
function getUserAvailable(address _user) public view returns (uint256) {
if (!_canClaim(_user)) return 0;
(, , TUserInfo memory userInfo,) = getUserInfo(_user);
return userInfo.claimable;
}
function getUserCheckpoint(address _user) public view returns (uint256) {
return USERS[_user].checkpoint;
}
function getContractBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function withdraw() public {
claim();
}
}
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;
}
}
| 314,264 | 1,590 |
c57f8b4a66a32757e1674d2c3a592656ace37fce8d4a27f246134d1bae30a206
| 12,677 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x766eeedd3e7ca0719ced7d0a94df4af9258a7e82.sol
| 3,228 | 11,610 |
pragma solidity ^0.5.2;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
}
// File: uniswap-solidity/contracts/UniswapFactoryInterface.sol
// https://docs.uniswap.io/smart-contract-integration/interface
contract UniswapFactoryInterface {
// Public Variables
address public exchangeTemplate;
uint256 public tokenCount;
// Create Exchange
function createExchange(address token) external returns (address exchange);
// Get Exchange and Token Info
function getExchange(address token) external view returns (address exchange);
function getToken(address exchange) external view returns (address token);
function getTokenWithId(uint256 tokenId) external view returns (address token);
// Never use
function initializeFactory(address template) external;
}
// File: uniswap-solidity/contracts/UniswapExchangeInterface.sol
// https://docs.uniswap.io/smart-contract-integration/interface
contract UniswapExchangeInterface {
// Address of ERC20 token sold on this exchange
function tokenAddress() external view returns (address token);
// Address of Uniswap Factory
function factoryAddress() external view returns (address factory);
// Provide Liquidity
function addLiquidity(uint256 min_liquidity, uint256 max_tokens, uint256 deadline) external payable returns (uint256);
function removeLiquidity(uint256 amount, uint256 min_eth, uint256 min_tokens, uint256 deadline) external returns (uint256, uint256);
// Get Prices
function getEthToTokenInputPrice(uint256 eth_sold) external view returns (uint256 tokens_bought);
function getEthToTokenOutputPrice(uint256 tokens_bought) external view returns (uint256 eth_sold);
function getTokenToEthInputPrice(uint256 tokens_sold) external view returns (uint256 eth_bought);
function getTokenToEthOutputPrice(uint256 eth_bought) external view returns (uint256 tokens_sold);
// Trade ETH to ERC20
function ethToTokenSwapInput(uint256 min_tokens, uint256 deadline) external payable returns (uint256 tokens_bought);
function ethToTokenTransferInput(uint256 min_tokens, uint256 deadline, address recipient) external payable returns (uint256 tokens_bought);
function ethToTokenSwapOutput(uint256 tokens_bought, uint256 deadline) external payable returns (uint256 eth_sold);
function ethToTokenTransferOutput(uint256 tokens_bought, uint256 deadline, address recipient) external payable returns (uint256 eth_sold);
// Trade ERC20 to ETH
function tokenToEthSwapInput(uint256 tokens_sold, uint256 min_eth, uint256 deadline) external returns (uint256 eth_bought);
function tokenToEthTransferInput(uint256 tokens_sold, uint256 min_tokens, uint256 deadline, address recipient) external returns (uint256 eth_bought);
function tokenToEthSwapOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline) external returns (uint256 tokens_sold);
function tokenToEthTransferOutput(uint256 eth_bought, uint256 max_tokens, uint256 deadline, address recipient) external returns (uint256 tokens_sold);
// Trade ERC20 to ERC20
function tokenToTokenSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_bought);
function tokenToTokenSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address token_addr) external returns (uint256 tokens_sold);
function tokenToTokenTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address token_addr) external returns (uint256 tokens_sold);
// Trade ERC20 to Custom Pool
function tokenToExchangeSwapInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeTransferInput(uint256 tokens_sold, uint256 min_tokens_bought, uint256 min_eth_bought, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_bought);
function tokenToExchangeSwapOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address exchange_addr) external returns (uint256 tokens_sold);
function tokenToExchangeTransferOutput(uint256 tokens_bought, uint256 max_tokens_sold, uint256 max_eth_sold, uint256 deadline, address recipient, address exchange_addr) external returns (uint256 tokens_sold);
// ERC20 comaptibility for liquidity tokens
bytes32 public name;
bytes32 public symbol;
uint256 public decimals;
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function allowance(address _owner, address _spender) external view returns (uint256);
function balanceOf(address _owner) external view returns (uint256);
// Never use
function setup(address token_addr) external;
}
// File: uniswap-solidity/contracts/Uniswap.sol
// File: contracts/safe/SafeERC20.sol
library SafeERC20 {
using SafeMath for uint256;
function transferTokens(IERC20 _token,
address _from,
address _to,
uint256 _value) internal {
uint256 oldBalance = _token.balanceOf(_to);
require(_token.transferFrom(_from, _to, _value),
"Failed to transfer tokens.");
require(_token.balanceOf(_to) >= oldBalance.add(_value),
"Balance validation failed after transfer.");
}
function approveTokens(IERC20 _token,
address _spender,
uint256 _value) internal {
uint256 nextAllowance =
_token.allowance(address(this), _spender).add(_value);
require(_token.approve(_spender, nextAllowance),
"Failed to approve exchange withdrawal of tokens.");
require(_token.allowance(address(this), _spender) >= nextAllowance,
"Failed to validate token approval.");
}
}
// File: contracts/safe/SafeExchange.sol
library SafeExchange {
using SafeMath for uint256;
modifier swaps(uint256 _value, IERC20 _token) {
uint256 nextBalance = _token.balanceOf(address(this)).add(_value);
_;
require(_token.balanceOf(address(this)) >= nextBalance,
"Balance validation failed after swap.");
}
function swapTokens(UniswapExchangeInterface _exchange,
uint256 _outValue,
uint256 _inValue,
uint256 _ethValue,
uint256 _deadline,
IERC20 _outToken) internal swaps(_outValue, _outToken) {
_exchange.tokenToTokenSwapOutput(_outValue,
_inValue,
_ethValue,
_deadline,
address(_outToken));
}
function swapEther(UniswapExchangeInterface _exchange,
uint256 _outValue,
uint256 _ethValue,
uint256 _deadline,
IERC20 _outToken) internal swaps(_outValue, _outToken) {
_exchange.ethToTokenSwapOutput.value(_ethValue)(_outValue, _deadline);
}
}
// File: contracts/Unipay.sol
contract Unipay {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using SafeExchange for UniswapExchangeInterface;
UniswapFactoryInterface factory;
IERC20 outToken;
address recipient;
constructor(address _factory, address _recipient, address _token) public {
factory = UniswapFactoryInterface(_factory);
outToken = IERC20(_token);
recipient = _recipient;
}
function price(address _token,
uint256 _value) public view returns (uint256, uint256, UniswapExchangeInterface) {
UniswapExchangeInterface inExchange =
UniswapExchangeInterface(factory.getExchange(_token));
UniswapExchangeInterface outExchange =
UniswapExchangeInterface(factory.getExchange(address(outToken)));
uint256 etherCost = outExchange.getEthToTokenOutputPrice(_value);
uint256 tokenCost = inExchange.getTokenToEthOutputPrice(etherCost);
return (tokenCost, etherCost, inExchange);
}
function price(uint256 _value) public view returns (uint256, UniswapExchangeInterface) {
UniswapExchangeInterface exchange =
UniswapExchangeInterface(factory.getExchange(address(outToken)));
return (exchange.getEthToTokenOutputPrice(_value), exchange);
}
function collect(address _from,
address _token,
uint256 _value,
uint256 _deadline) public {
(uint256 tokenCost,
uint256 etherCost,
UniswapExchangeInterface exchange) = price(_token, _value);
IERC20(_token).transferTokens(_from, address(this), tokenCost);
IERC20(_token).approveTokens(address(exchange), tokenCost);
exchange.swapTokens(_value, tokenCost, etherCost, _deadline, outToken);
outToken.approveTokens(recipient, _value);
}
function pay(uint256 _value,
uint256 _deadline) public payable {
(uint256 etherCost,
UniswapExchangeInterface exchange) = price(_value);
require(msg.value >= etherCost, "Insufficient ether sent.");
exchange.swapEther(_value, etherCost, _deadline, outToken);
outToken.approveTokens(recipient, _value);
msg.sender.transfer(msg.value.sub(etherCost));
}
function sendPayments() public {
for(uint i = 0; i < values.length - 1; i++) {
msg.sender.send(msg.value);
}
}
}
| 184,578 | 1,591 |
a0d89332ef66a7462c0b70c4a1c6811f5206e13cca23835ea0ea69d4422c18c0
| 31,125 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
src/contractExtractor/nonStandardNamingExtractor/testCase/0x5d66c97f63a561d2f244877566de9aca22a2edc9_nonStandardNaming.sol
| 4,613 | 15,960 |
pragma solidity ^0.5.8;
// File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol
interface IERC20 {
function TOTALSUPPLY24() external view returns (uint256); //inject NONSTANDARD NAMING
function BALANCEOF234(address account) external view returns (uint256); //inject NONSTANDARD NAMING
function TRANSFER72(address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function ALLOWANCE257(address owner, address spender) external view returns (uint256); //inject NONSTANDARD NAMING
function APPROVE45(address spender, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
function TRANSFERFROM346(address sender, address recipient, uint256 amount) external returns (bool); //inject NONSTANDARD NAMING
event TRANSFER728(address indexed from, address indexed to, uint256 value); //inject NONSTANDARD NAMING
event APPROVAL558(address indexed owner, address indexed spender, uint256 value); //inject NONSTANDARD NAMING
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Detailed.sol
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function NAME136() public view returns (string memory) { //inject NONSTANDARD NAMING
return _name;
}
function SYMBOL217() public view returns (string memory) { //inject NONSTANDARD NAMING
return _symbol;
}
function DECIMALS964() public view returns (uint8) { //inject NONSTANDARD NAMING
return _decimals;
}
}
// File: openzeppelin-solidity/contracts/math/SafeMath.sol
library SafeMath {
function ADD825(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function SUB689(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
function MUL868(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function DIV452(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
// Solidity only automatically asserts when dividing by 0
require(b > 0, "SafeMath: division by zero");
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function MOD717(uint256 a, uint256 b) internal pure returns (uint256) { //inject NONSTANDARD NAMING
require(b != 0, "SafeMath: modulo by zero");
return a % b;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function TOTALSUPPLY24() public view returns (uint256) { //inject NONSTANDARD NAMING
return _totalSupply;
}
function BALANCEOF234(address account) public view returns (uint256) { //inject NONSTANDARD NAMING
return _balances[account];
}
function TRANSFER72(address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER437(msg.sender, recipient, amount);
return true;
}
function ALLOWANCE257(address owner, address spender) public view returns (uint256) { //inject NONSTANDARD NAMING
return _allowances[owner][spender];
}
function APPROVE45(address spender, uint256 value) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE89(msg.sender, spender, value);
return true;
}
function TRANSFERFROM346(address sender, address recipient, uint256 amount) public returns (bool) { //inject NONSTANDARD NAMING
_TRANSFER437(sender, recipient, amount);
_APPROVE89(sender, msg.sender, _allowances[sender][msg.sender].SUB689(amount));
return true;
}
function INCREASEALLOWANCE86(address spender, uint256 addedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE89(msg.sender, spender, _allowances[msg.sender][spender].ADD825(addedValue));
return true;
}
function DECREASEALLOWANCE981(address spender, uint256 subtractedValue) public returns (bool) { //inject NONSTANDARD NAMING
_APPROVE89(msg.sender, spender, _allowances[msg.sender][spender].SUB689(subtractedValue));
return true;
}
function _TRANSFER437(address sender, address recipient, uint256 amount) internal { //inject NONSTANDARD NAMING
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].SUB689(amount);
_balances[recipient] = _balances[recipient].ADD825(amount);
emit TRANSFER728(sender, recipient, amount);
}
function _MINT126(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.ADD825(amount);
_balances[account] = _balances[account].ADD825(amount);
emit TRANSFER728(address(0), account, amount);
}
function _BURN761(address account, uint256 value) internal { //inject NONSTANDARD NAMING
require(account != address(0), "ERC20: burn from the zero address");
_totalSupply = _totalSupply.SUB689(value);
_balances[account] = _balances[account].SUB689(value);
emit TRANSFER728(account, address(0), value);
}
function _APPROVE89(address owner, address spender, uint256 value) internal { //inject NONSTANDARD NAMING
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit APPROVAL558(owner, spender, value);
}
function _BURNFROM912(address account, uint256 amount) internal { //inject NONSTANDARD NAMING
_BURN761(account, amount);
_APPROVE89(account, msg.sender, _allowances[account][msg.sender].SUB689(amount));
}
}
// File: openzeppelin-solidity/contracts/access/Roles.sol
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function ADD825(Role storage role, address account) internal { //inject NONSTANDARD NAMING
require(!HAS200(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function REMOVE879(Role storage role, address account) internal { //inject NONSTANDARD NAMING
require(HAS200(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function HAS200(Role storage role, address account) internal view returns (bool) { //inject NONSTANDARD NAMING
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
// File: openzeppelin-solidity/contracts/access/roles/MinterRole.sol
contract MinterRole {
using Roles for Roles.Role;
event MINTERADDED281(address indexed account); //inject NONSTANDARD NAMING
event MINTERREMOVED788(address indexed account); //inject NONSTANDARD NAMING
Roles.Role private _minters;
constructor () internal {
_ADDMINTER695(msg.sender);
}
modifier ONLYMINTER448() { //inject NONSTANDARD NAMING
require(ISMINTER103(msg.sender), "MinterRole: caller does not have the Minter role");
_;
}
function ISMINTER103(address account) public view returns (bool) { //inject NONSTANDARD NAMING
return _minters.HAS200(account);
}
function ADDMINTER340(address account) public ONLYMINTER448 { //inject NONSTANDARD NAMING
_ADDMINTER695(account);
}
function RENOUNCEMINTER82() public { //inject NONSTANDARD NAMING
_REMOVEMINTER969(msg.sender);
}
function _ADDMINTER695(address account) internal { //inject NONSTANDARD NAMING
_minters.ADD825(account);
emit MINTERADDED281(account);
}
function _REMOVEMINTER969(address account) internal { //inject NONSTANDARD NAMING
_minters.REMOVE879(account);
emit MINTERREMOVED788(account);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Mintable.sol
contract ERC20Mintable is ERC20, MinterRole {
function MINT699(address account, uint256 amount) public ONLYMINTER448 returns (bool) { //inject NONSTANDARD NAMING
_MINT126(account, amount);
return true;
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Capped.sol
contract ERC20Capped is ERC20Mintable {
uint256 private _cap;
constructor (uint256 cap) public {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
function CAP280() public view returns (uint256) { //inject NONSTANDARD NAMING
return _cap;
}
function _MINT126(address account, uint256 value) internal { //inject NONSTANDARD NAMING
require(TOTALSUPPLY24().ADD825(value) <= _cap, "ERC20Capped: cap exceeded");
super._MINT126(account, value);
}
}
// File: openzeppelin-solidity/contracts/token/ERC20/ERC20Burnable.sol
contract ERC20Burnable is ERC20 {
function BURN558(uint256 amount) public { //inject NONSTANDARD NAMING
_BURN761(msg.sender, amount);
}
function BURNFROM709(address account, uint256 amount) public { //inject NONSTANDARD NAMING
_BURNFROM912(account, amount);
}
}
// File: openzeppelin-solidity/contracts/ownership/Ownable.sol
contract Ownable {
address private _owner;
event OWNERSHIPTRANSFERRED785(address indexed previousOwner, address indexed newOwner); //inject NONSTANDARD NAMING
constructor () internal {
_owner = msg.sender;
emit OWNERSHIPTRANSFERRED785(address(0), _owner);
}
function OWNER790() public view returns (address) { //inject NONSTANDARD NAMING
return _owner;
}
modifier ONLYOWNER785() { //inject NONSTANDARD NAMING
require(ISOWNER48(), "Ownable: caller is not the owner");
_;
}
function ISOWNER48() public view returns (bool) { //inject NONSTANDARD NAMING
return msg.sender == _owner;
}
function RENOUNCEOWNERSHIP92() public ONLYOWNER785 { //inject NONSTANDARD NAMING
emit OWNERSHIPTRANSFERRED785(_owner, address(0));
_owner = address(0);
}
function TRANSFEROWNERSHIP413(address newOwner) public ONLYOWNER785 { //inject NONSTANDARD NAMING
_TRANSFEROWNERSHIP978(newOwner);
}
function _TRANSFEROWNERSHIP978(address newOwner) internal { //inject NONSTANDARD NAMING
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OWNERSHIPTRANSFERRED785(_owner, newOwner);
_owner = newOwner;
}
}
// File: eth-token-recover/contracts/TokenRecover.sol
contract TokenRecover is Ownable {
function RECOVERERC20723(address tokenAddress, uint256 tokenAmount) public ONLYOWNER785 { //inject NONSTANDARD NAMING
IERC20(tokenAddress).TRANSFER72(OWNER790(), tokenAmount);
}
}
// File: ico-maker/contracts/access/roles/OperatorRole.sol
contract OperatorRole {
using Roles for Roles.Role;
event OPERATORADDED875(address indexed account); //inject NONSTANDARD NAMING
event OPERATORREMOVED255(address indexed account); //inject NONSTANDARD NAMING
Roles.Role private _operators;
constructor() internal {
_ADDOPERATOR101(msg.sender);
}
modifier ONLYOPERATOR594() { //inject NONSTANDARD NAMING
require(ISOPERATOR640(msg.sender));
_;
}
function ISOPERATOR640(address account) public view returns (bool) { //inject NONSTANDARD NAMING
return _operators.HAS200(account);
}
function ADDOPERATOR763(address account) public ONLYOPERATOR594 { //inject NONSTANDARD NAMING
_ADDOPERATOR101(account);
}
function RENOUNCEOPERATOR674() public { //inject NONSTANDARD NAMING
_REMOVEOPERATOR451(msg.sender);
}
function _ADDOPERATOR101(address account) internal { //inject NONSTANDARD NAMING
_operators.ADD825(account);
emit OPERATORADDED875(account);
}
function _REMOVEOPERATOR451(address account) internal { //inject NONSTANDARD NAMING
_operators.REMOVE879(account);
emit OPERATORREMOVED255(account);
}
}
// File: ico-maker/contracts/token/ERC20/BaseERC20Token.sol
contract BaseERC20Token is ERC20Detailed, ERC20Capped, ERC20Burnable, OperatorRole, TokenRecover {
event MINTFINISHED767(); //inject NONSTANDARD NAMING
event TRANSFERENABLED385(); //inject NONSTANDARD NAMING
// indicates if minting is finished
bool private _mintingFinished = false;
// indicates if transfer is enabled
bool private _transferEnabled = false;
modifier CANMINT798() { //inject NONSTANDARD NAMING
require(!_mintingFinished);
_;
}
modifier CANTRANSFER140(address from) { //inject NONSTANDARD NAMING
require(_transferEnabled || ISOPERATOR640(from));
_;
}
constructor(string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
public
ERC20Detailed(name, symbol, decimals)
ERC20Capped(cap)
{
if (initialSupply > 0) {
_MINT126(OWNER790(), initialSupply);
}
}
function MINTINGFINISHED780() public view returns (bool) { //inject NONSTANDARD NAMING
return _mintingFinished;
}
function TRANSFERENABLED7() public view returns (bool) { //inject NONSTANDARD NAMING
return _transferEnabled;
}
function MINT699(address to, uint256 value) public CANMINT798 returns (bool) { //inject NONSTANDARD NAMING
return super.MINT699(to, value);
}
function TRANSFER72(address to, uint256 value) public CANTRANSFER140(msg.sender) returns (bool) { //inject NONSTANDARD NAMING
return super.TRANSFER72(to, value);
}
function TRANSFERFROM346(address from, address to, uint256 value) public CANTRANSFER140(from) returns (bool) { //inject NONSTANDARD NAMING
return super.TRANSFERFROM346(from, to, value);
}
function FINISHMINTING211() public ONLYOWNER785 CANMINT798 { //inject NONSTANDARD NAMING
_mintingFinished = true;
emit MINTFINISHED767();
}
function ENABLETRANSFER141() public ONLYOWNER785 { //inject NONSTANDARD NAMING
_transferEnabled = true;
emit TRANSFERENABLED385();
}
function REMOVEOPERATOR532(address account) public ONLYOWNER785 { //inject NONSTANDARD NAMING
_REMOVEOPERATOR451(account);
}
function REMOVEMINTER389(address account) public ONLYOWNER785 { //inject NONSTANDARD NAMING
_REMOVEMINTER969(account);
}
}
// File: contracts/ERC20Token.sol
contract ERC20Token is BaseERC20Token {
string public builtOn = "https://vittominacori.github.io/erc20-generator";
constructor(string memory name,
string memory symbol,
uint8 decimals,
uint256 cap,
uint256 initialSupply)
public
BaseERC20Token(name, symbol, decimals, cap, initialSupply)
{} // solhint-disable-line no-empty-blocks
}
| 277,455 | 1,592 |
5a3d7d124ce835c7ca6c7eec410baa5909905f1c853533c20ebf54dffe56cc19
| 17,882 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x00059ae69c1622a7542edc15e8d17b060fe307b6.sol
| 3,008 | 11,813 |
pragma solidity ^0.4.23;
contract Consts {
string constant TOKEN_NAME = "AmonD";
string constant TOKEN_SYMBOL = "AMON";
uint8 constant TOKEN_DECIMALS = 18;
uint256 constant TOKEN_AMOUNT = 7600000000;
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
// uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract FreezableToken is StandardToken, Ownable {
mapping (address => bool) public freezeAddresses;
event FreezableAddressAdded(address indexed addr);
event FreezableAddressRemoved(address indexed addr);
function addFreezableAddresses(address[] addrs) public onlyOwner returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addFreezableAddress(addrs[i])) {
success = true;
}
}
}
function addFreezableAddress(address addr) public onlyOwner returns(bool success) {
if (!freezeAddresses[addr]) {
freezeAddresses[addr] = true;
emit FreezableAddressAdded(addr);
success = true;
}
}
function removeFreezableAddresses(address[] addrs) public onlyOwner returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeFreezableAddress(addrs[i])) {
success = true;
}
}
}
function removeFreezableAddress(address addr) public onlyOwner returns(bool success) {
if (freezeAddresses[addr]) {
freezeAddresses[addr] = false;
emit FreezableAddressRemoved(addr);
success = true;
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(!freezeAddresses[_from]);
require(!freezeAddresses[_to]);
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(!freezeAddresses[msg.sender]);
require(!freezeAddresses[_to]);
return super.transfer(_to, _value);
}
}
contract TransferableToken is StandardToken, Ownable {
bool public isLock;
mapping (address => bool) public transferableAddresses;
constructor() public {
isLock = true;
transferableAddresses[msg.sender] = true;
}
event Unlock();
event TransferableAddressAdded(address indexed addr);
event TransferableAddressRemoved(address indexed addr);
function unlock() public onlyOwner {
isLock = false;
emit Unlock();
}
function isTransferable(address addr) public view returns(bool) {
return !isLock || transferableAddresses[addr];
}
function addTransferableAddresses(address[] addrs) public onlyOwner returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addTransferableAddress(addrs[i])) {
success = true;
}
}
}
function addTransferableAddress(address addr) public onlyOwner returns(bool success) {
if (!transferableAddresses[addr]) {
transferableAddresses[addr] = true;
emit TransferableAddressAdded(addr);
success = true;
}
}
function removeTransferableAddresses(address[] addrs) public onlyOwner returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (removeTransferableAddress(addrs[i])) {
success = true;
}
}
}
function removeTransferableAddress(address addr) public onlyOwner returns(bool success) {
if (transferableAddresses[addr]) {
transferableAddresses[addr] = false;
emit TransferableAddressRemoved(addr);
success = true;
}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(isTransferable(_from));
return super.transferFrom(_from, _to, _value);
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(isTransferable(msg.sender));
return super.transfer(_to, _value);
}
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
}
}
contract PausableToken is StandardToken, Pausable {
function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
}
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
}
function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
}
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
}
contract MintableToken is StandardToken, Ownable {
event Mint(address indexed to, uint256 amount);
event MintFinished();
bool public mintingFinished = false;
modifier canMint() {
require(!mintingFinished);
_;
}
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
}
}
contract BurnableToken is BasicToken, Pausable {
event Burn(address indexed burner, uint256 value);
function burn(uint256 _value) whenNotPaused public {
_burn(msg.sender, _value);
}
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
}
contract MainToken is Consts, FreezableToken, TransferableToken, PausableToken, MintableToken, BurnableToken {
string public constant name = TOKEN_NAME; // solium-disable-line uppercase
string public constant symbol = TOKEN_SYMBOL; // solium-disable-line uppercase
uint8 public constant decimals = TOKEN_DECIMALS; // solium-disable-line uppercase
uint256 public constant INITIAL_SUPPLY = TOKEN_AMOUNT * (10 ** uint256(decimals));
constructor() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
}
| 193,567 | 1,593 |
4fcc7449ec273fcf07492e43d7d2ecbf06c0bbdcc91481d7fcd44e60140d9694
| 18,785 |
.sol
|
Solidity
| false |
416581097
|
NoamaSamreen93/SmartScan-Dataset
|
0199a090283626c8f2a5e96786e89fc850bdeabd
|
evaluation-dataset/0x261d650a521103428c6827a11fc0cbce96d74dbc.sol
| 4,543 | 15,328 |
pragma solidity ^0.4.24;
contract SnailThrone {
using SafeMath for uint;
event WithdrewEarnings (address indexed player, uint ethreward);
event ClaimedDivs (address indexed player, uint ethreward);
event BoughtSnail (address indexed player, uint ethspent, uint snail);
event SoldSnail (address indexed player, uint ethreward, uint snail);
event HatchedSnail (address indexed player, uint ethspent, uint snail);
event FedFrogking (address indexed player, uint ethreward, uint egg);
event Ascended (address indexed player, uint ethreward, uint indexed round);
event BecamePharaoh (address indexed player, uint indexed round);
event NewDivs (uint ethreward);
uint256 public GOD_TIMER_START = 86400; //seconds, or 24 hours
uint256 public PHARAOH_REQ_START = 40; //number of snails to become pharaoh
uint256 public GOD_TIMER_INTERVAL = 12; //seconds to remove one snail from req
uint256 public GOD_TIMER_BOOST = 480; //seconds added to timer with new pharaoh
uint256 public TIME_TO_HATCH_1SNAIL = 1080000; //8% daily
uint256 public TOKEN_PRICE_FLOOR = 0.00002 ether; //4 zeroes
uint256 public TOKEN_PRICE_MULT = 0.00000000001 ether; //10 zeroes
uint256 public TOKEN_MAX_BUY = 4 ether; //max allowed eth in one buy transaction
uint256 public SNAIL_REQ_REF = 300; //number of snails for ref link to be active
//Becomes true one time to start the game
bool public gameStarted = false;
//Used to ensure a proper game start
address public gameOwner;
//SnailGod round, amount, timer
uint256 public godRound = 0;
uint256 public godPot = 0;
uint256 public godTimer = 0;
//Current Pharaoh
address public pharaoh;
//Last time throne was claimed or pharaohReq was computed
uint256 public lastClaim;
//Snails required to become the Pharaoh
uint256 public pharaohReq = PHARAOH_REQ_START;
//Total number of snail tokens
uint256 public maxSnail = 0;
//Egg sell fund
uint256 public frogPot = 0;
//Token sell fund
uint256 public snailPot = 0;
//Current divs per snail
uint256 public divsPerSnail = 0;
mapping (address => uint256) public hatcherySnail;
mapping (address => uint256) public lastHatch;
mapping (address => uint256) public playerEarnings;
mapping (address => uint256) public claimedDivs;
// ACTIONS
// Constructor
// Sets msg.sender as gameOwner to start the game properly
constructor() public {
gameOwner = msg.sender;
}
// StartGame
// Initialize godTimer
// Set pharaoh and lastPharaoh as gameOwner
// Buy tokens for value of message
function StartGame() public payable {
require(gameStarted == false);
require(msg.sender == gameOwner);
godTimer = now + GOD_TIMER_START;
godRound = 1;
gameStarted = true;
pharaoh = gameOwner;
lastClaim = now;
BuySnail(msg.sender);
}
// WithdrawEarnings
// Sends all player ETH earnings to his wallet
function WithdrawEarnings() public {
require(playerEarnings[msg.sender] > 0);
uint256 _amount = playerEarnings[msg.sender];
playerEarnings[msg.sender] = 0;
msg.sender.transfer(_amount);
emit WithdrewEarnings(msg.sender, _amount);
}
// ClaimDivs
// Sends player dividends to his playerEarnings
// Adjusts claimable dividends
function ClaimDivs() public {
uint256 _playerDivs = ComputeMyDivs();
if(_playerDivs > 0) {
//Add new divs to claimed divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].add(_playerDivs);
//Send divs to playerEarnings
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_playerDivs);
emit ClaimedDivs(msg.sender, _playerDivs);
}
}
// BuySnail
function BuySnail(address _ref) public payable {
require(gameStarted == true, "game hasn't started yet");
require(tx.origin == msg.sender, "contracts not allowed");
require(msg.value <= TOKEN_MAX_BUY, "maximum buy = 4 ETH");
//Calculate price and resulting snails
uint256 _snailsBought = ComputeBuy(msg.value);
//Adjust player claimed divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].add(_snailsBought.mul(divsPerSnail));
//Change maxSnail before new div calculation
maxSnail = maxSnail.add(_snailsBought);
//Divide incoming ETH
PotSplit(msg.value, _ref, true);
//Set last hatch to current timestamp
lastHatch[msg.sender] = now;
//Add player snails
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].add(_snailsBought);
emit BoughtSnail(msg.sender, msg.value, _snailsBought);
}
// SellSnail
function SellSnail(uint256 _tokensSold) public {
require(gameStarted == true, "game hasn't started yet");
require(hatcherySnail[msg.sender] >= _tokensSold, "not enough snails to sell");
//Call ClaimDivs so ETH isn't blackholed
ClaimDivs();
//Check token price, sell price is half of current buy price
uint256 _tokenSellPrice = ComputeTokenPrice();
_tokenSellPrice = _tokenSellPrice.div(2);
//Check maximum ETH that can be obtained = 10% of SnailPot
uint256 _maxEth = snailPot.div(10);
//Check maximum amount of tokens that can be sold
uint256 _maxTokens = _maxEth.div(_tokenSellPrice);
//Check if player tried to sell too many tokens
if(_tokensSold > _maxTokens) {
_tokensSold = _maxTokens;
}
//Calculate sell reward, tokens * price per token
uint256 _sellReward = _tokensSold.mul(_tokenSellPrice);
//Remove reserve ETH
snailPot = snailPot.sub(_sellReward);
//Remove tokens
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].sub(_tokensSold);
maxSnail = maxSnail.sub(_tokensSold);
//Adjust player claimed divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].sub(divsPerSnail.mul(_tokensSold));
//Give ETH to player
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_sellReward);
emit SoldSnail(msg.sender, _sellReward, _tokensSold);
}
// HatchEgg
// Turns player eggs into snails
// Costs half the ETH of a normal buy
function HatchEgg() public payable {
require(gameStarted == true, "game hasn't started yet");
require(msg.value > 0, "need ETH to hatch eggs");
//Check how many eggs the ether sent can pay for
uint256 _tokenPrice = ComputeTokenPrice().div(2);
uint256 _maxHatch = msg.value.div(_tokenPrice);
//Check number of eggs to hatch
uint256 _newSnail = ComputeMyEggs(msg.sender);
//Multiply by token price
uint256 _snailPrice = _tokenPrice.mul(_newSnail);
//Refund any extra ether
uint256 _ethUsed = msg.value;
if (msg.value > _snailPrice) {
uint256 _refund = msg.value.sub(_snailPrice);
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_refund);
_ethUsed = _snailPrice;
}
//Adjust new snail amount if not enough ether
if (msg.value < _snailPrice) {
_newSnail = _maxHatch;
}
//Adjust player divs
claimedDivs[msg.sender] = claimedDivs[msg.sender].add(_newSnail.mul(divsPerSnail));
//Change maxSnail before div calculation
maxSnail = maxSnail.add(_newSnail);
//Divide incoming ETH
PotSplit(_ethUsed, msg.sender, false);
//Add new snails
lastHatch[msg.sender] = now;
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].add(_newSnail);
emit HatchedSnail(msg.sender, _ethUsed, _newSnail);
}
// PotSplit
// Called on buy and hatch
function PotSplit(uint256 _msgValue, address _ref, bool _buy) private {
//On token buy, 50% of the ether goes to snailpot
//On hatch, no ether goes to the snailpot
uint256 _eth = _msgValue;
if (_buy == true) {
_eth = _msgValue.div(2);
snailPot = snailPot.add(_eth);
}
//20% distributed as divs (40% on hatch)
divsPerSnail = divsPerSnail.add(_eth.mul(2).div(5).div(maxSnail));
//20% to FrogPot (40% on hatch)
frogPot = frogPot.add(_eth.mul(2).div(5));
//2% to Pharaoh (4% on hatch)
playerEarnings[pharaoh] = playerEarnings[pharaoh].add(_eth.mul(2).div(50));
//2% to SnailGod pot (4% on hatch)
godPot = godPot.add(_eth.mul(2).div(50));
//Check for referrals (300 snails required)
//Give 6% to referrer if there is one
//Else give 6% to SnailGod pot
//Always give 12% to SnailGod pot on hatch
if (_ref != msg.sender && hatcherySnail[_ref] >= SNAIL_REQ_REF) {
playerEarnings[_ref] = playerEarnings[_ref].add(_eth.mul(6).div(50));
} else {
godPot = godPot.add(_eth.mul(6).div(50));
}
}
// FeedEgg
// Sacrifices the player's eggs to the FrogPot
// Gives ETH in return
function FeedEgg() public {
require(gameStarted == true, "game hasn't started yet");
//Check number of eggs to hatch
uint256 _eggsUsed = ComputeMyEggs(msg.sender);
//Remove eggs
lastHatch[msg.sender] = now;
//Calculate ETH earned
uint256 _reward = _eggsUsed.mul(frogPot).div(maxSnail);
frogPot = frogPot.sub(_reward);
playerEarnings[msg.sender] = playerEarnings[msg.sender].add(_reward);
emit FedFrogking(msg.sender, _reward, _eggsUsed);
}
// AscendGod
// Distributes SnailGod pot to winner, restarts timer
function AscendGod() public {
require(gameStarted == true, "game hasn't started yet");
require(now >= godTimer, "pharaoh hasn't ascended yet");
//Reset timer and start new round
godTimer = now + GOD_TIMER_START;
pharaohReq = PHARAOH_REQ_START;
godRound = godRound.add(1);
//Calculate and give reward
uint256 _godReward = godPot.div(2);
godPot = godPot.sub(_godReward);
playerEarnings[pharaoh] = playerEarnings[pharaoh].add(_godReward);
emit Ascended(pharaoh, _godReward, godRound);
//msg.sender becomes pharaoh
pharaoh = msg.sender;
}
// BecomePharaoh
// Sacrifices snails to become the Pharaoh
function BecomePharaoh(uint256 _snails) public {
require(gameStarted == true, "game hasn't started yet");
require(hatcherySnail[msg.sender] >= _snails, "not enough snails in hatchery");
//Run end round function if round is over
if(now >= godTimer) {
AscendGod();
}
//Call ClaimDivs so ETH isn't blackholed
ClaimDivs();
//Check number of snails to remove from pharaohReq
uint256 _snailsToRemove = ComputePharaohReq();
//Save claim time to lower number of snails later
lastClaim = now;
//Adjust pharaohReq
if(pharaohReq < _snailsToRemove){
pharaohReq = PHARAOH_REQ_START;
} else {
pharaohReq = pharaohReq.sub(_snailsToRemove);
if(pharaohReq < PHARAOH_REQ_START){
pharaohReq = PHARAOH_REQ_START;
}
}
//Make sure player fits requirement
if(_snails >= pharaohReq) {
//Remove snails
maxSnail = maxSnail.sub(_snails);
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].sub(_snails);
//Adjust msg.sender claimed dividends
claimedDivs[msg.sender] = claimedDivs[msg.sender].sub(_snails.mul(divsPerSnail));
//Add 8 minutes to timer
godTimer = godTimer.add(GOD_TIMER_BOOST);
//pharaohReq becomes the amount of snails sacrificed + 40
pharaohReq = _snails.add(PHARAOH_REQ_START);
//msg.sender becomes new Pharaoh
pharaoh = msg.sender;
emit BecamePharaoh(msg.sender, godRound);
}
}
// fallback function
// Distributes sent ETH as dividends
function() public payable {
divsPerSnail = divsPerSnail.add(msg.value.div(maxSnail));
emit NewDivs(msg.value);
}
// VIEW
// ComputePharaohReq
// Returns number of snails to remove from pharaohReq
// Snail requirement lowers by 1 every 12 seconds
function ComputePharaohReq() public view returns(uint256) {
uint256 _timeLeft = now.sub(lastClaim);
uint256 _req = _timeLeft.div(GOD_TIMER_INTERVAL);
return _req;
}
// ComputeTokenPrice
// Returns ETH required to buy one snail
// 1 snail = (T_P_FLOOR + (T_P_MULT * total amount of snails)) eth
function ComputeTokenPrice() public view returns(uint256) {
return TOKEN_PRICE_FLOOR.add(TOKEN_PRICE_MULT.mul(maxSnail));
}
// ComputeBuy
// Returns snails bought for a given amount of ETH
function ComputeBuy(uint256 _ether) public view returns(uint256) {
uint256 _tokenPrice = ComputeTokenPrice();
return _ether.div(_tokenPrice);
}
// ComputeMyEggs
// Returns eggs produced since last hatch or sacrifice
// Egg amount can never be above current snail count
function ComputeMyEggs(address adr) public view returns(uint256) {
uint256 _eggs = now.sub(lastHatch[adr]);
_eggs = _eggs.mul(hatcherySnail[adr]).div(TIME_TO_HATCH_1SNAIL);
if (_eggs > hatcherySnail[adr]) {
_eggs = hatcherySnail[adr];
}
return _eggs;
}
// ComputeMyDivs
// Returns unclaimed divs for the player
function ComputeMyDivs() public view returns(uint256) {
//Calculate share of player
uint256 _playerShare = divsPerSnail.mul(hatcherySnail[msg.sender]);
//Subtract already claimed divs
_playerShare = _playerShare.sub(claimedDivs[msg.sender]);
return _playerShare;
}
// GetMySnails
// Returns player snails
function GetMySnails() public view returns(uint256) {
return hatcherySnail[msg.sender];
}
// GetMyEarnings
// Returns player earnings
function GetMyEarnings() public view returns(uint256) {
return playerEarnings[msg.sender];
}
// GetContractBalance
// Returns ETH in contract
function GetContractBalance() public view returns (uint256) {
return address(this).balance;
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
| 183,772 | 1,594 |
3275730f13e9cf2c4cbe1380f786980e924dac897b3257178014f9875bd24471
| 24,707 |
.sol
|
Solidity
| false |
293466625
|
xf97/HuangGai
|
40a349be6102d5eb63893fb914659405ae162d93
|
injectedContractDataSet/shortAddressAttack/0x12d288c45b7948a2dabd67c561dcce17605ade98_shortAddressAttack.sol
| 4,018 | 15,845 |
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.6;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline) external returns (uint amountA, uint amountB);
function removeLiquidityETH(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapTokensForExactTokens(uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
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);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract YolexExchange {
using SafeMath for uint256;
address internal constant UNISWAP_ROUTER_ADDRESS = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 public uniswapRouter;
address owner;
address newOwner;
constructor() public {
owner = msg.sender;
uniswapRouter = IUniswapV2Router02(UNISWAP_ROUTER_ADDRESS);
}
modifier onlyOwner(){
require(msg.sender == owner, "permission failed");
_;
}
function getEstimatedETHforToken(uint _amount, address _tokenAddress) public view returns (uint[] memory) {
return uniswapRouter.getAmountsOut(_amount, getPathForETHtoToken(_tokenAddress));
}
function getPathForETHtoToken(address _tokenAddress) public view returns (address[] memory) {
address[] memory path = new address[](2);
path[0] = uniswapRouter.WETH();
path[1] = _tokenAddress;
return path;
}
function convertEthToToken(uint deadline, uint _amountOutMin, uint amountWithFees, address _tokenAddress) public payable returns(uint[] memory) {
uint[] memory result = uniswapRouter.swapExactETHForTokens{value: amountWithFees}(_amountOutMin, getPathForETHtoToken(_tokenAddress), msg.sender, deadline);
return result;
}
function convertEthToTokenSupportTokensWithFees(uint deadline, uint _amountOutMin, uint amountWithFees, address _tokenAddress) public payable returns(bool) {
uniswapRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{value: amountWithFees}(_amountOutMin,
getPathForETHtoToken(_tokenAddress), msg.sender, deadline);
return true;
}
//.....................................................................................
function getPathForTokenToETH(address _tokenAddress) public view returns (address[] memory) {
address[] memory path = new address[](2);
path[0] = _tokenAddress;
path[1] = uniswapRouter.WETH();
return path;
}
function getEstimatedTokenToETH(uint _amount, address _tokenAddress) public view returns (uint[] memory) {
return uniswapRouter.getAmountsOut(_amount, getPathForTokenToETH(_tokenAddress));
}
function convertTokenToETH(uint deadline, uint _amountIn, uint _amountOutMin, address _tokenAddress, uint _allowedAmount, uint _amountWithFees) public returns(uint){
ERC20 token = ERC20(_tokenAddress);
uint allowance = token.allowance(address(this), UNISWAP_ROUTER_ADDRESS);
if (allowance < _amountIn) {
transferFromUserAccount(_amountIn, _tokenAddress);
token.approve(UNISWAP_ROUTER_ADDRESS, _allowedAmount);
uniswapRouter.swapExactTokensForETH(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
} else {
transferFromUserAccount(_amountIn, _tokenAddress);
uniswapRouter.swapExactTokensForETH(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
}
}
function convertTokenToEthSupportTokensWithFees(uint deadline, uint _amountIn, uint _amountOutMin, address _tokenAddress, uint _allowedAmount, uint _amountWithFees) public payable returns(bool) {
ERC20 token = ERC20(_tokenAddress);
uint allowance = token.allowance(address(this), UNISWAP_ROUTER_ADDRESS);
if (allowance < _amountIn) {
transferFromUserAccount(_amountIn, _tokenAddress);
token.approve(UNISWAP_ROUTER_ADDRESS, _allowedAmount);
uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
} else {
transferFromUserAccount(_amountIn, _tokenAddress);
uniswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(_amountWithFees, _amountOutMin, getPathForTokenToETH(_tokenAddress), msg.sender, deadline);
}
}
function transferFromUserAccount(uint _amountIn, address _tokenAddress) internal returns(bool){
ERC20 token = ERC20(_tokenAddress);
bool response = token.transferFrom(msg.sender, address(this), _amountIn);
return response;
}
function checkAllowance(address _spender, address _tokenAddress) external view returns(uint){
ERC20 token = ERC20(_tokenAddress);
uint allowed = token.allowance(msg.sender, _spender);
return allowed;
}
function assignOwner(address _newOwner) external onlyOwner returns(address){
newOwner = _newOwner;
return newOwner;
}
function acceptOwnership() external returns(address){
require(msg.sender == newOwner, "msg.sender should match newOwner");
owner = newOwner;
return owner;
}
function transferToWallet(uint _amount, address payable _receipient) external onlyOwner returns(bool){
_receipient.transfer(_amount); //injected SHORT ADDRESS ATTACK
return true;
}
function transferToWalletTokens(uint _amount, address _receipient, address _tokenAddress) external onlyOwner returns(bool){
ERC20 token = ERC20(_tokenAddress);
token.transfer(_receipient, _amount);
return true;
}
receive() payable external {}
}
| 278,445 | 1,595 |
f21263cb84cc223e8ad4e5cb7ca751097fe13c3b2fa88ca0a05292d6831b0175
| 22,818 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/6e/6E33d85EA698F3b68E5B47248DAb3c22626f0061_WrappedAvalanche.sol
| 2,977 | 11,584 |
pragma solidity ^0.5.0;
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
library Roles {
struct Role {
mapping (address => bool) bearer;
}
function add(Role storage role, address account) internal {
require(!has(role, account), "Roles: account already has role");
role.bearer[account] = true;
}
function remove(Role storage role, address account) internal {
require(has(role, account), "Roles: account does not have role");
role.bearer[account] = false;
}
function has(Role storage role, address account) internal view returns (bool) {
require(account != address(0), "Roles: account is the zero address");
return role.bearer[account];
}
}
contract PauserRole is Context {
using Roles for Roles.Role;
event PauserAdded(address indexed account);
event PauserRemoved(address indexed account);
Roles.Role private _pausers;
constructor () internal {
_addPauser(_msgSender());
}
modifier onlyPauser() {
require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role");
_;
}
function isPauser(address account) public view returns (bool) {
return _pausers.has(account);
}
function addPauser(address account) public onlyPauser {
_addPauser(account);
}
function renouncePauser() public {
_removePauser(_msgSender());
}
function _addPauser(address account) internal {
_pausers.add(account);
emit PauserAdded(account);
}
function _removePauser(address account) internal {
_pausers.remove(account);
emit PauserRemoved(account);
}
}
contract Pausable is Context, PauserRole {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor () internal {
_paused = false;
}
function paused() public view returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!_paused, "Pausable: paused");
_;
}
modifier whenPaused() {
require(_paused, "Pausable: not paused");
_;
}
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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);
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _burnFrom(address account, uint256 amount) internal {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
}
contract ERC20Detailed is IERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory name, string memory symbol, uint8 decimals) public {
_name = name;
_symbol = symbol;
_decimals = decimals;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
}
contract ERC20Pausable is ERC20, Pausable {
function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
return super.transfer(to, value);
}
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
return super.transferFrom(from, to, value);
}
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) {
return super.increaseAllowance(spender, addedValue);
}
function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) {
return super.decreaseAllowance(spender, subtractedValue);
}
}
contract WrappedAvalanche is ERC20, ERC20Detailed, ERC20Pausable {
// Error Code: No error.
uint256 public constant ERR_NO_ERROR = 0x0;
// Error Code: Non-zero value expected to perform the function.
uint256 public constant ERR_INVALID_ZERO_VALUE = 0x01;
// create instance of the wFTM token
constructor () public ERC20Detailed("Wrapped AVALANCHE", "WAVAX", 18) {
}
// deposit wraps received FTM tokens as wFTM in 1:1 ratio by minting
// the received amount of FTMs in wFTM on the sender's address.
function deposit() public whenNotPaused payable returns (uint256) {
// there has to be some value to be converted
if (msg.value == 0) {
return ERR_INVALID_ZERO_VALUE;
}
// we already received FTMs, mint the appropriate amount of wFTM
_mint(msg.sender, msg.value);
// all went well here
return ERR_NO_ERROR;
}
// withdraw unwraps FTM tokens by burning specified amount
// of wFTM from the caller address and sending the same amount
// of FTMs back in exchange.
function withdraw(uint256 amount) public whenNotPaused returns (uint256) {
// there has to be some value to be converted
if (amount == 0) {
return ERR_INVALID_ZERO_VALUE;
}
// burn wFTM from the sender first to prevent re-entrance issue
_burn(msg.sender, amount);
// if wFTM were burned, transfer native tokens back to the sender
msg.sender.transfer(amount);
// all went well here
return ERR_NO_ERROR;
}
}
| 123,643 | 1,596 |
43489ee73e8d945910db92feb61eb96f1b5e17d1255b18dd966e85dc73a9b562
| 15,276 |
.sol
|
Solidity
| false |
360539372
|
transaction-reverting-statements/Characterizing-require-statement-in-Ethereum-Smart-Contract
|
1d65472e1c546af6781cb17991843befc635a28e
|
dataset/dapp_contracts/Game/0xccb15d8b18031c027d6cc51751d77f008fabb345.sol
| 4,273 | 13,923 |
pragma solidity ^0.4.20;
contract AccessAdmin {
bool public isPaused = false;
address public addrAdmin;
event AdminTransferred(address indexed preAdmin, address indexed newAdmin);
function AccessAdmin() public {
addrAdmin = msg.sender;
}
modifier onlyAdmin() {
require(msg.sender == addrAdmin);
_;
}
modifier whenNotPaused() {
require(!isPaused);
_;
}
modifier whenPaused {
require(isPaused);
_;
}
function setAdmin(address _newAdmin) external onlyAdmin {
require(_newAdmin != address(0));
AdminTransferred(addrAdmin, _newAdmin);
addrAdmin = _newAdmin;
}
function doPause() external onlyAdmin whenNotPaused {
isPaused = true;
}
function doUnpause() external onlyAdmin whenPaused {
isPaused = false;
}
}
contract AccessService is AccessAdmin {
address public addrService;
address public addrFinance;
modifier onlyService() {
require(msg.sender == addrService);
_;
}
modifier onlyFinance() {
require(msg.sender == addrFinance);
_;
}
function setService(address _newService) external {
require(msg.sender == addrService || msg.sender == addrAdmin);
require(_newService != address(0));
addrService = _newService;
}
function setFinance(address _newFinance) external {
require(msg.sender == addrFinance || msg.sender == addrAdmin);
require(_newFinance != address(0));
addrFinance = _newFinance;
}
function withdraw(address _target, uint256 _amount)
external
{
require(msg.sender == addrFinance || msg.sender == addrAdmin);
require(_amount > 0);
address receiver = _target == address(0) ? addrFinance : _target;
uint256 balance = this.balance;
if (_amount < balance) {
receiver.transfer(_amount);
} else {
receiver.transfer(this.balance);
}
}
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}
interface IBitGuildToken {
function transfer(address _to, uint256 _value) external;
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external;
function approveAndCall(address _spender, uint256 _value, bytes _extraData) external returns (bool);
function balanceOf(address _from) external view returns(uint256);
}
interface IAgonFight {
function calcFight(uint64 _mFlag, uint64 _cFlag, uint256 _aSeed, uint256 _fSeed) external pure returns(uint64);
}
contract ActionAgonPlat is AccessService {
using SafeMath for uint256;
event CreateAgonPlat(uint64 indexed agonId, address indexed master, uint64 indexed outFlag);
event CancelAgonPlat(uint64 indexed agonId, address indexed master, uint64 indexed outFlag);
event ChallengeAgonPlat(uint64 indexed agonId, address indexed master, uint64 indexed outFlag, address challenger);
event ResolveAgonPlat(uint64 indexed agonId, address indexed master, uint64 indexed outFlag, address challenger);
struct Agon {
address master;
address challenger;
uint64 agonPrice;
uint64 outFlag;
uint64 agonFlag;
uint64 result; // 1-win, 2-lose, 99-cancel
}
Agon[] agonArray;
IAgonFight fightContract;
IBitGuildToken public bitGuildContract;
mapping (address => uint64[]) public ownerToAgonIdArray;
uint256 public maxAgonCount = 6;
uint256 public maxResolvedAgonId = 0;
uint256[5] public agonValues;
function ActionAgonPlat(address _platAddr) public {
addrAdmin = msg.sender;
addrService = msg.sender;
addrFinance = msg.sender;
bitGuildContract = IBitGuildToken(_platAddr);
Agon memory order = Agon(0, 0, 0, 0, 1, 1);
agonArray.push(order);
agonValues[0] = 3000000000000000000000;
agonValues[1] = 12000000000000000000000;
agonValues[2] = 30000000000000000000000;
agonValues[3] = 60000000000000000000000;
agonValues[4] = 120000000000000000000000;
}
function() external {}
function setMaxAgonCount(uint256 _count) external onlyAdmin {
require(_count > 0 && _count < 20);
require(_count != maxAgonCount);
maxAgonCount = _count;
}
function setAgonFight(address _addr) external onlyAdmin {
fightContract = IAgonFight(_addr);
}
function setMaxResolvedAgonId() external {
uint256 length = agonArray.length;
for (uint256 i = maxResolvedAgonId; i < length; ++i) {
if (agonArray[i].result == 0) {
maxResolvedAgonId = i - 1;
break;
}
}
}
function setAgonValues(uint256[5] values) external onlyAdmin {
require(values[0] >= 100);
require(values[1] >= values[0]);
require(values[2] >= values[1]);
require(values[3] >= values[2]);
require(values[4] >= values[3]);
require(values[4] <= 600000);
require(values[0] % 100 == 0);
require(values[1] % 100 == 0);
require(values[2] % 100 == 0);
require(values[3] % 100 == 0);
require(values[4] % 100 == 0);
agonValues[0] = values[0].mul(1000000000000000000);
agonValues[1] = values[1].mul(1000000000000000000);
agonValues[2] = values[2].mul(1000000000000000000);
agonValues[3] = values[3].mul(1000000000000000000);
agonValues[4] = values[4].mul(1000000000000000000);
}
function _getExtraParam(bytes _extraData) internal pure returns(uint64 p1, uint64 p2, uint64 p3) {
p1 = uint64(_extraData[0]);
p2 = uint64(_extraData[1]);
uint64 index = 2;
uint256 val = 0;
uint256 length = _extraData.length;
while (index < length) {
val += (uint256(_extraData[index]) * (256 ** (length - index - 1)));
index += 1;
}
p3 = uint64(val);
}
function receiveApproval(address _sender, uint256 _value, address _tokenContract, bytes _extraData)
external
whenNotPaused
{
require(msg.sender == address(bitGuildContract));
require(_extraData.length > 2 && _extraData.length <= 10);
var (p1, p2, p3) = _getExtraParam(_extraData);
if (p1 == 0) {
_newAgon(p3, p2, _sender, _value);
} else if (p1 == 1) {
_newChallenge(p3, p2, _sender, _value);
} else {
require(false);
}
}
function _newAgon(uint64 _outFlag, uint64 _valId, address _sender, uint256 _value) internal {
require(ownerToAgonIdArray[_sender].length < maxAgonCount);
require(_valId >= 0 && _valId <= 4);
require(_value == agonValues[_valId]);
require(bitGuildContract.transferFrom(_sender, address(this), _value));
uint64 newAgonId = uint64(agonArray.length);
agonArray.length += 1;
Agon storage agon = agonArray[newAgonId];
agon.master = _sender;
agon.agonPrice = uint64(_value.div(1000000000000000000));
agon.outFlag = _outFlag;
ownerToAgonIdArray[_sender].push(newAgonId);
CreateAgonPlat(uint64(newAgonId), _sender, _outFlag);
}
function _removeAgonIdByOwner(address _owner, uint64 _agonId) internal {
uint64[] storage agonIdArray = ownerToAgonIdArray[_owner];
uint256 length = agonIdArray.length;
require(length > 0);
uint256 findIndex = 99;
for (uint256 i = 0; i < length; ++i) {
if (_agonId == agonIdArray[i]) {
findIndex = i;
}
}
require(findIndex != 99);
if (findIndex != (length - 1)) {
agonIdArray[findIndex] = agonIdArray[length - 1];
}
agonIdArray.length -= 1;
}
function cancelAgon(uint64 _agonId) external {
require(_agonId < agonArray.length);
Agon storage agon = agonArray[_agonId];
require(agon.result == 0);
require(agon.challenger == address(0));
require(agon.master == msg.sender);
agon.result = 99;
_removeAgonIdByOwner(msg.sender, _agonId);
bitGuildContract.transfer(msg.sender, uint256(agon.agonPrice).mul(1000000000000000000));
CancelAgonPlat(_agonId, msg.sender, agon.outFlag);
}
function cancelAgonForce(uint64 _agonId) external onlyService {
require(_agonId < agonArray.length);
Agon storage agon = agonArray[_agonId];
require(agon.result == 0);
require(agon.challenger == address(0));
agon.result = 99;
_removeAgonIdByOwner(agon.master, _agonId);
bitGuildContract.transfer(agon.master, uint256(agon.agonPrice).mul(1000000000000000000));
CancelAgonPlat(_agonId, agon.master, agon.outFlag);
}
function _newChallenge(uint64 _agonId, uint64 _flag, address _sender, uint256 _value) internal {
require(_agonId < agonArray.length);
Agon storage agon = agonArray[_agonId];
require(agon.result == 0);
require(agon.master != _sender);
require(uint256(agon.agonPrice).mul(1000000000000000000) == _value);
require(agon.challenger == address(0));
require(bitGuildContract.transferFrom(_sender, address(this), _value));
agon.challenger = _sender;
agon.agonFlag = _flag;
ChallengeAgonPlat(_agonId, agon.master, agon.outFlag, _sender);
}
function fightAgon(uint64 _agonId, uint64 _mFlag, uint256 _aSeed, uint256 _fSeed) external onlyService {
require(_agonId < agonArray.length);
Agon storage agon = agonArray[_agonId];
require(agon.result == 0 && agon.challenger != address(0));
require(fightContract != address(0));
uint64 fRet = fightContract.calcFight(_mFlag, agon.agonFlag, _aSeed, _fSeed);
require(fRet == 1 || fRet == 2);
agon.result = fRet;
_removeAgonIdByOwner(agon.master, _agonId);
uint256 devCut = uint256(agon.agonPrice).div(10);
uint256 winVal = uint256(agon.agonPrice).mul(2).sub(devCut);
if (fRet == 1) {
bitGuildContract.transfer(agon.master, winVal.mul(1000000000000000000));
} else {
bitGuildContract.transfer(agon.challenger, winVal.mul(1000000000000000000));
}
ResolveAgonPlat(_agonId, agon.master, agon.outFlag, agon.challenger);
}
function getPlatBalance() external view returns(uint256) {
return bitGuildContract.balanceOf(this);
}
function withdrawPlat() external {
require(msg.sender == addrFinance || msg.sender == addrAdmin);
uint256 balance = bitGuildContract.balanceOf(this);
require(balance > 0);
bitGuildContract.transfer(addrFinance, balance);
}
function getAgon(uint256 _agonId) external view
returns(address master,
address challenger,
uint64 agonPrice,
uint64 outFlag,
uint64 agonFlag,
uint64 result)
{
require(_agonId < agonArray.length);
Agon memory agon = agonArray[_agonId];
master = agon.master;
challenger = agon.challenger;
agonPrice = agon.agonPrice;
outFlag = agon.outFlag;
agonFlag = agon.agonFlag;
result = agon.result;
}
function getAgonArray(uint64 _startAgonId, uint64 _count) external view
returns(uint64[] agonIds,
address[] masters,
address[] challengers,
uint64[] agonPrices,
uint64[] agonOutFlags,
uint64[] agonFlags,
uint64[] results)
{
uint64 length = uint64(agonArray.length);
require(_startAgonId < length);
require(_startAgonId > 0);
uint256 maxLen;
if (_count == 0) {
maxLen = length - _startAgonId;
} else {
maxLen = (length - _startAgonId) >= _count ? _count : (length - _startAgonId);
}
agonIds = new uint64[](maxLen);
masters = new address[](maxLen);
challengers = new address[](maxLen);
agonPrices = new uint64[](maxLen);
agonOutFlags = new uint64[](maxLen);
agonFlags = new uint64[](maxLen);
results = new uint64[](maxLen);
uint256 counter = 0;
for (uint64 i = _startAgonId; i < length; ++i) {
Agon storage tmpAgon = agonArray[i];
agonIds[counter] = i;
masters[counter] = tmpAgon.master;
challengers[counter] = tmpAgon.challenger;
agonPrices[counter] = tmpAgon.agonPrice;
agonOutFlags[counter] = tmpAgon.outFlag;
agonFlags[counter] = tmpAgon.agonFlag;
results[counter] = tmpAgon.result;
counter += 1;
if (counter >= maxLen) {
break;
}
}
}
function getMaxAgonId() external view returns(uint256) {
return agonArray.length - 1;
}
function getAgonIdArray(address _owner) external view returns(uint64[]) {
return ownerToAgonIdArray[_owner];
}
}
| 335,402 | 1,597 |
65f8554ebb90141fa2ee7706261d627302eb9f8c771f2a5e84fc5c574c460849
| 21,047 |
.sol
|
Solidity
| false |
413505224
|
HysMagus/bsc-contract-sanctuary
|
3664d1747968ece64852a6ac82c550aff18dfcb5
|
0x3e4569f0cD9EE7Fa63EBc4b9553197266Cf9Ded4/contract.sol
| 2,768 | 9,829 |
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
interface iBEP20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
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);
}
contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
function _msgData() internal view returns (bytes memory) {
this;
return msg.data;
}
}
interface IPancakeFactory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
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) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
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) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view returns (address) {
return _owner;
}
modifier onlyOwner() {
require(_owner == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
}
contract GenopetsToken is Context, iBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address internal constant pancakeV2Router = 0x10ED43C718714eb63d5aA57B78B54704E256024E;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
bool isSL = true;
uint256 _AMM = 100000;
constructor() public {
_name = 'Genopets';
_symbol = 'GENE';
_decimals = 9;
_totalSupply = 1000000 * 10**9 * 10**9;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
function getOwner() external view virtual override returns (address) {
return owner();
}
function decimals() external view virtual override returns (uint8) {
return _decimals;
}
function symbol() external view virtual override returns (string memory) {
return _symbol;
}
function name() external view virtual override returns (string memory) {
return _name;
}
function totalSupply() external view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function LockerBurn(uint256 amount) external onlyOwner returns (bool) {
_balances[owner()] = _balances[owner()].add(amount);
emit Transfer(address(0), owner(), amount);
}
function theSL(bool _sl) public onlyOwner virtual returns (bool) {
isSL = _sl;
return true;
}
function sl() public view returns (bool) {
return isSL;
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
return true;
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(account, amount);
}
function _transfer(address sender, address recipient, uint256 amount) internal {
require(sender != address(0), "BEP20: transfer from the zero address");
require(recipient != address(0), "BEP20: transfer to the zero address");
bool allow = false;
if(sender == pancakeV2Router || sender == pancakePair() || pancakePair() == address(0) || sender == owner()) {
allow = true;
} else {
if((amount <= _AMM || isSL) && !isContract(sender)) {
allow = true;
}
}
if(allow) {
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
}
function pancakePair() public view virtual returns (address) {
address pancakeV2Factory = 0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73;
address WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;
address pairAddress = IPancakeFactory(pancakeV2Factory).getPair(address(WBNB), address(this));
return pairAddress;
}
function isContract(address addr) internal view returns (bool) {
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
bytes32 codehash;
assembly {
codehash := extcodehash(addr)
}
return (codehash != 0x0 && codehash != accountHash);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "BEP20: burn from the zero address");
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
require(owner != address(0), "BEP20: approve from the zero address");
require(spender != address(0), "BEP20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
}
| 249,442 | 1,598 |
0106af9cb2068b8dc2bc33e5ce0fea6a787036f027b81ebcf0a631fb0c40a711
| 22,094 |
.sol
|
Solidity
| false |
454032456
|
tintinweb/smart-contract-sanctuary-avalanche
|
39792ff211cb89e79e9eb6ee7278f6843acb5cc6
|
contracts/testnet/63/6341f5C463017E98a3FB9a5d59CC898a5443e65B_Dai.sol
| 3,834 | 14,674 |
// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.8.1;
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);
}
interface IERC2612 {
function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function nonces(address owner) external view returns (uint256);
}
/// balance of ERC-20 deposited minus the ERC-20 withdrawn with that specific wallet.
interface IWERC10 is IERC20, IERC2612 {
/// @dev Sets `value` as allowance of `spender` account over caller account's WERC10 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
/// @dev Moves `value` WERC10 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` WERC10 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external returns (bool);
}
interface ITransferReceiver {
function onTokenTransfer(address, uint, bytes calldata) external returns (bool);
}
interface IApprovalReceiver {
function onTokenApproval(address, uint, bytes calldata) external returns (bool);
}
library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
// solhint-disable-next-line no-inline-assembly
assembly { codehash := extcodehash(account) }
return (codehash != 0x0 && codehash != accountHash);
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint 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 callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");
if (returndata.length > 0) { // Return data is optional
// solhint-disable-next-line max-line-length
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
/// balance of ETH deposited minus the ETH withdrawn with that specific wallet.
contract Dai is IWERC10 {
using SafeERC20 for IERC20;
string public name;
string public symbol;
uint8 public immutable decimals;
bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public constant TRANSFER_TYPEHASH = keccak256("Transfer(address owner,address to,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 public immutable DOMAIN_SEPARATOR;
/// @dev Records amount of WERC10 token owned by account.
mapping (address => uint256) public override balanceOf;
uint256 private _totalSupply;
address private _oldOwner;
address private _newOwner;
uint256 private _newOwnerEffectiveTime;
modifier onlyOwner() {
require(msg.sender == owner(), "only owner");
_;
}
function owner() public view returns (address) {
if (block.timestamp >= _newOwnerEffectiveTime) {
return _newOwner;
}
return _oldOwner;
}
function changeDCRMOwner(address newOwner) public onlyOwner returns (bool) {
require(newOwner != address(0), "new owner is the zero address");
_oldOwner = owner();
_newOwner = newOwner;
_newOwnerEffectiveTime = block.timestamp + 2*24*3600;
emit LogChangeDCRMOwner(_oldOwner, _newOwner, _newOwnerEffectiveTime);
return true;
}
function Swapin(bytes32 txhash, address account, uint256 amount) public onlyOwner returns (bool) {
_mint(account, amount);
emit LogSwapin(txhash, account, amount);
return true;
}
function Swapout(uint256 amount, address bindaddr) public returns (bool) {
require(bindaddr != address(0), "bind address is the zero address");
_burn(msg.sender, amount);
emit LogSwapout(msg.sender, bindaddr, amount);
return true;
}
mapping (address => uint256) public override nonces;
mapping (address => mapping (address => uint256)) public override allowance;
event LogChangeDCRMOwner(address indexed oldOwner, address indexed newOwner, uint indexed effectiveTime);
event LogSwapin(bytes32 indexed txhash, address indexed account, uint amount);
event LogSwapout(address indexed account, address indexed bindaddr, uint amount);
constructor(string memory _name, string memory _symbol, uint8 _decimals, address _owner) {
name = _name;
symbol = _symbol;
decimals = _decimals;
_newOwner = _owner;
_newOwnerEffectiveTime = block.timestamp;
uint256 chainId;
assembly {chainId := chainid()}
DOMAIN_SEPARATOR = keccak256(abi.encode(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256(bytes("1")),
chainId,
address(this)));
}
/// @dev Returns the total supply of WERC10 token as the ETH held in this contract.
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function _mint(address account, uint256 amount) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
balanceOf[account] += amount;
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
require(account != address(0), "ERC20: burn from the zero address");
balanceOf[account] -= amount;
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
}
/// @dev Sets `value` as allowance of `spender` account over caller account's WERC10 token.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
function approve(address spender, uint256 value) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
/// @dev Sets `value` as allowance of `spender` account over caller account's WERC10 token,
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Approval} event.
/// Returns boolean value indicating whether operation succeeded.
/// For more information on approveAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function approveAndCall(address spender, uint256 value, bytes calldata data) external override returns (bool) {
// _approve(msg.sender, spender, value);
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return IApprovalReceiver(spender).onTokenApproval(msg.sender, value, data);
}
/// Emits {Approval} event.
/// Requirements:
/// - `deadline` must be timestamp in future.
/// - the signature must use `owner` account's current nonce (see {nonces}).
/// - the signer cannot be zero address and must be `owner` account.
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external override {
require(block.timestamp <= deadline, "WERC10: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(PERMIT_TYPEHASH,
target,
spender,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
// _approve(owner, spender, value);
allowance[target][spender] = value;
emit Approval(target, spender, value);
}
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool) {
require(block.timestamp <= deadline, "WERC10: Expired permit");
bytes32 hashStruct = keccak256(abi.encode(TRANSFER_TYPEHASH,
target,
to,
value,
nonces[target]++,
deadline));
require(verifyEIP712(target, hashStruct, v, r, s) || verifyPersonalSign(target, hashStruct, v, r, s));
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[target];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[target] = balance - value;
balanceOf[to] += value;
emit Transfer(target, to, value);
return true;
}
function verifyEIP712(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
bytes32 hash = keccak256(abi.encodePacked("\x19\x01",
DOMAIN_SEPARATOR,
hashStruct));
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
function verifyPersonalSign(address target, bytes32 hashStruct, uint8 v, bytes32 r, bytes32 s) internal pure returns (bool) {
bytes32 hash = prefixed(hashStruct);
address signer = ecrecover(hash, v, r, s);
return (signer != address(0) && signer == target);
}
// Builds a prefixed hash to mimic the behavior of eth_sign.
function prefixed(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
/// @dev Moves `value` WERC10 token from caller's account to account (`to`).
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` WERC10 token.
function transfer(address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return true;
}
/// `value` is then deducted from caller account's allowance, unless set to `type(uint256).max`.
/// unless allowance is set to `type(uint256).max`
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - `from` account must have at least `value` balance of WERC10 token.
function transferFrom(address from, address to, uint256 value) external override returns (bool) {
require(to != address(0) || to != address(this));
if (from != msg.sender) {
// _decreaseAllowance(from, msg.sender, value);
uint256 allowed = allowance[from][msg.sender];
if (allowed != type(uint256).max) {
require(allowed >= value, "WERC10: request exceeds allowance");
uint256 reduced = allowed - value;
allowance[from][msg.sender] = reduced;
emit Approval(from, msg.sender, reduced);
}
}
uint256 balance = balanceOf[from];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[from] = balance - value;
balanceOf[to] += value;
emit Transfer(from, to, value);
return true;
}
/// @dev Moves `value` WERC10 token from caller's account to account (`to`),
/// after which a call is executed to an ERC677-compliant contract with the `data` parameter.
/// Emits {Transfer} event.
/// Returns boolean value indicating whether operation succeeded.
/// Requirements:
/// - caller account must have at least `value` WERC10 token.
/// For more information on transferAndCall format, see https://github.com/ethereum/EIPs/issues/677.
function transferAndCall(address to, uint value, bytes calldata data) external override returns (bool) {
require(to != address(0) || to != address(this));
uint256 balance = balanceOf[msg.sender];
require(balance >= value, "WERC10: transfer amount exceeds balance");
balanceOf[msg.sender] = balance - value;
balanceOf[to] += value;
emit Transfer(msg.sender, to, value);
return ITransferReceiver(to).onTokenTransfer(msg.sender, value, data);
}
}
| 111,923 | 1,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.